open-vaf 0.4.2

A compiler frontend for VerilogA aimed predominently at compact modelling
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

//  * ******************************************************************************************
//  * Copyright (c) 2019 Pascal Kuthe. This file is part of the OpenVAF project.
//  * It is subject to the license terms in the LICENSE file found in the top-level directory
//  *  of this distribution and at  https://gitlab.com/DSPOM/OpenVAF/blob/master/LICENSE.
//  *  No part of OpenVAF, including this file, may be copied, modified, propagated, or
//  *  distributed except according to the terms contained in the LICENSE file.
//  * *******************************************************************************************

use crate::ir::ast::Discipline;
use crate::ir::{AttributeNode, Attributes};
use crate::parser::error::Type::{
    AttributeAlreadyDefined, DiscreteDisciplineHasNatures, UnexpectedToken,
};
use crate::parser::lexer::Token;
use crate::parser::{Error, Result};
use crate::symbol_table::SymbolDeclaration;
use crate::Parser;

impl<'lt, 'source_map> Parser<'lt, 'source_map> {
    pub fn parse_discipline(&mut self, attributes: Attributes) -> Result {
        let start = self.preprocessor.current_start();
        self.consume_lookahead();
        let name = self
            .parse_identifier(false)
            .map_err(|err| self.non_critical_errors.push(err));

        self.try_expect(Token::Semicolon);

        let mut potential_nature = None;
        let mut flow_nature = None;
        let mut continuous = None;
        self.parse_and_recover_on_tokens(
            Token::Semicolon,
            Token::EndDiscipline,
            true,
            true,
            |parser| {
                match parser.next_with_span()? {
                    (Token::Potential, _) if potential_nature.is_none() => {
                        potential_nature = Some(parser.parse_identifier(false)?);
                    }

                    (Token::Flow, _) if flow_nature.is_none() => {
                        flow_nature = Some(parser.parse_identifier(false)?);
                    }

                    (Token::Domain, _) if continuous.is_none() => {
                        continuous = match parser.next_with_span()? {
                            (Token::Continuous, _) => Some(true),
                            (Token::Discrete, _) => Some(false),
                            (_, source) => {
                                return Err(Error {
                                    error_type: UnexpectedToken {
                                        expected: vec![Token::Discrete, Token::Continuous],
                                    },
                                    source,
                                })
                            }
                        };
                    }

                    (Token::Potential, source)
                    | (Token::Flow, source)
                    | (Token::Domain, source) => {
                        return Err(Error {
                            error_type: AttributeAlreadyDefined,
                            source,
                        })
                    }

                    (_, source) => {
                        return Err(Error {
                            error_type: UnexpectedToken {
                                expected: vec![Token::Potential, Token::Flow, Token::Domain],
                            },
                            source,
                        })
                    }
                }
                parser.expect(Token::Semicolon)?;
                Ok(true)
            },
        )?;

        let source = self.span_to_current_end(start);

        let continuous = match continuous {
            Some(true) => Some(true),
            Some(false) if potential_nature.is_some() || potential_nature.is_some() => {
                self.non_critical_errors.push(Error {
                    error_type: DiscreteDisciplineHasNatures,
                    source,
                });
                return Ok(());
            }
            None if potential_nature.is_some() || potential_nature.is_some() => Some(true),
            v => v,
        };

        if let Ok(name) = name {
            let id = self.ast.disciplines.push(AttributeNode {
                attributes,
                source,
                contents: Discipline {
                    name,
                    flow_nature,
                    potential_nature,
                    continuous,
                },
            });
            self.insert_symbol(name, SymbolDeclaration::Discipline(id))
        }

        Ok(())
    }
}