Changeset - 48a151ff33b5
Parent rev.
Child rev.
[Not reviewed]
0 3 0
mh - 3 years ago 2022-02-11 09:38:59
contact@maxhenger.nl
Moved scope creation to initial AST construction
3 files changed with 129 insertions and 125 deletions:
src/protocol/ast.rs
16
src/protocol/parser/pass_definitions.rs
72
53
src/protocol/parser/pass_validation_linking.rs
41
72
0 comments (0 inline, 0 general)
src/protocol/ast.rs
➞
Show inline comments
 
@@ -734,12 +734,28 @@ pub struct Scope {
 
    // Location trackers/counters
 
    pub relative_pos_in_parent: i32,
 
    pub first_unique_id_in_scope: i32,
 
    pub next_unique_id_in_scope: i32,
 
}
 

			




	
	
	
		
 
impl Scope {

			




	
	
	
		
 
    pub(crate) fn new(id: ScopeId, association: ScopeAssociation) -> Self {

			




	
	
	
		
 
        return Self{

			




	
	
	
		
 
            this: id,

			




	
	
	
		
 
            parent: None,

			




	
	
	
		
 
            nested: Vec::new(),

			




	
	
	
		
 
            association,

			




	
	
	
		
 
            variables: Vec::new(),

			




	
	
	
		
 
            labels: Vec::new(),

			




	
	
	
		
 
            relative_pos_in_parent: -1,

			




	
	
	
		
 
            first_unique_id_in_scope: -1,

			




	
	
	
		
 
            next_unique_id_in_scope: -1,

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
impl Scope {

			




	
	
	
		
 
    pub(crate) fn new_invalid(this: ScopeId) -> Self {

			




	
	
	
		
 
        return Self{

			




	
	
	
		
 
            this,

			




	
	
	
		
 
            parent: None,

			




	
	
	
		
 
            nested: Vec::new(),

			




        

    


    
    

    

        

                

                    src/protocol/parser/pass_definitions.rs
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -336,54 +336,24 @@ impl PassDefinitions {

			




	
	
	
		
 
        } else if next == TokenKind::Ident {

			




	
	
	
		
 
            let ident = peek_ident(&module.source, iter).unwrap();

			




	
	
	
		
 
            if ident == KW_STMT_IF {

			




	
	
	
		
 
                // Consume if statement and place end-if statement directly

			




	
	
	
		
 
                // after it.

			




	
	
	
		
 
                let id = self.consume_if_statement(module, iter, ctx)?;

			




	
	
	
		
 

			




	
	
	
		
 
                let end_if = ctx.heap.alloc_end_if_statement(|this| EndIfStatement {

			




	
	
	
		
 
                    this,

			




	
	
	
		
 
                    start_if: id,

			




	
	
	
		
 
                    next: StatementId::new_invalid()

			




	
	
	
		
 
                });

			




	
	
	
		
 

			




	
	
	
		
 
                let if_stmt = &mut ctx.heap[id];

			




	
	
	
		
 
                if_stmt.end_if = end_if;

			




	
	
	
		
 

			




	
	
	
		
 
                return Ok(id.upcast());

			




	
	
	
		
 
            } else if ident == KW_STMT_WHILE {

			




	
	
	
		
 
                let id = self.consume_while_statement(module, iter, ctx)?;

			




	
	
	
		
 

			




	
	
	
		
 
                let end_while = ctx.heap.alloc_end_while_statement(|this| EndWhileStatement {

			




	
	
	
		
 
                    this,

			




	
	
	
		
 
                    start_while: id,

			




	
	
	
		
 
                    next: StatementId::new_invalid()

			




	
	
	
		
 
                });

			




	
	
	
		
 

			




	
	
	
		
 
                let while_stmt = &mut ctx.heap[id];

			




	
	
	
		
 
                while_stmt.end_while = end_while;

			




	
	
	
		
 

			




	
	
	
		
 
                return Ok(id.upcast());

			




	
	
	
		
 
            } else if ident == KW_STMT_BREAK {

			




	
	
	
		
 
                let id = self.consume_break_statement(module, iter, ctx)?;

			




	
	
	
		
 
                return Ok(id.upcast());

			




	
	
	
		
 
            } else if ident == KW_STMT_CONTINUE {

			




	
	
	
		
 
                let id = self.consume_continue_statement(module, iter, ctx)?;

			




	
	
	
		
 
                return Ok(id.upcast());

			




	
	
	
		
 
            } else if ident == KW_STMT_SYNC {

			




	
	
	
		
 
                let id = self.consume_synchronous_statement(module, iter, ctx)?;

			




	
	
	
		
 

			




	
	
	
		
 
                let end_sync = ctx.heap.alloc_end_synchronous_statement(|this| EndSynchronousStatement {

			




	
	
	
		
 
                    this,

			




	
	
	
		
 
                    start_sync: id,

			




	
	
	
		
 
                    next: StatementId::new_invalid()

			




	
	
	
		
 
                });

			




	
	
	
		
 

			




	
	
	
		
 
                let sync_stmt = &mut ctx.heap[id];

			




	
	
	
		
 
                sync_stmt.end_sync = end_sync;

			




	
	
	
		
 

			




	
	
	
		
 
                return Ok(id.upcast());

			




	
	
	
		
 
            } else if ident == KW_STMT_FORK {

			




	
	
	
		
 
                let id = self.consume_fork_statement(module, iter, ctx)?;

			




	
	
	
		
 

			




	
	
	
		
 
                let end_fork = ctx.heap.alloc_end_fork_statement(|this| EndForkStatement {

			




	
	
	
		
 
                    this,

			




	
	
		
 
@@ -394,22 +364,12 @@ impl PassDefinitions {

			




	
	
	
		
 
                let fork_stmt = &mut ctx.heap[id];

			




	
	
	
		
 
                fork_stmt.end_fork = end_fork;

			




	
	
	
		
 

			




	
	
	
		
 
                return Ok(id.upcast());

			




	
	
	
		
 
            } else if ident == KW_STMT_SELECT {

			




	
	
	
		
 
                let id = self.consume_select_statement(module, iter, ctx)?;

			




	
	
	
		
 

			




	
	
	
		
 
                let end_select = ctx.heap.alloc_end_select_statement(|this| EndSelectStatement{

			




	
	
	
		
 
                    this,

			




	
	
	
		
 
                    start_select: id,

			




	
	
	
		
 
                    next: StatementId::new_invalid(),

			




	
	
	
		
 
                });

			




	
	
	
		
 

			




	
	
	
		
 
                let select_stmt = &mut ctx.heap[id];

			




	
	
	
		
 
                select_stmt.end_select = end_select;

			




	
	
	
		
 

			




	
	
	
		
 
                return Ok(id.upcast());

			




	
	
	
		
 
            } else if ident == KW_STMT_RETURN {

			




	
	
	
		
 
                let id = self.consume_return_statement(module, iter, ctx)?;

			




	
	
	
		
 
                return Ok(id.upcast());

			




	
	
	
		
 
            } else if ident == KW_STMT_GOTO {

			




	
	
	
		
 
                let id = self.consume_goto_statement(module, iter, ctx)?;

			




	
	
		
 
@@ -469,45 +429,47 @@ impl PassDefinitions {

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        let statements = stmt_section.into_vec();

			




	
	
	
		
 
        let mut block_span = consume_token(&module.source, iter, TokenKind::CloseCurly)?;

			




	
	
	
		
 
        block_span.begin = open_curly_span.begin;

			




	
	
	
		
 

			




	
	
	
		
 
        let id = ctx.heap.alloc_block_statement(|this| BlockStatement{

			




	
	
	
		
 
        let block_id = ctx.heap.alloc_block_statement(|this| BlockStatement{

			




	
	
	
		
 
            this,

			




	
	
	
		
 
            is_implicit: false,

			




	
	
	
		
 
            span: block_span,

			




	
	
	
		
 
            statements,

			




	
	
	
		
 
            end_block: EndBlockStatementId::new_invalid(),

			




	
	
	
		
 
            scope: ScopeId::new_invalid(),

			




	
	
	
		
 
            next: StatementId::new_invalid(),

			




	
	
	
		
 
        });

			




	
	
	
		
 
        let scope_id = ctx.heap.alloc_scope(|this| Scope::new(this, ScopeAssociation::Block(block_id)));

			




	
	
	
		
 

			




	
	
	
		
 
        let end_block = ctx.heap.alloc_end_block_statement(|this| EndBlockStatement{

			




	
	
	
		
 
            this, start_block: id, next: StatementId::new_invalid()

			




	
	
	
		
 
        let end_block_id = ctx.heap.alloc_end_block_statement(|this| EndBlockStatement{

			




	
	
	
		
 
            this, start_block: block_id, next: StatementId::new_invalid()

			




	
	
	
		
 
        });

			




	
	
	
		
 

			




	
	
	
		
 
        let block_stmt = &mut ctx.heap[id];

			




	
	
	
		
 
        block_stmt.end_block = end_block;

			




	
	
	
		
 
        let block_stmt = &mut ctx.heap[block_id];

			




	
	
	
		
 
        block_stmt.end_block = end_block_id;

			




	
	
	
		
 
        block_stmt.scope = scope_id;

			




	
	
	
		
 

			




	
	
	
		
 
        Ok(id)

			




	
	
	
		
 
        Ok(block_id)

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    fn consume_if_statement(

			




	
	
	
		
 
        &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx

			




	
	
	
		
 
    ) -> Result<IfStatementId, ParseError> {

			




	
	
	
		
 
        let if_span = consume_exact_ident(&module.source, iter, KW_STMT_IF)?;

			




	
	
	
		
 
        consume_token(&module.source, iter, TokenKind::OpenParen)?;

			




	
	
	
		
 
        let test = self.consume_expression(module, iter, ctx)?;

			




	
	
	
		
 
        consume_token(&module.source, iter, TokenKind::CloseParen)?;

			




	
	
	
		
 

			




	
	
	
		
 
        // Consume bodies of if-statement

			




	
	
	
		
 
        let true_body = IfStatementCase{

			




	
	
	
		
 
            body: self.consume_statement(module, iter, ctx)?,

			




	
	
	
		
 
            scope: ScopeId::new_invalid(),

			




	
	
	
		
 
        };

			




	
	
	
		
 
        let true_body_scope_id = true_body.scope;

			




	
	
	
		
 

			




	
	
	
		
 
        let (false_body, false_body_scope_id) = if has_ident(&module.source, iter, KW_STMT_ELSE) {

			




	
	
	
		
 
            iter.consume();

			




	
	
	
		
 
            let false_body = IfStatementCase{

			




	
	
	
		
 
                body: self.consume_statement(module, iter, ctx)?,

			




	
	
	
		
 
                scope: ScopeId::new_invalid(),

			




	
	
		
 
@@ -516,20 +478,35 @@ impl PassDefinitions {

			




	
	
	
		
 
            let false_body_scope_id = false_body.scope;

			




	
	
	
		
 
            (Some(false_body), Some(false_body_scope_id))

			




	
	
	
		
 
        } else {

			




	
	
	
		
 
            (None, None)

			




	
	
	
		
 
        };

			




	
	
	
		
 

			




	
	
	
		
 
        // Construct AST elements

			




	
	
	
		
 
        let if_stmt_id = ctx.heap.alloc_if_statement(|this| IfStatement{

			




	
	
	
		
 
            this,

			




	
	
	
		
 
            span: if_span,

			




	
	
	
		
 
            test,

			




	
	
	
		
 
            true_case: true_body,

			




	
	
	
		
 
            false_case: false_body,

			




	
	
	
		
 
            end_if: EndIfStatementId::new_invalid(),

			




	
	
	
		
 
        });

			




	
	
	
		
 
        let end_if_stmt_id = ctx.heap.alloc_end_if_statement(|this| EndIfStatement{

			




	
	
	
		
 
            this,

			




	
	
	
		
 
            start_if: if_stmt_id,

			




	
	
	
		
 
            next: StatementId::new_invalid(),

			




	
	
	
		
 
        });

			




	
	
	
		
 
        let true_scope_id = ctx.heap.alloc_scope(|this| Scope::new(this, ScopeAssociation::If(if_stmt_id, true)));

			




	
	
	
		
 

			




	
	
	
		
 
        let if_stmt = &mut ctx.heap[if_stmt_id];

			




	
	
	
		
 
        if_stmt.end_if = end_if_stmt_id;

			




	
	
	
		
 
        if_stmt.true_case.scope = true_scope_id;

			




	
	
	
		
 
        if let Some(false_case) = &mut if_stmt.false_case {

			




	
	
	
		
 
            let false_scope_id = ctx.heap.alloc_scope(|this| Scope::new(this, ScopeAssociation::If(if_stmt_id, false)));

			




	
	
	
		
 
            false_case.scope = false_scope_id

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        return Ok(if_stmt_id);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    fn consume_while_statement(

			




	
	
	
		
 
        &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx

			




	
	
		
 
@@ -537,21 +514,33 @@ impl PassDefinitions {

			




	
	
	
		
 
        let while_span = consume_exact_ident(&module.source, iter, KW_STMT_WHILE)?;

			




	
	
	
		
 
        consume_token(&module.source, iter, TokenKind::OpenParen)?;

			




	
	
	
		
 
        let test = self.consume_expression(module, iter, ctx)?;

			




	
	
	
		
 
        consume_token(&module.source, iter, TokenKind::CloseParen)?;

			




	
	
	
		
 
        let body = self.consume_statement(module, iter, ctx)?;

			




	
	
	
		
 

			




	
	
	
		
 
        Ok(ctx.heap.alloc_while_statement(|this| WhileStatement{

			




	
	
	
		
 
        let while_stmt_id = ctx.heap.alloc_while_statement(|this| WhileStatement{

			




	
	
	
		
 
            this,

			




	
	
	
		
 
            span: while_span,

			




	
	
	
		
 
            test,

			




	
	
	
		
 
            scope: ScopeId::new_invalid(),

			




	
	
	
		
 
            body,

			




	
	
	
		
 
            end_while: EndWhileStatementId::new_invalid(),

			




	
	
	
		
 
            in_sync: SynchronousStatementId::new_invalid(),

			




	
	
	
		
 
        }))

			




	
	
	
		
 
        });

			




	
	
	
		
 
        let end_while_stmt_id = ctx.heap.alloc_end_while_statement(|this| EndWhileStatement{

			




	
	
	
		
 
            this,

			




	
	
	
		
 
            start_while: while_stmt_id,

			




	
	
	
		
 
            next: StatementId::new_invalid(),

			




	
	
	
		
 
        });

			




	
	
	
		
 
        let scope_id = ctx.heap.alloc_scope(|this| Scope::new(this, ScopeAssociation::While(while_stmt_id)));

			




	
	
	
		
 

			




	
	
	
		
 
        let while_stmt = &mut ctx.heap[while_stmt_id];

			




	
	
	
		
 
        while_stmt.scope = scope_id;

			




	
	
	
		
 
        while_stmt.end_while = end_while_stmt_id;

			




	
	
	
		
 

			




	
	
	
		
 
        Ok(while_stmt_id)

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    fn consume_break_statement(

			




	
	
	
		
 
        &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx

			




	
	
	
		
 
    ) -> Result<BreakStatementId, ParseError> {

			




	
	
	
		
 
        let break_span = consume_exact_ident(&module.source, iter, KW_STMT_BREAK)?;

			




	
	
		
 
@@ -592,19 +581,31 @@ impl PassDefinitions {

			




	
	
	
		
 
    fn consume_synchronous_statement(

			




	
	
	
		
 
        &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx

			




	
	
	
		
 
    ) -> Result<SynchronousStatementId, ParseError> {

			




	
	
	
		
 
        let synchronous_span = consume_exact_ident(&module.source, iter, KW_STMT_SYNC)?;

			




	
	
	
		
 
        let body = self.consume_statement(module, iter, ctx)?;

			




	
	
	
		
 

			




	
	
	
		
 
        Ok(ctx.heap.alloc_synchronous_statement(|this| SynchronousStatement{

			




	
	
	
		
 
        let sync_stmt_id = ctx.heap.alloc_synchronous_statement(|this| SynchronousStatement{

			




	
	
	
		
 
            this,

			




	
	
	
		
 
            span: synchronous_span,

			




	
	
	
		
 
            scope: ScopeId::new_invalid(),

			




	
	
	
		
 
            body,

			




	
	
	
		
 
            end_sync: EndSynchronousStatementId::new_invalid(),

			




	
	
	
		
 
        }))

			




	
	
	
		
 
        });

			




	
	
	
		
 
        let end_sync_stmt_id = ctx.heap.alloc_end_synchronous_statement(|this| EndSynchronousStatement{

			




	
	
	
		
 
            this,

			




	
	
	
		
 
            start_sync: sync_stmt_id,

			




	
	
	
		
 
            next: StatementId::new_invalid(),

			




	
	
	
		
 
        });

			




	
	
	
		
 
        let scope_id = ctx.heap.alloc_scope(|this| Scope::new(this, ScopeAssociation::Synchronous(sync_stmt_id)));

			




	
	
	
		
 

			




	
	
	
		
 
        let sync_stmt = &mut ctx.heap[sync_stmt_id];

			




	
	
	
		
 
        sync_stmt.scope = scope_id;

			




	
	
	
		
 
        sync_stmt.end_sync = end_sync_stmt_id;

			




	
	
	
		
 

			




	
	
	
		
 
        return Ok(sync_stmt_id);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    fn consume_fork_statement(

			




	
	
	
		
 
        &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx

			




	
	
	
		
 
    ) -> Result<ForkStatementId, ParseError> {

			




	
	
	
		
 
        let fork_span = consume_exact_ident(&module.source, iter, KW_STMT_FORK)?;

			




	
	
		
 
@@ -665,18 +666,36 @@ impl PassDefinitions {

			




	
	
	
		
 

			




	
	
	
		
 
            next = iter.next();

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        consume_token(&module.source, iter, TokenKind::CloseCurly)?;

			




	
	
	
		
 

			




	
	
	
		
 
        Ok(ctx.heap.alloc_select_statement(|this| SelectStatement{

			




	
	
	
		
 
        let num_cases = cases.len();

			




	
	
	
		
 
        let select_stmt_id = ctx.heap.alloc_select_statement(|this| SelectStatement{

			




	
	
	
		
 
            this,

			




	
	
	
		
 
            span: select_span,

			




	
	
	
		
 
            cases,

			




	
	
	
		
 
            end_select: EndSelectStatementId::new_invalid(),

			




	
	
	
		
 
        }))

			




	
	
	
		
 
        });

			




	
	
	
		
 
        let end_select_stmt_id = ctx.heap.alloc_end_select_statement(|this| EndSelectStatement{

			




	
	
	
		
 
            this,

			




	
	
	
		
 
            start_select: select_stmt_id,

			




	
	
	
		
 
            next: StatementId::new_invalid(),

			




	
	
	
		
 
        });

			




	
	
	
		
 

			




	
	
	
		
 
        let select_stmt = &mut ctx.heap[select_stmt_id];

			




	
	
	
		
 
        select_stmt.end_select = end_select_stmt_id;

			




	
	
	
		
 

			




	
	
	
		
 
        for case_index in 0..num_cases {

			




	
	
	
		
 
            let scope_id = ctx.heap.alloc_scope(|this| Scope::new(this, ScopeAssociation::SelectCase(select_stmt_id, case_index as u32)));

			




	
	
	
		
 
            let select_stmt = &mut ctx.heap[select_stmt_id];

			




	
	
	
		
 
            let select_case = &mut select_stmt.cases[case_index];

			




	
	
	
		
 
            select_case.scope = scope_id;

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        return Ok(select_stmt_id)

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    fn consume_return_statement(

			




	
	
	
		
 
        &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx

			




	
	
	
		
 
    ) -> Result<ReturnStatementId, ParseError> {

			




	
	
	
		
 
        let return_span = consume_exact_ident(&module.source, iter, KW_STMT_RETURN)?;

			




        

    


    
    

    

        

                

                    src/protocol/parser/pass_validation_linking.rs
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -206,20 +206,22 @@ impl Visitor for PassValidationLinking {

			




	
	
	
		
 
    // Definition visitors

			




	
	
	
		
 
    //--------------------------------------------------------------------------

			




	
	
	
		
 

			




	
	
	
		
 
    fn visit_component_definition(&mut self, ctx: &mut Ctx, id: ComponentDefinitionId) -> VisitorResult {

			




	
	
	
		
 
        self.reset_state();

			




	
	
	
		
 

			




	
	
	
		
 
        self.def_type = match &ctx.heap[id].variant {

			




	
	
	
		
 
        let definition = &ctx.heap[id];

			




	
	
	
		
 
        self.def_type = match &definition.variant {

			




	
	
	
		
 
            ComponentVariant::Primitive => DefinitionType::Primitive(id),

			




	
	
	
		
 
            ComponentVariant::Composite => DefinitionType::Composite(id),

			




	
	
	
		
 
        };

			




	
	
	
		
 
        self.expr_parent = ExpressionParent::None;

			




	
	
	
		
 

			




	
	
	
		
 
        // Visit parameters and assign a unique scope ID

			




	
	
	
		
 
        let old_scope = self.push_scope(ctx, ScopeAssociation::Definition(id.upcast()));

			




	
	
	
		
 
        let definition_scope_id = definition.scope;

			




	
	
	
		
 
        let old_scope = self.push_scope(ctx, true, definition_scope_id);

			




	
	
	
		
 

			




	
	
	
		
 
        let definition = &ctx.heap[id];

			




	
	
	
		
 
        let body_id = definition.body;

			




	
	
	
		
 
        let section = self.variable_buffer.start_section_initialized(&definition.parameters);

			




	
	
	
		
 
        for variable_idx in 0..section.len() {

			




	
	
	
		
 
            let variable_id = section[variable_idx];

			




	
	
		
 
@@ -250,13 +252,15 @@ impl Visitor for PassValidationLinking {

			




	
	
	
		
 

			




	
	
	
		
 
        // Set internal statement indices

			




	
	
	
		
 
        self.def_type = DefinitionType::Function(id);

			




	
	
	
		
 
        self.expr_parent = ExpressionParent::None;

			




	
	
	
		
 

			




	
	
	
		
 
        // Visit parameters and assign a unique scope ID

			




	
	
	
		
 
        let old_scope = self.push_scope(ctx, ScopeAssociation::Definition(id.upcast()));

			




	
	
	
		
 
        let definition = &ctx.heap[id];

			




	
	
	
		
 
        let definition_scope_id = definition.scope;

			




	
	
	
		
 
        let old_scope = self.push_scope(ctx, true, definition_scope_id);

			




	
	
	
		
 

			




	
	
	
		
 
        let definition = &ctx.heap[id];

			




	
	
	
		
 
        let body_id = definition.body;

			




	
	
	
		
 
        let section = self.variable_buffer.start_section_initialized(&definition.parameters);

			




	
	
	
		
 
        for variable_idx in 0..section.len() {

			




	
	
	
		
 
            let variable_id = section[variable_idx];

			




	
	
		
 
@@ -284,16 +288,17 @@ impl Visitor for PassValidationLinking {

			




	
	
	
		
 
    //--------------------------------------------------------------------------

			




	
	
	
		
 

			




	
	
	
		
 
    fn visit_block_stmt(&mut self, ctx: &mut Ctx, id: BlockStatementId) -> VisitorResult {

			




	
	
	
		
 
        // Get end of block

			




	
	
	
		
 
        let block_stmt = &ctx.heap[id];

			




	
	
	
		
 
        let end_block_id = block_stmt.end_block;

			




	
	
	
		
 
        let scope_id = block_stmt.scope;

			




	
	
	
		
 

			




	
	
	
		
 
        // Traverse statements in block

			




	
	
	
		
 
        let statement_section = self.statement_buffer.start_section_initialized(&block_stmt.statements);

			




	
	
	
		
 
        let old_scope = self.push_scope(ctx, ScopeAssociation::Block(id));

			




	
	
	
		
 
        let old_scope = self.push_scope(ctx, false, scope_id);

			




	
	
	
		
 
        assign_and_replace_next_stmt!(self, ctx, id.upcast());

			




	
	
	
		
 

			




	
	
	
		
 
        for stmt_idx in 0..statement_section.len() {

			




	
	
	
		
 
            self.relative_pos_in_parent = stmt_idx as i32;

			




	
	
	
		
 
            self.visit_stmt(ctx, statement_section[stmt_idx])?;

			




	
	
	
		
 
        }

			




	
	
		
 
@@ -362,19 +367,19 @@ impl Visitor for PassValidationLinking {

			




	
	
	
		
 
        self.expr_parent = ExpressionParent::None;

			




	
	
	
		
 

			




	
	
	
		
 
        // Visit true and false branch. Executor chooses next statement based on

			




	
	
	
		
 
        // test expression, not on if-statement itself. Hence the if statement

			




	
	
	
		
 
        // does not have a static subsequent statement.

			




	
	
	
		
 
        assign_then_erase_next_stmt!(self, ctx, id.upcast());

			




	
	
	
		
 
        let old_scope = self.push_scope(ctx, ScopeAssociation::If(id, true));

			




	
	
	
		
 
        let old_scope = self.push_scope(ctx, false, true_case.scope);

			




	
	
	
		
 
        self.visit_stmt(ctx, true_case.body)?;

			




	
	
	
		
 
        self.pop_scope(old_scope);

			




	
	
	
		
 
        assign_then_erase_next_stmt!(self, ctx, end_if_id.upcast());

			




	
	
	
		
 

			




	
	
	
		
 
        if let Some(false_case) = false_case {

			




	
	
	
		
 
            let old_scope = self.push_scope(ctx, ScopeAssociation::If(id, false));

			




	
	
	
		
 
            let old_scope = self.push_scope(ctx, false, false_case.scope);

			




	
	
	
		
 
            self.visit_stmt(ctx, false_case.body)?;

			




	
	
	
		
 
            self.pop_scope(old_scope);

			




	
	
	
		
 
            assign_then_erase_next_stmt!(self, ctx, end_if_id.upcast());

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        self.prev_stmt = end_if_id.upcast();

			




	
	
		
 
@@ -383,12 +388,13 @@ impl Visitor for PassValidationLinking {

			




	
	
	
		
 

			




	
	
	
		
 
    fn visit_while_stmt(&mut self, ctx: &mut Ctx, id: WhileStatementId) -> VisitorResult {

			




	
	
	
		
 
        let stmt = &ctx.heap[id];

			




	
	
	
		
 
        let end_while_id = stmt.end_while;

			




	
	
	
		
 
        let test_expr_id = stmt.test;

			




	
	
	
		
 
        let body_stmt_id = stmt.body;

			




	
	
	
		
 
        let scope_id = stmt.scope;

			




	
	
	
		
 

			




	
	
	
		
 
        let old_while = self.in_while;

			




	
	
	
		
 
        self.in_while = id;

			




	
	
	
		
 

			




	
	
	
		
 
        // Visit test expression

			




	
	
	
		
 
        debug_assert_eq!(self.expr_parent, ExpressionParent::None);

			




	
	
		
 
@@ -399,13 +405,13 @@ impl Visitor for PassValidationLinking {

			




	
	
	
		
 
        self.in_test_expr = StatementId::new_invalid();

			




	
	
	
		
 

			




	
	
	
		
 
        // Link up to body statement

			




	
	
	
		
 
        assign_then_erase_next_stmt!(self, ctx, id.upcast());

			




	
	
	
		
 

			




	
	
	
		
 
        self.expr_parent = ExpressionParent::None;

			




	
	
	
		
 
        let old_scope = self.push_scope(ctx, ScopeAssociation::While(id));

			




	
	
	
		
 
        let old_scope = self.push_scope(ctx, false, scope_id);

			




	
	
	
		
 
        self.visit_stmt(ctx, body_stmt_id)?;

			




	
	
	
		
 
        self.pop_scope(old_scope);

			




	
	
	
		
 
        self.in_while = old_while;

			




	
	
	
		
 

			




	
	
	
		
 
        // Link final entry in while's block statement back to the while. The

			




	
	
	
		
 
        // executor will go to the end-while statement if the test expression

			




	
	
		
 
@@ -442,12 +448,14 @@ impl Visitor for PassValidationLinking {

			




	
	
	
		
 

			




	
	
	
		
 
    fn visit_synchronous_stmt(&mut self, ctx: &mut Ctx, id: SynchronousStatementId) -> VisitorResult {

			




	
	
	
		
 
        // Check for validity of synchronous statement

			




	
	
	
		
 
        let sync_stmt = &ctx.heap[id];

			




	
	
	
		
 
        let end_sync_id = sync_stmt.end_sync;

			




	
	
	
		
 
        let cur_sync_span = sync_stmt.span;

			




	
	
	
		
 
        let scope_id = sync_stmt.scope;

			




	
	
	
		
 

			




	
	
	
		
 
        if !self.in_sync.is_invalid() {

			




	
	
	
		
 
            // Nested synchronous statement

			




	
	
	
		
 
            let old_sync_span = ctx.heap[self.in_sync].span;

			




	
	
	
		
 
            return Err(ParseError::new_error_str_at_span(

			




	
	
	
		
 
                &ctx.module().source, cur_sync_span, "Illegal nested synchronous statement"

			




	
	
	
		
 
            ).with_info_str_at_span(

			




	
	
		
 
@@ -468,13 +476,13 @@ impl Visitor for PassValidationLinking {

			




	
	
	
		
 
        // Visit block statement. Note that we explicitly push the scope here

			




	
	
	
		
 
        // (and the `visit_block_stmt` will also push, but without effect) to

			




	
	
	
		
 
        // ensure the scope contains the sync ID.

			




	
	
	
		
 
        let sync_body = ctx.heap[id].body;

			




	
	
	
		
 
        debug_assert!(self.in_sync.is_invalid());

			




	
	
	
		
 
        self.in_sync = id;

			




	
	
	
		
 
        let old_scope = self.push_scope(ctx, ScopeAssociation::Synchronous(id));

			




	
	
	
		
 
        let old_scope = self.push_scope(ctx, false, scope_id);

			




	
	
	
		
 
        self.visit_stmt(ctx, sync_body)?;

			




	
	
	
		
 
        self.pop_scope(old_scope);

			




	
	
	
		
 
        assign_and_replace_next_stmt!(self, ctx, end_sync_id.upcast());

			




	
	
	
		
 

			




	
	
	
		
 
        self.in_sync = SynchronousStatementId::new_invalid();

			




	
	
	
		
 

			




	
	
		
 
@@ -529,35 +537,38 @@ impl Visitor for PassValidationLinking {

			




	
	
	
		
 
                "select statements may only be used in primitive components"

			




	
	
	
		
 
            ));

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        // Visit the various arms in the select block

			




	
	
	
		
 
        let mut case_stmt_ids = self.statement_buffer.start_section();

			




	
	
	
		
 
        let mut case_scope_ids = self.scope_buffer.start_section();

			




	
	
	
		
 
        let num_cases = select_stmt.cases.len();

			




	
	
	
		
 
        for case in &select_stmt.cases {

			




	
	
	
		
 
            // We add them in pairs, so the subsequent for-loop retrieves in pairs

			




	
	
	
		
 
            case_stmt_ids.push(case.guard);

			




	
	
	
		
 
            case_stmt_ids.push(case.body);

			




	
	
	
		
 
            case_scope_ids.push(case.scope);

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        assign_then_erase_next_stmt!(self, ctx, id.upcast());

			




	
	
	
		
 

			




	
	
	
		
 
        for idx in 0..num_cases {

			




	
	
	
		
 
            let base_idx = 2 * idx;

			




	
	
	
		
 
            let guard_id     = case_stmt_ids[base_idx    ];

			




	
	
	
		
 
            let case_body_id = case_stmt_ids[base_idx + 1];

			




	
	
	
		
 
        for index in 0..num_cases {

			




	
	
	
		
 
            let base_index = 2 * index;

			




	
	
	
		
 
            let guard_id     = case_stmt_ids[base_index];

			




	
	
	
		
 
            let case_body_id = case_stmt_ids[base_index + 1];

			




	
	
	
		
 
            let case_scope_id = case_scope_ids[index];

			




	
	
	
		
 

			




	
	
	
		
 
            // The guard statement ends up belonging to the block statement

			




	
	
	
		
 
            // following the arm. The reason we parse it separately is to

			




	
	
	
		
 
            // extract all of the "get" calls.

			




	
	
	
		
 
            let old_scope = self.push_scope(ctx, ScopeAssociation::SelectCase(id, idx as u32));

			




	
	
	
		
 
            let old_scope = self.push_scope(ctx, false, case_scope_id);

			




	
	
	
		
 

			




	
	
	
		
 
            // Visit the guard of this arm

			




	
	
	
		
 
            debug_assert!(self.in_select_guard.is_invalid());

			




	
	
	
		
 
            self.in_select_guard = id;

			




	
	
	
		
 
            self.in_select_arm = idx as u32;

			




	
	
	
		
 
            self.in_select_arm = index as u32;

			




	
	
	
		
 
            self.visit_stmt(ctx, guard_id)?;

			




	
	
	
		
 
            self.in_select_guard = SelectStatementId::new_invalid();

			




	
	
	
		
 

			




	
	
	
		
 
            // Visit the code associated with the guard

			




	
	
	
		
 
            self.visit_stmt(ctx, case_body_id)?;

			




	
	
	
		
 
            self.pop_scope(old_scope);

			




	
	
		
 
@@ -1450,77 +1461,35 @@ impl PassValidationLinking {

			




	
	
	
		
 

			




	
	
	
		
 
    /// Pushes a new scope associated with a particular statement. If that

			




	
	
	
		
 
    /// statement already has an associated scope (i.e. scope associated with

			




	
	
	
		
 
    /// sync statement or select statement's arm) then we won't do anything.

			




	
	
	
		
 
    /// In all cases the caller must call `pop_statement_scope` with the scope

			




	
	
	
		
 
    /// and relative scope position returned by this function.

			




	
	
	
		
 
    fn push_scope(&mut self, ctx: &mut Ctx, association: ScopeAssociation) -> (ScopeId, i32) {

			




	
	
	
		
 
        // Create new scope and assign as ScopeId to the specified associated

			




	
	
	
		
 
        // statement.

			




	
	
	
		
 
        let is_first_scope = match association {

			




	
	
	
		
 
            ScopeAssociation::Definition(_) => true,

			




	
	
	
		
 
            _ => false,

			




	
	
	
		
 
        };

			




	
	
	
		
 

			




	
	
	
		
 
        let old_scope_id = self.cur_scope.clone();

			




	
	
	
		
 
        let new_scope_id = ctx.heap.alloc_scope(|this| Scope{

			




	
	
	
		
 
            this,

			




	
	
	
		
 
            parent: if is_first_scope { None } else { Some(old_scope_id) },

			




	
	
	
		
 
            nested: Vec::new(),

			




	
	
	
		
 
            association,

			




	
	
	
		
 
            variables: Vec::new(),

			




	
	
	
		
 
            labels: Vec::new(),

			




	
	
	
		
 
            relative_pos_in_parent: self.relative_pos_in_parent,

			




	
	
	
		
 
            first_unique_id_in_scope: -1,

			




	
	
	
		
 
            next_unique_id_in_scope: -1,

			




	
	
	
		
 
        });

			




	
	
	
		
 

			




	
	
	
		
 
        match association {

			




	
	
	
		
 
            ScopeAssociation::Definition(definition_id) => {

			




	
	
	
		
 
                let def = &mut ctx.heap[definition_id];

			




	
	
	
		
 
                match def {

			




	
	
	
		
 
                    Definition::Function(def) => def.scope = new_scope_id,

			




	
	
	
		
 
                    Definition::Component(def) => def.scope = new_scope_id,

			




	
	
	
		
 
                    _ => unreachable!(),

			




	
	
	
		
 
                }

			




	
	
	
		
 
            },

			




	
	
	
		
 
            ScopeAssociation::Block(stmt_id) => {

			




	
	
	
		
 
                ctx.heap[stmt_id].scope = new_scope_id;

			




	
	
	
		
 
            },

			




	
	
	
		
 
            ScopeAssociation::If(stmt_id, in_true_body) => {

			




	
	
	
		
 
                let stmt = &mut ctx.heap[stmt_id];

			




	
	
	
		
 
                if in_true_body {

			




	
	
	
		
 
                    stmt.true_case.scope = new_scope_id;

			




	
	
	
		
 
                } else {

			




	
	
	
		
 
                    let false_body = stmt.false_case.as_mut().unwrap();

			




	
	
	
		
 
                    false_body.scope = new_scope_id;

			




	
	
	
		
 
                }

			




	
	
	
		
 
            },

			




	
	
	
		
 
            ScopeAssociation::While(stmt_id) => {

			




	
	
	
		
 
                ctx.heap[stmt_id].scope = new_scope_id;

			




	
	
	
		
 
            },

			




	
	
	
		
 
            ScopeAssociation::Synchronous(stmt_id) => {

			




	
	
	
		
 
                ctx.heap[stmt_id].scope = new_scope_id;

			




	
	
	
		
 
            },

			




	
	
	
		
 
            ScopeAssociation::SelectCase(stmt_id, case_index) => {

			




	
	
	
		
 
                let select_stmt = &mut ctx.heap[stmt_id];

			




	
	
	
		
 
                select_stmt.cases[case_index as usize].scope = new_scope_id;

			




	
	
	
		
 
            }

			




	
	
	
		
 
    fn push_scope(&mut self, ctx: &mut Ctx, is_top_level_scope: bool, pushed_scope_id: ScopeId) -> (ScopeId, i32) {

			




	
	
	
		
 
        // Set the properties of the pushed scope (it is already created during

			




	
	
	
		
 
        // AST construction, but most values are not yet set to their correct

			




	
	
	
		
 
        // values)

			




	
	
	
		
 
        let old_scope_id = self.cur_scope;

			




	
	
	
		
 

			




	
	
	
		
 
        let scope = &mut ctx.heap[pushed_scope_id];

			




	
	
	
		
 
        if is_top_level_scope {

			




	
	
	
		
 
            scope.parent = Some(old_scope_id);

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        scope.relative_pos_in_parent = self.relative_pos_in_parent;

			




	
	
	
		
 
        let old_relative_pos = self.relative_pos_in_parent;

			




	
	
	
		
 
        self.relative_pos_in_parent = 0;

			




	
	
	
		
 

			




	
	
	
		
 
        // Link up scopes

			




	
	
	
		
 
        if !is_first_scope {

			




	
	
	
		
 
        if !is_top_level_scope {

			




	
	
	
		
 
            let old_scope = &mut ctx.heap[old_scope_id];

			




	
	
	
		
 
            old_scope.nested.push(new_scope_id);

			




	
	
	
		
 
            old_scope.nested.push(pushed_scope_id);

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        // Set as current traversal scope, then return old scope

			




	
	
	
		
 
        self.cur_scope = new_scope_id;

			




	
	
	
		
 

			




	
	
	
		
 
        let old_relative_pos = self.relative_pos_in_parent;

			




	
	
	
		
 
        self.relative_pos_in_parent = 0;

			




	
	
	
		
 
        self.cur_scope = pushed_scope_id;

			




	
	
	
		
 
        return (old_scope_id, old_relative_pos)

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    fn pop_scope(&mut self, scope_to_restore: (ScopeId, i32)) {

			




	
	
	
		
 
        self.cur_scope = scope_to_restore.0;

			




	
	
	
		
 
        self.relative_pos_in_parent = scope_to_restore.1;

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        Server instance: kalli-1464864
    
    
        This site is powered by
            Kallithea,
        which is
        © 2010–2022 by various authors & licensed under GPLv3.
            – Support