use crate::{
grammar::{
ParseResult,
cpp::{decls, exprs, modules, types},
},
kind::{CppSyntaxKind, CppTokenKind},
parser::{CompleteMarker, CppParser, MarkerEventContainer},
parser_error::CppParseError,
};
use super::{decls::parse_using_declaration, expect_token, exprs::parse_expr};
pub(crate) fn parse_compound_stat(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::CompoundStat);
if p.current_token() == CppTokenKind::LeftBrace {
p.bump();
if p.parse_config.skips_bodies() {
let mut depth = 1usize;
while depth > 0 {
match p.current_token() {
CppTokenKind::Eof => break,
CppTokenKind::LeftBrace => depth += 1,
CppTokenKind::RightBrace => depth -= 1,
_ => {}
}
p.bump();
}
return Ok(m.complete(p));
}
p.enter_type_name_scope();
p.enter_block_body();
parse_stats(p);
p.leave_block_body();
p.leave_type_name_scope();
if p.current_token() == CppTokenKind::RightBrace {
p.bump();
return Ok(m.complete(p));
}
p.emit_missing_node();
p.push_error(CppParseError::syntax_error_from(
&t!("expected `}`"),
p.current_token_range(),
));
return Ok(m.complete(p));
}
if let Err(err) = parse_stat(p) {
p.close_marks_above(base);
return Err(err);
}
Ok(m.complete(p))
}
pub fn parse_stats(p: &mut CppParser) {
let mut unclosed_braces = 0isize;
let mut the_last_early_exit = usize::MAX;
let since = p.current_token_range().start_offset;
while !block_follow(p) || unclosed_braces > 0 {
if p.is_eof() {
break;
}
if p.crossed_a_file_boundary_since(since) {
break;
}
p.emit_trivia_after_current_token();
if p.is_eof() || (block_follow(p) && unclosed_braces <= 0) {
break;
}
if p.current_token() == CppTokenKind::RightBrace {
unclosed_braces -= 1;
let error = p.mark(CppSyntaxKind::ErrorNode);
p.bump();
error.complete(p);
continue;
}
let level = p.open_marks();
let before_events = p.current_event_count();
match parse_stat(p) {
Ok(_) => {}
Err(err) => {
let before = p.current_token_index();
if before != the_last_early_exit {
p.push_error(err);
}
p.recover_to_level(level);
unclosed_braces += p.brace_balance_since(before_events).max(0);
if before != the_last_early_exit && begins_a_statement(p) {
the_last_early_exit = before;
continue;
}
the_last_early_exit = usize::MAX;
while !p.is_eof()
&& p.current_token() != CppTokenKind::Semicolon
&& p.current_token() != CppTokenKind::RightBrace
{
if p.current_token() == CppTokenKind::LeftBrace {
unclosed_braces += 1;
}
p.bump();
}
if p.current_token() == CppTokenKind::Semicolon {
p.bump();
}
if p.current_token_index() == before {
if p.current_token() == CppTokenKind::LeftBrace {
unclosed_braces += 1;
let error = p.mark(CppSyntaxKind::ErrorNode);
p.bump();
error.complete(p);
continue;
}
break;
}
}
}
}
}
fn begins_a_statement(p: &mut CppParser) -> bool {
match p.current_token() {
CppTokenKind::IfKeyword
| CppTokenKind::WhileKeyword
| CppTokenKind::DoKeyword
| CppTokenKind::ForKeyword
| CppTokenKind::SwitchKeyword
| CppTokenKind::TryKeyword
| CppTokenKind::ReturnKeyword
| CppTokenKind::CoReturnKeyword
| CppTokenKind::CoYieldKeyword
| CppTokenKind::BreakKeyword
| CppTokenKind::ContinueKeyword
| CppTokenKind::GotoKeyword
| CppTokenKind::ThrowKeyword
| CppTokenKind::LeftBrace => true,
CppTokenKind::AutoKeyword => true,
CppTokenKind::Identifier => a_type_and_a_name_follow(p) || a_member_access_follows(p),
kind => exprs::starter_of_a_builtin_type(kind) || decls::can_begin_a_declaration(kind),
}
}
fn a_member_access_follows(p: &CppParser) -> bool {
matches!(
p.peek_token_kind_at(1..2).first().copied(),
Some(CppTokenKind::Dot | CppTokenKind::Arrow)
)
}
fn a_type_and_a_name_follow(p: &CppParser) -> bool {
const MAX_TOKENS: usize = 96;
let kind = |offset: usize| p.peek_token_kind_at(offset..offset + 1).first().copied();
if !matches!(kind(0), Some(CppTokenKind::Identifier)) {
return false;
}
let mut at = 1usize;
while at < MAX_TOKENS {
match kind(at) {
Some(CppTokenKind::Scope) if matches!(kind(at + 1), Some(CppTokenKind::Identifier)) => {
at += 2
}
Some(CppTokenKind::Less) => {
let mut depth = 0usize;
loop {
match kind(at) {
Some(CppTokenKind::Less) => {
depth += 1;
at += 1;
}
Some(CppTokenKind::Greater) => {
depth = depth.saturating_sub(1);
at += 1;
}
Some(_) => at += 1,
None => return false,
}
if depth == 0 {
break;
}
if at >= MAX_TOKENS {
return false;
}
}
}
_ => break,
}
}
while matches!(
kind(at),
Some(CppTokenKind::Star | CppTokenKind::Ampersand | CppTokenKind::ConstKeyword)
) {
at += 1;
}
if !matches!(kind(at), Some(CppTokenKind::Identifier)) {
return false;
}
matches!(
kind(at + 1),
Some(
CppTokenKind::Assign
| CppTokenKind::Semicolon
| CppTokenKind::LeftParen
| CppTokenKind::LeftBracket
| CppTokenKind::LeftBrace
| CppTokenKind::Comma
| CppTokenKind::Colon
)
)
}
fn block_follow(p: &CppParser) -> bool {
matches!(
p.current_token(),
CppTokenKind::RightBrace | CppTokenKind::Eof | CppTokenKind::CaseKeyword | CppTokenKind::DefaultKeyword | CppTokenKind::ElseKeyword | CppTokenKind::CatchKeyword )
}
pub fn parse_stat(p: &mut CppParser) -> ParseResult {
let _phase = crate::parser::phases::during("statement");
let base = p.open_marks();
let result = match p.current_token() {
CppTokenKind::IfKeyword => parse_if_statement(p),
CppTokenKind::WhileKeyword => parse_while_statement(p),
CppTokenKind::DoKeyword => parse_do_while_statement(p),
CppTokenKind::ForKeyword => parse_for_statement(p),
CppTokenKind::SwitchKeyword => parse_switch_statement(p),
CppTokenKind::TryKeyword => parse_try_statement(p),
CppTokenKind::Identifier if at_the_implementations_try(p) => parse_try_statement(p),
CppTokenKind::Identifier if at_an_asm_statement(p) => parse_asm_statement(p),
CppTokenKind::ReturnKeyword => parse_return_statement(p),
CppTokenKind::CoReturnKeyword => parse_return_statement(p),
CppTokenKind::CoYieldKeyword => parse_throw_statement(p),
CppTokenKind::BreakKeyword => parse_keyword_statement(p, CppSyntaxKind::BreakStat),
CppTokenKind::ContinueKeyword => parse_keyword_statement(p, CppSyntaxKind::ContinueStat),
CppTokenKind::GotoKeyword => parse_goto_statement(p),
CppTokenKind::ThrowKeyword => parse_throw_statement(p),
CppTokenKind::LeftBrace => parse_compound_stat(p),
_ if types::at_an_attribute(p) => {
if let Err(err) = types::parse_attribute_specifiers(p) {
Err(err)
} else if matches!(
p.current_token(),
CppTokenKind::CaseKeyword | CppTokenKind::DefaultKeyword
) {
if let Err(err) = read_switch_labels(p, base) {
Err(err)
} else {
parse_stat(p)
}
} else {
parse_stat(p)
}
}
_ if modules::starts_module_related_declaration(p) => decls::parse_declaration(p),
CppTokenKind::Identifier
if p.peek_token_kind_at(1..2).as_slice() == [CppTokenKind::Colon] =>
{
parse_label_statement(p)
}
CppTokenKind::Semicolon => {
let m = p.mark(CppSyntaxKind::EmptyStat);
p.bump();
Ok(m.complete(p))
}
CppTokenKind::Identifier if at_a_macro_that_stands_for_a_declaration(p) => {
parse_a_macro_that_stands_for_a_declaration(p)
}
_ => parse_declaration_or_expression_statement(p),
};
if result.is_err() {
p.close_marks_above(base);
}
result
}
fn at_an_asm_statement(p: &CppParser) -> bool {
if p.current_token() != CppTokenKind::Identifier
|| !matches!(p.current_token_text(), "asm" | "__asm" | "__asm__")
{
return false;
}
let mut offset = 1usize;
loop {
match p.peek_token_kind_at(offset..offset + 1).first() {
Some(
&CppTokenKind::VolatileKeyword
| &CppTokenKind::InlineKeyword
| &CppTokenKind::GotoKeyword,
) => offset += 1,
Some(&CppTokenKind::Identifier)
if matches!(p.peek_token_text_at(offset), "__volatile__" | "__volatile") =>
{
offset += 1;
}
Some(&CppTokenKind::LeftParen | &CppTokenKind::LeftBrace) => return true,
_ => return false,
}
}
}
fn parse_asm_statement(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::AsmStat);
p.bump();
loop {
match p.current_token() {
CppTokenKind::VolatileKeyword
| CppTokenKind::InlineKeyword
| CppTokenKind::GotoKeyword => p.bump(),
CppTokenKind::Identifier
if matches!(p.current_token_text(), "__volatile__" | "__volatile") =>
{
p.bump();
}
_ => break,
}
}
let (open, close, closes_itself) = match p.current_token() {
CppTokenKind::LeftParen => (CppTokenKind::LeftParen, CppTokenKind::RightParen, false),
CppTokenKind::LeftBrace => (CppTokenKind::LeftBrace, CppTokenKind::RightBrace, true),
_ => {
p.close_marks_above(base);
return Err(CppParseError::syntax_error_from(
&t!("expected `(` after `asm`"),
p.current_token_range(),
));
}
};
let mut depth = 0isize;
while !p.is_eof() {
let kind = p.current_token();
if kind == open {
depth += 1;
} else if kind == close {
depth -= 1;
if depth == 0 {
p.bump();
break;
}
}
p.bump();
}
if depth != 0 {
p.close_marks_above(base);
return Err(CppParseError::syntax_error_from(
&t!("unterminated `asm` payload"),
p.current_token_range(),
));
}
if p.current_token() == CppTokenKind::Semicolon {
p.bump();
} else if !closes_itself {
p.emit_missing_node();
p.push_error(CppParseError::syntax_error_from(
&t!("expected `;`"),
p.current_token_range(),
));
}
Ok(m.complete(p))
}
fn parse_a_macro_invocation_statement(p: &mut CppParser, start: usize) -> ParseResult {
let after_the_name = decls::next_significant_index(p, start);
if p.token_kind_at(after_the_name) != CppTokenKind::LeftParen {
return parse_a_macro_that_stands_for_a_declaration(p);
}
parse_macro_call(p)
}
pub(super) fn a_macro_invocation_starts_at(p: &CppParser, index: usize) -> bool {
if p.token_kind_at(index) != CppTokenKind::Identifier {
return false;
}
let name = p.token_text_at(index);
let after = decls::next_significant_index(p, index);
p.token_kind_at(after) == CppTokenKind::LeftParen
&& types::written_in_the_implementations_namespace(name)
&& kind_after_the_balanced_group(p, index).is_some_and(ends_a_statement)
}
fn index_after_a_reserved_invocation_before_a_declaration(
p: &CppParser,
index: usize,
) -> Option<usize> {
if p.token_kind_at(index) != CppTokenKind::Identifier
|| !types::written_in_the_implementations_namespace(p.token_text_at(index))
{
return None;
}
if p.token_kind_at(decls::next_significant_index(p, index)) != CppTokenKind::LeftParen {
return None;
}
let after = index_after_the_balanced_group(p, index)?;
let kind = p.token_kind_at(after);
(starts_a_new_declaration(kind) || kind == CppTokenKind::ExportKeyword).then_some(after)
}
fn index_after_a_run_of_annotation_invocations(p: &CppParser, index: usize) -> Option<usize> {
let mut index = index;
let mut saw_a_group = false;
loop {
if p.token_kind_at(index) != CppTokenKind::Identifier
|| !types::written_in_the_implementations_namespace(p.token_text_at(index))
{
break;
}
if p.token_kind_at(decls::next_significant_index(p, index)) == CppTokenKind::LeftParen {
index = index_after_the_balanced_group(p, index)?;
saw_a_group = true;
} else {
index = decls::next_significant_index(p, index);
}
}
let a_declaration_begins_here = starts_a_new_declaration(p.token_kind_at(index))
|| p.token_kind_at(index) == CppTokenKind::Identifier;
(saw_a_group && a_declaration_begins_here).then_some(index)
}
pub(super) fn index_after_the_balanced_group(p: &CppParser, index: usize) -> Option<usize> {
let mut index = decls::next_significant_index(p, index);
let mut depth = 0isize;
while index < p.token_count() {
match p.token_kind_at(index) {
CppTokenKind::LeftParen => depth += 1,
CppTokenKind::RightParen => {
depth -= 1;
if depth == 0 {
return Some(decls::next_significant_index(p, index));
}
}
CppTokenKind::Semicolon | CppTokenKind::Eof | CppTokenKind::None => return None,
_ => {}
}
index += 1;
}
None
}
fn kind_after_the_balanced_group(p: &CppParser, index: usize) -> Option<CppTokenKind> {
index_after_the_balanced_group(p, index).map(|after| p.token_kind_at(after))
}
fn ends_a_statement(kind: CppTokenKind) -> bool {
matches!(
kind,
CppTokenKind::RightBrace
| CppTokenKind::Hash
| CppTokenKind::Eof
| CppTokenKind::None
| CppTokenKind::IfKeyword
| CppTokenKind::WhileKeyword
| CppTokenKind::ForKeyword
| CppTokenKind::SwitchKeyword
| CppTokenKind::DoKeyword
| CppTokenKind::ReturnKeyword
| CppTokenKind::TryKeyword
| CppTokenKind::ThrowKeyword
| CppTokenKind::BreakKeyword
| CppTokenKind::ContinueKeyword
| CppTokenKind::GotoKeyword
| CppTokenKind::CaseKeyword
| CppTokenKind::DefaultKeyword
| CppTokenKind::ElseKeyword
| CppTokenKind::CatchKeyword
| CppTokenKind::Identifier
)
|| starts_a_new_declaration(kind)
}
fn at_a_macro_that_stands_for_a_declaration(p: &CppParser) -> bool {
if p.current_token() != CppTokenKind::Identifier || p.is_inside_a_body() {
return false;
}
let after = decls::kind_after_the_run_of_names(p);
starts_a_new_declaration(after) || ends_the_scope(after)
}
fn starts_a_new_declaration(kind: CppTokenKind) -> bool {
decls::can_begin_a_declaration(kind) || types::is_type_specifier_keyword(kind)
}
fn ends_the_scope(kind: CppTokenKind) -> bool {
matches!(
kind,
CppTokenKind::RightBrace | CppTokenKind::Hash | CppTokenKind::Eof | CppTokenKind::None
)
}
pub(super) fn parse_a_macro_that_stands_for_a_declaration(p: &mut CppParser) -> ParseResult {
let m = p.mark(CppSyntaxKind::MacroCall);
let name = p.mark(CppSyntaxKind::NameExpr);
p.bump();
name.complete(p);
if p.current_token() == CppTokenKind::LeftParen {
decls::parse_balanced_token_group(p, CppSyntaxKind::ArgumentList)?;
}
Ok(m.complete(p))
}
fn parse_macro_call(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::MacroCall);
let name = p.mark(CppSyntaxKind::NameExpr);
p.bump();
name.complete(p);
decls::parse_balanced_token_group(p, CppSyntaxKind::ArgumentList)?;
match p.current_token() {
CppTokenKind::LeftBrace => {
if let Err(err) = parse_compound_stat(p) {
p.close_marks_above(base);
return Err(err);
}
}
CppTokenKind::Semicolon => p.bump(),
_ => {}
}
Ok(m.complete(p))
}
fn parse_declaration_or_expression_statement(p: &mut CppParser) -> ParseResult {
if p.current_token() == CppTokenKind::Hash {
return parse_preprocessor_directive(p);
}
if p.current_token() == CppTokenKind::UsingKeyword {
return parse_using_declaration(p);
}
if decls::starts_declaration(p) {
return decls::parse_declaration(p);
}
if a_call_whose_first_argument_is_an_address(p) {
return parse_expression_statement(p);
}
let start = p.current_token_index();
let checkpoint = p.checkpoint();
match decls::parse_declaration(p) {
Ok(marker) => {
if p.last_consumed_token_kind() != Some(CppTokenKind::Semicolon)
&& a_macro_invocation_starts_at(p, start)
{
p.rollback(checkpoint);
return parse_a_macro_invocation_statement(p, start);
}
Ok(marker)
}
Err(err) => {
if std::env::var("CPPLS_TRACE_DECLARATION").is_ok() {
eprintln!(
"[decl] the declaration reading failed at {}: {err:?}",
p.current_token_range().start_offset
);
}
p.rollback(checkpoint);
if a_macro_invocation_starts_at(p, start) {
return parse_a_macro_invocation_statement(p, start);
}
if let Some(after) = index_after_a_reserved_invocation_before_a_declaration(p, start) {
while p.current_token_index() < after && !p.is_eof() {
p.bump();
}
return decls::parse_declaration(p);
}
if index_after_a_run_of_annotation_invocations(p, start).is_some() {
return parse_a_macro_that_stands_for_a_declaration(p);
}
parse_expression_statement(p)
}
}
}
pub(super) fn parse_preprocessor_directive(p: &mut CppParser) -> ParseResult {
let m = p.mark(CppSyntaxKind::PreprocessorDirective);
let directive_from = p.current_token_range().start_offset;
let text = p.origin_text();
let mut line_end = logical_line_end(text, p.current_token_range().start_offset);
p.bump();
if p.current_token_range().start_offset < line_end {
p.note_a_directive_name();
}
let directive_is_include = p.current_token() == CppTokenKind::Identifier
&& matches!(p.current_token_text(), "include" | "include_next");
if p.current_token() == CppTokenKind::Identifier {
p.bump();
}
let mut header_name_expected = directive_is_include;
while !p.is_eof() && p.current_token_range().start_offset < line_end {
if p.current_token() == CppTokenKind::LineContinuation {
p.bump();
line_end = logical_line_end(text, p.current_token_range().start_offset);
continue;
}
if header_name_expected {
header_name_expected = false;
if p.try_lex_header_name() {
continue;
}
}
p.bump();
}
let directive_to = p.current_token_range().start_offset;
p.forget_unrecognized_characters_within(directive_from, directive_to);
Ok(m.complete(p))
}
pub(super) fn logical_line_end(text: &str, start: usize) -> usize {
let Some(rest) = text.get(start..) else {
return text.len();
};
let bytes = rest.as_bytes();
let mut index = 0;
while index < bytes.len() {
if bytes[index] == b'\n' {
let before = if index > 0 && bytes[index - 1] == b'\r' {
index.checked_sub(2)
} else {
index.checked_sub(1)
};
let spliced = before.is_some_and(|at| bytes[at] == b'\\');
if !spliced {
return start + index;
}
}
index += 1;
}
text.len()
}
fn parse_expression_statement(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::ExpressionStat);
if let Err(err) = parse_expr(p) {
p.close_marks_above(base);
return Err(err);
}
if p.current_token() == CppTokenKind::Semicolon {
p.bump();
return Ok(m.complete(p));
}
p.emit_missing_node();
p.end_marks_to(base);
Err(CppParseError::syntax_error_from(
&t!("expected `;` after expression"),
p.current_token_range(),
))
}
fn parse_if_statement(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::IfStat);
p.bump();
let consteval_form = if p.current_token() == CppTokenKind::ConstexprKeyword {
p.bump();
false
} else if p.current_token() == CppTokenKind::ConstevalKeyword
|| (p.current_token() == CppTokenKind::Identifier && p.current_token_text() == "consteval")
{
p.bump();
true
} else if p.current_token() == CppTokenKind::LogicalNot
&& p.peek_token_kind_at(1..2).as_slice() == [CppTokenKind::ConstevalKeyword]
{
p.bump(); p.bump(); true
} else {
false
};
if p.current_token() == CppTokenKind::Identifier
&& p.peek_next_token() == CppTokenKind::LeftParen
{
p.bump(); }
if !consteval_form && let Err(err) = parse_condition(p) {
p.close_marks_above(base);
return Err(err);
}
if let Err(err) = parse_statement_body(p) {
p.close_marks_above(base);
return Err(err);
}
if let Err(err) = eat_preprocessor_directives(p) {
p.close_marks_above(base);
return Err(err);
}
if p.current_token() == CppTokenKind::ElseKeyword {
let else_m = p.mark(CppSyntaxKind::ElseStat);
p.bump();
if let Err(err) = eat_preprocessor_directives(p) {
p.close_marks_above(base);
return Err(err);
}
if let Err(err) = parse_statement_body(p) {
p.close_marks_above(base);
return Err(err);
}
else_m.complete(p);
}
Ok(m.complete(p))
}
fn parse_while_statement(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::WhileStat);
p.bump();
if let Err(err) = parse_condition(p) {
p.close_marks_above(base);
return Err(err);
}
if let Err(err) = parse_statement_body(p) {
p.close_marks_above(base);
return Err(err);
}
Ok(m.complete(p))
}
fn parse_do_while_statement(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::DoWhileStat);
p.bump(); if let Err(err) = parse_statement_body(p) {
p.close_marks_above(base);
return Err(err);
}
if let Err(err) = expect_token(p, CppTokenKind::WhileKeyword) {
p.close_marks_above(base);
return Err(err);
}
if let Err(err) = parse_condition(p) {
p.close_marks_above(base);
return Err(err);
}
if let Err(err) = expect_token(p, CppTokenKind::Semicolon) {
p.close_marks_above(base);
return Err(err);
}
Ok(m.complete(p))
}
fn parse_condition(p: &mut CppParser) -> ParseResult {
let _ = p.open_marks();
let m = p.mark(CppSyntaxKind::ParenExpr);
expect_token(p, CppTokenKind::LeftParen)?;
if a_semicolon_ends_an_initializer(p) {
parse_initializer_part(p)?;
expect_token(p, CppTokenKind::Semicolon)?;
parse_expr(p)?;
expect_token(p, CppTokenKind::RightParen)?;
return Ok(m.complete(p));
}
let checkpoint = p.checkpoint();
if decls::parse_condition_declaration(p).is_err() {
p.rollback(checkpoint);
parse_expr(p)?;
}
if !matches!(p.current_token(), CppTokenKind::RightParen) {
types::skip_to_the_closing_paren(p);
}
expect_token(p, CppTokenKind::RightParen)?;
Ok(m.complete(p))
}
fn a_semicolon_ends_an_initializer(p: &CppParser) -> bool {
let mut depth = 0isize;
for kind in p.peek_token_kind_at(0..64) {
match kind {
CppTokenKind::LeftParen | CppTokenKind::LeftBracket | CppTokenKind::LeftBrace => {
depth += 1
}
CppTokenKind::RightParen | CppTokenKind::RightBracket | CppTokenKind::RightBrace => {
if depth == 0 {
return false;
}
depth -= 1;
}
CppTokenKind::Semicolon if depth == 0 => return true,
CppTokenKind::Eof | CppTokenKind::None => return false,
_ => {}
}
}
false
}
fn parse_initializer_part(p: &mut CppParser) -> ParseResult {
let checkpoint = p.checkpoint();
if decls::parse_for_init_declaration(p).is_ok() {
return Ok(CompleteMarker::empty());
}
p.rollback(checkpoint);
parse_expr(p)
}
fn parse_statement_body(p: &mut CppParser) -> ParseResult {
types::parse_attribute_specifiers(p)?;
if p.current_token() == CppTokenKind::LeftBrace {
return parse_compound_stat(p);
}
parse_stat(p)
}
fn parse_for_statement(p: &mut CppParser) -> ParseResult {
let _ = p.open_marks();
let m = p.mark(CppSyntaxKind::ForStat);
p.bump();
if p.current_token() == CppTokenKind::CoAwaitKeyword {
p.bump();
}
expect_token(p, CppTokenKind::LeftParen)?;
if starts_a_range_for(p) {
let checkpoint = p.checkpoint();
if decls::parse_for_init_declaration(p).is_err() {
p.rollback(checkpoint.clone());
parse_expr(p)?;
}
if p.current_token() == CppTokenKind::Colon {
let mut m = m;
m.set_kind(p, CppSyntaxKind::RangeForStat);
p.bump();
if p.current_token() == CppTokenKind::LeftBrace {
decls::parse_braced_initializer(p)?;
} else {
parse_expr(p)?;
}
expect_token(p, CppTokenKind::RightParen)?;
parse_statement_body(p)?;
return Ok(m.complete(p));
}
p.rollback(checkpoint);
}
if p.current_token() != CppTokenKind::Semicolon {
parse_declaration_or_expression_statement_without_semicolon(p)?;
}
expect_token(p, CppTokenKind::Semicolon)?;
if p.current_token() != CppTokenKind::Semicolon {
parse_expr(p)?;
}
expect_token(p, CppTokenKind::Semicolon)?;
if p.current_token() != CppTokenKind::RightParen {
parse_declaration_or_expression_statement_without_semicolon(p)?;
}
expect_token(p, CppTokenKind::RightParen)?;
parse_statement_body(p)?;
Ok(m.complete(p))
}
fn starts_a_range_for(p: &CppParser) -> bool {
let mut depth = 0isize;
let mut saw_question = false;
for kind in p.peek_token_kind_at(0..64) {
match kind {
CppTokenKind::LeftParen | CppTokenKind::LeftBracket | CppTokenKind::LeftBrace => {
depth += 1
}
CppTokenKind::RightParen | CppTokenKind::RightBracket | CppTokenKind::RightBrace => {
depth -= 1;
if depth < 0 {
return false;
}
}
CppTokenKind::Question => saw_question = true,
CppTokenKind::Semicolon if depth == 0 => return false,
CppTokenKind::Colon if depth == 0 => return !saw_question,
CppTokenKind::Eof | CppTokenKind::None => return false,
_ => {}
}
}
false
}
fn parse_declaration_or_expression_statement_without_semicolon(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let checkpoint = p.checkpoint();
if decls::parse_for_init_declaration(p).is_ok() {
return Ok(CompleteMarker::empty());
}
p.rollback(checkpoint);
let m = p.mark(CppSyntaxKind::ExpressionStat);
if let Err(err) = parse_expr(p) {
p.close_marks_above(base);
return Err(err);
}
Ok(m.complete(p))
}
fn parse_switch_statement(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::SwitchStat);
p.bump();
if let Err(err) = parse_condition(p) {
p.close_marks_above(base);
return Err(err);
}
if p.current_token() != CppTokenKind::LeftBrace {
read_switch_labels(p, base)?;
if let Err(err) = parse_stat(p) {
p.close_marks_above(base);
return Err(err);
}
return Ok(m.complete(p));
}
if let Err(err) = expect_token(p, CppTokenKind::LeftBrace) {
p.close_marks_above(base);
return Err(err);
}
while p.current_token() != CppTokenKind::RightBrace && !p.is_eof() {
match p.current_token() {
CppTokenKind::CaseKeyword | CppTokenKind::DefaultKeyword => {
read_switch_labels(p, base)?;
}
_ => {
parse_stat(p)?;
}
}
}
if p.current_token() == CppTokenKind::RightBrace {
p.bump();
} else {
p.emit_missing_node();
}
Ok(m.complete(p))
}
fn read_switch_labels(p: &mut CppParser, base: usize) -> ParseResult {
loop {
match p.current_token() {
CppTokenKind::CaseKeyword => {
let case = p.mark(CppSyntaxKind::CaseStat);
p.bump();
if let Err(err) = exprs::parse_expr_without_pack_expansion(p) {
p.close_marks_above(base);
return Err(err);
}
if p.current_token() == CppTokenKind::Ellipsis {
p.bump();
if let Err(err) = parse_expr(p) {
p.close_marks_above(base);
return Err(err);
}
}
if let Err(err) = expect_token(p, CppTokenKind::Colon) {
p.close_marks_above(base);
return Err(err);
}
case.complete(p);
}
CppTokenKind::DefaultKeyword => {
let default = p.mark(CppSyntaxKind::DefaultStat);
p.bump();
if let Err(err) = expect_token(p, CppTokenKind::Colon) {
p.close_marks_above(base);
return Err(err);
}
default.complete(p);
}
_ => return Ok(CompleteMarker::empty()),
}
}
}
const THE_KEYWORD_TRY_IS_SPELLED: &str = "__try";
const THE_KEYWORD_CATCH_IS_SPELLED: &str = "__catch";
const THE_KEYWORD_EXCEPT_IS_SPELLED: &str = "__except";
const THE_KEYWORD_FINALLY_IS_SPELLED: &str = "__finally";
fn at_the_implementations_handler(p: &CppParser) -> bool {
p.current_token() == CppTokenKind::Identifier
&& matches!(
p.current_token_text(),
THE_KEYWORD_EXCEPT_IS_SPELLED | THE_KEYWORD_FINALLY_IS_SPELLED
)
}
fn parse_parenthesized_filter(p: &mut CppParser) -> ParseResult {
let m = p.mark(CppSyntaxKind::ParenExpr);
expect_token(p, CppTokenKind::LeftParen)?;
crate::grammar::cpp::exprs::parse_expr(p)?;
expect_token(p, CppTokenKind::RightParen)?;
Ok(m.complete(p))
}
fn at_the_implementations_try(p: &CppParser) -> bool {
p.current_token() == CppTokenKind::Identifier
&& p.current_token_text() == THE_KEYWORD_TRY_IS_SPELLED
&& p.peek_next_token() == CppTokenKind::LeftBrace
}
fn at_the_implementations_catch(p: &CppParser) -> bool {
p.current_token() == CppTokenKind::Identifier
&& p.current_token_text() == THE_KEYWORD_CATCH_IS_SPELLED
&& p.peek_next_token() == CppTokenKind::LeftParen
}
fn parse_try_statement(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::TryStat);
p.bump();
if let Err(err) = eat_preprocessor_directives(p) {
p.close_marks_above(base);
return Err(err);
}
if let Err(err) = parse_compound_stat(p) {
p.close_marks_above(base);
return Err(err);
}
if let Err(err) = eat_preprocessor_directives(p) {
p.close_marks_above(base);
return Err(err);
}
while at_the_implementations_handler(p) {
let handler = p.mark(CppSyntaxKind::CatchStat);
let is_a_filter = p.current_token_text() == THE_KEYWORD_EXCEPT_IS_SPELLED;
p.bump();
if is_a_filter
&& p.current_token() == CppTokenKind::LeftParen
&& let Err(err) = parse_parenthesized_filter(p)
{
p.close_marks_above(base);
return Err(err);
}
if let Err(err) = eat_preprocessor_directives(p) {
p.close_marks_above(base);
return Err(err);
}
if let Err(err) = parse_compound_stat(p) {
p.close_marks_above(base);
return Err(err);
}
handler.complete(p);
if let Err(err) = eat_preprocessor_directives(p) {
p.close_marks_above(base);
return Err(err);
}
}
while p.current_token() == CppTokenKind::CatchKeyword || at_the_implementations_catch(p) {
let handler = p.mark(CppSyntaxKind::CatchStat);
p.bump();
if p.current_token() == CppTokenKind::LeftParen
&& let Err(err) = parse_parameter_list_inline(p)
{
p.close_marks_above(base);
return Err(err);
}
if let Err(err) = eat_preprocessor_directives(p) {
p.close_marks_above(base);
return Err(err);
}
if let Err(err) = parse_compound_stat(p) {
p.close_marks_above(base);
return Err(err);
}
handler.complete(p);
if let Err(err) = eat_preprocessor_directives(p) {
p.close_marks_above(base);
return Err(err);
}
}
Ok(m.complete(p))
}
fn eat_preprocessor_directives(p: &mut CppParser) -> ParseResult {
while p.current_token() == CppTokenKind::Hash {
parse_preprocessor_directive(p)?;
}
Ok(CompleteMarker::empty())
}
fn parse_parameter_list_inline(p: &mut CppParser) -> ParseResult {
decls::parse_parameter_list(p)
}
fn parse_return_statement(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::ReturnStat);
p.bump();
if p.current_token() != CppTokenKind::Semicolon
&& !p.is_eof()
&& let Err(err) = parse_return_value(p)
{
p.close_marks_above(base);
return Err(err);
}
if p.current_token() == CppTokenKind::Semicolon {
p.bump();
} else {
if let Err(err) = decls::expect_semicolon(p) {
p.close_marks_above(base);
return Err(err);
}
}
Ok(m.complete(p))
}
fn parse_return_value(p: &mut CppParser) -> ParseResult {
if p.current_token() == CppTokenKind::LeftBrace {
return decls::parse_braced_initializer(p);
}
parse_expr(p)
}
fn parse_keyword_statement(p: &mut CppParser, kind: CppSyntaxKind) -> ParseResult {
let base = p.open_marks();
let m = p.mark(kind);
p.bump();
if p.current_token() == CppTokenKind::Semicolon {
p.bump();
} else {
p.close_marks_above(base);
return Err(CppParseError::syntax_error_from(
&t!("expected `;`"),
p.current_token_range(),
));
}
Ok(m.complete(p))
}
fn parse_goto_statement(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::GotoStat);
p.bump();
if p.current_token() == CppTokenKind::Star
&& p.language()
.support(crate::features::Feature::LabelsAsValues)
{
p.bump();
if let Err(err) = crate::grammar::cpp::exprs::parse_expr(p) {
p.close_marks_above(base);
return Err(err);
}
if let Err(err) = expect_token(p, CppTokenKind::Semicolon) {
p.close_marks_above(base);
return Err(err);
}
return Ok(m.complete(p));
}
if p.current_token() == CppTokenKind::Identifier {
p.bump();
}
if let Err(err) = expect_token(p, CppTokenKind::Semicolon) {
p.close_marks_above(base);
return Err(err);
}
Ok(m.complete(p))
}
fn parse_throw_statement(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::ThrowStat);
p.bump(); if p.current_token() != CppTokenKind::Semicolon
&& let Err(err) = parse_expr(p)
{
p.close_marks_above(base);
return Err(err);
}
if let Err(err) = expect_token(p, CppTokenKind::Semicolon) {
p.close_marks_above(base);
return Err(err);
}
Ok(m.complete(p))
}
fn parse_label_statement(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::LabelStat);
p.bump(); if let Err(err) = expect_token(p, CppTokenKind::Colon) {
p.close_marks_above(base);
return Err(err);
}
while p.current_token() == CppTokenKind::LeftBracket
&& p.peek_next_token() == CppTokenKind::LeftBracket
{
if types::parse_attribute_specifier(p).is_err() {
break;
}
}
Ok(m.complete(p))
}
fn a_call_whose_first_argument_is_an_address(p: &CppParser) -> bool {
let at = p.current_token_index();
p.token_kind_at(at) == CppTokenKind::Identifier
&& p.token_kind_at(at + 1) == CppTokenKind::LeftParen
&& p.token_kind_at(at + 2) == CppTokenKind::Ampersand
}