qualia_q_forge/qasm/
parser.rs1use crate::qasm::{QasmProgram, QasmStatement};
2use qualia_core_db::q_hash;
3
4pub struct Parser<'a> {
6 input: &'a str,
7 pos: usize,
8}
9
10impl<'a> Parser<'a> {
11 pub fn new(input: &'a str) -> Self {
13 Self { input, pos: 0 }
14 }
15
16 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 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 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 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 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; }
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 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; self.skip_whitespace();
144 }
145
146 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 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 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}