//! Paragraph, table, and line parsing: leaf-block production inside the
//! first pass.
///|
/// Scanning modes for `parse_line`.
priv enum TableParseMode {
/// Inside a paragraph, scanning for table headers.
Scan
/// Inside a table.
Active
/// Inside a paragraph, not scanning for table headers.
Disabled
}
///|
/// footnote definitions and GFM quote markers can be "interrupted"
/// like paragraphs, but otherwise can't have other blocks after them.
fn FirstPass::scan_next_line_or_lazy_continuation(
self : FirstPass,
bytes : BytesView,
) -> LineStart? {
let line_start = LineStart::new(bytes)
let tree_position = line_start.scan_containers(self.tree, self.options)
let current_container = tree_position == self.tree.spine_len()
let interrupted = !line_start.scan_space(4) &&
self.scan_paragraph_interrupt(
bytes.exact_view(start=line_start.bytes_scanned()),
current_container,
tree_position,
)
let blank = scan_blank_line(
bytes.exact_view(start=line_start.bytes_scanned()),
)
is Some(_)
guard !(interrupted || blank) else { None }
line_start.scan_all_space()
Some(line_start)
}
///|
/// Returns the offset of the first line after the table.
fn FirstPass::parse_table(
self : FirstPass,
table_cols : Int32,
head_start : Int32,
body_start : Int32,
) -> Int32? {
// filled empty cells are limited to protect against quadratic growth
let missing_empty_cells = 0
// parse header
guard self.parse_table_row_inner(head_start, table_cols, missing_empty_cells)
is Some((_sep_start, thead_ix)) else {
None
}
self.tree.nodes[thead_ix].item.body = TableHead
// parse body
let mut ix = body_start
while true {
guard self.parse_table_row(ix, table_cols, missing_empty_cells)
is Some((next_ix, _row_ix)) else {
break
}
ix = next_ix
}
self.pop(ix)
Some(ix)
}
///|
/// Call this when containers are taken care of.
/// Returns bytes scanned, row_ix
fn FirstPass::parse_table_row_inner(
self : FirstPass,
ix : Int32,
row_cells : Int32,
missing_empty_cells : Int32,
) -> (Int32, Int32)? {
let mut ix = ix
// Limit to prevent a malicious input from causing a denial of service.
let max_autocompleted_cells = 1 << 18
let bytes = self.text
let mut cells = 0
let mut final_cell_ix : Int32? = None
let mut missing_empty_cells = missing_empty_cells
let old_cur = self.tree.cur()
let row_ix = self.tree.append(Item::{ start: ix, end: 0, body: TableRow, })
ignore(self.tree.push())
while true {
ix += scan_ch(bytes.exact_view(start=ix), b'|')
let start_ix = ix
ix += scan_whitespace_no_nl(bytes.exact_view(start=ix))
if scan_eol(bytes.exact_view(start=ix)) is Some(eol_bytes) {
ix += eol_bytes
break
}
let cell_ix = self.tree.append(Item::{
start: start_ix,
end: ix,
body: TableCell,
})
ignore(self.tree.push())
let (next_ix, _brk) = self.parse_line(ix, None, Active)
self.tree.nodes[cell_ix].item.end = next_ix
ignore(self.tree.pop())
ix = next_ix
cells += 1
if cells == row_cells {
final_cell_ix = Some(cell_ix)
}
}
if old_cur is Some(cur) {
if cells == 0 {
ignore(self.pop(ix))
self.tree.nodes[cur].next = None
return None
}
}
// fill empty cells if needed
for _ in cells.. (Int32, Int32)? {
let mut ix = ix
let bytes = self.text
let line_start = LineStart::new(bytes.exact_view(start=ix))
let tree_position = line_start.scan_containers(self.tree, self.options)
let current_container = tree_position == self.tree.spine_len()
guard current_container else { return None }
line_start.scan_all_space()
ix += line_start.bytes_scanned()
guard !scan_paragraph_interrupt_no_table(
bytes.exact_view(start=ix),
current_container,
self.options.contains(enable_footnotes()),
self.options.contains(enable_definition_list()),
self.tree,
tree_position,
) else {
return None
}
self.parse_table_row_inner(ix, row_cells, missing_empty_cells)
}
///|
/// Returns offset of line start after paragraph.
fn FirstPass::parse_paragraph(
self : FirstPass,
start_ix : Int32,
tasklist_marker : Item?,
) -> Int32 {
let body = {
guard self.tree.peek_up() is Some(idx) else {
self.finish_list(start_ix)
Paragraph
}
let is_deflist = self.tree.nodes[idx].item.body is DefinitionList(_)
let cur_is_def = self.tree
.cur()
.map_or(true, idx2 => {
self.tree.nodes[idx2].item.body is DefinitionListDefinition(_)
})
if is_deflist && cur_is_def {
// blank lines between the previous definition and this one don't count
self.last_line_blank = false
MaybeDefinitionListTitle
} else {
self.finish_list(start_ix)
Paragraph
}
}
let node_ix = self.tree.append(Item::{ start: start_ix, end: 0, body, })
ignore(self.tree.push())
if tasklist_marker is Some(item) {
ignore(self.tree.append(item))
}
let bytes = self.text
let mut ix = start_ix
while true {
let scan_mode = if self.options.contains(enable_tables()) && ix == start_ix {
Scan
} else {
Disabled
}
let (next_ix, brk) = self.parse_line(ix, None, scan_mode)
// break out when we find a table
if brk is Some(brk_item) {
if brk_item.body is Table(alignment_ix) {
let table_cols = self.allocs.alignments[alignment_ix].length()
self.tree.nodes[node_ix].item.body = Table(alignment_ix)
// this clears out any stuff we may have appended
self.tree.nodes[node_ix].child = None
ignore(self.tree.pop())
let is_maybe_title = body is MaybeDefinitionListTitle
if is_maybe_title {
self.finish_list(ix)
}
ignore(self.tree.push())
if self.parse_table(table_cols, ix, next_ix) is Some(result) {
return result
}
}
}
ix = next_ix
let line_start = LineStart::new(bytes.exact_view(start=ix))
let tree_position = line_start.scan_containers(self.tree, self.options)
let current_container = tree_position == self.tree.spine_len()
let trailing_backslash_pos = if brk is Some(brk_item) &&
brk_item.body is HardBreak(true) &&
bytes.length() > brk_item.start &&
bytes.unsafe_get(brk_item.start) == b'\\' {
Some(brk_item.start)
} else {
None
}
if !line_start.scan_space(4) {
let ix_new = ix + line_start.bytes_scanned()
// first check for non-empty lists, then for other interrupts
let suffix = bytes.exact_view(start=ix_new)
if self.scan_paragraph_interrupt(suffix, current_container, tree_position) {
if trailing_backslash_pos is Some(pos) {
self.tree.append_text(pos, pos + 1)
}
break
}
let close_container = self.options.contains(enable_container_extensions()) &&
!current_container &&
line_start.scan_closing_container_extensions_fence(3)
guard !close_container else { break }
}
line_start.scan_all_space()
if line_start.is_at_eol() {
if trailing_backslash_pos is Some(pos) {
self.tree.append_text(pos, pos + 1)
}
break
}
if self.options.contains(enable_container_extensions()) {
let closes = closes_container(self.tree, line_start)
guard !closes else { break }
}
ix = next_ix + line_start.bytes_scanned()
if brk is Some(item) {
ignore(self.tree.append(item))
}
}
self.pop(ix)
ix
}
///|
/// True when `line_start` scans a closing container-extension fence on the
/// spine: walk from the innermost node, and a closing fence on a container
/// closes every container above it.
fn closes_container(tree : Tree[Item], line_start : LineStart) -> Bool {
let spine = tree.walk_spine()
for idx in 1..
if line_start.scan_closing_container_extensions_fence(length) {
return true
}
_ => return false
}
}
false
}
///|
/// Mutable state for `parse_line`.
priv struct LineState {
mut pipes : Int32
mut last_pipe_ix : Int32
mut begin_text : Int32
}
///|
/// Parse a line of input, appending text and items to tree.
/// Returns: index after line and an item representing the break.
fn FirstPass::parse_line(
self : FirstPass,
start : Int32,
end : Int32?,
mode : TableParseMode,
) -> (Int32, Item?) {
let bytes = self.text
let bytes_len = bytes.length()
let limit = end.unwrap_or(bytes_len)
let mut state = LineState::{
pipes: 0,
last_pipe_ix: start,
begin_text: start,
}
let mut final_ix = limit
let mut brk : Item? = None
let lut = special_bytes(self.options)
let mut ix = start
let mut done = false
while ix < limit && !done {
let byte = bytes.unsafe_get(ix)
if lut[byte.to_int()] {
let (action, new_state) = self.handle_special_byte(
ix, byte, mode, limit, bytes_len, start, state,
)
state = new_state
match action {
ParseLineAction::Continue(skip) => ix += skip
ParseLineAction::BreakWith(end_ix, item) => {
final_ix = end_ix
brk = item
done = true
}
}
}
ix += 1
}
if brk is None {
let trailing_whitespace = scan_rev_while(
bytes.exact_view(start=state.begin_text, end=final_ix),
c => c.is_ascii_whitespace_no_nl(),
)
// need to close text at eof
self.tree.append_text(state.begin_text, final_ix - trailing_whitespace)
}
(final_ix, brk)
}
///|
priv enum ParseLineAction {
Continue(Int32)
BreakWith(Int32, Item?)
}