use crate::ast::{Arg, BinOp, Expr, IndexKind, NaKind, Param, UnOp};
use crate::host::{fixed_decimals, render_fixed, render_sci, sci_decimals};
pub(crate) const CUTOFF: usize = 60;
pub(crate) struct Deparser {
lines: Vec<String>,
buf: String,
len: usize,
indent: usize,
startline: bool,
incurly: usize,
cutoff: usize,
}
impl Deparser {
pub(crate) fn new() -> Self {
Self::with_cutoff(CUTOFF)
}
pub(crate) fn with_cutoff(cutoff: usize) -> Self {
Deparser {
lines: Vec::new(),
buf: String::new(),
len: 0,
indent: 0,
startline: true,
incurly: 0,
cutoff,
}
}
pub(crate) fn print(&mut self, s: &str) {
if self.startline {
self.startline = false;
self.tabs(self.indent);
}
self.buf.push_str(s);
self.len += s.len();
}
fn tabs(&mut self, n: usize) {
for i in 1..=n {
self.print(match i {
1..=4 => " ",
5..=6 => " ",
_ => " ",
});
}
}
pub(crate) fn writeline(&mut self) {
self.lines.push(std::mem::take(&mut self.buf));
self.len = 0;
self.startline = true;
}
pub(crate) fn linebreak(&mut self, lbreak: &mut bool) {
if self.len > self.cutoff {
if !*lbreak {
*lbreak = true;
self.indent += 1;
}
self.writeline();
}
}
pub(crate) fn end_break(&mut self, lbreak: bool) {
if lbreak {
self.indent -= 1;
}
}
pub(crate) fn wrap_vector(&mut self) {
if self.len > self.cutoff {
self.writeline();
}
}
pub(crate) fn finish(mut self) -> Vec<String> {
if !self.startline || !self.buf.is_empty() {
self.writeline();
}
self.lines
}
fn formals(&mut self, params: &[Param]) {
let mut lbreak = false;
for (i, p) in params.iter().enumerate() {
self.print("e_name(&p.name));
if let Some(d) = &p.default {
self.print(" = ");
self.expr(d);
}
if i + 1 < params.len() {
self.print(", ");
self.linebreak(&mut lbreak);
}
}
if lbreak {
self.indent -= 1;
}
}
fn args(&mut self, args: &[Arg]) {
let mut lbreak = false;
for (i, a) in args.iter().enumerate() {
if let Some(n) = &a.name {
self.print("e_name(n));
self.print(" = ");
}
if let Some(v) = &a.value {
self.expr(v);
}
if i + 1 < args.len() {
self.print(", ");
self.linebreak(&mut lbreak);
}
}
if lbreak {
self.indent -= 1;
}
}
fn binary(&mut self, lhs: &Expr, op: &str, rhs: &Expr, main: Prec) {
let mut lbreak = false;
self.operand(lhs, main, true);
self.print(" ");
self.print(op);
self.print(" ");
self.linebreak(&mut lbreak);
self.operand(rhs, main, false);
if lbreak {
self.indent -= 1;
}
}
fn binary2(&mut self, lhs: &Expr, op: &str, rhs: &Expr, main: Prec) {
self.operand(lhs, main, true);
self.print(op);
self.operand(rhs, main, false);
}
fn operand(&mut self, e: &Expr, main: Prec, left: bool) {
if needs_parens(main, e, left) {
self.print("(");
self.expr(e);
self.print(")");
} else {
self.expr(e);
}
}
pub(crate) fn expr(&mut self, e: &Expr) {
match e {
Expr::Num(n) => {
let s = num_literal(*n);
self.print(&s)
}
Expr::Int(i) => {
let s = format!("{i}L");
self.print(&s)
}
Expr::Str(s) => {
let q = format!("\"{}\"", crate::builtins::encode_string(s));
self.print(&q)
}
Expr::Bool(true) => self.print("TRUE"),
Expr::Bool(false) => self.print("FALSE"),
Expr::Null => self.print("NULL"),
Expr::Na(k) => self.print(match k {
NaKind::Logical => "NA",
NaKind::Integer => "NA_integer_",
NaKind::Real => "NA_real_",
NaKind::Character => "NA_character_",
}),
Expr::Inf => self.print("Inf"),
Expr::NaN => self.print("NaN"),
Expr::Ident(s) => {
let q = quote_name(s);
self.print(&q)
}
Expr::Dots => self.print("..."),
Expr::Break => self.print("break"),
Expr::Next => self.print("next"),
Expr::Paren(inner) => {
self.print("(");
self.expr(inner);
self.print(")");
}
Expr::Call { fun, args } => {
self.expr(fun);
self.print("(");
self.args(args);
self.print(")");
}
Expr::Function { params, body } => {
self.print("function(");
self.formals(params);
self.print(") ");
self.expr(body);
}
Expr::If { cond, then, els } => {
self.print("if (");
self.expr(cond);
self.print(") ");
let mut lookahead = false;
if self.incurly > 0 {
lookahead = matches!(then.as_ref(), Expr::Block(_));
if !lookahead {
self.writeline();
self.indent += 1;
}
}
self.expr(then);
match els {
Some(els) => {
if self.incurly > 0 {
self.writeline();
if !lookahead {
self.indent -= 1;
}
} else {
self.print(" ");
}
self.print("else ");
self.expr(els);
}
None => {
if self.incurly > 0 && !lookahead {
self.indent -= 1;
}
}
}
}
Expr::For { var, seq, body } => {
self.print("for (");
let v = quote_name(var);
self.print(&v);
self.print(" in ");
self.expr(seq);
self.print(") ");
self.expr(body);
}
Expr::While { cond, body } => {
self.print("while (");
self.expr(cond);
self.print(") ");
self.expr(body);
}
Expr::Repeat(body) => {
self.print("repeat ");
self.expr(body);
}
Expr::Block(stmts) => {
self.print("{");
self.incurly += 1;
self.indent += 1;
self.writeline();
for s in stmts {
self.expr(s);
self.writeline();
}
self.indent -= 1;
self.print("}");
self.incurly -= 1;
}
Expr::Assign {
target,
value,
super_assign,
} => {
self.expr(target);
self.print(if *super_assign { " <<- " } else { " <- " });
self.expr(value);
}
Expr::Formula { lhs, rhs } => match lhs {
Some(l) => self.binary(l, "~", rhs, Prec::left(PREC_TILDE)),
None => {
self.print("~");
self.operand(rhs, Prec::left(PREC_TILDE), false);
}
},
Expr::Binary { op, lhs, rhs } => match op {
BinOp::Div => self.binary2(lhs, "/", rhs, Prec::left(PREC_PROD)),
BinOp::Pow => self.binary2(lhs, "^", rhs, Prec::right(PREC_POWER)),
BinOp::Colon => self.binary2(lhs, ":", rhs, Prec::left(PREC_COLON)),
_ => {
let name = match op {
BinOp::Add => "+",
BinOp::Sub => "-",
BinOp::Mul => "*",
BinOp::Lt => "<",
BinOp::Gt => ">",
BinOp::Le => "<=",
BinOp::Ge => ">=",
BinOp::Eq => "==",
BinOp::Ne => "!=",
BinOp::And => "&",
BinOp::Or => "|",
BinOp::And2 => "&&",
BinOp::Or2 => "||",
BinOp::Div | BinOp::Pow | BinOp::Colon => unreachable!(),
};
self.binary(lhs, name, rhs, Prec::left(binop_prec(op)))
}
},
Expr::Special { name, lhs, rhs } => {
let op = format!("%{name}%");
if name.is_empty() || name == "/" {
self.binary2(lhs, &op, rhs, Prec::left(PREC_PERCENT))
} else {
self.binary(lhs, &op, rhs, Prec::left(PREC_PERCENT))
}
}
Expr::Unary { op, operand } => {
self.print(match op {
UnOp::Neg => "-",
UnOp::Plus => "+",
UnOp::Not => "!",
});
let main = match op {
UnOp::Not => PREC_NOT,
UnOp::Neg | UnOp::Plus => PREC_SIGN,
};
self.operand(operand, Prec::left(main), false);
}
Expr::Index { kind, obj, args } => {
self.operand(obj, Prec::left(PREC_SUBSET), true);
match kind {
IndexKind::Single => {
self.print("[");
self.args(args);
self.print("]");
}
IndexKind::Double => {
self.print("[[");
self.args(args);
self.print("]]");
}
IndexKind::Dollar | IndexKind::At => {
self.print(if matches!(kind, IndexKind::Dollar) {
"$"
} else {
"@"
});
for a in args {
match a.value.as_ref() {
Some(Expr::Str(s)) => {
let q = quote_name(s);
self.print(&q)
}
Some(v) => self.expr(v),
None => {}
}
}
}
}
}
}
}
}
pub fn deparse_closure(params: &[Param], body: &Expr) -> Vec<String> {
let mut d = Deparser::new();
d.print("function (");
d.formals(params);
d.print(") ");
d.writeline();
d.expr(body);
d.finish()
}
pub fn deparse_expr(e: &Expr) -> String {
let mut d = Deparser::new();
d.expr(e);
d.finish().join("")
}
pub fn deparse_first_line(e: &Expr) -> String {
let mut d = Deparser::new();
d.expr(e);
d.finish().into_iter().next().unwrap_or_default()
}
pub fn binop_symbol(op: &BinOp) -> &'static str {
match op {
BinOp::Add => "+",
BinOp::Sub => "-",
BinOp::Mul => "*",
BinOp::Div => "/",
BinOp::Pow => "^",
BinOp::Lt => "<",
BinOp::Gt => ">",
BinOp::Le => "<=",
BinOp::Ge => ">=",
BinOp::Eq => "==",
BinOp::Ne => "!=",
BinOp::And => "&",
BinOp::Or => "|",
BinOp::And2 => "&&",
BinOp::Or2 => "||",
BinOp::Colon => ":",
}
}
pub fn deparse_all_lines(e: &Expr) -> Vec<String> {
let mut d = Deparser::new();
d.expr(e);
d.finish()
}
pub fn deparse_lines(e: &Expr) -> String {
let mut d = Deparser::new();
d.expr(e);
d.finish().join("\n")
}
const PREC_LEFT: u8 = 2;
const PREC_TILDE: u8 = 4;
const PREC_OR: u8 = 5;
const PREC_AND: u8 = 6;
const PREC_NOT: u8 = 7;
const PREC_COMPARE: u8 = 8;
const PREC_SUM: u8 = 9;
const PREC_PROD: u8 = 10;
const PREC_PERCENT: u8 = 11;
const PREC_COLON: u8 = 12;
const PREC_SIGN: u8 = 13;
const PREC_POWER: u8 = 14;
const PREC_SUBSET: u8 = 15;
#[derive(Clone, Copy)]
struct Prec {
prec: u8,
right_assoc: bool,
}
impl Prec {
fn left(prec: u8) -> Self {
Prec {
prec,
right_assoc: false,
}
}
fn right(prec: u8) -> Self {
Prec {
prec,
right_assoc: true,
}
}
}
fn binop_prec(op: &BinOp) -> u8 {
match op {
BinOp::Or | BinOp::Or2 => PREC_OR,
BinOp::And | BinOp::And2 => PREC_AND,
BinOp::Lt | BinOp::Gt | BinOp::Le | BinOp::Ge | BinOp::Eq | BinOp::Ne => PREC_COMPARE,
BinOp::Add | BinOp::Sub => PREC_SUM,
BinOp::Mul | BinOp::Div => PREC_PROD,
BinOp::Colon => PREC_COLON,
BinOp::Pow => PREC_POWER,
}
}
fn needs_parens(main: Prec, arg: &Expr, left: bool) -> bool {
let outranks = |p: u8| main.prec > p || (main.prec == p && left == main.right_assoc);
match arg {
Expr::Binary { op, .. } => {
let p = binop_prec(op);
(main.prec == PREC_COMPARE && p == PREC_COMPARE) || outranks(p)
}
Expr::Special { .. } => outranks(PREC_PERCENT),
Expr::Formula { lhs: Some(_), .. } => outranks(PREC_TILDE),
Expr::Formula { lhs: None, .. } => left && outranks(PREC_TILDE),
Expr::Unary { op, .. } => {
let p = match op {
UnOp::Not => PREC_NOT,
UnOp::Neg | UnOp::Plus => PREC_SIGN,
};
left && outranks(p)
}
Expr::Assign { .. } => outranks(PREC_LEFT),
Expr::Index { .. } => outranks(PREC_SUBSET),
Expr::If { .. } | Expr::For { .. } | Expr::While { .. } | Expr::Repeat(_) => left,
_ => false,
}
}
fn num_literal(x: f64) -> String {
if !x.is_finite() {
return render_fixed(x, 0);
}
let fixed = render_fixed(x, fixed_decimals(x));
let sci = render_sci(x, sci_decimals(x));
if crate::host::prefers_fixed(fixed.chars().count(), sci.chars().count()) {
fixed
} else {
sci
}
}
pub fn is_syntactic_name(s: &str) -> bool {
if s == "..." {
return true;
}
let mut cs = s.chars();
let Some(first) = cs.next() else {
return false;
};
if first != '.' && !first.is_ascii_alphabetic() {
return false;
}
if first == '.' && cs.clone().next().is_some_and(|c| c.is_ascii_digit()) {
return false;
}
if !cs.all(|c| c.is_ascii_alphanumeric() || c == '.' || c == '_') {
return false;
}
!matches!(
s,
"NULL"
| "NA"
| "TRUE"
| "FALSE"
| "Inf"
| "NaN"
| "NA_integer_"
| "NA_real_"
| "NA_character_"
| "function"
| "while"
| "repeat"
| "for"
| "if"
| "in"
| "else"
| "next"
| "break"
)
}
pub(crate) fn quote_tag(s: &str) -> String {
if is_syntactic_name(s) {
s.to_string()
} else {
format!("\"{}\"", crate::builtins::encode_string(s))
}
}
pub(crate) fn quote_name(s: &str) -> String {
if is_syntactic_name(s) {
s.to_string()
} else {
format!("`{s}`")
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::parser::parse;
fn dep(src: &str) -> Vec<String> {
let exprs = parse(src).expect("parse");
match &exprs[0] {
Expr::Function { params, body } => deparse_closure(params, body),
other => panic!("not a function: {other:?}"),
}
}
#[test]
fn header_is_its_own_line_with_a_trailing_space() {
assert_eq!(dep("function(x) x + 1"), vec!["function (x) ", "x + 1"]);
}
#[test]
fn if_breaks_only_inside_braces() {
assert_eq!(
dep("function(a, b) if (a > b) a else b"),
vec!["function (a, b) ", "if (a > b) a else b"]
);
assert_eq!(
dep("function(y) { if (y > 3) y else 0 }"),
vec![
"function (y) ",
"{",
" if (y > 3) ",
" y",
" else 0",
"}"
]
);
}
#[test]
fn tight_operators_take_no_spaces() {
assert_eq!(dep("function(x) x/2")[1], "x/2");
assert_eq!(dep("function(x) x^2")[1], "x^2");
assert_eq!(dep("function(x) x %% 3")[1], "x%%3");
assert_eq!(dep("function(x) x %in% y")[1], "x %in% y");
assert_eq!(dep("function(x) x * 2 + 1")[1], "x * 2 + 1");
}
#[test]
fn parentheses_survive_verbatim() {
assert_eq!(dep("function(x) (x + 1) * 2")[1], "(x + 1) * 2");
assert_eq!(dep("function(x) -(x + 1)")[1], "-(x + 1)");
}
#[test]
fn long_binary_run_wraps_at_the_cutoff() {
assert_eq!(
dep("function(a) { a + 100000 + 200000 + 300000 + 400000 + 500000 + 600000 + 700000 + 800000 }"),
vec![
"function (a) ",
"{",
" a + 1e+05 + 2e+05 + 3e+05 + 4e+05 + 5e+05 + 6e+05 + 7e+05 + ",
" 8e+05",
"}",
]
);
}
#[test]
fn defaults_and_nested_functions() {
assert_eq!(
dep("function(x = c(1,2), y = \"a\") function(z = 2) z"),
vec!["function (x = c(1, 2), y = \"a\") ", "function(z = 2) z"]
);
}
#[test]
fn non_syntactic_names_are_backticked() {
assert!(!is_syntactic_name("my var"));
assert!(!is_syntactic_name("if"));
assert!(!is_syntactic_name(".5x"));
assert!(is_syntactic_name("..."));
assert!(is_syntactic_name(".x"));
}
}