ironcalc_base/expressions/parser/
mod.rs

1/*!
2# GRAMMAR
3
4<pre class="rust">
5opComp   => '=' | '<' | '>' | '<=' } '>=' | '<>'
6opFactor => '*' | '/'
7unaryOp  => '-' | '+'
8
9expr    => concat (opComp concat)*
10concat  => term ('&' term)*
11term    => factor (opFactor factor)*
12factor  => prod (opProd prod)*
13prod    => power ('^' power)*
14power   => (unaryOp)* range '%'*
15range   => implicit (':' primary)?
16implicit=> '@' primary | primary
17primary => '(' expr ')'
18        => number
19        => function '(' f_args ')'
20        => name
21        => string
22        => '{' a_args '}'
23        => bool
24        => bool()
25        => error
26
27f_args  => e (',' e)*
28</pre>
29*/
30
31use std::collections::HashMap;
32
33use crate::functions::Function;
34use crate::language::get_default_language;
35use crate::language::get_language;
36use crate::language::Language;
37use crate::locale::get_default_locale;
38use crate::locale::get_locale;
39use crate::locale::Locale;
40use crate::types::Table;
41
42use super::lexer;
43use super::token;
44use super::token::OpUnary;
45use super::token::TableReference;
46use super::token::TokenType;
47use super::types::*;
48use super::utils::number_to_column;
49
50use token::OpCompare;
51
52pub mod move_formula;
53pub mod static_analysis;
54pub mod stringify;
55
56#[cfg(test)]
57mod tests;
58
59pub(crate) fn parse_range(formula: &str) -> Result<(i32, i32, i32, i32), String> {
60    let mut lexer = lexer::Lexer::new(
61        formula,
62        lexer::LexerMode::A1,
63        #[allow(clippy::expect_used)]
64        get_locale("en").expect(""),
65        #[allow(clippy::expect_used)]
66        get_language("en").expect(""),
67    );
68    if let TokenType::Range {
69        left,
70        right,
71        sheet: _,
72    } = lexer.next_token()
73    {
74        Ok((left.column, left.row, right.column, right.row))
75    } else {
76        Err("Not a range".to_string())
77    }
78}
79
80fn get_table_column_by_name(table_column_name: &str, table: &Table) -> Option<i32> {
81    for (index, table_column) in table.columns.iter().enumerate() {
82        if table_column.name == table_column_name {
83            return Some(index as i32);
84        }
85    }
86    None
87}
88
89// DefinedNameS is a tuple with the name of the defined name, the index of the sheet and the formula
90pub type DefinedNameS = (String, Option<u32>, String);
91
92pub(crate) struct Reference<'a> {
93    sheet_name: &'a Option<String>,
94    sheet_index: u32,
95    absolute_row: bool,
96    absolute_column: bool,
97    row: i32,
98    column: i32,
99}
100
101#[derive(PartialEq, Clone, Debug)]
102pub enum ArrayNode {
103    Boolean(bool),
104    Number(f64),
105    String(String),
106    Error(token::Error),
107}
108
109#[derive(PartialEq, Clone, Debug)]
110pub enum Node {
111    BooleanKind(bool),
112    NumberKind(f64),
113    StringKind(String),
114    ReferenceKind {
115        sheet_name: Option<String>,
116        sheet_index: u32,
117        absolute_row: bool,
118        absolute_column: bool,
119        row: i32,
120        column: i32,
121    },
122    RangeKind {
123        sheet_name: Option<String>,
124        sheet_index: u32,
125        absolute_row1: bool,
126        absolute_column1: bool,
127        row1: i32,
128        column1: i32,
129        absolute_row2: bool,
130        absolute_column2: bool,
131        row2: i32,
132        column2: i32,
133    },
134    WrongReferenceKind {
135        sheet_name: Option<String>,
136        absolute_row: bool,
137        absolute_column: bool,
138        row: i32,
139        column: i32,
140    },
141    WrongRangeKind {
142        sheet_name: Option<String>,
143        absolute_row1: bool,
144        absolute_column1: bool,
145        row1: i32,
146        column1: i32,
147        absolute_row2: bool,
148        absolute_column2: bool,
149        row2: i32,
150        column2: i32,
151    },
152    OpRangeKind {
153        left: Box<Node>,
154        right: Box<Node>,
155    },
156    OpConcatenateKind {
157        left: Box<Node>,
158        right: Box<Node>,
159    },
160    OpSumKind {
161        kind: token::OpSum,
162        left: Box<Node>,
163        right: Box<Node>,
164    },
165    OpProductKind {
166        kind: token::OpProduct,
167        left: Box<Node>,
168        right: Box<Node>,
169    },
170    OpPowerKind {
171        left: Box<Node>,
172        right: Box<Node>,
173    },
174    FunctionKind {
175        kind: Function,
176        args: Vec<Node>,
177    },
178    InvalidFunctionKind {
179        name: String,
180        args: Vec<Node>,
181    },
182    ArrayKind(Vec<Vec<ArrayNode>>),
183    DefinedNameKind(DefinedNameS),
184    TableNameKind(String),
185    WrongVariableKind(String),
186    ImplicitIntersection {
187        automatic: bool,
188        child: Box<Node>,
189    },
190    CompareKind {
191        kind: OpCompare,
192        left: Box<Node>,
193        right: Box<Node>,
194    },
195    UnaryKind {
196        kind: OpUnary,
197        right: Box<Node>,
198    },
199    ErrorKind(token::Error),
200    ParseErrorKind {
201        formula: String,
202        message: String,
203        position: usize,
204    },
205    EmptyArgKind,
206}
207
208#[derive(Clone)]
209pub struct Parser<'a> {
210    lexer: lexer::Lexer<'a>,
211    worksheets: Vec<String>,
212    defined_names: Vec<DefinedNameS>,
213    context: CellReferenceRC,
214    tables: HashMap<String, Table>,
215    locale: &'a Locale,
216    language: &'a Language,
217}
218
219pub fn new_parser_english<'a>(
220    worksheets: Vec<String>,
221    defined_names: Vec<DefinedNameS>,
222    tables: HashMap<String, Table>,
223) -> Parser<'a> {
224    let locale = get_default_locale();
225    let language = get_default_language();
226    Parser::new(worksheets, defined_names, tables, locale, language)
227}
228
229impl<'a> Parser<'a> {
230    pub fn new(
231        worksheets: Vec<String>,
232        defined_names: Vec<DefinedNameS>,
233        tables: HashMap<String, Table>,
234        locale: &'a Locale,
235        language: &'a Language,
236    ) -> Parser<'a> {
237        let lexer = lexer::Lexer::new("", lexer::LexerMode::A1, locale, language);
238        let context = CellReferenceRC {
239            sheet: worksheets.first().map_or("", |v| v).to_string(),
240            column: 1,
241            row: 1,
242        };
243        Parser {
244            lexer,
245            worksheets,
246            defined_names,
247            context,
248            tables,
249            locale,
250            language,
251        }
252    }
253    pub fn set_lexer_mode(&mut self, mode: lexer::LexerMode) {
254        self.lexer.set_lexer_mode(mode)
255    }
256
257    pub fn set_locale(&mut self, locale: &'a Locale) {
258        self.locale = locale;
259        self.lexer.set_locale(locale);
260    }
261
262    pub fn set_language(&mut self, language: &'a Language) {
263        self.language = language;
264        self.lexer.set_language(language);
265    }
266
267    pub fn set_worksheets_and_names(
268        &mut self,
269        worksheets: Vec<String>,
270        defined_names: Vec<DefinedNameS>,
271    ) {
272        self.worksheets = worksheets;
273        self.defined_names = defined_names;
274    }
275
276    pub fn parse(&mut self, formula: &str, context: &CellReferenceRC) -> Node {
277        self.lexer.set_formula(formula);
278        self.context = context.clone();
279        self.parse_expr()
280    }
281
282    // Returns the token used to separate arguments in functions and arrays
283    // If the locale decimal separator is '.', then it is a comma ','
284    // Otherwise, it is a semicolon ';'
285    fn get_argument_separator_token(&self) -> TokenType {
286        if self.locale.numbers.symbols.decimal == "." {
287            TokenType::Comma
288        } else {
289            TokenType::Semicolon
290        }
291    }
292
293    // Returns the token used to separate columns in arrays
294    // If the locale decimal separator is '.', then it is a semicolon ';'
295    fn get_column_separator_token(&self) -> TokenType {
296        if self.locale.numbers.symbols.decimal == "." {
297            TokenType::Semicolon
298        } else {
299            TokenType::Backslash
300        }
301    }
302
303    fn get_sheet_index_by_name(&self, name: &str) -> Option<u32> {
304        let worksheets = &self.worksheets;
305        for (i, sheet) in worksheets.iter().enumerate() {
306            if sheet == name {
307                return Some(i as u32);
308            }
309        }
310        None
311    }
312
313    // Returns:
314    //  * None: If there is no defined name by that name
315    //  * Some((Some(index), formula)): If there is a defined name local to that sheet
316    //  * Some(None): If there is a global defined name
317    fn get_defined_name(&self, name: &str, sheet: u32) -> Option<(Option<u32>, String)> {
318        for (df_name, df_scope, df_formula) in &self.defined_names {
319            if name.to_lowercase() == df_name.to_lowercase() && df_scope == &Some(sheet) {
320                return Some((*df_scope, df_formula.to_owned()));
321            }
322        }
323        for (df_name, df_scope, df_formula) in &self.defined_names {
324            if name.to_lowercase() == df_name.to_lowercase() && df_scope.is_none() {
325                return Some((None, df_formula.to_owned()));
326            }
327        }
328        None
329    }
330
331    fn parse_expr(&mut self) -> Node {
332        let mut t = self.parse_concat();
333        if let Node::ParseErrorKind { .. } = t {
334            return t;
335        }
336        let mut next_token = self.lexer.peek_token();
337        while let TokenType::Compare(op) = next_token {
338            self.lexer.advance_token();
339            let p = self.parse_concat();
340            if let Node::ParseErrorKind { .. } = p {
341                return p;
342            }
343            t = Node::CompareKind {
344                kind: op,
345                left: Box::new(t),
346                right: Box::new(p),
347            };
348            next_token = self.lexer.peek_token();
349        }
350        t
351    }
352
353    fn parse_concat(&mut self) -> Node {
354        let mut t = self.parse_term();
355        if let Node::ParseErrorKind { .. } = t {
356            return t;
357        }
358        let mut next_token = self.lexer.peek_token();
359        while next_token == TokenType::And {
360            self.lexer.advance_token();
361            let p = self.parse_term();
362            if let Node::ParseErrorKind { .. } = p {
363                return p;
364            }
365            t = Node::OpConcatenateKind {
366                left: Box::new(t),
367                right: Box::new(p),
368            };
369            next_token = self.lexer.peek_token();
370        }
371        t
372    }
373
374    fn parse_term(&mut self) -> Node {
375        let mut t = self.parse_factor();
376        if let Node::ParseErrorKind { .. } = t {
377            return t;
378        }
379        let mut next_token = self.lexer.peek_token();
380        while let TokenType::Addition(op) = next_token {
381            self.lexer.advance_token();
382            let p = self.parse_factor();
383            if let Node::ParseErrorKind { .. } = p {
384                return p;
385            }
386            t = Node::OpSumKind {
387                kind: op,
388                left: Box::new(t),
389                right: Box::new(p),
390            };
391
392            next_token = self.lexer.peek_token();
393        }
394        t
395    }
396
397    fn parse_factor(&mut self) -> Node {
398        let mut t = self.parse_prod();
399        if let Node::ParseErrorKind { .. } = t {
400            return t;
401        }
402        let mut next_token = self.lexer.peek_token();
403        while let TokenType::Product(op) = next_token {
404            self.lexer.advance_token();
405            let p = self.parse_prod();
406            if let Node::ParseErrorKind { .. } = p {
407                return p;
408            }
409            t = Node::OpProductKind {
410                kind: op,
411                left: Box::new(t),
412                right: Box::new(p),
413            };
414            next_token = self.lexer.peek_token();
415        }
416        t
417    }
418
419    fn parse_prod(&mut self) -> Node {
420        let mut t = self.parse_power();
421        if let Node::ParseErrorKind { .. } = t {
422            return t;
423        }
424        let mut next_token = self.lexer.peek_token();
425        while next_token == TokenType::Power {
426            self.lexer.advance_token();
427            let p = self.parse_power();
428            if let Node::ParseErrorKind { .. } = p {
429                return p;
430            }
431            t = Node::OpPowerKind {
432                left: Box::new(t),
433                right: Box::new(p),
434            };
435            next_token = self.lexer.peek_token();
436        }
437        t
438    }
439
440    fn parse_power(&mut self) -> Node {
441        let mut next_token = self.lexer.peek_token();
442        let mut sign = 1;
443        while let TokenType::Addition(op) = next_token {
444            self.lexer.advance_token();
445            if op == token::OpSum::Minus {
446                sign = -sign;
447            }
448            next_token = self.lexer.peek_token();
449        }
450
451        let mut t = self.parse_range();
452        if let Node::ParseErrorKind { .. } = t {
453            return t;
454        }
455        if sign == -1 {
456            t = Node::UnaryKind {
457                kind: token::OpUnary::Minus,
458                right: Box::new(t),
459            }
460        }
461        next_token = self.lexer.peek_token();
462        while next_token == TokenType::Percent {
463            self.lexer.advance_token();
464            t = Node::UnaryKind {
465                kind: token::OpUnary::Percentage,
466                right: Box::new(t),
467            };
468            next_token = self.lexer.peek_token();
469        }
470        t
471    }
472
473    fn parse_range(&mut self) -> Node {
474        let t = self.parse_implicit();
475        if let Node::ParseErrorKind { .. } = t {
476            return t;
477        }
478        let next_token = self.lexer.peek_token();
479        if next_token == TokenType::Colon {
480            self.lexer.advance_token();
481            let p = self.parse_primary();
482            if let Node::ParseErrorKind { .. } = p {
483                return p;
484            }
485            return Node::OpRangeKind {
486                left: Box::new(t),
487                right: Box::new(p),
488            };
489        }
490        t
491    }
492
493    fn parse_implicit(&mut self) -> Node {
494        let next_token = self.lexer.peek_token();
495        if next_token == TokenType::At {
496            self.lexer.advance_token();
497            let t = self.parse_primary();
498            if let Node::ParseErrorKind { .. } = t {
499                return t;
500            }
501            return Node::ImplicitIntersection {
502                automatic: false,
503                child: Box::new(t),
504            };
505        }
506        self.parse_primary()
507    }
508
509    fn parse_array_row(&mut self) -> Result<Vec<ArrayNode>, Node> {
510        let mut row = Vec::new();
511        let column_separator_token = self.get_argument_separator_token();
512        // and array can only have numbers, string or booleans
513        // otherwise it is a syntax error
514        let first_element = match self.parse_expr() {
515            Node::BooleanKind(s) => ArrayNode::Boolean(s),
516            Node::NumberKind(s) => ArrayNode::Number(s),
517            Node::StringKind(s) => ArrayNode::String(s),
518            Node::ErrorKind(kind) => ArrayNode::Error(kind),
519            Node::UnaryKind {
520                kind: OpUnary::Minus,
521                right,
522            } => {
523                if let Node::NumberKind(n) = *right {
524                    ArrayNode::Number(-n)
525                } else {
526                    return Err(Node::ParseErrorKind {
527                        formula: self.lexer.get_formula(),
528                        message: "Invalid value in array".to_string(),
529                        position: self.lexer.get_position() as usize,
530                    });
531                }
532            }
533            error @ Node::ParseErrorKind { .. } => return Err(error),
534            _ => {
535                return Err(Node::ParseErrorKind {
536                    formula: self.lexer.get_formula(),
537                    message: "Invalid value in array".to_string(),
538                    position: self.lexer.get_position() as usize,
539                });
540            }
541        };
542        row.push(first_element);
543        let mut next_token = self.lexer.peek_token();
544        while next_token == column_separator_token {
545            self.lexer.advance_token();
546            let value = match self.parse_expr() {
547                Node::BooleanKind(s) => ArrayNode::Boolean(s),
548                Node::NumberKind(s) => ArrayNode::Number(s),
549                Node::StringKind(s) => ArrayNode::String(s),
550                Node::ErrorKind(kind) => ArrayNode::Error(kind),
551                Node::UnaryKind {
552                    kind: OpUnary::Minus,
553                    right,
554                } => {
555                    if let Node::NumberKind(n) = *right {
556                        ArrayNode::Number(-n)
557                    } else {
558                        return Err(Node::ParseErrorKind {
559                            formula: self.lexer.get_formula(),
560                            message: "Invalid value in array".to_string(),
561                            position: self.lexer.get_position() as usize,
562                        });
563                    }
564                }
565                error @ Node::ParseErrorKind { .. } => return Err(error),
566                _ => {
567                    return Err(Node::ParseErrorKind {
568                        formula: self.lexer.get_formula(),
569                        message: "Invalid value in array".to_string(),
570                        position: self.lexer.get_position() as usize,
571                    });
572                }
573            };
574            row.push(value);
575            next_token = self.lexer.peek_token();
576        }
577        Ok(row)
578    }
579
580    fn parse_primary(&mut self) -> Node {
581        let next_token = self.lexer.next_token();
582        match next_token {
583            TokenType::LeftParenthesis => {
584                let t = self.parse_expr();
585                if let Node::ParseErrorKind { .. } = t {
586                    return t;
587                }
588
589                if let Err(err) = self.lexer.expect(TokenType::RightParenthesis) {
590                    return Node::ParseErrorKind {
591                        formula: self.lexer.get_formula(),
592                        position: err.position,
593                        message: err.message,
594                    };
595                }
596                t
597            }
598            TokenType::Number(s) => Node::NumberKind(s),
599            TokenType::String(s) => Node::StringKind(s),
600            TokenType::LeftBrace => {
601                // It's an array. It's a collection of rows all of the same dimension
602                let column_separator_token = self.get_column_separator_token();
603
604                let first_row = match self.parse_array_row() {
605                    Ok(s) => s,
606                    Err(error) => return error,
607                };
608                let length = first_row.len();
609
610                let mut matrix = Vec::new();
611                matrix.push(first_row);
612                let mut next_token = self.lexer.peek_token();
613                while next_token == column_separator_token {
614                    self.lexer.advance_token();
615                    let row = match self.parse_array_row() {
616                        Ok(s) => s,
617                        Err(error) => return error,
618                    };
619                    next_token = self.lexer.peek_token();
620                    if row.len() != length {
621                        return Node::ParseErrorKind {
622                            formula: self.lexer.get_formula(),
623                            position: self.lexer.get_position() as usize,
624                            message: "All rows in an array should be the same length".to_string(),
625                        };
626                    }
627                    matrix.push(row);
628                }
629
630                if let Err(err) = self.lexer.expect(TokenType::RightBrace) {
631                    return Node::ParseErrorKind {
632                        formula: self.lexer.get_formula(),
633                        position: err.position,
634                        message: err.message,
635                    };
636                }
637                Node::ArrayKind(matrix)
638            }
639            TokenType::Reference {
640                sheet,
641                row,
642                column,
643                absolute_column,
644                absolute_row,
645            } => {
646                let context = &self.context;
647                let sheet_index = match &sheet {
648                    Some(name) => self.get_sheet_index_by_name(name),
649                    None => self.get_sheet_index_by_name(&context.sheet),
650                };
651                let a1_mode = self.lexer.is_a1_mode();
652                let row = if absolute_row || !a1_mode {
653                    row
654                } else {
655                    row - context.row
656                };
657                let column = if absolute_column || !a1_mode {
658                    column
659                } else {
660                    column - context.column
661                };
662                match sheet_index {
663                    Some(index) => Node::ReferenceKind {
664                        sheet_name: sheet,
665                        sheet_index: index,
666                        row,
667                        column,
668                        absolute_row,
669                        absolute_column,
670                    },
671                    None => Node::WrongReferenceKind {
672                        sheet_name: sheet,
673                        row,
674                        column,
675                        absolute_row,
676                        absolute_column,
677                    },
678                }
679            }
680            TokenType::Range { sheet, left, right } => {
681                let context = &self.context;
682                let sheet_index = match &sheet {
683                    Some(name) => self.get_sheet_index_by_name(name),
684                    None => self.get_sheet_index_by_name(&context.sheet),
685                };
686                let mut row1 = left.row;
687                let mut column1 = left.column;
688                let mut row2 = right.row;
689                let mut column2 = right.column;
690
691                let mut absolute_column1 = left.absolute_column;
692                let mut absolute_column2 = right.absolute_column;
693                let mut absolute_row1 = left.absolute_row;
694                let mut absolute_row2 = right.absolute_row;
695
696                if self.lexer.is_a1_mode() {
697                    if row1 > row2 {
698                        (row2, row1) = (row1, row2);
699                        (absolute_row2, absolute_row1) = (absolute_row1, absolute_row2);
700                    }
701                    if column1 > column2 {
702                        (column2, column1) = (column1, column2);
703                        (absolute_column2, absolute_column1) = (absolute_column1, absolute_column2);
704                    }
705                }
706
707                if self.lexer.is_a1_mode() {
708                    if !absolute_row1 {
709                        row1 -= context.row
710                    };
711                    if !absolute_column1 {
712                        column1 -= context.column
713                    };
714                    if !absolute_row2 {
715                        row2 -= context.row
716                    };
717                    if !absolute_column2 {
718                        column2 -= context.column
719                    };
720                }
721
722                match sheet_index {
723                    Some(index) => Node::RangeKind {
724                        sheet_name: sheet,
725                        sheet_index: index,
726                        row1,
727                        column1,
728                        row2,
729                        column2,
730                        absolute_column1,
731                        absolute_column2,
732                        absolute_row1,
733                        absolute_row2,
734                    },
735                    None => Node::WrongRangeKind {
736                        sheet_name: sheet,
737                        row1,
738                        column1,
739                        row2,
740                        column2,
741                        absolute_column1,
742                        absolute_column2,
743                        absolute_row1,
744                        absolute_row2,
745                    },
746                }
747            }
748            TokenType::Ident(name) => {
749                let next_token = self.lexer.peek_token();
750                if next_token == TokenType::LeftParenthesis {
751                    // It's a function call "SUM(.."
752                    self.lexer.advance_token();
753                    let args = match self.parse_function_args() {
754                        Ok(s) => s,
755                        Err(e) => return e,
756                    };
757                    if let Err(err) = self.lexer.expect(TokenType::RightParenthesis) {
758                        return Node::ParseErrorKind {
759                            formula: self.lexer.get_formula(),
760                            position: err.position,
761                            message: err.message,
762                        };
763                    }
764                    // We should do this *only* importing functions from xlsx
765                    if &name == "_xlfn.SINGLE" {
766                        if args.len() != 1 {
767                            return Node::ParseErrorKind {
768                                formula: self.lexer.get_formula(),
769                                position: self.lexer.get_position() as usize,
770                                message: "Implicit Intersection requires just one argument"
771                                    .to_string(),
772                            };
773                        }
774                        return Node::ImplicitIntersection {
775                            automatic: false,
776                            child: Box::new(args[0].clone()),
777                        };
778                    }
779                    // We should do this *only* importing functions from xlsx
780                    if let Some(function_kind) = self
781                        .language
782                        .functions
783                        .lookup(name.trim_start_matches("_xlfn."))
784                    {
785                        return Node::FunctionKind {
786                            kind: function_kind,
787                            args,
788                        };
789                    }
790                    return Node::InvalidFunctionKind { name, args };
791                }
792                let context = &self.context;
793
794                let context_sheet_index = match self.get_sheet_index_by_name(&context.sheet) {
795                    Some(i) => i,
796                    None => {
797                        return Node::ParseErrorKind {
798                            formula: self.lexer.get_formula(),
799                            position: 0,
800                            message: format!("sheet not found: {}", context.sheet),
801                        };
802                    }
803                };
804
805                // Could be a defined name or a table
806                if let Some((scope, formula)) = self.get_defined_name(&name, context_sheet_index) {
807                    return Node::DefinedNameKind((name, scope, formula));
808                }
809                let name_lower = name.to_lowercase();
810                for table_name in self.tables.keys() {
811                    if table_name.to_lowercase() == name_lower {
812                        return Node::TableNameKind(name);
813                    }
814                }
815                Node::WrongVariableKind(name)
816            }
817            TokenType::Error(kind) => Node::ErrorKind(kind),
818            TokenType::Illegal(error) => Node::ParseErrorKind {
819                formula: self.lexer.get_formula(),
820                position: error.position,
821                message: error.message,
822            },
823            TokenType::EOF => Node::ParseErrorKind {
824                formula: self.lexer.get_formula(),
825                position: 0,
826                message: "Unexpected end of input.".to_string(),
827            },
828            TokenType::Boolean(value) => {
829                // Could be a function call "TRUE()"
830                let next_token = self.lexer.peek_token();
831                if next_token == TokenType::LeftParenthesis {
832                    self.lexer.advance_token();
833                    // We parse all the arguments, although technically this is moot
834                    // But is has the upside of transforming `=TRUE( 4 )` into `=TRUE(4)`
835                    let args = match self.parse_function_args() {
836                        Ok(s) => s,
837                        Err(e) => return e,
838                    };
839                    if let Err(err) = self.lexer.expect(TokenType::RightParenthesis) {
840                        return Node::ParseErrorKind {
841                            formula: self.lexer.get_formula(),
842                            position: err.position,
843                            message: err.message,
844                        };
845                    }
846                    if value {
847                        return Node::FunctionKind {
848                            kind: Function::True,
849                            args,
850                        };
851                    } else {
852                        return Node::FunctionKind {
853                            kind: Function::False,
854                            args,
855                        };
856                    }
857                }
858                Node::BooleanKind(value)
859            }
860            TokenType::Compare(_) => {
861                // A primary Node cannot start with an operator
862                Node::ParseErrorKind {
863                    formula: self.lexer.get_formula(),
864                    position: 0,
865                    message: "Unexpected token: 'COMPARE'".to_string(),
866                }
867            }
868            TokenType::Addition(_) => {
869                // A primary Node cannot start with an operator
870                Node::ParseErrorKind {
871                    formula: self.lexer.get_formula(),
872                    position: 0,
873                    message: "Unexpected token: 'SUM'".to_string(),
874                }
875            }
876            TokenType::Product(_) => {
877                // A primary Node cannot start with an operator
878                Node::ParseErrorKind {
879                    formula: self.lexer.get_formula(),
880                    position: 0,
881                    message: "Unexpected token: 'PRODUCT'".to_string(),
882                }
883            }
884            TokenType::Power => {
885                // A primary Node cannot start with an operator
886                Node::ParseErrorKind {
887                    formula: self.lexer.get_formula(),
888                    position: 0,
889                    message: "Unexpected token: 'POWER'".to_string(),
890                }
891            }
892            TokenType::At => {
893                // A primary Node cannot start with an operator
894                Node::ParseErrorKind {
895                    formula: self.lexer.get_formula(),
896                    position: 0,
897                    message: "Unexpected token: '@'".to_string(),
898                }
899            }
900            TokenType::RightParenthesis
901            | TokenType::RightBracket
902            | TokenType::Colon
903            | TokenType::Semicolon
904            | TokenType::Backslash
905            | TokenType::RightBrace
906            | TokenType::Comma
907            | TokenType::Bang
908            | TokenType::And
909            | TokenType::Percent => Node::ParseErrorKind {
910                formula: self.lexer.get_formula(),
911                position: 0,
912                message: format!("Unexpected token: '{next_token:?}'"),
913            },
914            TokenType::LeftBracket => Node::ParseErrorKind {
915                formula: self.lexer.get_formula(),
916                position: 0,
917                message: "Unexpected token: '['".to_string(),
918            },
919            TokenType::StructuredReference {
920                table_name,
921                specifier,
922                table_reference,
923            } => {
924                // We will try to convert to a normal reference
925                // table_name[column_name] => cell1:cell2
926                // table_name[[#This Row], [column_name]:[column_name]] => cell1:cell2
927                let context = &self.context;
928                let context_sheet_index = match self.get_sheet_index_by_name(&context.sheet) {
929                    Some(i) => i,
930                    None => {
931                        return Node::ParseErrorKind {
932                            formula: self.lexer.get_formula(),
933                            position: 0,
934                            message: format!("sheet not found: {}", context.sheet),
935                        };
936                    }
937                };
938                // table-name => table
939                let table = match self.tables.get(&table_name) {
940                    Some(t) => t,
941                    None => {
942                        let message = format!(
943                            "Table not found: '{table_name}' at '{}!{}{}'",
944                            context.sheet,
945                            number_to_column(context.column)
946                                .unwrap_or(format!("{}", context.column)),
947                            context.row
948                        );
949                        return Node::ParseErrorKind {
950                            formula: self.lexer.get_formula(),
951                            position: 0,
952                            message,
953                        };
954                    }
955                };
956                let table_sheet_index = match self.get_sheet_index_by_name(&table.sheet_name) {
957                    Some(i) => i,
958                    None => {
959                        return Node::ParseErrorKind {
960                            formula: self.lexer.get_formula(),
961                            position: 0,
962                            message: format!("table sheet not found: {}", table.sheet_name),
963                        };
964                    }
965                };
966
967                let sheet_name = if table_sheet_index == context_sheet_index {
968                    None
969                } else {
970                    Some(table.sheet_name.clone())
971                };
972
973                // context must be with tables.reference
974                #[allow(clippy::expect_used)]
975                let (column_start, mut row_start, column_end, mut row_end) =
976                    parse_range(&table.reference).expect("Failed parsing range");
977
978                let totals_row_count = table.totals_row_count as i32;
979                let header_row_count = table.header_row_count as i32;
980                row_end -= totals_row_count;
981
982                match specifier {
983                    Some(token::TableSpecifier::ThisRow) => {
984                        row_start = context.row;
985                        row_end = context.row;
986                    }
987                    Some(token::TableSpecifier::Totals) => {
988                        if totals_row_count != 0 {
989                            row_start = row_end + 1;
990                            row_end = row_start;
991                        } else {
992                            // Table1[#Totals] is #REF! if Table1 does not have totals
993                            return Node::ErrorKind(token::Error::REF);
994                        }
995                    }
996                    Some(token::TableSpecifier::Headers) => {
997                        row_end = row_start;
998                    }
999                    Some(token::TableSpecifier::Data) => {
1000                        row_start += header_row_count;
1001                    }
1002                    Some(token::TableSpecifier::All) => {
1003                        if totals_row_count != 0 {
1004                            row_end += 1;
1005                        }
1006                    }
1007                    None => {
1008                        // skip the headers
1009                        row_start += header_row_count;
1010                    }
1011                }
1012                match table_reference {
1013                    None => Node::RangeKind {
1014                        sheet_name,
1015                        sheet_index: table_sheet_index,
1016                        absolute_row1: true,
1017                        absolute_column1: true,
1018                        row1: row_start,
1019                        column1: column_start,
1020                        absolute_row2: true,
1021                        absolute_column2: true,
1022                        row2: row_end,
1023                        column2: column_end,
1024                    },
1025                    Some(TableReference::ColumnReference(s)) => {
1026                        let column_index = match get_table_column_by_name(&s, table) {
1027                            Some(s) => s + column_start,
1028                            None => {
1029                                return Node::ParseErrorKind {
1030                                    formula: self.lexer.get_formula(),
1031                                    position: self.lexer.get_position() as usize,
1032                                    message: format!("Expecting column: {s} in table {table_name}"),
1033                                };
1034                            }
1035                        };
1036                        if row_start == row_end {
1037                            return Node::ReferenceKind {
1038                                sheet_name,
1039                                sheet_index: table_sheet_index,
1040                                absolute_row: true,
1041                                absolute_column: true,
1042                                row: row_start,
1043                                column: column_index,
1044                            };
1045                        }
1046                        Node::RangeKind {
1047                            sheet_name,
1048                            sheet_index: table_sheet_index,
1049                            absolute_row1: true,
1050                            absolute_column1: true,
1051                            row1: row_start,
1052                            column1: column_index,
1053                            absolute_row2: true,
1054                            absolute_column2: true,
1055                            row2: row_end,
1056                            column2: column_index,
1057                        }
1058                    }
1059                    Some(TableReference::RangeReference((left, right))) => {
1060                        let left_column_index = match get_table_column_by_name(&left, table) {
1061                            Some(f) => f + column_start,
1062                            None => {
1063                                return Node::ParseErrorKind {
1064                                    formula: self.lexer.get_formula(),
1065                                    position: self.lexer.get_position() as usize,
1066                                    message: format!(
1067                                        "Expecting column: {left} in table {table_name}"
1068                                    ),
1069                                };
1070                            }
1071                        };
1072
1073                        let right_column_index = match get_table_column_by_name(&right, table) {
1074                            Some(f) => f + column_start,
1075                            None => {
1076                                return Node::ParseErrorKind {
1077                                    formula: self.lexer.get_formula(),
1078                                    position: self.lexer.get_position() as usize,
1079                                    message: format!(
1080                                        "Expecting column: {right} in table {table_name}"
1081                                    ),
1082                                };
1083                            }
1084                        };
1085                        Node::RangeKind {
1086                            sheet_name,
1087                            sheet_index: table_sheet_index,
1088                            absolute_row1: true,
1089                            absolute_column1: true,
1090                            row1: row_start,
1091                            column1: left_column_index,
1092                            absolute_row2: true,
1093                            absolute_column2: true,
1094                            row2: row_end,
1095                            column2: right_column_index,
1096                        }
1097                    }
1098                }
1099            }
1100        }
1101    }
1102
1103    fn parse_function_args(&mut self) -> Result<Vec<Node>, Node> {
1104        let arg_separator_token = &self.get_argument_separator_token();
1105        let mut args: Vec<Node> = Vec::new();
1106        let mut next_token = self.lexer.peek_token();
1107        if next_token == TokenType::RightParenthesis {
1108            return Ok(args);
1109        }
1110        if &self.lexer.peek_token() == arg_separator_token {
1111            args.push(Node::EmptyArgKind);
1112        } else {
1113            let t = self.parse_expr();
1114            if let Node::ParseErrorKind { .. } = t {
1115                return Err(t);
1116            }
1117            args.push(t);
1118        }
1119        next_token = self.lexer.peek_token();
1120        while &next_token == arg_separator_token {
1121            self.lexer.advance_token();
1122            if &self.lexer.peek_token() == arg_separator_token {
1123                args.push(Node::EmptyArgKind);
1124                next_token = arg_separator_token.clone();
1125            } else if self.lexer.peek_token() == TokenType::RightParenthesis {
1126                args.push(Node::EmptyArgKind);
1127                return Ok(args);
1128            } else {
1129                let p = self.parse_expr();
1130                if let Node::ParseErrorKind { .. } = p {
1131                    return Err(p);
1132                }
1133                next_token = self.lexer.peek_token();
1134                args.push(p);
1135            }
1136        }
1137        Ok(args)
1138    }
1139}
ironcalc_base/expressions/parser/mod.rs

ironcalc_base/expressions/parser/
mod.rs
