Fix double right brack and dumps in parser

calixteman · calixteman · commit cc5ed9534cd3 · 2020-06-13T20:02:29.000+02:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -24,7 +24,7 @@ name = "cpp_parser"
 path = "src/lib.rs"
 
 [workspace]
-members = ["cli_macro_stats"]
+members = ["cli_macro_stats", "cli_ast"]
 
 [profile.release]
 lto = true
diff --git a/cli_ast/Cargo.toml b/cli_ast/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "ast"
+version = "0.0.1"
+authors = ["calixteman <calixte.denizet@gmail.com>"]
+edition = "2018"
+
+[dependencies]
+clap = "2.33"
+cpp-parser = { path = ".." }
diff --git a/cli_ast/src/main.rs b/cli_ast/src/main.rs
@@ -0,0 +1,58 @@
+// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
+// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
+// http://opensource.org/licenses/MIT>, at your option. This file may not be
+// copied, modified, or distributed except according to those terms.
+
+#[macro_use]
+extern crate clap;
+
+use clap::{App, Arg};
+use cpp_parser::args::{Language, PreprocOptions};
+use cpp_parser::defaults;
+use cpp_parser::lexer::preprocessor::cache::IfCache;
+use cpp_parser::lexer::preprocessor::context::{DefaultContext, PreprocContext};
+use cpp_parser::lexer::source::{self, FileId, SourceMutex};
+use cpp_parser::lexer::{Lexer, TLexer};
+use cpp_parser::parser::{Context, Dump, Unit, UnitParser};
+use std::path::PathBuf;
+use std::sync::{Arc, Mutex};
+
+fn main() {
+    let matches = App::new("AST dump")
+        .version(crate_version!())
+        .author(&*env!("CARGO_PKG_AUTHORS").replace(':', "\n"))
+        .about("Report macro use")
+        .arg(
+            Arg::with_name("file")
+                .help("File to dump")
+                .takes_value(true),
+        )
+        .get_matches();
+
+    let file = matches.value_of("file").unwrap().to_string();
+
+    let source = source::get_source_mutex();
+    let if_cache = Arc::new(IfCache::default());
+    let opt = PreprocOptions {
+        def: defaults::get_defined(),
+        sys_paths: defaults::get_sys_paths(),
+        includes: vec![],
+        current_dir: PathBuf::from("."),
+        file: PathBuf::from(""),
+        lang: Language::CPP,
+    };
+
+    let lexer = Lexer::<DefaultContext>::new_from_file(&file, source, if_cache, opt);
+
+    let context = Context::default();
+    let mut parser = UnitParser { lexer, context };
+
+    match parser.parse() {
+        Ok(unit) => {
+            unit.dump_me();
+        }
+        Err(e) => {
+            eprintln!("{:?}", e);
+        }
+    }
+}
diff --git a/cli_macro_stats/src/main.rs b/cli_macro_stats/src/main.rs
@@ -168,10 +168,6 @@ impl PreprocContext for StatsContext {
             stats: HashMap::default(),
         }
     }
-
-    fn toto(&self) -> Vec<IfState> {
-        self.default.toto()
-    }
 }
 
 impl IncludeLocator for StatsContext {
diff --git a/src/lexer/lexer.rs b/src/lexer/lexer.rs
@@ -191,6 +191,8 @@ mk_maps! {
     "_Imaginary", Imaginary,
     "import", Import,
     "inline", Inline,
+    "__inline", UInline,
+    "__inline__", UInlineU,
     "int", Int,
     "long", Long,
     "module", Module,
@@ -413,6 +415,8 @@ pub enum Token {
     Imaginary,
     Import,
     Inline,
+    UInline,
+    UInlineU,
     Int,
     Long,
     Module,
diff --git a/src/lexer/preprocessor/context.rs b/src/lexer/preprocessor/context.rs
@@ -69,10 +69,6 @@ pub trait PreprocContext: Default + IncludeLocator {
     fn save_switch(&self, file: FileId, pos: usize, next: Position);
 
     fn new_with_if_cache(if_cache: Arc<IfCache>) -> Self;
-
-    fn toto(&self) -> Vec<IfState> {
-        Vec::new()
-    }
 }
 
 #[derive(Default)]
@@ -281,10 +277,6 @@ impl<IL: IncludeLocator> PreprocContext for Context<IL> {
             buffer: None,
         }
     }
-
-    fn toto(&self) -> Vec<IfState> {
-        self.if_stack.clone()
-    }
 }
 
 impl<IL: IncludeLocator> IncludeLocator for Context<IL> {
diff --git a/src/parser/declarations/array.rs b/src/parser/declarations/array.rs
@@ -3,8 +3,11 @@
 // http://opensource.org/licenses/MIT>, at your option. This file may not be
 // copied, modified, or distributed except according to those terms.
 
+use termcolor::StandardStreamLock;
+
 use crate::lexer::{TLexer, Token};
 use crate::parser::attributes::{Attributes, AttributesParser};
+use crate::parser::dump::Dump;
 use crate::parser::errors::ParserError;
 use crate::parser::expressions::{ExprNode, ExpressionParser};
 use crate::parser::types::Type;
@@ -16,14 +19,32 @@ pub struct Dimension {
     pub attributes: Option<Attributes>,
 }
 
+impl Dump for Dimension {
+    fn dump(&self, name: &str, prefix: &str, last: bool, stdout: &mut StandardStreamLock) {
+        dump_obj!(self, name, "", prefix, last, stdout, size, attributes);
+    }
+}
+
 pub type Dimensions = Vec<Dimension>;
 
+impl Dump for Dimensions {
+    fn dump(&self, name: &str, prefix: &str, last: bool, stdout: &mut StandardStreamLock) {
+        dump_vec!(name, self, "dim", prefix, last, stdout);
+    }
+}
+
 #[derive(Clone, Debug, PartialEq)]
 pub struct Array {
     pub base: Option<Type>,
     pub dimensions: Dimensions,
 }
 
+impl Dump for Array {
+    fn dump(&self, name: &str, prefix: &str, last: bool, stdout: &mut StandardStreamLock) {
+        dump_obj!(self, name, "array", prefix, last, stdout, base, dimensions);
+    }
+}
+
 pub struct ArrayParser<'a, L: TLexer> {
     lexer: &'a mut L,
 }
diff --git a/src/parser/declarations/class.rs b/src/parser/declarations/class.rs
@@ -386,7 +386,6 @@ mod tests {
 
     use super::*;
     use crate::lexer::{preprocessor::context::DefaultContext, Lexer};
-    use crate::mk_var;
     use crate::parser::declarations::{self, *};
     use crate::parser::expressions::{self, *};
     use crate::parser::initializer::Initializer;
diff --git a/src/parser/declarations/specifier.rs b/src/parser/declarations/specifier.rs
@@ -93,7 +93,7 @@ impl Specifier {
                 *self |= Specifier::TYPEDEF;
                 true
             }
-            Token::Inline => {
+            Token::Inline | Token::UInline | Token::UInlineU => {
                 *self |= Specifier::INLINE;
                 true
             }
@@ -173,6 +173,8 @@ impl Specifier {
         match tok {
             Token::Typedef
             | Token::Inline
+            | Token::UInline
+            | Token::UInlineU
             | Token::Virtual
             | Token::Explicit
             | Token::Friend
diff --git a/src/parser/declarations/types.rs b/src/parser/declarations/types.rs
@@ -1861,6 +1861,87 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_array_no_size() {
+        let mut l = Lexer::<DefaultContext>::new(b"unsigned short foo[]");
+        let p = TypeDeclaratorParser::new(&mut l);
+        let mut context = Context::default();
+        let (_, decl) = p.parse(None, None, true, &mut context).unwrap();
+        let decl = decl.unwrap();
+
+        assert_eq!(
+            decl,
+            Rc::new(TypeDeclarator {
+                typ: Type {
+                    base: BaseType::Array(Box::new(Array {
+                        base: Some(Type {
+                            base: BaseType::Primitive(Primitive::UnsignedShort),
+                            cv: CVQualifier::empty(),
+                            pointers: None,
+                        }),
+                        dimensions: vec![Dimension {
+                            size: None,
+                            attributes: None,
+                        }],
+                    })),
+                    cv: CVQualifier::empty(),
+                    pointers: None,
+                },
+                specifier: Specifier::empty(),
+                identifier: Identifier {
+                    identifier: Some(mk_id!("foo")),
+                    attributes: None
+                },
+                init: None,
+                bitfield_size: None,
+            })
+        );
+    }
+
+    #[test]
+    fn test_array_no_size_init() {
+        let mut l = Lexer::<DefaultContext>::new(b"static unsigned short foo[] = { 1, 2 }");
+        let p = TypeDeclaratorParser::new(&mut l);
+        let mut context = Context::default();
+        let (_, decl) = p.parse(None, None, true, &mut context).unwrap();
+        let decl = decl.unwrap();
+
+        assert_eq!(
+            decl,
+            Rc::new(TypeDeclarator {
+                typ: Type {
+                    base: BaseType::Array(Box::new(Array {
+                        base: Some(Type {
+                            base: BaseType::Primitive(Primitive::UnsignedShort),
+                            cv: CVQualifier::empty(),
+                            pointers: None,
+                        }),
+                        dimensions: vec![Dimension {
+                            size: None,
+                            attributes: None,
+                        }],
+                    })),
+                    cv: CVQualifier::empty(),
+                    pointers: None,
+                },
+                specifier: Specifier::STATIC,
+                identifier: Identifier {
+                    identifier: Some(mk_id!("foo")),
+                    attributes: None
+                },
+                init: Some(Initializer::Equal(ExprNode::ListInit(Box::new(vec![
+                    ExprNode::Integer(Box::new(literals::Integer {
+                        value: IntLiteral::Int(1)
+                    })),
+                    ExprNode::Integer(Box::new(literals::Integer {
+                        value: IntLiteral::Int(2)
+                    })),
+                ])))),
+                bitfield_size: None,
+            })
+        );
+    }
+
     #[test]
     fn test_enum() {
         let mut l = Lexer::<DefaultContext>::new(b"typedef enum A { a } B");
diff --git a/src/parser/expressions/expr.rs b/src/parser/expressions/expr.rs
diff --git a/src/parser/statements/stmt.rs b/src/parser/statements/stmt.rs
diff --git a/src/parser/types/type.rs b/src/parser/types/type.rs
diff --git a/src/parser/unit.rs b/src/parser/unit.rs

Original file line number	Diff line number	Diff line change
`@@ -168,10 +168,6 @@ impl PreprocContext for StatsContext {`
`168`	`168`	`stats: HashMap::default(),`
`169`	`169`	`}`
`170`	`170`	`}`
`171`		`-`
`172`		`- fn toto(&self) -> Vec<IfState> {`
`173`		`- self.default.toto()`
`174`		`- }`
`175`	`171`	`}`
`176`	`172`
`177`	`173`	`impl IncludeLocator for StatsContext {`
Original file line number	Diff line number	Diff line change
`@@ -69,10 +69,6 @@ pub trait PreprocContext: Default + IncludeLocator {`
`69`	`69`	`fn save_switch(&self, file: FileId, pos: usize, next: Position);`
`70`	`70`
`71`	`71`	`fn new_with_if_cache(if_cache: Arc<IfCache>) -> Self;`
`72`		`-`
`73`		`- fn toto(&self) -> Vec<IfState> {`
`74`		`- Vec::new()`
`75`		`- }`
`76`	`72`	`}`
`77`	`73`
`78`	`74`	`#[derive(Default)]`
`@@ -281,10 +277,6 @@ impl<IL: IncludeLocator> PreprocContext for Context<IL> {`
`281`	`277`	`buffer: None,`
`282`	`278`	`}`
`283`	`279`	`}`
`284`		`-`
`285`		`- fn toto(&self) -> Vec<IfState> {`
`286`		`- self.if_stack.clone()`
`287`		`- }`
`288`	`280`	`}`
`289`	`281`
`290`	`282`	`impl<IL: IncludeLocator> IncludeLocator for Context<IL> {`