use crate::DynPart;
const fn arg_name_bytes(name: &str) -> &[u8] {
let bytes = name.as_bytes();
if bytes.len() > 2 && bytes[0] == b'r' && bytes[1] == b'#' {
bytes.split_at(2).1
} else {
bytes
}
}
const fn bytes_eq(a: &[u8], b: &[u8]) -> bool {
if a.len() != b.len() {
return false;
}
let mut i = 0;
while i < a.len() {
if a[i] != b[i] {
return false;
}
i += 1;
}
true
}
const fn placeholder_matches(bytes: &[u8], start: usize, end: usize, name: &[u8]) -> bool {
if end - start != name.len() {
return false;
}
let mut i = 0;
while i < name.len() {
if bytes[start + i] != name[i] {
return false;
}
i += 1;
}
true
}
pub const fn has_brace(fmt: &str) -> bool {
let bytes = fmt.as_bytes();
let mut i = 0;
while i < bytes.len() {
if bytes[i] == b'{' || bytes[i] == b'}' {
return true;
}
i += 1;
}
false
}
pub const fn check_named_format(fmt: &str, names: &[&str]) {
assert!(
names.len() <= 128,
"safe_html_format!: at most 128 named arguments are supported"
);
let mut i = 0;
while i < names.len() {
let mut j = i + 1;
while j < names.len() {
assert!(
!bytes_eq(arg_name_bytes(names[i]), arg_name_bytes(names[j])),
"safe_html_format!: duplicate named argument"
);
j += 1;
}
i += 1;
}
let bytes = fmt.as_bytes();
let mut used: u128 = 0;
let mut i = 0;
while i < bytes.len() {
if bytes[i] == b'{' {
if i + 1 < bytes.len() && bytes[i + 1] == b'{' {
i += 2;
continue;
}
let start = i + 1;
let mut end = start;
while end < bytes.len() && bytes[end] != b'}' && bytes[end] != b'{' {
end += 1;
}
assert!(
end < bytes.len() && bytes[end] == b'}',
"safe_html_format!: unclosed placeholder; double the brace to emit a literal brace"
);
assert!(
end > start,
"safe_html_format!: an empty placeholder is not allowed with named arguments; name it to match a `name = value` argument"
);
let mut k = start;
while k < end {
assert!(
bytes[k] != b':',
"safe_html_format!: format specs are not supported in placeholders; pre-format the value into the argument instead"
);
k += 1;
}
let mut m = 0;
let mut found = false;
while m < names.len() {
if placeholder_matches(bytes, start, end, arg_name_bytes(names[m])) {
used |= 1u128 << m;
found = true;
break;
}
m += 1;
}
assert!(
found,
"safe_html_format!: placeholder has no matching `name = value` argument; implicit capture of locals is not supported because every value must be routed through escaping"
);
i = end + 1;
} else if bytes[i] == b'}' {
assert!(
i + 1 < bytes.len() && bytes[i + 1] == b'}',
"safe_html_format!: unmatched closing brace; double the brace to emit a literal brace"
);
i += 2;
} else {
i += 1;
}
}
assert!(
used.count_ones() as usize == names.len(),
"safe_html_format!: a named argument is never used in the format string"
);
}
pub const fn check_positional_format(fmt: &str, count: usize) {
let bytes = fmt.as_bytes();
let mut seen = 0usize;
let mut i = 0;
while i < bytes.len() {
if bytes[i] == b'{' {
if i + 1 < bytes.len() && bytes[i + 1] == b'{' {
i += 2;
continue;
}
assert!(
i + 1 < bytes.len() && bytes[i + 1] == b'}',
"safe_html_format!: only empty placeholders are allowed with positional arguments; use `name = value` arguments for named placeholders"
);
seen += 1;
i += 2;
} else if bytes[i] == b'}' {
assert!(
i + 1 < bytes.len() && bytes[i + 1] == b'}',
"safe_html_format!: unmatched closing brace; double the brace to emit a literal brace"
);
i += 2;
} else {
i += 1;
}
}
assert!(
seen == count,
"safe_html_format!: the number of empty placeholders must equal the number of arguments"
);
}
fn arg_name(name: &str) -> &str {
match name.as_bytes() {
[b'r', b'#', _, ..] => name.get(2..).unwrap_or(name),
_ => name,
}
}
pub fn format_named_to(
fmt: &str,
parts: &[(&str, &dyn DynPart)],
w: &mut dyn core::fmt::Write,
) -> core::fmt::Result {
let bytes = fmt.as_bytes();
let mut start = 0;
let mut i = 0;
while i < bytes.len() {
let b = bytes[i];
if b != b'{' && b != b'}' {
i += 1;
continue;
}
if let Some(run) = fmt.get(start..i)
&& !run.is_empty()
{
w.write_str(run)?;
}
if i + 1 < bytes.len() && bytes[i + 1] == b {
w.write_char(b as char)?;
i += 2;
} else if b == b'{' {
let mut end = i + 1;
while end < bytes.len() && bytes[end] != b'}' {
end += 1;
}
let name = fmt.get(i + 1..end).unwrap_or("");
if let Some((_, part)) = parts.iter().find(|(n, _)| arg_name(n) == name) {
part.dyn_write_to(w)?;
}
i = end.saturating_add(1);
} else {
w.write_char('}')?;
i += 1;
}
start = i;
}
if let Some(tail) = fmt.get(start..)
&& !tail.is_empty()
{
w.write_str(tail)?;
}
Ok(())
}
pub fn format_positional_to(
fmt: &str,
parts: &[&dyn DynPart],
w: &mut dyn core::fmt::Write,
) -> core::fmt::Result {
let bytes = fmt.as_bytes();
let mut start = 0;
let mut i = 0;
let mut next = 0usize;
while i < bytes.len() {
let b = bytes[i];
if b != b'{' && b != b'}' {
i += 1;
continue;
}
if let Some(run) = fmt.get(start..i)
&& !run.is_empty()
{
w.write_str(run)?;
}
if i + 1 < bytes.len() && bytes[i + 1] == b {
w.write_char(b as char)?;
i += 2;
} else if b == b'{' {
let mut end = i + 1;
while end < bytes.len() && bytes[end] != b'}' {
end += 1;
}
if end == i + 1 {
if let Some(part) = parts.get(next) {
part.dyn_write_to(w)?;
}
next += 1;
}
i = end.saturating_add(1);
} else {
w.write_char('}')?;
i += 1;
}
start = i;
}
if let Some(tail) = fmt.get(start..)
&& !tail.is_empty()
{
w.write_str(tail)?;
}
Ok(())
}
#[cfg(feature = "alloc")]
pub fn format_named_into(
buf: &mut alloc::string::String,
fmt: &str,
parts: &[(&str, &dyn DynPart)],
) {
let mut cap = fmt.len();
for (_, part) in parts {
cap = cap.saturating_add(part.dyn_size_hint());
}
buf.reserve(cap);
let _ = format_named_to(fmt, parts, buf);
}
#[cfg(feature = "alloc")]
pub fn format_positional_into(buf: &mut alloc::string::String, fmt: &str, parts: &[&dyn DynPart]) {
let mut cap = fmt.len();
for part in parts {
cap = cap.saturating_add(part.dyn_size_hint());
}
buf.reserve(cap);
let _ = format_positional_to(fmt, parts, buf);
}
#[cfg(feature = "alloc")]
pub fn format_named(fmt: &str, parts: &[(&str, &dyn DynPart)]) -> crate::types::SafeHtml {
let mut buf = alloc::string::String::new();
format_named_into(&mut buf, fmt, parts);
crate::__private::finish_safe_html(buf)
}
#[cfg(feature = "alloc")]
pub fn format_positional(fmt: &str, parts: &[&dyn DynPart]) -> crate::types::SafeHtml {
let mut buf = alloc::string::String::new();
format_positional_into(&mut buf, fmt, parts);
crate::__private::finish_safe_html(buf)
}
#[cfg(feature = "alloc")]
#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
#[macro_export]
macro_rules! safe_html_format {
($fmt:literal $(,)?) => {{
const _: () = $crate::__private::check_named_format($fmt, &[]);
const HAS_BRACE: bool = $crate::__private::has_brace($fmt);
if HAS_BRACE {
$crate::__private::format_named($fmt, &[])
} else {
$crate::SafeHtml::from_constant($fmt)
}
}};
($fmt:literal, $($name:ident = $val:expr),+ $(,)?) => {{
const _: () = $crate::__private::check_named_format($fmt, &[$(stringify!($name)),+]);
$crate::__private::format_named(
$fmt,
&[$((stringify!($name), &$val as &dyn $crate::__private::DynPart)),+],
)
}};
($fmt:literal, $($val:expr),+ $(,)?) => {{
const _: () = $crate::__private::check_positional_format(
$fmt,
<[()]>::len(&[$($crate::__private::unit(stringify!($val))),+]),
);
$crate::__private::format_positional(
$fmt,
&[$(&$val as &dyn $crate::__private::DynPart),+],
)
}};
($builder:expr, $fmt:literal $(,)?) => {{
const _: () = $crate::__private::check_named_format($fmt, &[]);
($builder).__format_named($fmt, &[]);
}};
($builder:expr, $fmt:literal, $($name:ident = $val:expr),+ $(,)?) => {{
const _: () = $crate::__private::check_named_format($fmt, &[$(stringify!($name)),+]);
($builder).__format_named(
$fmt,
&[$((stringify!($name), &$val as &dyn $crate::__private::DynPart)),+],
);
}};
($builder:expr, $fmt:literal, $($val:expr),+ $(,)?) => {{
const _: () = $crate::__private::check_positional_format(
$fmt,
<[()]>::len(&[$($crate::__private::unit(stringify!($val))),+]),
);
($builder).__format_positional(
$fmt,
&[$(&$val as &dyn $crate::__private::DynPart),+],
);
}};
}
#[macro_export]
macro_rules! safe_html_format_to {
($w:expr, $fmt:literal $(,)?) => {{
const _: () = $crate::__private::check_named_format($fmt, &[]);
$crate::__private::format_named_to($fmt, &[], &mut $w)
}};
($w:expr, $fmt:literal, $($name:ident = $val:expr),+ $(,)?) => {{
const _: () = $crate::__private::check_named_format($fmt, &[$(stringify!($name)),+]);
$crate::__private::format_named_to(
$fmt,
&[$((stringify!($name), &$val as &dyn $crate::__private::DynPart)),+],
&mut $w,
)
}};
($w:expr, $fmt:literal, $($val:expr),+ $(,)?) => {{
const _: () = $crate::__private::check_positional_format(
$fmt,
<[()]>::len(&[$($crate::__private::unit(stringify!($val))),+]),
);
$crate::__private::format_positional_to(
$fmt,
&[$(&$val as &dyn $crate::__private::DynPart),+],
&mut $w,
)
}};
}
pub const fn unit(_: &str) {}