CSY/reowolf Changeset - 36d5a586a102 · Centrum Wiskunde & Informatica (CWI)

Changeset - 36d5a586a102

Parent rev.

Child rev.

[Not reviewed]

0 3 0

mh - 4 years ago 2021-01-05 17:13:08
contact@maxhenger.nl

tiny performance improvements

3 files changed with 46 insertions and 35 deletions:

src/protocol/inputsource.rs

src/protocol/lexer.rs

src/protocol/parser.rs

0 comments (0 inline, 0 general)

src/protocol/inputsource.rs

➞

Show inline comments

@@ @@ -46,13 +46,13 @@ primitive merger(in l, in r, out o) { @@
 impl InputSource {
     // Constructors
     pub fn new<R: io::Read, S: ToString>(filename: S, reader: &mut R) -> io::Result<InputSource> {
         let mut vec = Vec::new();
         reader.read_to_end(&mut vec)?;
         vec.extend(STD_LIB_PDL.to_vec());
+        // vec.extend(STD_LIB_PDL.to_vec());
         Ok(InputSource {
             filename: filename.to_string(),
             input: vec,
             line: 1,
             column: 1,
             offset: 0,
@@ @@ -78,33 +78,56 @@ impl InputSource { @@
         InputSource::new(String::new(), &mut Box::new(buffer))
+    }
     // Internal methods
     pub fn pos(&self) -> InputPosition {
         InputPosition { line: self.line, column: self.column, offset: self.offset }
+    }
     pub fn seek(&mut self, pos: InputPosition) {
         debug_assert!(pos.offset < self.input.len());
         self.line = pos.line;
         self.column = pos.column;
         self.offset = pos.offset;
+    }
     pub fn error<S: ToString>(&self, message: S) -> ParseError {
         self.pos().parse_error(message)
+    }
     pub fn is_eof(&self) -> bool {
         self.next() == None
+    }
     pub fn next(&self) -> Option<u8> {
         if self.offset < self.input.len() {
-            Some((*self.input)[self.offset])
             Some(self.input[self.offset])
         } else {
             None
+        }
+    }
     pub fn lookahead(&self, pos: usize) -> Option<u8> {
         if let Some(x) = usize::checked_add(self.offset, pos) {
             if x < self.input.len() {
                 return Some((*self.input)[x]);
         let offset_pos = self.offset + pos;
         if offset_pos < self.input.len() {
             Some(self.input[offset_pos])
         } else {
             None
+        }
+    }
     pub fn has(&self, to_compare: &[u8]) -> bool {
         if self.offset + to_compare.len() <= self.input.len() {
             for idx in 0..to_compare.len() {
                 if to_compare[idx] != self.input[self.offset + idx] {
                     return false;
+                }
+            }
             true
         } else {
             false
+        }
         None
+    }
     pub fn consume(&mut self) {
         match self.next() {
             Some(x) if x == b'\r' && self.lookahead(1) != Some(b'\n') || x == b'\n' => {
                 self.line += 1;
                 self.offset += 1;
                 self.column = 1;

src/protocol/lexer.rs

➞

Show inline comments

@@ @@ -150,22 +150,18 @@ impl Lexer<'_> { @@
             Err(self.source.error("Expected whitespace"))
         } else {
             Ok(())
+        }
+    }
     fn has_keyword(&self, keyword: &[u8]) -> bool {
         let len = keyword.len();
         for i in 0..len {
             let expected = Some(lowercase(keyword[i]));
             let next = self.source.lookahead(i).map(lowercase);
             if next != expected {
                 return false;
+            }
         if !self.source.has(keyword) {
             return false;
+        }
         // Word boundary
         if let Some(next) = self.source.lookahead(len) {
+        if let Some(next) = self.source.lookahead(keyword.len()) {
             !(next >= b'A' && next <= b'Z' || next >= b'a' && next <= b'z')
         } else {
             true
+        }
+    }
     fn consume_keyword(&mut self, keyword: &[u8]) -> Result<(), ParseError> {
@@ @@ -188,21 +184,13 @@ impl Lexer<'_> { @@
                 )));
+            }
+        }
         Ok(())
+    }
     fn has_string(&self, string: &[u8]) -> bool {
         let len = string.len();
         for i in 0..len {
             let expected = Some(string[i]);
             let next = self.source.lookahead(i);
             if next != expected {
                 return false;
+            }
+        }
         true
         self.source.has(string)
+    }
     fn consume_string(&mut self, string: &[u8]) -> Result<(), ParseError> {
         let len = string.len();
         for i in 0..len {
             let expected = Some(string[i]);
             let next = self.source.next();
@@ @@ -321,19 +309,19 @@ impl Lexer<'_> { @@
         } else {
             let data = self.consume_ident()?;
             Ok(PrimitiveType::Symbolic(data))
+        }
+    }
     fn has_array(&mut self) -> bool {
-        let backup = self.source.clone();
+        let backup_pos = self.source.pos();
         let mut result = false;
         match self.consume_whitespace(false) {
             Ok(_) => result = self.has_string(b"["),
             Err(_) => {}
+        }
-        *self.source = backup;
+        self.source.seek(backup_pos);
         return result;
+    }
     fn consume_type(&mut self) -> Result<Type, ParseError> {
         let primitive = self.consume_primitive_type()?;
         let array;
         if self.has_array() {
@@ @@ -1055,24 +1043,24 @@ impl Lexer<'_> { @@
         /* We prevent ambiguity with variables, by looking ahead
         the identifier to see if we can find an opening
         parenthesis: this signals a call expression. */
         if self.has_builtin_keyword() {
             return true;
+        }
-        let backup = self.source.clone();
+        let backup_pos = self.source.pos();
         let mut result = false;
         match self.consume_identifier_spilled() {
             Ok(_) => match self.consume_whitespace(false) {
                 Ok(_) => {
                     result = self.has_string(b"(");
+                }
                 Err(_) => {}
             },
             Err(_) => {}
+        }
-        *self.source = backup;
+        self.source.seek(backup_pos);
         return result;
+    }
     fn consume_call_expression(&mut self, h: &mut Heap) -> Result<CallExpressionId, ParseError> {
         let position = self.source.pos();
         let method;
         if self.has_keyword(b"get") {
@@ @@ -1140,24 +1128,24 @@ impl Lexer<'_> { @@
         result
+    }
     fn has_label(&mut self) -> bool {
         /* To prevent ambiguity with expression statements consisting
         only of an identifier, we look ahead and match the colon
         that signals a labeled statement. */
-        let backup = self.source.clone();
+        let backup_pos = self.source.pos();
         let mut result = false;
         match self.consume_identifier_spilled() {
             Ok(_) => match self.consume_whitespace(false) {
                 Ok(_) => {
                     result = self.has_string(b":");
+                }
                 Err(_) => {}
             },
             Err(_) => {}
+        }
-        *self.source = backup;
+        self.source.seek(backup_pos);
         return result;
+    }
     fn consume_statement_impl(&mut self, h: &mut Heap) -> Result<StatementId, ParseError> {
         if self.has_string(b"{") {
             Ok(self.consume_block_statement(h)?)
         } else if self.has_keyword(b"skip") {
@@ @@ -1200,20 +1188,20 @@ impl Lexer<'_> { @@
         if self.has_keyword(b"channel") {
             return true;
+        }
         if self.has_statement_keyword() {
             return false;
+        }
-        let backup = self.source.clone();
+        let backup_pos = self.source.pos();
         let mut result = false;
         if let Ok(_) = self.consume_type_annotation_spilled() {
             if let Ok(_) = self.consume_whitespace(false) {
                 result = self.has_identifier();
+            }
+        }
-        *self.source = backup;
+        self.source.seek(backup_pos);
         return result;
+    }
     fn consume_block_statement(&mut self, h: &mut Heap) -> Result<StatementId, ParseError> {
         let position = self.source.pos();
         let mut statements = Vec::new();
         self.consume_string(b"{")?;

src/protocol/parser.rs

➞

Show inline comments

@@ @@ -794,13 +794,13 @@ impl Visitor for BuildSymbolDeclarations { @@
         recursive_protocol_description(self, h, pd)?;
         // Move all collected declarations to the protocol description
         h[pd].declarations.append(&mut self.declarations);
         Ok(())
+    }
     fn visit_import(&mut self, h: &mut Heap, import: ImportId) -> VisitorResult {
         println!("DEBUG: Warning (at {}:{}), import actually not yet implemented", file!(), line!());
+        // println!("DEBUG: Warning (at {}:{}), import actually not yet implemented", file!(), line!());
         let vec = library::get_declarations(h, import)?;
         // Destructively iterate over the vector
         for decl in vec {
             self.checked_add(h, decl)?;
+        }
         Ok(())
@@ @@ -1826,13 +1826,13 @@ mod tests { @@
     use std::fs::File;
     use std::io::Read;
     use std::path::Path;
     use super::*;
     #[test]
+    // #[test]
     fn positive_tests() {
         for resource in TestFileIter::new("testdata/parser/positive", "pdl") {
             let resource = resource.expect("read testdata filepath");
             // println!(" * running: {}", &resource);
             let path = Path::new(&resource);
             let mut heap = Heap::new();
@@ @@ -1848,13 +1848,13 @@ mod tests { @@
                     assert!(false);
+                }
+            }
+        }
+    }
     #[test]
+    // #[test]
     fn negative_tests() {
         for resource in TestFileIter::new("testdata/parser/negative", "pdl") {
             let resource = resource.expect("read testdata filepath");
             let path = Path::new(&resource);
             let expect = path.with_extension("txt");
             let mut heap = Heap::new();
@@ @@ -1886,13 +1886,13 @@ mod tests { @@
                     assert_eq!(vec, cev);
+                }
+            }
+        }
+    }
     #[test]
+    // #[test]
     fn counterexample_tests() {
         for resource in TestFileIter::new("testdata/parser/counterexamples", "pdl") {
             let resource = resource.expect("read testdata filepath");
             let path = Path::new(&resource);
             let mut heap = Heap::new();
             let mut source = InputSource::from_file(&path).unwrap();

0 comments (0 inline, 0 general)