///|
fn dimension(text : String) -> Int32? {
  let chars = text.to_array()
  if chars.is_empty() {
    return None
  }
  let mut value = 0
  let mut digits = 0
  for i = 0; i < chars.length(); i = i + 1 {
    let c = chars[i]
    if c >= '0' && c <= '9' {
      if value > 10000 {
        return None
      }
      value = value * 10 + c.to_int() - 48
      digits = digits + 1
    } else if i == chars.length() - 1 && digits > 0 && (c == 'n' || c == 'm') {
      return Some(value)
    } else {
      return None
    }
  }
  Some(value)
}

///|
fn Parser::capture_tag(self : Parser) -> Unit {
  if self.pending_tag && !self.current.is_empty() {
    self.kind = Tagged(self.current)
    self.current = []
    self.pending_tag = false
    self.continues = false
  }
}

///|
fn Parser::layout_request(
  self : Parser,
  name : String,
  args : Array[String],
  line : Int32,
) -> Bool {
  match name {
    "TP" => {
      if self.pending_tag {
        self.warn("missing-tag", "Previous TP has no tag", line)
      }
      self.begin(Tagged([]), line)
      self.pending_tag = true
      true
    }
    "IP" => {
      self.begin(Paragraph, line)
      if !args.is_empty() {
        self.append(args[0], line, join=false)
        self.kind = Tagged(self.current)
        self.current = []
      }
      self.pending_tag = false
      true
    }
    "HP" => {
      let width = if args.is_empty() { Some(4) } else { dimension(args[0]) }
      match width {
        Some(n) if n <= self.options.max_indent => self.begin(Hanging(n), line)
        _ => {
          self.flush()
          self.warn(
            "invalid-indent", "HP width must be bounded integral n/m units", line,
          )
        }
      }
      true
    }
    "RS" => {
      self.flush()
      let width = if args.is_empty() { Some(4) } else { dimension(args[0]) }
      match width {
        Some(n) =>
          if n > self.options.max_indent - self.indent ||
            self.indent_stack.length() >= self.options.max_indent {
            self.fatal = Some(
              diagnostic(
                "indent-limit",
                "RS exceeds max_indent",
                line,
                severity=Error,
              ),
            )
          } else {
            self.indent_stack.push(self.indent)
            self.indent = self.indent + n
          }
        None =>
          self.warn(
            "invalid-indent", "RS width must be integral n/m units", line,
          )
      }
      true
    }
    "RE" => {
      self.flush()
      match self.indent_stack.pop() {
        Some(previous) => self.indent = previous
        None => self.warn("unmatched-indent", "RE has no matching RS", line)
      }
      if !args.is_empty() {
        self.warn(
          "unsupported-indent-level", "Explicit RE levels are not implemented", line,
        )
      }
      true
    }
    _ => false
  }
}