use std::fmt::Write as _;
use crate::math::*;
use crate::model::{BSpline, BSplineSurface, Brep, Curve, Face, Surface};
#[derive(Clone, Debug, PartialEq)]
pub struct StepOptions {
pub product_name: String,
pub file_name: String,
pub timestamp: String,
pub author: String,
pub organization: String,
pub originating_system: String,
pub description: String,
}
impl Default for StepOptions {
fn default() -> Self {
StepOptions {
product_name: "part".into(),
file_name: "part.step".into(),
timestamp: "1970-01-01T00:00:00".into(),
author: String::new(),
organization: String::new(),
originating_system: concat!("meshbrep ", env!("CARGO_PKG_VERSION")).into(),
description: String::new(),
}
}
}
fn string(s: &str) -> String {
let mut out = String::from("'");
let mut wide: Vec<u16> = Vec::new();
let flush = |wide: &mut Vec<u16>, out: &mut String| {
if !wide.is_empty() {
out.push_str("\\X2\\");
for u in wide.iter() {
let _ = write!(out, "{u:04X}");
}
out.push_str("\\X0\\");
wide.clear();
}
};
for c in s.chars() {
if c.is_ascii() && !c.is_ascii_control() {
flush(&mut wide, &mut out);
match c {
'\'' => out.push_str("''"),
'\\' => out.push_str("\\\\"),
_ => out.push(c),
}
} else {
let mut buf = [0u16; 2];
wide.extend_from_slice(c.encode_utf16(&mut buf));
}
}
flush(&mut wide, &mut out);
out.push('\'');
out
}
fn real(x: f64) -> String {
let mut out = String::new();
push_real(&mut out, x, &mut String::new());
out
}
fn push_real(out: &mut String, x: f64, scratch: &mut String) {
if x == 0.0 {
out.push_str("0.");
return;
}
if push_integral(out, x) {
return;
}
scratch.clear();
let _ = write!(scratch, "{x:E}");
let (mant, exp) = scratch.split_once('E').expect("exponent");
out.push_str(mant);
if !mant.contains('.') {
out.push('.');
}
if exp != "0" {
out.push('E');
out.push_str(exp);
}
}
fn push_integral(out: &mut String, x: f64) -> bool {
const LIMIT: f64 = 9_007_199_254_740_992.0; let a = x.abs();
if !a.is_finite() || a >= LIMIT || a.fract() != 0.0 || a == 0.0 {
return false;
}
let mut v = a as u64;
let mut buf = [0u8; 20];
let mut i = buf.len();
while v > 0 {
i -= 1;
buf[i] = b'0' + (v % 10) as u8;
v /= 10;
}
let digits = &buf[i..];
let exponent = digits.len() - 1;
let mut end = digits.len();
while end > 1 && digits[end - 1] == b'0' {
end -= 1;
}
if x < 0.0 {
out.push('-');
}
out.push(char::from(digits[0]));
out.push('.');
for &d in &digits[1..end] {
out.push(char::from(d));
}
if exponent > 0 {
out.push('E');
push_uint(out, exponent);
}
true
}
struct Reals {
slots: Vec<Slot>,
bits: u32,
scratch: String,
}
#[derive(Clone, Copy)]
struct Slot {
bits: u64,
len: u8,
text: [u8; Reals::MAX_LEN],
}
impl Reals {
const MAX_LEN: usize = 24;
fn new(reals: usize) -> Reals {
Reals {
slots: Vec::new(),
bits: reals.next_power_of_two().trailing_zeros().clamp(8, 16),
scratch: String::new(),
}
}
fn push(&mut self, out: &mut String, x: f64) {
if x == 0.0 {
out.push_str("0.");
return;
}
if push_integral(out, x) {
return;
}
if self.slots.is_empty() {
self.slots = vec![
Slot {
bits: 0,
len: 0,
text: [0; Reals::MAX_LEN],
};
1 << self.bits
];
}
let bits = x.to_bits();
let at = (bits.wrapping_mul(0x9e37_79b9_7f4a_7c15) >> (64 - self.bits)) as usize;
let slot = &mut self.slots[at];
if slot.len > 0 && slot.bits == bits {
let text = &slot.text[..slot.len as usize];
out.push_str(std::str::from_utf8(text).expect("ASCII"));
return;
}
let start = out.len();
push_real(out, x, &mut self.scratch);
let text = &out.as_bytes()[start..];
if text.len() <= Reals::MAX_LEN {
slot.bits = bits;
slot.len = text.len() as u8;
slot.text[..text.len()].copy_from_slice(text);
}
}
}
fn push_uint(out: &mut String, mut v: usize) {
let mut buf = [0u8; 20];
let mut i = buf.len();
loop {
i -= 1;
buf[i] = b'0' + (v % 10) as u8;
v /= 10;
if v == 0 {
break;
}
}
for &b in &buf[i..] {
out.push(char::from(b));
}
}
struct W {
body: String,
n: usize,
reals: Reals,
holes: Vec<(usize, usize, String)>,
}
impl W {
fn new(vertices: usize) -> W {
W {
body: String::new(),
n: 0,
reals: Reals::new(6 * vertices),
holes: Vec::new(),
}
}
fn start(&mut self) -> usize {
self.n += 1;
self.body.push('#');
push_uint(&mut self.body, self.n);
self.body.push('=');
self.n
}
fn finish(&mut self) {
self.body.push_str(";\n");
}
fn add(&mut self, s: String) -> usize {
let id = self.start();
self.body.push_str(&s);
self.finish();
id
}
fn addf(&mut self, args: std::fmt::Arguments<'_>) -> usize {
let id = self.start();
let _ = self.body.write_fmt(args);
self.finish();
id
}
fn reserve(&mut self) -> usize {
self.n += 1;
self.holes.push((self.n, self.body.len(), String::new()));
self.n
}
fn set(&mut self, id: usize, s: String) {
if let Some(h) = self.holes.iter_mut().find(|h| h.0 == id) {
h.2 = s;
}
}
fn tuple(&mut self, kind: &str, xs: &[f64]) -> usize {
let id = self.start();
self.body.push_str(kind);
self.body.push_str("('',(");
for (i, &x) in xs.iter().enumerate() {
if i > 0 {
self.body.push(',');
}
self.reals.push(&mut self.body, x);
}
self.body.push_str("))");
self.finish();
id
}
fn id(&mut self, i: usize) {
self.body.push('#');
push_uint(&mut self.body, i);
}
fn ids(&mut self, xs: &[usize]) {
for (k, &i) in xs.iter().enumerate() {
if k > 0 {
self.body.push(',');
}
self.id(i);
}
}
fn refers(&mut self, kind: &str, xs: &[usize]) -> usize {
let n = self.start();
self.body.push_str(kind);
self.body.push_str("(''");
for &i in xs {
self.body.push(',');
self.id(i);
}
self.body.push(')');
self.finish();
n
}
fn pt(&mut self, p: [f64; 3]) -> usize {
self.tuple("CARTESIAN_POINT", &p)
}
fn pt2(&mut self, p: [f64; 2]) -> usize {
self.tuple("CARTESIAN_POINT", &p)
}
fn dir(&mut self, d: [f64; 3]) -> usize {
self.tuple("DIRECTION", &d)
}
fn ax2(&mut self, o: [f64; 3], z: [f64; 3], x: [f64; 3]) -> usize {
let p = self.pt(o);
let a = self.dir(z);
let b = self.dir(x);
self.refers("AXIS2_PLACEMENT_3D", &[p, a, b])
}
fn into_file(self) -> String {
let mut body = self.body;
let mut holes = self.holes;
holes.sort_by_key(|h| h.1);
for (id, off, text) in holes.into_iter().rev() {
let mut line = String::with_capacity(text.len() + 24);
line.push('#');
push_uint(&mut line, id);
line.push('=');
line.push_str(&text);
line.push_str(";\n");
body.insert_str(off, &line);
}
body.push_str("ENDSEC;\nEND-ISO-10303-21;\n");
body
}
}
struct Refs<'a>(&'a [usize]);
impl std::fmt::Display for Refs<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
for (k, i) in self.0.iter().enumerate() {
if k > 0 {
f.write_str(",")?;
}
write!(f, "#{i}")?;
}
Ok(())
}
}
fn bspline_entity<const D: usize>(w: &mut W, b: &BSpline<D>) -> usize {
let cps: Vec<usize> = b
.control
.iter()
.map(|p| {
if D == 3 {
w.pt([p[0], p[1], p[2 % D]])
} else {
w.pt2([p[0], p[1]])
}
})
.collect();
let mut ks: Vec<f64> = Vec::new();
let mut ms: Vec<usize> = Vec::new();
for &k in &b.knots {
if ks.last() == Some(&k) {
*ms.last_mut().expect("multiplicity") += 1;
} else {
ks.push(k);
ms.push(1);
}
}
w.addf(format_args!(
"B_SPLINE_CURVE_WITH_KNOTS('',{},({}),.UNSPECIFIED.,.F.,.F.,({}),({}),.UNSPECIFIED.)",
b.degree,
Refs(&cps),
ms.iter()
.map(|m| m.to_string())
.collect::<Vec<_>>()
.join(","),
ks.iter().map(|&k| real(k)).collect::<Vec<_>>().join(",")
))
}
fn curve_entity(w: &mut W, c: &Curve) -> usize {
match c {
Curve::Line { origin, direction } => {
let p = w.pt(*origin);
let d = w.dir(*direction);
let vct = w.start();
w.body.push_str("VECTOR('',");
w.id(d);
w.body.push_str(",1.)");
w.finish();
w.refers("LINE", &[p, vct])
}
Curve::Circle {
center,
normal,
x_axis,
radius,
} => {
let a = w.ax2(*center, *normal, *x_axis);
w.addf(format_args!("CIRCLE('',#{a},{})", real(*radius)))
}
Curve::Ellipse {
center,
normal,
x_axis,
major,
minor,
} => {
let a = w.ax2(*center, *normal, *x_axis);
w.addf(format_args!(
"ELLIPSE('',#{a},{},{})",
real(*major),
real(*minor)
))
}
Curve::BSpline(b) => bspline_entity(w, b),
}
}
fn knot_runs(knots: &[f64]) -> (Vec<f64>, Vec<usize>) {
let mut ks: Vec<f64> = Vec::new();
let mut ms: Vec<usize> = Vec::new();
for &k in knots {
if ks.last() == Some(&k) {
*ms.last_mut().expect("multiplicity") += 1;
} else {
ks.push(k);
ms.push(1);
}
}
(ks, ms)
}
fn int_list(xs: &[usize]) -> String {
let parts: Vec<String> = xs.iter().map(|m| m.to_string()).collect();
format!("({})", parts.join(","))
}
fn real_list(xs: &[f64]) -> String {
let parts: Vec<String> = xs.iter().map(|&k| real(k)).collect();
format!("({})", parts.join(","))
}
fn bspline_surface_entity(w: &mut W, b: &BSplineSurface) -> usize {
let rows: Vec<String> = b
.control
.iter()
.map(|row| {
let ids: Vec<usize> = row.iter().map(|&p| w.pt(p)).collect();
format!("({})", Refs(&ids))
})
.collect();
let net = format!("({})", rows.join(","));
let (ku, mu) = knot_runs(&b.knots_u);
let (kv, mv) = knot_runs(&b.knots_v);
let knots = format!(
"{},{},{},{},.UNSPECIFIED.",
int_list(&mu),
int_list(&mv),
real_list(&ku),
real_list(&kv)
);
match &b.weights {
None => w.addf(format_args!(
"B_SPLINE_SURFACE_WITH_KNOTS('',{},{},{net},.UNSPECIFIED.,.F.,.F.,.F.,{knots})",
b.degree_u, b.degree_v
)),
Some(ws) => {
let rows: Vec<String> = ws.iter().map(|r| real_list(r)).collect();
w.addf(format_args!(
"(BOUNDED_SURFACE()B_SPLINE_SURFACE({},{},{net},.UNSPECIFIED.,.F.,.F.,.F.)B_SPLINE_SURFACE_WITH_KNOTS({knots})GEOMETRIC_REPRESENTATION_ITEM()RATIONAL_B_SPLINE_SURFACE(({}))REPRESENTATION_ITEM('')SURFACE())",
b.degree_u,
b.degree_v,
rows.join(",")
))
}
}
}
fn surface_entity(w: &mut W, f: &Face) -> usize {
if let Surface::BSpline(b) = &f.surface {
return bspline_surface_entity(w, b);
}
let fr = f.frame;
let a = w.ax2(fr.origin, fr.z, fr.x);
match &f.surface {
Surface::Cylinder { radius, .. } => w.addf(format_args!(
"CYLINDRICAL_SURFACE('',#{a},{})",
real(*radius)
)),
Surface::Cone { slope, .. } => w.addf(format_args!(
"CONICAL_SURFACE('',#{a},{},{})",
real(f.ref_radius),
real(atan(*slope))
)),
Surface::Sphere { radius, .. } => {
w.addf(format_args!("SPHERICAL_SURFACE('',#{a},{})", real(*radius)))
}
Surface::Torus {
major_radius,
minor_radius,
..
} if major_radius < minor_radius => w.addf(format_args!(
"DEGENERATE_TOROIDAL_SURFACE('',#{a},{},{},.T.)",
real(*major_radius),
real(*minor_radius)
)),
Surface::Torus {
major_radius,
minor_radius,
..
} => w.addf(format_args!(
"TOROIDAL_SURFACE('',#{a},{},{})",
real(*major_radius),
real(*minor_radius)
)),
_ => w.refers("PLANE", &[a]),
}
}
fn void_parents(b: &Brep) -> Vec<Option<usize>> {
let bbox = |s: &crate::model::Shell| {
let mut lo = [f64::INFINITY; 3];
let mut hi = [f64::NEG_INFINITY; 3];
for &f in &s.faces {
for lp in &b.faces[f as usize].loops {
for c in &lp.coedges {
let e = &b.edges[c.edge as usize];
for vtx in [e.start, e.end] {
let p = b.vertices[vtx as usize];
for k in 0..3 {
lo[k] = lo[k].min(p[k]);
hi[k] = hi[k].max(p[k]);
}
}
}
}
}
(lo, hi)
};
let boxes: Vec<_> = b.shells.iter().map(bbox).collect();
let size = |(lo, hi): ([f64; 3], [f64; 3])| (0..3).map(|k| hi[k] - lo[k]).product::<f64>();
b.shells
.iter()
.enumerate()
.map(|(i, s)| {
if !s.void {
return None;
}
let (vl, vh) = boxes[i];
b.shells
.iter()
.enumerate()
.filter(|(j, o)| {
!o.void && (0..3).all(|k| boxes[*j].0[k] <= vl[k] && vh[k] <= boxes[*j].1[k])
})
.min_by(|a, c| size(boxes[a.0]).total_cmp(&size(boxes[c.0])))
.map(|(j, _)| j)
})
.collect()
}
pub fn write_step(brep: &Brep, opts: &StepOptions) -> String {
let mut header = String::new();
header.push_str("ISO-10303-21;\nHEADER;\n");
let _ = writeln!(
header,
"FILE_DESCRIPTION(({}),'2;1');",
string(&opts.description)
);
let _ = writeln!(
header,
"FILE_NAME({},{},({}),({}),{},{},'');",
string(&opts.file_name),
string(&opts.timestamp),
string(&opts.author),
string(&opts.organization),
string("meshbrep"),
string(&opts.originating_system)
);
header.push_str(
"FILE_SCHEMA(('AUTOMOTIVE_DESIGN { 1 0 10303 214 1 1 1 1 }'));\nENDSEC;\nDATA;\n",
);
let mut w = W::new(brep.vertices.len());
w.body.push_str(&header);
w.body
.reserve(560 * brep.edges.len() + 320 * brep.faces.len() + 96 * brep.vertices.len());
let name = string(&opts.product_name);
let app = w.add("APPLICATION_CONTEXT('automotive design')".into());
w.addf(format_args!(
"APPLICATION_PROTOCOL_DEFINITION('international standard','automotive_design',2000,#{app})"
));
let pc = w.addf(format_args!("PRODUCT_CONTEXT('',#{app},'mechanical')"));
let prod = w.addf(format_args!("PRODUCT({name},{name},'',(#{pc}))"));
let pdf = w.addf(format_args!("PRODUCT_DEFINITION_FORMATION('','',#{prod})"));
let pdc = w.addf(format_args!(
"PRODUCT_DEFINITION_CONTEXT('part definition',#{app},'design')"
));
let pd = w.addf(format_args!(
"PRODUCT_DEFINITION('design','',#{pdf},#{pdc})"
));
let pds = w.addf(format_args!("PRODUCT_DEFINITION_SHAPE('','',#{pd})"));
let sdr = w.reserve();
let lu = w.add("(LENGTH_UNIT()NAMED_UNIT(*)SI_UNIT(.MILLI.,.METRE.))".into());
let au = w.add("(NAMED_UNIT(*)PLANE_ANGLE_UNIT()SI_UNIT($,.RADIAN.))".into());
let su = w.add("(NAMED_UNIT(*)SI_UNIT($,.STERADIAN.)SOLID_ANGLE_UNIT())".into());
let unc = w.addf(format_args!(
"UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#{lu},'distance_accuracy_value','confusion accuracy')"
));
let ctx = w.addf(format_args!(
"(GEOMETRIC_REPRESENTATION_CONTEXT(3)GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#{unc}))GLOBAL_UNIT_ASSIGNED_CONTEXT((#{lu},#{au},#{su}))REPRESENTATION_CONTEXT('Context3D','3D'))"
));
let ctx2 = w.add(
"(GEOMETRIC_REPRESENTATION_CONTEXT(2)PARAMETRIC_REPRESENTATION_CONTEXT()REPRESENTATION_CONTEXT('2D SPACE',''))"
.into(),
);
let origin = w.ax2([0.0; 3], [0.0, 0.0, 1.0], [1.0, 0.0, 0.0]);
let sids: Vec<usize> = brep
.faces
.iter()
.map(|f| surface_entity(&mut w, f))
.collect();
let vids: Vec<usize> = brep
.vertices
.iter()
.map(|&p| {
let q = w.pt(p);
w.refers("VERTEX_POINT", &[q])
})
.collect();
let mut pcs: Vec<Vec<(usize, &BSpline<2>)>> = vec![Vec::new(); brep.edges.len()];
for (fi, f) in brep.faces.iter().enumerate() {
for lp in &f.loops {
for c in &lp.coedges {
if let Some(pc) = &c.pcurve {
pcs[c.edge as usize].push((fi, pc));
}
}
}
}
let eids: Vec<usize> = brep
.edges
.iter()
.enumerate()
.map(|(i, e)| {
let c3 = curve_entity(&mut w, &e.curve);
let geom = if pcs[i].is_empty() {
c3
} else {
let ps: Vec<usize> = pcs[i]
.iter()
.map(|&(fi, pc)| {
let b = bspline_entity(&mut w, pc);
let dr = w.addf(format_args!(
"DEFINITIONAL_REPRESENTATION('',(#{b}),#{ctx2})"
));
w.addf(format_args!("PCURVE('',#{},#{dr})", sids[fi]))
})
.collect();
let kind = if e.seam {
"SEAM_CURVE"
} else {
"SURFACE_CURVE"
};
w.addf(format_args!("{kind}('',#{c3},({}),.PCURVE_S1.)", Refs(&ps)))
};
let n = w.start();
w.body.push_str("EDGE_CURVE('',");
w.ids(&[vids[e.start as usize], vids[e.end as usize], geom]);
w.body.push_str(",.T.)");
w.finish();
n
})
.collect();
let parents = void_parents(brep);
let face_entity = |w: &mut W, fi: usize, flip: bool| -> usize {
let f = &brep.faces[fi];
let bounds: Vec<usize> = f
.loops
.iter()
.map(|lp| {
let oes: Vec<usize> = lp
.coedges
.iter()
.map(|c| {
let n = w.start();
w.body.push_str("ORIENTED_EDGE('',*,*,");
w.id(eids[c.edge as usize]);
w.body.push_str(if c.forward { ",.T.)" } else { ",.F.)" });
w.finish();
n
})
.collect();
let l = w.start();
w.body.push_str("EDGE_LOOP('',(");
w.ids(&oes);
w.body.push_str("))");
w.finish();
let kind = if lp.outer {
"FACE_OUTER_BOUND"
} else {
"FACE_BOUND"
};
let n = w.start();
w.body.push_str(kind);
w.body.push_str("('',");
w.id(l);
w.body.push_str(if flip { ",.F.)" } else { ",.T.)" });
w.finish();
n
})
.collect();
let n = w.start();
w.body.push_str("ADVANCED_FACE('',(");
w.ids(&bounds);
w.body.push_str("),");
w.id(sids[fi]);
w.body.push_str(if f.same_sense != flip {
",.T.)"
} else {
",.F.)"
});
w.finish();
n
};
let mut shell_ids = Vec::with_capacity(brep.shells.len());
for sh in &brep.shells {
let fs: Vec<usize> = sh
.faces
.iter()
.map(|&f| face_entity(&mut w, f as usize, sh.void))
.collect();
shell_ids.push(w.addf(format_args!("CLOSED_SHELL('',({}))", Refs(&fs))));
}
let mut solids = Vec::new();
for (i, sh) in brep.shells.iter().enumerate() {
if sh.void && parents[i].is_some() {
continue;
}
let voids: Vec<usize> = (0..brep.shells.len())
.filter(|&j| parents[j] == Some(i))
.map(|j| {
w.addf(format_args!(
"ORIENTED_CLOSED_SHELL('',*,#{},.F.)",
shell_ids[j]
))
})
.collect();
solids.push(if voids.is_empty() {
w.addf(format_args!("MANIFOLD_SOLID_BREP('',#{})", shell_ids[i]))
} else {
w.addf(format_args!(
"BREP_WITH_VOIDS('',#{},({}))",
shell_ids[i],
Refs(&voids)
))
});
}
let mut items = solids;
items.push(origin);
let rep = w.addf(format_args!(
"ADVANCED_BREP_SHAPE_REPRESENTATION('',({}),#{ctx})",
Refs(&items)
));
w.set(
sdr,
format!("SHAPE_DEFINITION_REPRESENTATION(#{pds},#{rep})"),
);
w.into_file()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn reals_always_have_a_point() {
assert_eq!(real(0.0), "0.");
assert_eq!(real(-0.0), "0.");
assert_eq!(real(1.0), "1.");
assert_eq!(real(1.5), "1.5");
assert_eq!(real(15.0), "1.5E1");
assert_eq!(real(1e-7), "1.E-7");
assert_eq!(real(-2.5e-12), "-2.5E-12");
for x in [0.1, 1.0 / 3.0, 123456.789, -1e300, 5e-324] {
assert_eq!(real(x).parse::<f64>().unwrap(), x);
}
}
#[test]
fn real_shortcuts_give_the_formatted_text() {
let slow = |x: f64| {
let mut out = String::new();
if x == 0.0 {
out.push_str("0.");
return out;
}
let s = format!("{x:E}");
let (mant, exp) = s.split_once('E').unwrap();
out.push_str(mant);
if !mant.contains('.') {
out.push('.');
}
if exp != "0" {
out.push('E');
out.push_str(exp);
}
out
};
let mut seed: u64 = 0x2545_f491_4f6c_dd1d;
let mut rnd = move || {
seed ^= seed << 13;
seed ^= seed >> 7;
seed ^= seed << 17;
seed
};
let mut values: Vec<f64> = Vec::new();
for k in 0..=54 {
let p = 2f64.powi(k);
values.extend([p - 1.0, p, p + 1.0, -p, 10f64.powi(k.min(22))]);
}
values.extend([1.0, -1.0, 15.0, 100.0, 1e15, 1.5, 0.1, 1e-7, 5e-324]);
for _ in 0..20_000 {
let r = rnd();
values.push(f64::from_bits(r));
values.push((r % 2_000_001) as f64 - 1_000_000.0);
values.push((r % 1_000_000) as f64 / 64.0);
values.push(((r >> 11) as f64) * 1e-3);
}
values.retain(|x| x.is_finite());
let (mut small, mut large) = (Reals::new(0), Reals::new(1 << 20));
for round in 0..3 {
for &x in &values {
for cache in [&mut small, &mut large] {
let mut fast = String::new();
cache.push(&mut fast, x);
assert_eq!(fast, slow(x), "{x:?} (round {round})");
}
let mut plain = String::new();
push_real(&mut plain, x, &mut String::new());
assert_eq!(plain, slow(x), "{x:?}");
}
}
}
#[test]
fn strings_are_escaped() {
assert_eq!(string("it's"), "'it''s'");
assert_eq!(string("a\\b"), "'a\\\\b'");
assert_eq!(string("é"), "'\\X2\\00E9\\X0\\'");
}
}