use crate::SQLError;
use uqa_core::memory::{Produced, ProductionControl, ProductionString};
mod declaration;
#[allow(unsafe_code)]
mod parser;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum XmlOption {
Content,
Document,
}
pub fn validate(input: &str, option: XmlOption) -> Result<(), SQLError> {
validate_with_notices(input, option, |_| {})
}
pub fn validate_with_notices(
input: &str,
option: XmlOption,
notice: impl FnMut(crate::SQLNotice),
) -> Result<(), SQLError> {
validate_with_control(input, option, &ProductionControl::uncontrolled(), notice)
}
pub fn validate_with_control(
input: &str,
option: XmlOption,
control: &ProductionControl<'_>,
notice: impl FnMut(crate::SQLNotice),
) -> Result<(), SQLError> {
control.check()?;
let declaration = if option == XmlOption::Content {
declaration::parse(input, control).map_err(|failure| match failure {
declaration::Failure::Invalid(detail) => error(option, true, Some(detail.into())),
declaration::Failure::Control(error) => error.into(),
})?
} else {
declaration::Declaration::default()
};
let body = &input[declaration.length..];
let document = option == XmlOption::Document || declaration::has_doctype(body, control)?;
parser::validate(
if document { input } else { body },
document,
declaration.version.unwrap_or("1.0"),
control,
notice,
)
.map_err(|failure| match failure {
parser::Failure::Invalid(detail) => error(option, false, detail),
parser::Failure::Memory => SQLError::Routine {
sqlstate: "53200".into(),
message: "out of memory while parsing XML".into(),
},
parser::Failure::Limit => SQLError::Routine {
sqlstate: "54000".into(),
message: "XML input is too large".into(),
},
parser::Failure::Control(error) => error.into(),
})
}
fn error(option: XmlOption, declaration: bool, detail: Option<String>) -> SQLError {
let (sqlstate, message) = match (option, declaration) {
(XmlOption::Content, true) => ("2200N", "invalid XML content: invalid XML declaration"),
(XmlOption::Content, false) => ("2200N", "invalid XML content"),
(XmlOption::Document, _) => ("2200M", "invalid XML document"),
};
SQLError::Diagnostic {
sqlstate: sqlstate.into(),
message: message.into(),
detail,
hint: None,
}
}
pub fn output_with_control(
input: &str,
control: &ProductionControl<'_>,
) -> Result<Produced<String>, SQLError> {
control.check()?;
let declaration = declaration::parse(input, control).map_err(|failure| match failure {
declaration::Failure::Invalid(detail) => {
SQLError::Internal(format!("invalid stored XML declaration: {detail}"))
}
declaration::Failure::Control(error) => error.into(),
})?;
let mut output = ProductionString::new(*control);
let version = declaration.version.unwrap_or("1.0");
let mut body = &input[declaration.length..];
if version != "1.0" || declaration.standalone.is_some() {
output.push_str("<?xml version=\"")?;
output.push_str(version)?;
output.push_str("\"")?;
if let Some(standalone) = declaration.standalone {
output.push_str(if standalone {
" standalone=\"yes\""
} else {
" standalone=\"no\""
})?;
}
output.push_str("?>")?;
} else {
body = body.strip_prefix('\n').unwrap_or(body);
}
output.push_str(body)?;
Ok(output.finish()?)
}
#[cfg(test)]
mod tests;