1use crate::{
3 Code, Diagnostic, Parsed,
4 ast::{
5 Algorithm, Assignment, Binding, BindingKind, Block, Body, Branch, Decl, Expr, Fairness,
6 Label, Macro, Name, Procedure, Process, Span, Statement, StatementKind, StmtId, Syntax,
7 Token, WithBinding,
8 },
9 lexer,
10};
11use serde::{Deserialize, Serialize};
12
13#[derive(Clone, Debug, Serialize, Deserialize)]
15pub struct Options {
16 #[serde(default = "current_version")]
19 pub input_version: i32,
20 pub max_bytes: usize,
22 pub max_tokens: usize,
24 pub max_nodes: usize,
26 pub max_depth: usize,
28}
29const fn current_version() -> i32 {
30 1903
31}
32impl Default for Options {
33 fn default() -> Self {
34 Self {
35 input_version: current_version(),
36 max_bytes: 1_048_576,
37 max_tokens: 100_000,
38 max_nodes: 50_000,
39 max_depth: 128,
40 }
41 }
42}
43
44pub fn parse(source: &str, opts: &Options) -> Result<Parsed, Diagnostic> {
50 parse_at(source, 0..source.len(), opts)
51}
52
53pub fn parse_at(
64 source: &str,
65 region: std::ops::Range<usize>,
66 opts: &Options,
67) -> Result<Parsed, Diagnostic> {
68 parse_scoped(source, region, opts, true)
69}
70
71pub(crate) fn parse_prefix_at(
72 source: &str,
73 region: std::ops::Range<usize>,
74 opts: &Options,
75) -> Result<Parsed, Diagnostic> {
76 parse_scoped(source, region, opts, false)
77}
78
79fn parse_scoped(
80 source: &str,
81 region: std::ops::Range<usize>,
82 opts: &Options,
83 complete: bool,
84) -> Result<Parsed, Diagnostic> {
85 std::thread::scope(|scope| {
86 let failure = |code, message: String| Diagnostic {
87 code,
88 span: Span::default(),
89 message,
90 };
91 let worker = std::thread::Builder::new()
92 .name("dive-pluscal-parser".into())
93 .stack_size(16 * 1024 * 1024)
94 .spawn_scoped(scope, || parse_selected(source, region, opts, complete))
95 .map_err(|error| {
96 failure(
97 Code::Resource,
98 format!("cannot start PlusCal parser: {error}"),
99 )
100 })?;
101 worker.join().map_err(|_| {
102 failure(
103 Code::Internal,
104 "PlusCal parser worker failed; report this input as a bug".into(),
105 )
106 })?
107 })
108}
109
110fn parse_selected(
111 source: &str,
112 region: std::ops::Range<usize>,
113 opts: &Options,
114 complete: bool,
115) -> Result<Parsed, Diagnostic> {
116 let nearest = |offset: usize| {
117 let mut offset = offset.min(source.len());
118 while !source.is_char_boundary(offset) {
119 offset -= 1;
120 }
121 offset
122 };
123 let start = nearest(region.start);
124 let span = Span {
125 start,
126 end: nearest(region.end).max(start),
127 };
128 let error = |code, message: &str| Diagnostic {
129 code,
130 span,
131 message: message.into(),
132 };
133 if source.len() > opts.max_bytes.min(4_194_304) {
134 return Err(error(Code::Resource, "PlusCal source byte limit reached"));
135 }
136 let Some(text) = source.get(region.clone()) else {
137 return Err(error(Code::Syntax, "invalid PlusCal source region"));
138 };
139 let trimmed = text.trim_start();
140 let begin = region.start + text.len() - trimmed.len();
141 let (prefix, fair) = if trimmed.starts_with("--algorithm") {
142 ("--algorithm", false)
143 } else if trimmed.starts_with("--fair") {
144 ("--fair", true)
145 } else {
146 return Err(error(
147 Code::Syntax,
148 "expected --algorithm or --fair algorithm",
149 ));
150 };
151 let after = begin + prefix.len();
152 if source
153 .get(after..region.end)
154 .and_then(|s| s.chars().next())
155 .is_some_and(|c| c.is_alphanumeric() || c == '_')
156 {
157 return Err(error(
158 Code::Syntax,
159 "algorithm marker requires a token boundary",
160 ));
161 }
162 let (tokens, deferred) = if complete {
163 (
164 lexer::tokenize(source, after, region.end, opts.max_tokens)?,
165 Vec::new(),
166 )
167 } else {
168 lexer::tokenize_prefix(source, after, region.end, opts.max_tokens)?
169 };
170 let mut parser = Parser {
171 tokens,
172 pos: 0,
173 statements: Vec::new(),
174 syntax: Syntax::P,
175 opts,
176 nodes: 0,
177 in_macro: false,
178 end: region.end,
179 };
180 if fair {
181 parser.need("algorithm")?;
182 }
183 let algorithm = parser
184 .algorithm(begin, fair)
185 .map_err(|error| deferred.first().cloned().unwrap_or(error))?;
186 if let Some(error) = deferred
187 .into_iter()
188 .find(|error| error.span.start < algorithm.span.end)
189 {
190 return Err(error);
191 }
192 if complete && parser.pos != parser.tokens.len() {
193 return Err(parser.error(Code::Syntax, "unexpected trailing algorithm content"));
194 }
195 parser.tokens.truncate(parser.pos);
196 Ok(Parsed {
197 source: source.to_owned(),
198 algorithm,
199 statements: parser.statements,
200 tokens: parser.tokens,
201 })
202}
203
204struct Parser<'a> {
205 tokens: Vec<Token>,
206 pos: usize,
207 statements: Vec<Statement>,
208 syntax: Syntax,
209 opts: &'a Options,
210 nodes: usize,
211 in_macro: bool,
212 end: usize,
213}
214impl Parser<'_> {
215 fn peek(&self) -> &str {
216 self.tokens.get(self.pos).map_or("", |t| t.text.as_str())
217 }
218 fn at(&self, n: usize) -> &str {
219 self.tokens
220 .get(self.pos.saturating_add(n))
221 .map_or("", |t| t.text.as_str())
222 }
223 fn start(&self) -> usize {
224 self.tokens.get(self.pos).map_or(self.end, |t| t.span.start)
225 }
226 fn last(&self) -> usize {
227 self.pos
228 .checked_sub(1)
229 .and_then(|i| self.tokens.get(i))
230 .map_or(self.start(), |t| t.span.end)
231 }
232 fn error(&self, code: Code, message: &str) -> Diagnostic {
233 Diagnostic {
234 code,
235 span: self.tokens.get(self.pos).map_or(
236 Span {
237 start: self.end,
238 end: self.end,
239 },
240 |t| t.span,
241 ),
242 message: message.into(),
243 }
244 }
245 fn take(&mut self) -> Result<Token, Diagnostic> {
246 let token = self
247 .tokens
248 .get(self.pos)
249 .cloned()
250 .ok_or_else(|| self.error(Code::Syntax, "unexpected end of algorithm"))?;
251 self.pos += 1;
252 Ok(token)
253 }
254 fn eat(&mut self, word: &str) -> bool {
255 if self.peek() == word {
256 self.pos += 1;
257 true
258 } else {
259 false
260 }
261 }
262 fn need(&mut self, word: &str) -> Result<(), Diagnostic> {
263 if self.eat(word) {
264 Ok(())
265 } else {
266 Err(self.error(
267 Code::Syntax,
268 &format!("expected {word:?}, found {:?}", self.peek()),
269 ))
270 }
271 }
272 fn charge(&mut self, depth: usize) -> Result<(), Diagnostic> {
273 if depth > self.opts.max_depth.min(256) || self.nodes >= self.opts.max_nodes {
274 return Err(self.error(Code::Resource, "PlusCal node/nesting limit reached"));
275 }
276 self.nodes += 1;
277 Ok(())
278 }
279 fn name(&mut self) -> Result<Name, Diagnostic> {
280 let token = self.take()?;
281 if token.text.is_empty()
284 || matches!(
285 token.text.as_str(),
286 ";" | "," | "(" | ")" | "{" | "}" | ":=" | "≔"
287 )
288 {
289 return Err(Diagnostic {
290 code: Code::Syntax,
291 span: token.span,
292 message: "expected a name token".into(),
293 });
294 }
295 Ok(Name {
296 text: token.text,
297 span: token.span,
298 })
299 }
300 fn semi(&mut self) -> Result<(), Diagnostic> {
301 if self.eat(";")
302 || matches!(
303 self.peek(),
304 "end"
305 | "begin"
306 | "else"
307 | "elsif"
308 | "or"
309 | "do"
310 | "macro"
311 | "procedure"
312 | "process"
313 | "fair"
314 | "define"
315 | "}"
316 | "{"
317 )
318 {
319 Ok(())
320 } else {
321 Err(self.error(Code::Syntax, "expected statement/declaration separator ';'"))
322 }
323 }
324 fn separator(&mut self) -> Result<(), Diagnostic> {
325 if self.eat(",") { Ok(()) } else { self.semi() }
326 }
327 fn binding(&mut self) -> Result<Binding, Diagnostic> {
328 let kind = if self.eat("=") {
329 BindingKind::Equal
330 } else if self.eat("\\in") || self.eat("∈") {
331 BindingKind::Member
332 } else {
333 return Err(self.error(Code::Syntax, "expected '=' or membership binder"));
334 };
335 Ok(Binding {
336 kind,
337 expression: self.expression(false, false)?,
338 })
339 }
340 fn declaration(&mut self, parameter: bool) -> Result<Decl, Diagnostic> {
341 self.charge(0)?;
342 let name = self.name()?;
343 let start = name.span.start;
344 let initial = if matches!(self.peek(), "=" | "\\in" | "∈") {
345 if parameter && self.peek() != "=" {
346 return Err(self.error(
347 Code::Syntax,
348 "procedure parameter cannot use membership initialization",
349 ));
350 }
351 Some(self.binding()?)
352 } else {
353 None
354 };
355 Ok(Decl {
356 name,
357 initial,
358 span: Span {
359 start,
360 end: self.last(),
361 },
362 })
363 }
364 fn variables(&mut self, parameter: bool) -> Result<Vec<Decl>, Diagnostic> {
365 if !self.eat("variable") && !self.eat("variables") {
366 return Ok(Vec::new());
367 }
368 let mut variables = Vec::new();
369 while !matches!(
370 self.peek(),
371 "begin" | "{" | "define" | "macro" | "procedure" | "process" | "fair" | ""
372 ) {
373 variables.push(self.declaration(parameter)?);
374 self.separator()?;
375 }
376 Ok(variables)
377 }
378 fn begin(&mut self) -> Result<(), Diagnostic> {
379 self.need(if self.syntax == Syntax::P {
380 "begin"
381 } else {
382 "{"
383 })
384 }
385 fn finish(&mut self, role: &str) -> Result<(), Diagnostic> {
386 if self.syntax == Syntax::P {
387 self.need("end")?;
388 self.need(role)
389 } else {
390 self.need("}")
391 }
392 }
393 fn algorithm(&mut self, start: usize, fair: bool) -> Result<Algorithm, Diagnostic> {
394 self.charge(0)?;
395 let name = self.name()?;
396 if self.eat("{") {
397 self.syntax = Syntax::C;
398 }
399 let variables = self.variables(false)?;
400 let definitions = if self.eat("define") {
401 if self.syntax == Syntax::C {
402 self.need("{")?;
403 }
404 let expression = self.expression(true, true)?;
405 self.finish("define")?;
406 self.semi()?;
407 Some(expression)
408 } else {
409 None
410 };
411 let mut macros = Vec::new();
412 while self.peek() == "macro" {
413 macros.push(self.macro_def()?);
414 }
415 let mut procedures = Vec::new();
416 while self.peek() == "procedure" {
417 procedures.push(self.procedure()?);
418 }
419 let legacy_fair = self.opts.input_version == 1500
420 && self.peek() == "fair"
421 && self.tokens.get(self.pos + 1).is_some_and(|t| {
422 matches!(t.text.as_str(), "begin" | "{")
423 || (t.text == "+"
424 && self
425 .tokens
426 .get(self.pos + 2)
427 .is_some_and(|next| matches!(next.text.as_str(), "begin" | "{")))
428 });
429 if legacy_fair {
430 self.eat("fair");
431 self.eat("+");
432 }
433 let body = if matches!(self.peek(), "process" | "fair") {
434 let mut processes = Vec::new();
435 while matches!(self.peek(), "process" | "fair") {
436 processes.push(self.process()?);
437 }
438 Body::Processes(processes)
439 } else {
440 self.begin()?;
441 let block = self.sequence(0, &["end", "}"], self.syntax == Syntax::C)?;
442 if self.syntax == Syntax::C {
443 self.need("}")?;
444 }
445 Body::Sequential(block)
446 };
447 self.finish("algorithm")?;
448 self.eat(";");
449 Ok(Algorithm {
450 name,
451 syntax: self.syntax,
452 fairness: if fair {
453 Fairness::Weak
454 } else {
455 Fairness::Unfair
456 },
457 legacy_fair,
458 variables,
459 definitions,
460 macros,
461 procedures,
462 body,
463 span: Span {
464 start,
465 end: self.last(),
466 },
467 })
468 }
469 fn macro_def(&mut self) -> Result<Macro, Diagnostic> {
470 self.charge(0)?;
471 let start = self.start();
472 self.need("macro")?;
473 let name = self.name()?;
474 self.need("(")?;
475 let mut parameters = Vec::new();
476 while self.peek() != ")" {
477 parameters.push(self.name()?);
478 if self.peek() != ")" {
479 self.need(",")?;
480 }
481 }
482 self.need(")")?;
483 self.begin()?;
484 self.in_macro = true;
485 let body = self.sequence(0, &["end", "}"], self.syntax == Syntax::C)?;
486 self.in_macro = false;
487 self.finish("macro")?;
488 self.eat(";");
489 Ok(Macro {
490 name,
491 parameters,
492 body,
493 span: Span {
494 start,
495 end: self.last(),
496 },
497 })
498 }
499 fn procedure(&mut self) -> Result<Procedure, Diagnostic> {
500 self.charge(0)?;
501 let start = self.start();
502 self.need("procedure")?;
503 let name = self.name()?;
504 self.need("(")?;
505 let mut parameters = Vec::new();
506 while self.peek() != ")" {
507 parameters.push(self.declaration(true)?);
508 if self.peek() != ")" {
509 self.need(",")?;
510 }
511 }
512 self.need(")")?;
513 let variables = self.variables(true)?;
514 self.begin()?;
515 let body = self.sequence(0, &["end", "}"], self.syntax == Syntax::C)?;
516 self.finish("procedure")?;
517 self.eat(";");
518 Ok(Procedure {
519 name,
520 parameters,
521 variables,
522 body,
523 span: Span {
524 start,
525 end: self.last(),
526 },
527 })
528 }
529 fn process(&mut self) -> Result<Process, Diagnostic> {
530 self.charge(0)?;
531 let start = self.start();
532 let fairness = if self.eat("fair") {
533 if self.eat("+") {
534 Fairness::Strong
535 } else {
536 Fairness::Weak
537 }
538 } else {
539 Fairness::Unfair
540 };
541 self.need("process")?;
542 if self.syntax == Syntax::C {
543 self.need("(")?;
544 }
545 let name = self.name()?;
546 let id = self.binding()?;
547 if self.syntax == Syntax::C {
548 self.need(")")?;
549 }
550 let variables = self.variables(false)?;
551 self.begin()?;
552 let body = self.sequence(0, &["end", "}"], self.syntax == Syntax::C)?;
553 self.finish("process")?;
554 self.eat(";");
555 Ok(Process {
556 name,
557 fairness,
558 id,
559 variables,
560 body,
561 span: Span {
562 start,
563 end: self.last(),
564 },
565 })
566 }
567
568 fn expression(&mut self, define: bool, empty: bool) -> Result<Expr, Diagnostic> {
569 let start = self.start();
570 let first = self.pos;
571 let mut depth = 0usize;
572 let mut quantifier = false;
573 let mut previous = " ".to_owned();
574 while !self.peek().is_empty() {
575 let word = self.peek();
576 let field = matches!(previous.as_str(), "." | "[" | ",")
577 && word
578 .chars()
579 .next()
580 .is_some_and(|c| c.is_alphabetic() || c == '_');
581 let delimiter = matches!(
582 word,
583 ";" | "do"
584 | "then"
585 | ":="
586 | "≔"
587 | "begin"
588 | "variable"
589 | "variables"
590 | "||"
591 | "‖"
592 | "end"
593 | "else"
594 | "elsif"
595 | "if"
596 | "either"
597 | "or"
598 | "while"
599 | "with"
600 | "call"
601 | "return"
602 | "goto"
603 | "print"
604 | "assert"
605 | "skip"
606 | "procedure"
607 | "define"
608 | "process"
609 | "fair"
610 ) && !field;
611 if delimiter
612 || (depth == 0 && matches!(word, ")" | "}"))
613 || (depth == 0 && word == "," && !quantifier && !define)
614 {
615 if depth != 0 || quantifier {
616 return Err(self.error(
617 Code::Expression,
618 "expression has unmatched nesting or a quantifier without ':'",
619 ));
620 }
621 break;
622 }
623 if matches!(word, "(" | "[" | "{" | "<<" | "⟨") {
624 depth += 1;
625 if depth > self.opts.max_depth.min(256) {
626 return Err(
627 self.error(Code::Resource, "PlusCal expression nesting limit reached")
628 );
629 }
630 } else if matches!(word, ")" | "]" | "}" | ">>" | "⟩" | "]_" | ">>_" | "⟩_") {
631 depth = depth.checked_sub(1).ok_or_else(|| {
632 self.error(Code::Expression, "extra closing expression delimiter")
633 })?;
634 }
635 if depth == 0 && matches!(word, "\\A" | "∀" | "\\E" | "∃") {
636 quantifier = true;
637 }
638 if depth == 0 && word == ":" {
639 quantifier = false;
640 }
641 previous = if word.starts_with('"') {
642 " ".into()
643 } else {
644 word.to_owned()
645 };
646 self.pos += 1;
647 }
648 if depth != 0 || quantifier {
649 return Err(self.error(
650 Code::Expression,
651 "unterminated expression nesting or quantifier",
652 ));
653 }
654 if self.pos == first && !empty {
655 return Err(self.error(Code::Expression, "missing expression"));
656 }
657 Ok(Expr {
658 span: Span {
659 start,
660 end: if self.pos == first {
661 start
662 } else {
663 self.last()
664 },
665 },
666 })
667 }
668 fn label(&mut self) -> Result<Option<Label>, Diagnostic> {
669 if self.at(1) != ":"
670 || matches!(
671 self.peek(),
672 "while"
673 | "if"
674 | "else"
675 | "elsif"
676 | "either"
677 | "or"
678 | "end"
679 | "with"
680 | "when"
681 | "await"
682 | "skip"
683 | "call"
684 | "return"
685 | "goto"
686 | "assert"
687 | "print"
688 )
689 {
690 return Ok(None);
691 }
692 let name = self.name()?;
693 if self.in_macro || matches!(name.text.as_str(), "Done" | "Error") {
694 return Err(Diagnostic {
695 code: Code::Label,
696 span: name.span,
697 message: "reserved label or label inside a macro".into(),
698 });
699 }
700 self.need(":")?;
701 let modifier = if self.eat("+") {
702 Some('+')
703 } else if self.eat("-") {
704 Some('-')
705 } else {
706 None
707 };
708 let span = Span {
709 start: name.span.start,
710 end: self.last(),
711 };
712 Ok(Some(Label {
713 name,
714 modifier,
715 span,
716 }))
717 }
718 fn sequence(
719 &mut self,
720 depth: usize,
721 stops: &[&str],
722 nonempty: bool,
723 ) -> Result<Block, Diagnostic> {
724 let start = self.start();
725 let mut statements = Vec::new();
726 while !self.peek().is_empty() && !stops.contains(&self.peek()) {
727 statements.push(self.statement(depth + 1)?);
728 }
729 if nonempty && statements.is_empty() {
730 return Err(self.error(Code::Syntax, "empty statement body"));
731 }
732 let end = if statements.is_empty() {
733 start
734 } else {
735 self.last()
736 };
737 Ok(Block {
738 span: Span { start, end },
739 statements,
740 })
741 }
742 fn c_body(&mut self, depth: usize) -> Result<Block, Diagnostic> {
743 let start = self.start();
744 let id = self.statement(depth + 1)?;
745 Ok(Block {
746 span: Span {
747 start,
748 end: self.last(),
749 },
750 statements: vec![id],
751 })
752 }
753 fn arguments(&mut self) -> Result<Vec<Expr>, Diagnostic> {
754 self.need("(")?;
755 let mut args = Vec::new();
756 while self.peek() != ")" {
757 args.push(self.expression(false, false)?);
758 if self.peek() != ")" {
759 self.need(",")?;
760 }
761 }
762 self.need(")")?;
763 Ok(args)
764 }
765 fn assignment(&mut self) -> Result<Assignment, Diagnostic> {
766 self.charge(0)?;
767 let variable = self.name()?;
768 let start = variable.span.start;
769 let selectors = self.expression(false, true)?;
770 if !self.eat(":=") && !self.eat("≔") {
771 return Err(self.error(Code::Syntax, "expected ':=' assignment token"));
772 }
773 let value = self.expression(false, false)?;
774 Ok(Assignment {
775 variable,
776 selectors: if selectors.span.start == selectors.span.end {
777 None
778 } else {
779 Some(selectors)
780 },
781 value,
782 span: Span {
783 start,
784 end: self.last(),
785 },
786 })
787 }
788 #[allow(clippy::too_many_lines)]
791 fn statement(&mut self, depth: usize) -> Result<StmtId, Diagnostic> {
792 self.charge(depth)?;
793 let start = self.start();
794 let label = self.label()?;
795 let kind = match self.peek() {
796 "{" if self.syntax == Syntax::C => {
797 self.need("{")?;
798 let mut body = self.sequence(depth, &["}"], true)?;
799 self.need("}")?;
800 self.semi()?;
801 body.span = Span {
802 start,
803 end: self.last(),
804 };
805 if label.is_some()
806 && body
807 .statements
808 .first()
809 .and_then(|i| self.statements.get(i.0))
810 .is_some_and(|s| s.label.is_some())
811 {
812 return Err(self.error(Code::Label, "duplicate labeling of statement block"));
813 }
814 StatementKind::Block(body)
815 }
816 "while" => {
817 self.need("while")?;
818 if self.syntax == Syntax::C {
819 self.need("(")?;
820 }
821 let test = self.expression(false, false)?;
822 let body = if self.syntax == Syntax::P {
823 self.need("do")?;
824 let body = self.sequence(depth, &["end"], true)?;
825 self.finish("while")?;
826 self.semi()?;
827 body
828 } else {
829 self.need(")")?;
830 self.c_body(depth)?
831 };
832 StatementKind::While { test, body }
833 }
834 "if" => {
835 self.need("if")?;
836 let mut branches = Vec::new();
837 loop {
838 self.charge(depth)?;
839 if self.syntax == Syntax::C {
840 self.need("(")?;
841 }
842 let test = self.expression(false, false)?;
843 let body = if self.syntax == Syntax::P {
844 self.need("then")?;
845 self.sequence(depth, &["else", "elsif", "end"], false)?
846 } else {
847 self.need(")")?;
848 self.c_body(depth)?
849 };
850 branches.push(Branch { test, body });
851 if self.syntax == Syntax::P && self.eat("elsif") {
852 continue;
853 }
854 break;
855 }
856 let otherwise = if self.eat("else") {
857 Some(if self.syntax == Syntax::P {
858 self.sequence(depth, &["end"], false)?
859 } else {
860 self.c_body(depth)?
861 })
862 } else {
863 None
864 };
865 if branches
866 .last()
867 .is_none_or(|branch| branch.body.statements.is_empty())
868 && otherwise
869 .as_ref()
870 .is_none_or(|body| body.statements.is_empty())
871 {
872 return Err(self.error(Code::Syntax, "if statement has no branch statements"));
873 }
874 if self.syntax == Syntax::P {
875 self.finish("if")?;
876 self.semi()?;
877 }
878 StatementKind::If {
879 branches,
880 otherwise,
881 }
882 }
883 "either" => {
884 self.need("either")?;
885 let mut branches = Vec::new();
886 loop {
887 self.charge(depth)?;
888 branches.push(if self.syntax == Syntax::P {
889 self.sequence(depth, &["or", "end"], true)?
890 } else {
891 self.c_body(depth)?
892 });
893 if !self.eat("or") {
894 break;
895 }
896 }
897 if branches.len() < 2 {
898 return Err(self.error(Code::Syntax, "either requires an or clause"));
899 }
900 if self.syntax == Syntax::P {
901 self.finish("either")?;
902 self.semi()?;
903 }
904 StatementKind::Either(branches)
905 }
906 "with" => {
907 self.need("with")?;
908 if self.syntax == Syntax::C {
909 self.need("(")?;
910 }
911 let mut bindings = Vec::new();
912 loop {
913 self.charge(depth)?;
914 let name = self.name()?;
915 let binding = self.binding()?;
916 bindings.push(WithBinding { name, binding });
917 if self.syntax == Syntax::C && self.peek() == ")" {
918 break;
919 }
920 self.separator()?;
921 if (self.syntax == Syntax::P && self.peek() == "do")
922 || (self.syntax == Syntax::C && self.peek() == ")")
923 {
924 break;
925 }
926 }
927 let body = if self.syntax == Syntax::P {
928 self.need("do")?;
929 let body = self.sequence(depth, &["end"], true)?;
930 self.finish("with")?;
931 self.semi()?;
932 body
933 } else {
934 self.need(")")?;
935 self.c_body(depth)?
936 };
937 StatementKind::With { bindings, body }
938 }
939 "when" | "await" => {
940 let when = self.eat("when");
941 if !when {
942 self.need("await")?;
943 }
944 let condition = self.expression(false, false)?;
945 self.semi()?;
946 StatementKind::Await { when, condition }
947 }
948 "assert" => {
949 self.need("assert")?;
950 let e = self.expression(false, false)?;
951 self.semi()?;
952 StatementKind::Assert(e)
953 }
954 "print" => {
955 self.need("print")?;
956 let e = self.expression(false, false)?;
957 self.semi()?;
958 StatementKind::Print(e)
959 }
960 "skip" => {
961 self.need("skip")?;
962 self.semi()?;
963 StatementKind::Skip
964 }
965 "return" => {
966 self.need("return")?;
967 self.semi()?;
968 StatementKind::Return
969 }
970 "goto" => {
971 self.need("goto")?;
972 let name = self.name()?;
973 self.semi()?;
974 StatementKind::Goto(name)
975 }
976 "call" => {
977 self.need("call")?;
978 let name = self.name()?;
979 let arguments = self.arguments()?;
980 self.semi()?;
981 StatementKind::Call { name, arguments }
982 }
983 _ if self.at(1) == "(" => {
984 let name = self.name()?;
985 let arguments = self.arguments()?;
986 self.semi()?;
987 StatementKind::MacroCall { name, arguments }
988 }
989 _ => {
990 let mut assignments = vec![self.assignment()?];
991 while self.eat("||") || self.eat("‖") {
992 assignments.push(self.assignment()?);
993 }
994 self.semi()?;
995 StatementKind::Assign(assignments)
996 }
997 };
998 let id = StmtId(self.statements.len());
999 self.statements.push(Statement {
1000 span: Span {
1001 start,
1002 end: self.last(),
1003 },
1004 label,
1005 kind,
1006 });
1007 Ok(id)
1008 }
1009}