qprime 0.0.5

An experimental programming language for quantum and weather calculations/applications.
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use crate::token::Token;
use num_bigint::BigInt;
use num_rational::BigRational;

pub struct Lexer {
    input: Vec<char>,
    position: usize,
    pub line: usize,
}

impl Lexer {
    pub fn new(input: String) -> Self {
        Self {
            input: input.chars().collect(),
            position: 0,
            line: 1,
        }
    }

    pub fn next_token(&mut self) -> Token {
        self.skip_whitespace();
        if self.position >= self.input.len() {
            return Token::EOF;
        }

        let ch = self.input[self.position];
        self.position += 1;

        match ch {
            '+' => Token::Plus,
            '-' => Token::Minus,
            '*' => Token::Star,
            '/' => Token::Slash,
            '>' => Token::GreaterThan,
            '<' => Token::LessThan,
            '=' => Token::Assign,
            '{' => Token::LBrace,
            '}' => Token::RBrace,
            '(' => Token::LParen,
            ')' => Token::RParen,
            '"' => self.read_string_literal(),
            '0'..='9' | '.' => self.read_number(ch),
            'a'..='z' | 'A'..='Z' | '_' => self.read_identifier(ch),
            ',' => Token::Comma,
            '#' => {
                while self.position < self.input.len() && self.input[self.position] != '\n' {
                    self.position += 1;
                }
                self.next_token()
            }
            '\n' => {
                self.line += 1;
                self.next_token()
            }
            _ => panic!("Unexpected character '{}' on line {}.", ch, self.line),
        }
    }

    pub fn skip_whitespace(&mut self) {
        while self.position < self.input.len() && self.input[self.position].is_whitespace() {
            if self.input[self.position] == '\n' {
                self.line += 1;
            }
            self.position += 1;
        }
    }

    fn read_number(&mut self, first_char: char) -> Token {
        let mut number = first_char.to_string();
        let mut is_float = false;

        while self.position < self.input.len() && (self.input[self.position].is_digit(10) || self.input[self.position] == '.') {
            if self.input[self.position] == '.' {
                is_float = true;
            }
            number.push(self.input[self.position]);
            self.position += 1;
        }

        if is_float {
            Token::Float(BigRational::from_float(number.parse::<f64>().unwrap()).unwrap())
        } else {
            Token::Float(BigRational::from_integer(number.parse::<BigInt>().unwrap()))
        }
    }

    pub fn read_identifier(&mut self, first_char: char) -> Token {
        let mut identifier = first_char.to_string();
        while self.position < self.input.len() && (self.input[self.position].is_alphanumeric() || self.input[self.position] == '_') {
            identifier.push(self.input[self.position]);
            self.position += 1;
        }
        match identifier.as_str() {
            "call" => Token::Call,
            "print" => Token::Print,
            "if" => Token::If,
            "else" => Token::Else,
            "dewpoint" => Token::DewPoint,
            "ftoc" => Token::FToC,
            "ctof" => Token::CToF,
            "ctok" => Token::CToK,
            "ktoc" => Token::KToC,
            "ftok" => Token::FToK,
            "ktof" => Token::KToF,
            "pauli_x" => Token::PauliX,
            "pauli_y" => Token::PauliY,
            "pauli_z" => Token::PauliZ,
            "hadamard" => Token::Hadamard,
            "cnot" => Token::CNot,
            "qubit" => Token::Qubit,
            "measure" => Token::MeasureQubit,
            "fn" => Token::Function,
            "import" => Token::Import,
            "_pi_" => Token::Pi,
            "_kelvin_" => Token::Kelvin,
            "_rd_" => Token::RD,
            "_cp_" => Token::CP,
            "_p0_" => Token::P0,
            "_lv_" => Token::LV,
            "_cw_" => Token::CW,
            "_rho_air_" => Token::RhoAir,
            "_rho_water_" => Token::RhoWater,
            "_g_" => Token::G,
            _ => Token::Identifier(identifier),
        }
    }

    pub fn read_string_literal(&mut self) -> Token {
        let mut string = String::new();
        while self.position < self.input.len() && self.input[self.position] != '"' {
            string.push(self.input[self.position]);
            self.position += 1;
        }
        self.position += 1; // Consume closing quote
        Token::StringLiteral(string)
    }
}