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

Changeset - ce6477db7861

Parent rev.

Child rev.

[Not reviewed]

0 2 0

MH - 3 years ago 2022-02-04 18:11:51
contact@maxhenger.nl

WIP: More AST rewriting

2 files changed with 182 insertions and 6 deletions:

src/protocol/input_source.rs

src/protocol/parser/pass_rewriting.rs

180

0 comments (0 inline, 0 general)

src/protocol/input_source.rs

➞

Show inline comments

 use std::fmt;
 use std::sync::{RwLock, RwLockReadGuard};
 use std::fmt::Write;
 #[derive(Debug, Clone, Copy)]
 pub struct InputPosition {
     pub line: u32,
     pub offset: u32,
+}
 impl InputPosition {
     pub(crate) fn with_offset(&self, offset: u32) -> Self {
         InputPosition { line: self.line, offset: self.offset + offset }
+    }
+}
 #[derive(Debug, Clone, Copy)]
 pub struct InputSpan {
     pub begin: InputPosition,
     pub end: InputPosition,
+}
 impl InputSpan {
     // This will only be used for builtin functions
     // This must only be used if you're sure that the span will not be involved
     // in creating an error message.
     #[inline]
     pub fn new() -> InputSpan {
         InputSpan{ begin: InputPosition{ line: 0, offset: 0 }, end: InputPosition{ line: 0, offset: 0 }}
+    }
     #[inline]
     pub fn from_positions(begin: InputPosition, end: InputPosition) -> Self {
         Self { begin, end }
+    }
+}
 /// Wrapper around source file with optional filename. Ensures that the file is
 /// only scanned once.
 pub struct InputSource {
     pub(crate) filename: String,
     pub(crate) input: Vec<u8>,
     // Iteration
     line: u32,
     offset: usize,
     // State tracking
     pub(crate) had_error: Option<ParseError>,
     // The offset_lookup is built on-demand upon attempting to report an error.
     // Only one procedure will actually create the lookup, afterwards only read
     // locks will be held.
     offset_lookup: RwLock<Vec<u32>>,
+}
 impl InputSource {
     pub fn new(filename: String, input: Vec<u8>) -> Self {
         Self{
             filename,
             input,
             line: 1,
             offset: 0,
             had_error: None,
             offset_lookup: RwLock::new(Vec::new()),
+        }
+    }
     #[inline]
     pub fn pos(&self) -> InputPosition {
         InputPosition { line: self.line, offset: self.offset as u32 }
+    }
     pub fn next(&self) -> Option<u8> {
         if self.offset < self.input.len() {
             Some(self.input[self.offset])
         } else {
             None
+        }
+    }
     pub fn lookahead(&self, offset: usize) -> Option<u8> {
         let offset_pos = self.offset + offset;
         if offset_pos < self.input.len() {
             Some(self.input[offset_pos])
         } else {
             None
+        }
+    }
     #[inline]
     pub fn section_at_pos(&self, start: InputPosition, end: InputPosition) -> &[u8] {
         &self.input[start.offset as usize..end.offset as usize]
+    }
     #[inline]
     pub fn section_at_span(&self, span: InputSpan) -> &[u8] {
         &self.input[span.begin.offset as usize..span.end.offset as usize]
+    }
     // Consumes the next character. Will check well-formedness of newlines: \r
     // must be followed by a \n, because this is used for error reporting. Will
     // not check for ascii-ness of the file, better left to a tokenizer.
     pub fn consume(&mut self) {
         match self.next() {
             Some(b'\r') => {
                 if Some(b'\n') == self.lookahead(1) {
                     // Well formed file
                     self.offset += 1;
                 } else {
                     // Not a well-formed file, pretend like we can continue
                     self.offset += 1;
                     self.set_error("Encountered carriage-feed without a following newline");
+                }
             },
             Some(b'\n') => {
                 self.line += 1;
                 self.offset += 1;
             },
             Some(_) => {
                 self.offset += 1;
+            }
             None => {}
+        }
         // Maybe we actually want to check this in release mode. Then again:
         // a 4 gigabyte source file... Really?
         debug_assert!(self.offset < u32::max_value() as usize);
+    }
     fn set_error(&mut self, msg: &str) {
         if self.had_error.is_none() {
             self.had_error = Some(ParseError::new_error_str_at_pos(self, self.pos(), msg));
+        }
+    }
     fn get_lookup(&self) -> RwLockReadGuard<Vec<u32>> {
         // Once constructed the lookup always contains one element. We use this
         // to see if it is constructed already.
+        {
             let lookup = self.offset_lookup.read().unwrap();
             if !lookup.is_empty() {
                 return lookup;
+            }
+        }
         // Lookup was not constructed yet
         let mut lookup = self.offset_lookup.write().unwrap();
         if !lookup.is_empty() {
             // Somebody created it before we had the chance
             drop(lookup);
             let lookup = self.offset_lookup.read().unwrap();
             return lookup;
+        }
         // Build the line number (!) to offset lookup, so offset by 1. We
         // assume the entire source file is scanned (most common case) for
         // preallocation.
         lookup.reserve(self.line as usize + 2);
         lookup.push(0); // line 0: never used
         lookup.push(0); // first line: first character
         for char_idx in 0..self.input.len() {
             if self.input[char_idx] == b'\n' {
                 lookup.push(char_idx as u32 + 1);
+            }
+        }
         lookup.push(self.input.len() as u32 + 1); // for lookup_line_end, intentionally adding one character
         // Return created lookup
         drop(lookup);
         let lookup = self.offset_lookup.read().unwrap();
         return lookup;
+    }
     /// Retrieves offset at which line starts (right after newline)
     fn lookup_line_start_offset(&self, line_number: u32) -> u32 {
         let lookup = self.get_lookup();
         lookup[line_number as usize]
+    }
     /// Retrieves offset at which line ends (at the newline character or the
     /// preceding carriage feed for \r\n-encoded newlines)
     fn lookup_line_end_offset(&self, line_number: u32) -> u32 {
         let lookup = self.get_lookup();
         let offset = lookup[(line_number + 1) as usize] - 1;
         let offset_usize = offset as usize;
         // Compensate for newlines and a potential carriage feed. Note that the
         // end position is exclusive. So we only need to compensate for a
         // "\r\n"
         if offset_usize > 0 && offset_usize < self.input.len() && self.input[offset_usize] == b'\n' && self.input[offset_usize - 1] == b'\r' {
             offset - 1
         } else {
             offset
+        }
+    }
+}
 #[derive(Debug)]
 pub enum StatementKind {
     Info,
     Error
+}
 #[derive(Debug)]
 pub enum ContextKind {
     SingleLine,
     MultiLine,
+}
 #[derive(Debug)]
 pub struct ErrorStatement {
     pub(crate) statement_kind: StatementKind,
     pub(crate) context_kind: ContextKind,
     pub(crate) start_line: u32,
     pub(crate) start_column: u32,
     pub(crate) end_line: u32,
     pub(crate) end_column: u32,
     pub(crate) filename: String,
     pub(crate) context: String,
     pub(crate) message: String,
+}
 impl ErrorStatement {
     fn from_source_at_pos(statement_kind: StatementKind, source: &InputSource, position: InputPosition, message: String) -> Self {
         // Seek line start and end
         let line_start = source.lookup_line_start_offset(position.line);
         let line_end = source.lookup_line_end_offset(position.line);
         let context = Self::create_context(source, line_start as usize, line_end as usize);
         debug_assert!(position.offset >= line_start);
         let column = position.offset - line_start + 1;
         Self{
             statement_kind,
             context_kind: ContextKind::SingleLine,
             start_line: position.line,
             start_column: column,
             end_line: position.line,
             end_column: column + 1,
             filename: source.filename.clone(),
             context,
             message,
+        }
+    }
     pub(crate) fn from_source_at_span(statement_kind: StatementKind, source: &InputSource, span: InputSpan, message: String) -> Self {
         debug_assert!(span.end.line >= span.begin.line);
         debug_assert!(span.end.offset >= span.begin.offset);
         let first_line_start = source.lookup_line_start_offset(span.begin.line);
         let last_line_start = source.lookup_line_start_offset(span.end.line);
         let last_line_end = source.lookup_line_end_offset(span.end.line);
         let context = Self::create_context(source, first_line_start as usize, last_line_end as usize);
         debug_assert!(span.begin.offset >= first_line_start);
         let start_column = span.begin.offset - first_line_start + 1;
         let end_column = span.end.offset - last_line_start + 1;
         let context_kind = if span.begin.line == span.end.line {
             ContextKind::SingleLine
         } else {
             ContextKind::MultiLine
         };
         Self{
             statement_kind,
             context_kind,
             start_line: span.begin.line,
             start_column,
             end_line: span.end.line,
             end_column,
             filename: source.filename.clone(),
             context,
             message,
+        }
+    }
     /// Produces context from source
     fn create_context(source: &InputSource, start: usize, end: usize) -> String {
         let context_raw = &source.input[start..end];
         String::from_utf8_lossy(context_raw).to_string()
+    }
+}
 impl fmt::Display for ErrorStatement {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         // Write kind of statement and message
         match self.statement_kind {
             StatementKind::Info => f.write_str(" INFO: ")?,
             StatementKind::Error => f.write_str("ERROR: ")?,
+        }
         f.write_str(&self.message)?;
         f.write_char('\n')?;
         // Write originating file/line/column
         f.write_str(" +- ")?;
         if !self.filename.is_empty() {
             write!(f, "in {} ", self.filename)?;
+        }
         match self.context_kind {
             ContextKind::SingleLine => writeln!(f, " at {}:{}", self.start_line, self.start_column),
             ContextKind::MultiLine => writeln!(
                 f, " from {}:{} to {}:{}",
                 self.start_line, self.start_column, self.end_line, self.end_column
+            )
         }?;
         // Helper function for writing context: converting tabs into 4 spaces
         // (oh, the controversy!) and creating an annotated line
         fn transform_context(source: &str, target: &mut String) {
             for char in source.chars() {
                 if char == '\t' {
                     target.push_str("    ");
                 } else {
                     target.push(char);
+                }
+            }
+        }
         fn extend_annotation(first_col: u32, last_col: u32, source: &str, target: &mut String, extend_char: char) {
             debug_assert!(first_col > 0 && last_col > first_col);
             // If the first index exceeds the size of the context then we should
             // have a message placed at the newline character
             let first_idx = first_col as usize - 1;
             let last_idx = last_col as usize - 1;
             if first_idx >= source.len() {
                 // If any of these fail then the logic behind reporting errors
                 // is incorrect.
                 debug_assert_eq!(first_idx, source.len());
                 debug_assert_eq!(first_idx + 1, last_idx);
                 target.push(extend_char);
             } else {
                 for (char_idx, char) in source.chars().enumerate().skip(first_idx) {
                     if char_idx == last_idx as usize {
                         break;
+                    }
                     if char == '\t' {
                         for _ in 0..4 { target.push(extend_char); }
                     } else {
                         target.push(extend_char);
+                    }
+                }
+            }
+        }
         // Write source context
         writeln!(f, " | ")?;
         let mut context = String::with_capacity(128);
         let mut annotation = String::with_capacity(128);
         match self.context_kind {
             ContextKind::SingleLine => {
                 // Write single line of context with indicator for the offending
                 // span underneath.
                 context.push_str(" |  ");
                 transform_context(&self.context, &mut context);
                 context.push('\n');
                 f.write_str(&context)?;
                 annotation.push_str(" | ");
                 extend_annotation(1, self.start_column + 1, &self.context, &mut annotation, ' ');
                 extend_annotation(self.start_column, self.end_column, &self.context, &mut annotation, '~');
                 annotation.push('\n');
                 f.write_str(&annotation)?;
             },
             ContextKind::MultiLine => {
                 // Annotate all offending lines
                 // - first line
                 let mut lines = self.context.lines();
                 let first_line = lines.next().unwrap();
                 transform_context(first_line, &mut context);
                 writeln!(f, " |- {}", &context)?;
                 // - remaining lines
                 let mut last_line = first_line;
                 while let Some(cur_line) = lines.next() {
                     context.clear();
                     transform_context(cur_line, &mut context);
                     writeln!(f, " |  {}", &context)?;
                     last_line = cur_line;
+                }
                 // - underline beneath last line
                 annotation.push_str(" \\__");
                 extend_annotation(1, self.end_column, &last_line, &mut annotation, '_');
                 annotation.push_str("/\n");
                 f.write_str(&annotation)?;
+            }
+        }
         Ok(())
+    }
+}
 #[derive(Debug)]
 pub struct ParseError {
     pub(crate) statements: Vec<ErrorStatement>
+}
 impl fmt::Display for ParseError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         if self.statements.is_empty() {
             return Ok(())
+        }
         self.statements[0].fmt(f)?;
         for statement in self.statements.iter().skip(1) {
             writeln!(f)?;
             statement.fmt(f)?;
+        }
         Ok(())
+    }
+}
 impl ParseError {
     pub fn new_error_at_pos(source: &InputSource, position: InputPosition, message: String) -> Self {
         Self{ statements: vec!(ErrorStatement::from_source_at_pos(
             StatementKind::Error, source, position, message
         )) }
+    }
     pub fn new_error_str_at_pos(source: &InputSource, position: InputPosition, message: &str) -> Self {
         Self{ statements: vec!(ErrorStatement::from_source_at_pos(
             StatementKind::Error, source, position, message.to_string()
         )) }
+    }
     pub fn new_error_at_span(source: &InputSource, span: InputSpan, message: String) -> Self {
         Self{ statements: vec!(ErrorStatement::from_source_at_span(
             StatementKind::Error, source, span, message
         )) }
+    }
     pub fn new_error_str_at_span(source: &InputSource, span: InputSpan, message: &str) -> Self {
         Self{ statements: vec!(ErrorStatement::from_source_at_span(
             StatementKind::Error, source, span, message.to_string()
         )) }
+    }
     pub fn with_at_span(mut self, error_type: StatementKind, source: &InputSource, span: InputSpan, message: String) -> Self {
         self.statements.push(ErrorStatement::from_source_at_span(error_type, source, span, message.to_string()));
         self
+    }
     pub fn with_info_at_span(self, source: &InputSource, span: InputSpan, msg: String) -> Self {
         self.with_at_span(StatementKind::Info, source, span, msg)
+    }
     pub fn with_info_str_at_pos(self, source: &InputSource, pos: InputPosition, msg: &str) -> Self {
         self.with_at_span(
             StatementKind::Info, source,
             InputSpan::from_positions(pos, pos.with_offset(1)),
             msg.to_string()
+        )
+    }
     pub fn with_info_str_at_span(self, source: &InputSource, span: InputSpan, msg: &str) -> Self {
         self.with_at_span(StatementKind::Info, source, span, msg.to_string())
+    }
+}

src/protocol/parser/pass_rewriting.rs

➞

Show inline comments

 // TODO: File contains a lot of manual AST element construction. Wherein we have
 //  (for the first time in this compiler) a lot of fields that have no real
 //  meaning (e.g. the InputSpan of a AST-transformation). What are we going to
 //  do with this to make the code and datastructures more easily grokable?
 //  We could do an intermediate AST structure. But considering how close this
 //  phase of compilation is to bytecode generation, that might be a lot of busy-
 //  work with few results. Alternatively we may put the AST elements inside
 //  a special substructure. We could also force ourselves (and put the
 //  appropriate comments in the code) to not use certain fields anymore after
 //  a particular stage of compilation.
 use crate::collections::*;
 use crate::protocol::*;
 use super::visitor::*;
 pub(crate) struct PassRewriting {
     current_scope: BlockStatementId,
     statement_buffer: ScopedBuffer<StatementId>,
     call_expr_buffer: ScopedBuffer<CallExpressionId>,
     expression_buffer: ScopedBuffer<ExpressionId>,
+}
 impl PassRewriting {
     pub(crate) fn new() -> Self {
         Self{
             current_scope: BlockStatementId::new_invalid(),
             statement_buffer: ScopedBuffer::with_capacity(16),
             call_expr_buffer: ScopedBuffer::with_capacity(16),
             expression_buffer: ScopedBuffer::with_capacity(16),
+        }
+    }
+}
 impl Visitor for PassRewriting {
     // --- Visiting procedures
     fn visit_component_definition(&mut self, ctx: &mut Ctx, id: ComponentDefinitionId) -> VisitorResult {
         let def = &ctx.heap[id];
         let body_id = def.body;
         return self.visit_block_stmt(ctx, body_id);
+    }
     fn visit_function_definition(&mut self, ctx: &mut Ctx, id: FunctionDefinitionId) -> VisitorResult {
         let def = &ctx.heap[id];
         let body_id = def.body;
         return self.visit_block_stmt(ctx, body_id);
+    }
     // --- Visiting statements (that are not the select statement)
     fn visit_block_stmt(&mut self, ctx: &mut Ctx, id: BlockStatementId) -> VisitorResult {
         let block_stmt = &ctx.heap[id];
         let stmt_section = self.statement_buffer.start_section_initialized(&block_stmt.statements);
         self.current_scope = id;
         for stmt_idx in 0..stmt_section.len() {
             self.visit_stmt(ctx, stmt_section[stmt_idx])?;
+        }
         stmt_section.forget();
         return Ok(())
+    }
     fn visit_labeled_stmt(&mut self, ctx: &mut Ctx, id: LabeledStatementId) -> VisitorResult {
         let labeled_stmt = &ctx.heap[id];
         let body_id = labeled_stmt.body;
         return self.visit_stmt(ctx, body_id);
+    }
     fn visit_if_stmt(&mut self, ctx: &mut Ctx, id: IfStatementId) -> VisitorResult {
         let if_stmt = &ctx.heap[id];
         let true_body_id = if_stmt.true_body;
         let false_body_id = if_stmt.false_body;
         self.visit_block_stmt(ctx, true_body_id)?;
         if let Some(false_body_id) = false_body_id {
             self.visit_block_stmt(ctx, false_body_id)?;
+        }
         return Ok(())
+    }
     fn visit_while_stmt(&mut self, ctx: &mut Ctx, id: WhileStatementId) -> VisitorResult {
         let while_stmt = &ctx.heap[id];
         let body_id = while_stmt.body;
         return self.visit_block_stmt(ctx, body_id);
+    }
     fn visit_synchronous_stmt(&mut self, ctx: &mut Ctx, id: SynchronousStatementId) -> VisitorResult {
         let sync_stmt = &ctx.heap[id];
         let body_id = sync_stmt.body;
         return self.visit_block_stmt(ctx, body_id);
+    }
     // --- Visiting the select statement
     fn visit_select_stmt(&mut self, ctx: &mut Ctx, id: SelectStatementId) -> VisitorResult {
         // We're going to transform the select statement by a block statement
         // containing builtin runtime-calls. And to do so we create temporary
         // variables and move some other statements around.
         let select_stmt = &ctx.heap[id];
         let mut total_num_cases = select_stmt.cases.len();
         let mut total_num_ports = 0;
         // Put heap IDs into temporary buffers to handle borrowing rules
         let mut call_id_section = self.call_expr_buffer.start_section();
         let mut expr_id_section = self.expression_buffer.start_section();
         for case in select_stmt.cases.iter() {
             total_num_ports += case.involved_ports.len();
             for (call_id, expr_id) in case.involved_ports.iter().copied() {
                 call_id_section.push(call_id);
                 expr_id_section.push(expr_id);
+            }
+        }
         // Transform all of the call expressions by takings its argument (the
         // port from which we `get`) and turning it into a temporary variable.
         let mut transformed_stmts = Vec::with_capacity(total_num_ports); // TODO: Recompute this preallocated length, put assert at the end
         let mut locals = Vec::with_capacity(total_num_ports);
         for port_var_idx in 0..call_id_section.len() {
             let call_id = call_id_section[port_var_idx];
             let expr_id = expr_id_section[port_var_idx];
             let (replacement_variable_id, variable_stmt_id) = self.modify_call_and_create_replacement_variable(ctx, call_id, expr_id);
             transformed_stmts.push(variable_stmt_id);
             let (replacement_variable_id, variable_stmt_id) = self.modify_get_call_insert_variable(ctx, call_id, expr_id);
             transformed_stmts.push(variable_stmt_id.upcast().upcast());
             locals.push(replacement_variable_id);
+        }
         // Our transformed statements now contain all of the temporary port
         // calculations. We'll now insert the appropriate runtime calls to
         // notify the runtime that we're going to wait on these ports.
         let (_, select_start_stmt_id) = self.create_runtime_select_start_call_statement(ctx, total_num_cases, total_num_ports);
         transformed_stmts.push(select_start_stmt_id.upcast());
         // TODO: Call the runtime function for eeach of the substituted port variables to register all ports for the select statement
         call_id_section.forget();
         expr_id_section.forget();
         // let block = ctx.heap.alloc_block_statement(|this| BlockStatement{
         //     this,
         //     is_implicit: true,
         //     span: stmt.span,
         //     statements: vec![],
         //     end_block: EndBlockStatementId(),
         //     scope_node: ScopeNode {},
         //     first_unique_id_in_scope: 0,
         //     next_unique_id_in_scope: 0,
         //     locals,
         //     labels: vec![],
         //     next: ()
         // });
         return Ok(())
+    }
+}
 impl PassRewriting {
-    fn modify_call_and_create_replacement_variable(&self, ctx: &mut Ctx, call_expr_id: CallExpressionId, port_expr_id: ExpressionId) -> (VariableId, MemoryStatementId) {
+    fn modify_get_call_insert_variable(&self, ctx: &mut Ctx, call_expr_id: CallExpressionId, port_expr_id: ExpressionId) -> (VariableId, MemoryStatementId) {
         // Retrieve original expression which we're going to transplant into
         // its own variable
         let port_expr = &ctx.heap[port_expr_id];
         let port_expr_span = port_expr.full_span();
         let port_expr_unique_id = port_expr.get_unique_id_in_definition();
         // Create the entries in the heap
         let variable_expr_id = ctx.heap.alloc_variable_expression(|this| VariableExpression{
             this,
             identifier: Identifier::new_empty(port_expr_span),
             declaration: None,
             used_as_binding_target: false,
             parent: ExpressionParent::None,
             unique_id_in_definition: port_expr_unique_id,
         });
         let initial_expr_id = ctx.heap.alloc_assignment_expression(|this| AssignmentExpression{
             this,
             operator_span: port_expr_span,
             full_span: port_expr_span,
             left: variable_expr_id.upcast(),
             operation: AssignmentOperator::Set,
             right: port_expr_id,
             parent: ExpressionParent::None,
             unique_id_in_definition: -1,
         });
         let variable_id = ctx.heap.alloc_variable(|this| Variable{
             this,
             kind: VariableKind::Local,
             parser_type: ParserType{ elements: vec![ParserTypeElement{
                     element_span: port_expr_span,
                     variant: ParserTypeVariant::Inferred,
                 }],
                 full_span: port_expr_span
             },
             identifier: Identifier::new_empty(port_expr_span),
             relative_pos_in_block: 0,
             unique_id_in_scope: 0,
             relative_pos_in_block: -1,
             unique_id_in_scope: -1,
         });
         let variable_decl_stmt = ctx.heap.alloc_memory_statement(|this| MemoryStatement{
             this,
             span: port_expr_span,
             variable: variable_id,
             initial_expr: initial_expr_id,
             next: StatementId::new_invalid(),
         });
         // Modify all entries that required access other heap entries
         let variable_expr = &mut ctx.heap[variable_expr_id];
         variable_expr.declaration = Some(variable_id);
         variable_expr.parent = ExpressionParent::Expression(initial_expr_id.upcast(), 1);
         let initial_expr = &mut ctx.heap[initial_expr_id];
         initial_expr.parent = ExpressionParent::Memory(variable_decl_stmt);
         // Modify the parent of the expression that we just transplanted
         let port_expr = &mut ctx.heap[port_expr_id];
         *port_expr.parent_mut() = ExpressionParent::Expression(initial_expr_id.upcast(), 1);
         // Modify the call expression (that should contain the port expression
         // as the first argument) to point to the new variable
         let call_arg_expr_id = ctx.heap.alloc_variable_expression(|this| VariableExpression{
             this,
             identifier: Identifier::new_empty(port_expr_span),
             declaration: Some(variable_id),
             used_as_binding_target: false,
             parent: ExpressionParent::Expression(call_expr_id.upcast(), 0),
             unique_id_in_definition: port_expr_unique_id,
         });
         let call_expr = &mut ctx.heap[call_expr_id];
         debug_assert_eq!(call_expr.method, Method::Get);
         debug_assert!(call_expr.arguments.len() == 1 && call_expr.arguments[0] == port_expr_id);
         call_expr.arguments[0] = call_arg_expr_id.upcast();
         return (variable_id, variable_decl_stmt);
+    }
     fn create_runtime_call_statement(&self, ctx: &mut Ctx, method: Method, arguments: Vec<ExpressionId>) -> (CallExpressionId, ExpressionStatementId) {
         let call_expr_id = ctx.heap.alloc_call_expression(|this| CallExpression{
             this,
             func_span: InputSpan::new(),
             full_span: InputSpan::new(),
             parser_type: ParserType{
                 elements: Vec::new(),
                 full_span: InputSpan::new(),
             },
             method,
             arguments,
             definition: DefinitionId::new_invalid(),
             parent: ExpressionParent::None,
             unique_id_in_definition: -1,
         });
         let call_stmt_id = ctx.heap.alloc_expression_statement(|this| ExpressionStatement{
             this,
             span: InputSpan::new(),
             expression: call_expr_id.upcast(),
             next: StatementId::new_invalid(),
         });
         let call_expr = &mut ctx.heap[call_expr_id];
         call_expr.parent = ExpressionParent::ExpressionStmt(call_stmt_id);
         return (call_expr_id, call_stmt_id);
+    }
     fn create_runtime_select_start_call_statement(&self, ctx: &mut Ctx, num_cases: usize, num_ports_total: usize) -> (CallExpressionId, ExpressionStatementId) {
         let num_cases_expr_id = self.create_literal_integer(ctx, num_cases as u64);
         let num_ports_expr_id = self.create_literal_integer(ctx, num_ports_total as u64);
         let arguments = vec![
             num_cases_expr_id.upcast(),
             num_ports_expr_id.upcast()
         ];
         let (call_expr_id, call_stmt_id) = self.create_runtime_call_statement(ctx, Method::SelectStart, arguments);
         let num_cases_expr = &mut ctx.heap[num_cases_expr_id];
         num_cases_expr.parent = ExpressionParent::Expression(call_expr_id.upcast(), 0);
         let num_ports_expr = &mut ctx.heap[num_ports_expr_id];
         num_ports_expr.parent = ExpressionParent::Expression(num_ports_expr_id.upcast(), 1);
         return (call_expr_id, call_stmt_id);
+    }
     fn create_runtime_select_register_port_call_statement(&self, ctx: &mut Ctx, case_index: usize, port_index: usize, original_port_expr_id: ExpressionId, port_variable_id: VariableId) -> (CallExpressionId, ExpressionStatementId) {
         let original_port_expr = &ctx.heap[original_port_expr_id];
         let original_port_span = original_port_expr.full_span();
         let original_port_unique_id = original_port_expr.get_unique_id_in_definition();
         let case_index_expr_id = self.create_literal_integer(ctx, case_index as u64);
         let port_index_expr_id = self.create_literal_integer(ctx, port_index as u64);
         let port_var_expr_id = self.create_variable_expr(ctx, port_variable_id);
         let arguments = vec![
             case_index_expr_id.upcast(),
             port_index_expr_id.upcast(),
             port_var_expr_id.upcast()
         ];
         let (call_expr_id, call_stmt_id) = self.create_runtime_call_statement(ctx, Method::SelectRegisterCasePort, arguments);
         let case_index_expr = &mut ctx.heap[case_index_expr_id];
         case_index_expr.parent = ExpressionParent::Expression(call_expr_id.upcast(), 0);
         let port_index_expr = &mut ctx.heap[port_index_expr_id];
         port_index_expr.parent = ExpressionParent::Expression(call_expr_id.upcast(), 1);
         let port_var_expr = &mut ctx.heap[port_var_expr_id];
         port_var_expr.parent = ExpressionParent::Expression(call_expr_id.upcast(), 2);
         return (call_expr_id, call_stmt_id);
+    }
     fn create_runtime_select_wait_variable_and_statement(&self, ctx: &mut Ctx) -> (VariableId, MemoryStatementId) {
         let variable_id = ctx.heap.alloc_variable(|this| Variable{
             this,
             kind: VariableKind::Local,
             parser_type: ParserType{
                 elements: Vec::new(),
                 full_span: InputSpan::new(),
             },
             identifier: Identifier::new_empty(InputSpan::new()),
             relative_pos_in_block: -1,
             unique_id_in_scope: -1
         });
         let variable_expr_id = self.create_variable_expr(ctx, variable_id);
         let runtime_call_expr_id = ctx.heap.alloc_call_expression(|this| CallExpression{
             this,
             func_span: InputSpan::new(),
             full_span: InputSpan::new(),
             parser_type: ParserType{
                 elements: Vec::new(),
                 full_span: InputSpan::new(),
             },
             method: Method::SelectWait,
             arguments: Vec::new(),
             definition: DefinitionId::new_invalid(),
             parent: ExpressionParent::None,
             unique_id_in_definition: -1
         });
         let initial_expr_id = ctx.heap.alloc_assignment_expression(|this| AssignmentExpression{
             this,
             operator_span: InputSpan::new(),
             full_span: InputSpan::new(),
             left: variable_expr_id.upcast(),
             operation: AssignmentOperator::Set,
             right: runtime_call_expr_id.upcast(),
             parent: ExpressionParent::None,
             unique_id_in_definition: -1
         });
         let variable_statement_id = ctx.heap.alloc_memory_statement(|this| MemoryStatement{
             this,
             span: InputSpan::new(),
             variable: variable_id,
             initial_expr: initial_expr_id,
             next: StatementId::new_invalid()
         });
         let variable_expr = &mut ctx.heap[variable_expr_id];
         variable_expr.parent = ExpressionParent::Expression(initial_expr_id.upcast(), 0);
         let runtime_call_expr = &mut ctx.heap[runtime_call_expr_id];
         runtime_call_expr.parent = ExpressionParent::Expression(initial_expr_id.upcast(), 1);
         let initial_expr = &mut ctx.heap[initial_expr_id];
         initial_expr.parent = ExpressionParent::Memory(variable_statement_id);
         return (variable_id, variable_statement_id);
+    }
     /// Creates an integer literal. The caller still needs to set its expression
     /// parent afterwards.
     fn create_literal_integer(&self, ctx: &mut Ctx, value: u64) -> LiteralExpressionId {
         return ctx.heap.alloc_literal_expression(|this| LiteralExpression{
             this,
             span: InputSpan::new(),
             value: Literal::Integer(LiteralInteger{
                 unsigned_value: value,
                 negated: false,
             }),
             parent: ExpressionParent::None,
             unique_id_in_definition: -1
         });
+    }
     fn create_variable_expr(&self, ctx: &mut Ctx, variable_id: VariableId) -> VariableExpressionId {
         return ctx.heap.alloc_variable_expression(|this| VariableExpression{
             this,
             identifier: Identifier::new_empty(InputSpan::new()),
             declaration: Some(variable_id),
             used_as_binding_target: false,
             parent: ExpressionParent::None,
             unique_id_in_definition: -1
         })
+    }
+}
@@ \ No newline at end of file @@

0 comments (0 inline, 0 general)