Skip to main content

qualia_q_forge/qasm/
parser.rs

1use crate::qasm::{QasmProgram, QasmStatement};
2use qualia_core_db::q_hash;
3
4/// Zero-allocation OpenQASM 3 Parser.
5pub struct Parser<'a> {
6    input: &'a str,
7    pos: usize,
8}
9
10impl<'a> Parser<'a> {
11    /// Creates a new instance.
12    pub fn new(input: &'a str) -> Self {
13        Self { input, pos: 0 }
14    }
15
16    /// Parses.
17    pub fn parse(&mut self) -> Result<QasmProgram, &'static str> {
18        let mut program = QasmProgram::new();
19        self.skip_whitespace();
20
21        while self.pos < self.input.len() {
22            let statement = self.parse_statement()?;
23            program.push(statement)?;
24            self.skip_whitespace();
25        }
26
27        Ok(program)
28    }
29
30    fn skip_whitespace(&mut self) {
31        while self.pos < self.input.len() {
32            let c = self.input[self.pos..].chars().next().unwrap();
33            if c.is_whitespace() {
34                self.pos += c.len_utf8();
35            } else if self.input[self.pos..].starts_with("//") {
36                // Skip comment
37                while self.pos < self.input.len() && !self.input[self.pos..].starts_with('\n') {
38                    self.pos += 1;
39                }
40            } else {
41                break;
42            }
43        }
44    }
45
46    fn parse_statement(&mut self) -> Result<QasmStatement, &'static str> {
47        if self.starts_with_keyword("OPENQASM") {
48            self.parse_version()?;
49            return Ok(QasmStatement::Empty);
50        } else if self.starts_with_keyword("include") {
51            self.parse_include()?;
52            return Ok(QasmStatement::Empty);
53        } else if self.starts_with_keyword("qubit") {
54            return self.parse_qubit_decl();
55        } else if self.starts_with_keyword("gate") {
56            return self.parse_gate_decl();
57        }
58
59        // Try parsing a gate call
60        if let Some(ident) = self.parse_identifier() {
61            return self.parse_gate_call(ident);
62        }
63
64        Err("Unexpected token or unsupported statement")
65    }
66
67    fn starts_with_keyword(&self, kw: &str) -> bool {
68        if self.input[self.pos..].starts_with(kw) {
69            let next_char = self.input[self.pos + kw.len()..].chars().next();
70            match next_char {
71                Some(c) if c.is_alphanumeric() || c == '_' => false,
72                _ => true,
73            }
74        } else {
75            false
76        }
77    }
78
79    fn parse_version(&mut self) -> Result<(), &'static str> {
80        self.pos += "OPENQASM".len();
81        self.skip_whitespace();
82        // Parse version number (e.g., "3.0")
83        while self.pos < self.input.len() && !self.input[self.pos..].starts_with(';') {
84            self.pos += 1;
85        }
86        self.expect_char(';')?;
87        Ok(())
88    }
89
90    fn parse_include(&mut self) -> Result<(), &'static str> {
91        self.pos += "include".len();
92        self.skip_whitespace();
93        // Skip string literal
94        if self.input[self.pos..].starts_with('"') {
95            self.pos += 1;
96            while self.pos < self.input.len() && !self.input[self.pos..].starts_with('"') {
97                self.pos += 1;
98            }
99            if self.pos < self.input.len() {
100                self.pos += 1; // Skip closing quote
101            }
102        }
103        self.skip_whitespace();
104        self.expect_char(';')?;
105        Ok(())
106    }
107
108    fn parse_qubit_decl(&mut self) -> Result<QasmStatement, &'static str> {
109        self.pos += "qubit".len();
110        self.skip_whitespace();
111
112        let mut size = 1;
113        if self.input[self.pos..].starts_with('[') {
114            self.pos += 1;
115            size = self.parse_u16()?;
116            self.expect_char(']')?;
117        }
118
119        self.skip_whitespace();
120        let name = self.parse_identifier().ok_or("Expected qubit name")?;
121        self.skip_whitespace();
122        self.expect_char(';')?;
123
124        Ok(QasmStatement::QubitDecl {
125            name_hash: q_hash(name),
126            size,
127        })
128    }
129
130    fn parse_gate_decl(&mut self) -> Result<QasmStatement, &'static str> {
131        self.pos += "gate".len();
132        self.skip_whitespace();
133        let name = self.parse_identifier().ok_or("Expected gate name")?;
134        self.skip_whitespace();
135
136        // Skip parameters if present (e.g., gate rx(theta) q { ... })
137        if self.input[self.pos..].starts_with('(') {
138            self.pos += 1;
139            while self.pos < self.input.len() && !self.input[self.pos..].starts_with(')') {
140                self.pos += 1;
141            }
142            self.pos += 1; // Skip ')'
143            self.skip_whitespace();
144        }
145
146        // Parse qubit formal arguments
147        let mut qubit_params: [&'a str; 8] = [""; 8];
148        let mut num_qubits = 0u8;
149        while self.pos < self.input.len() && !self.input[self.pos..].starts_with('{') {
150            if let Some(arg) = self.parse_identifier() {
151                if (num_qubits as usize) < qubit_params.len() {
152                    qubit_params[num_qubits as usize] = arg;
153                    num_qubits += 1;
154                }
155            }
156            self.skip_whitespace();
157            if self.input[self.pos..].starts_with(',') {
158                self.pos += 1;
159                self.skip_whitespace();
160            }
161        }
162
163        self.expect_char('{')?;
164        self.skip_whitespace();
165
166        use crate::qasm::GateBodyOp;
167        let mut body_ops = [GateBodyOp::default(); 16];
168        let mut body_count = 0u8;
169
170        while self.pos < self.input.len() && !self.input[self.pos..].starts_with('}') {
171            let op_name = self.parse_identifier().ok_or("Expected gate name inside body")?;
172            self.skip_whitespace();
173            let mut target_indices = [0u8; 4];
174            let mut num_targets = 0u8;
175
176            while self.pos < self.input.len() && !self.input[self.pos..].starts_with(';') {
177                let target_name = self.parse_identifier().ok_or("Expected target qubit name")?;
178                let idx = qubit_params[..num_qubits as usize]
179                    .iter()
180                    .position(|&p| p == target_name)
181                    .ok_or("Undeclared qubit in gate body")? as u8;
182                if (num_targets as usize) < target_indices.len() {
183                    target_indices[num_targets as usize] = idx;
184                    num_targets += 1;
185                }
186                self.skip_whitespace();
187                if self.input[self.pos..].starts_with(',') {
188                    self.pos += 1;
189                    self.skip_whitespace();
190                } else {
191                    break;
192                }
193            }
194            self.expect_char(';')?;
195            self.skip_whitespace();
196
197            if (body_count as usize) < body_ops.len() {
198                body_ops[body_count as usize] = GateBodyOp {
199                    name_hash: q_hash(op_name),
200                    target_indices,
201                    num_targets,
202                };
203                body_count += 1;
204            }
205        }
206        self.expect_char('}')?;
207
208        Ok(QasmStatement::GateDecl {
209            name_hash: q_hash(name),
210            num_qubits,
211            body_count,
212            body_ops,
213        })
214    }
215
216    fn parse_gate_call(&mut self, name: &'a str) -> Result<QasmStatement, &'static str> {
217        self.skip_whitespace();
218
219        let mut params = [0.0; 4];
220        let mut num_params = 0;
221
222        if self.input[self.pos..].starts_with('(') {
223            self.pos += 1;
224            self.skip_whitespace();
225            while self.pos < self.input.len() && !self.input[self.pos..].starts_with(')') {
226                if num_params >= 4 {
227                    return Err("Too many parameters");
228                }
229                params[num_params as usize] = self.parse_f64()?;
230                num_params += 1;
231                self.skip_whitespace();
232                if self.input[self.pos..].starts_with(',') {
233                    self.pos += 1;
234                    self.skip_whitespace();
235                }
236            }
237            self.expect_char(')')?;
238            self.skip_whitespace();
239        }
240
241        let mut target_qubits = [0; 4];
242        let mut num_targets = 0;
243
244        while self.pos < self.input.len() && !self.input[self.pos..].starts_with(';') {
245            if num_targets >= 4 {
246                return Err("Too many targets");
247            }
248            let _qubit_name = self.parse_identifier().ok_or("Expected qubit name")?;
249            self.skip_whitespace();
250
251            let mut index = 0;
252            if self.input[self.pos..].starts_with('[') {
253                self.pos += 1;
254                index = self.parse_u16()?;
255                self.expect_char(']')?;
256                self.skip_whitespace();
257            }
258
259            target_qubits[num_targets as usize] = index;
260            num_targets += 1;
261
262            if self.input[self.pos..].starts_with(',') {
263                self.pos += 1;
264                self.skip_whitespace();
265            } else {
266                break;
267            }
268        }
269
270        self.expect_char(';')?;
271
272        Ok(QasmStatement::GateCall {
273            name_hash: q_hash(name),
274            target_qubits,
275            num_targets,
276            params,
277            num_params,
278        })
279    }
280
281    fn parse_identifier(&mut self) -> Option<&'a str> {
282        let start = self.pos;
283        while self.pos < self.input.len() {
284            let c = self.input[self.pos..].chars().next().unwrap();
285            if c.is_alphanumeric() || c == '_' {
286                self.pos += c.len_utf8();
287            } else {
288                break;
289            }
290        }
291        if self.pos > start {
292            Some(&self.input[start..self.pos])
293        } else {
294            None
295        }
296    }
297
298    fn parse_u16(&mut self) -> Result<u16, &'static str> {
299        let start = self.pos;
300        while self.pos < self.input.len() {
301            let c = self.input[self.pos..].chars().next().unwrap();
302            if c.is_ascii_digit() {
303                self.pos += 1;
304            } else {
305                break;
306            }
307        }
308        if self.pos > start {
309            self.input[start..self.pos]
310                .parse()
311                .map_err(|_| "Invalid u16")
312        } else {
313            Err("Expected number")
314        }
315    }
316
317    fn parse_f64(&mut self) -> Result<f64, &'static str> {
318        let start = self.pos;
319        while self.pos < self.input.len() {
320            let c = self.input[self.pos..].chars().next().unwrap();
321            if c.is_ascii_digit() || c == '.' || c == '-' || c == '+' || c == 'e' || c == 'E' {
322                self.pos += 1;
323            } else {
324                break;
325            }
326        }
327        if self.pos > start {
328            // NOTE: In #![no_std], f64 parsing might be tricky if we don't have alloc.
329            // core::str::parse::<f64> exists and is usable.
330            self.input[start..self.pos]
331                .parse()
332                .map_err(|_| "Invalid f64")
333        } else {
334            Err("Expected number")
335        }
336    }
337
338    fn expect_char(&mut self, expected: char) -> Result<(), &'static str> {
339        if self.input[self.pos..].starts_with(expected) {
340            self.pos += expected.len_utf8();
341            Ok(())
342        } else {
343            Err("Unexpected character")
344        }
345    }
346}
347
348#[cfg(test)]
349mod tests {
350    use super::*;
351
352    #[test]
353    fn test_parse_basic() {
354        let source = "
355            OPENQASM 3.0;
356            include \"stdgates.inc\";
357            qubit[2] q;
358            h q[0];
359            cx q[0], q[1];
360        ";
361        let mut parser = Parser::new(source);
362        let program = parser.parse().unwrap();
363        assert_eq!(program.statement_count, 5);
364
365        match program.statements[2] {
366            QasmStatement::QubitDecl { size, .. } => assert_eq!(size, 2),
367            _ => panic!("Expected QubitDecl"),
368        }
369    }
370
371    #[test]
372    fn test_composite_gate_expansion() {
373        let source = "
374            OPENQASM 3.0;
375            qubit[2] q;
376            gate bell a, b {
377                h a;
378                cx a, b;
379            }
380            bell q[0], q[1];
381        ";
382        let mut parser = Parser::new(source);
383        let program = parser.parse().unwrap();
384        assert_eq!(program.statement_count, 4);
385
386        let expanded = program.expand_composite_gates().unwrap();
387        // Statements in expanded:
388        // 0: Empty (OPENQASM)
389        // 1: QubitDecl
390        // 2: GateDecl (bell)
391        // 3: GateCall (h q[0])
392        // 4: GateCall (cx q[0], q[1])
393        assert_eq!(expanded.statement_count, 5);
394        match expanded.statements[3] {
395            QasmStatement::GateCall { name_hash, target_qubits, num_targets, .. } => {
396                assert_eq!(name_hash, q_hash("h"));
397                assert_eq!(target_qubits[0], 0);
398                assert_eq!(num_targets, 1);
399            }
400            _ => panic!("Expected GateCall for h"),
401        }
402        match expanded.statements[4] {
403            QasmStatement::GateCall { name_hash, target_qubits, num_targets, .. } => {
404                assert_eq!(name_hash, q_hash("cx"));
405                assert_eq!(target_qubits[0], 0);
406                assert_eq!(target_qubits[1], 1);
407                assert_eq!(num_targets, 2);
408            }
409            _ => panic!("Expected GateCall for cx"),
410        }
411    }
412}