Last updated on 2026-11-09 03:51:52 CET.
| Flavor | Version | Tinstall | Tcheck | Ttotal | Status | Flags |
|---|---|---|---|---|---|---|
| r-devel-linux-x86_64-debian-clang | 2.0.2 | 3.43 | 223.65 | 227.08 | OK | |
| r-devel-linux-x86_64-debian-gcc | 2.0.2 | 2.45 | 220.50 | 222.95 | OK | |
| r-devel-linux-x86_64-fedora-clang | 2.0.2 | OK | ||||
| r-devel-linux-x86_64-fedora-gcc | 2.0.2 | 188.37 | OK | |||
| r-devel-windows-x86_64 | 2.0.2 | 6.00 | 143.00 | 149.00 | OK | |
| r-patched-linux-x86_64 | 2.0.2 | OK | ||||
| r-release-linux-x86_64 | 2.0.2 | 3.34 | 211.51 | 214.85 | OK | |
| r-release-macos-arm64 | 2.0.2 | 1.00 | 56.00 | 57.00 | OK | |
| r-release-macos-x86_64 | 2.0.2 | 3.00 | 208.00 | 211.00 | OK | |
| r-release-windows-x86_64 | 2.0.2 | 7.00 | 129.00 | 136.00 | OK | |
| r-oldrel-macos-arm64 | 2.0.2 | 2.00 | 44.00 | 46.00 | ERROR | |
| r-oldrel-macos-x86_64 | 2.0.2 | 3.00 | 201.00 | 204.00 | OK | |
| r-oldrel-windows-x86_64 | 2.0.2 | 8.00 | 160.00 | 168.00 | OK |
Version: 2.0.2
Check: re-building of vignette outputs
Result: ERROR
Error(s) in re-building vignettes:
--- re-building ‘rEDM-tutorial.Rmd’ using rmarkdown
2026-11-09 08:26:16.061 R[43959:68532] XType: Using static font registry.
*** caught segfault ***
address 0x110, cause 'invalid permissions'
*** caught segfault ***
address 0x110, cause 'invalid permissions'
*** caught segfault ***
address 0x110, cause 'invalid permissions'
*** caught segfault ***
address 0x110, cause 'invalid permissions'
Traceback:
1: RowCumsum(valid)
2: FindNeighbors(embedding, lib_i, pred_i, knn, exclusionRadius = exclusionRadius, validLib = validLib, libOverlap = idx$libOverlap, backend = backend, tieBreak = FALSE, verbose = verbose)
3: SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp, knn = knn, tau = tau, theta = th, exclusionRadius = exclusionRadius, embedded = embedded, validLib = validLib, noTime = noTime, ignoreNan = ignoreNan, backend = backend)
Traceback:
4: 1: ComputeError(predictions$Observations, predictions$Predictions)
RowCumsum(valid)
5: 2: SweepRho(SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp, FindNeighbors(embedding, lib_i, pred_i, knn, exclusionRadius = exclusionRadius, knn = knn, tau = tau, theta = th, exclusionRadius = exclusionRadius, validLib = validLib, libOverlap = idx$libOverlap, backend = backend, embedded = embedded, validLib = validLib, noTime = noTime, tieBreak = FALSE, verbose = verbose) ignoreNan = ignoreNan, backend = backend)$predictions)
3: 6: SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp, knn = knn, tau = tau, theta = th, exclusionRadius = exclusionRadius, FUN(X[[i]], ...) embedded = embedded, validLib = validLib, noTime = noTime,
ignoreNan = ignoreNan, backend = backend) 7:
lapply(X = S, FUN = FUN, ...) 4:
ComputeError(predictions$Observations, predictions$Predictions) 8: doTryCatch(return(expr), name, parentenv, handler)
5: SweepRho(SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp, 9: knn = knn, tau = tau, theta = th, exclusionRadius = exclusionRadius, tryCatchOne(expr, names, parentenv, handlers[[1L]]) embedded = embedded, validLib = validLib, noTime = noTime,
ignoreNan = ignoreNan, backend = backend)$predictions)
10: 6: tryCatchList(expr, classes, parentenv, handlers)
FUN(X[[i]], ...)11:
tryCatch(expr, error = function(e) { 7: call <- conditionCall(e)lapply(X = S, FUN = FUN, ...) if (!is.null(call)) {
if (identical(call[[1L]], quote(doTryCatch))) 8: doTryCatch(return(expr), name, parentenv, handler) call <- sys.call(-4L)
dcall <- deparse(call, nlines = 1L) 9: prefix <- paste("Error in", dcall, ": ")tryCatchOne(expr, names, parentenv, handlers[[1L]]) LONG <- 75L
sm <- strsplit(conditionMessage(e), "\n")[[1L]]10: w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")tryCatchList(expr, classes, parentenv, handlers) if (is.na(w))
w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], 11: type = "b")tryCatch(expr, error = function(e) { if (w > LONG) call <- conditionCall(e) prefix <- paste0(prefix, "\n ") if (!is.null(call)) { if (identical(call[[1L]], quote(doTryCatch))) } call <- sys.call(-4L) else prefix <- "Error : " dcall <- deparse(call, nlines = 1L) prefix <- paste("Error in", dcall, ": ") msg <- paste0(prefix, conditionMessage(e), "\n") .Internal(seterrmessage(msg[1L])) LONG <- 75L if (!silent && isTRUE(getOption("show.error.messages"))) { sm <- strsplit(conditionMessage(e), "\n")[[1L]] cat(msg, file = outFile) w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w") .Internal(printDeferredWarnings()) if (is.na(w)) w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], } invisible(structure(msg, class = "try-error", condition = e)) type = "b")}) if (w > LONG)
prefix <- paste0(prefix, "\n ")12: }try(lapply(X = S, FUN = FUN, ...), silent = TRUE) else prefix <- "Error : "
msg <- paste0(prefix, conditionMessage(e), "\n")13: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE)) .Internal(seterrmessage(msg[1L]))
if (!silent && isTRUE(getOption("show.error.messages"))) {14: cat(msg, file = outFile)FUN(X[[i]], ...) .Internal(printDeferredWarnings())
}15: invisible(structure(msg, class = "try-error", condition = e))lapply(seq_len(cores), inner.do)})
16: 12: parallel::mclapply(values, worker, mc.cores = cores, mc.preschedule = TRUE)
17: doTryCatch(return(expr), name, parentenv, handler)try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
18: 13: tryCatchOne(expr, names, parentenv, handlers[[1L]])sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
19: 14: tryCatchList(expr, classes, parentenv, handlers)FUN(X[[i]], ...)
20: 15: tryCatch(parallel::mclapply(values, worker, mc.cores = cores, lapply(seq_len(cores), inner.do) mc.preschedule = TRUE), error = function(e) NULL)
16: 21: SweepApply(theta, worker, numProcess)parallel::mclapply(values, worker, mc.cores = cores, mc.preschedule = TRUE)
22: 17: unlist(SweepApply(theta, worker, numProcess))doTryCatch(return(expr), name, parentenv, handler)
23: 18: PredictNonlinear(dataFrame = Thrips, columns = "Thrips_imaginis", tryCatchOne(expr, names, parentenv, handlers[[1L]]) target = "Thrips_imaginis", lib = "1 73", pred = "1 73",
E = E, showPlot = TRUE)19:
tryCatchList(expr, classes, parentenv, handlers)24:
eval(expr, envir)20:
tryCatch(parallel::mclapply(values, worker, mc.cores = cores, mc.preschedule = TRUE), error = function(e) NULL)25:
eval(expr, envir)21:
SweepApply(theta, worker, numProcess)26:
22: withVisible(eval(expr, envir))unlist(SweepApply(theta, worker, numProcess))
23: 27: PredictNonlinear(dataFrame = Thrips, columns = "Thrips_imaginis", withCallingHandlers(code, error = function (e) target = "Thrips_imaginis", lib = "1 73", pred = "1 73", rlang::entrace(e), message = function (cnd) E = E, showPlot = TRUE){
watcher$capture_plot_and_output() if (on_message$capture) { watcher$push(cnd)24: }eval(expr, envir) if (on_message$silence) {
invokeRestart("muffleMessage") }25: }, warning = function (cnd) eval(expr, envir)
{ if (getOption("warn") >= 2 || getOption("warn") < 0) {26: return()withVisible(eval(expr, envir)) }
watcher$capture_plot_and_output()27: if (on_warning$capture) {withCallingHandlers(code, error = function (e) cnd <- sanitize_call(cnd)rlang::entrace(e), message = function (cnd) watcher$push(cnd){ } watcher$capture_plot_and_output() if (on_warning$silence) { if (on_message$capture) { invokeRestart("muffleWarning") watcher$push(cnd) } }}, error = function (cnd) if (on_message$silence) {{ invokeRestart("muffleMessage") watcher$capture_plot_and_output() } cnd <- sanitize_call(cnd)}, warning = function (cnd)
Traceback:
watcher$push(cnd){ 1: if (getOption("warn") >= 2 || getOption("warn") < 0) {RowCumsum(valid) switch(on_error, continue = invokeRestart("eval_continue"),
stop = invokeRestart("eval_stop"), error = NULL) return()}) 2: }FindNeighbors(embedding, lib_i, pred_i, knn, exclusionRadius = exclusionRadius,
validLib = validLib, libOverlap = idx$libOverlap, backend = backend, watcher$capture_plot_and_output() tieBreak = FALSE, verbose = verbose) if (on_warning$capture) {28:
cnd <- sanitize_call(cnd)eval(call) 3: watcher$push(cnd)SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp, knn = knn, } tau = tau, theta = th, exclusionRadius = exclusionRadius,
embedded = embedded, validLib = validLib, noTime = noTime, 29: ignoreNan = ignoreNan, backend = backend)eval(call) if (on_warning$silence) {
invokeRestart("muffleWarning") 4: }ComputeError(predictions$Observations, predictions$Predictions)30: }, error = function (cnd)
with_handlers({{ 5: for (expr in tle$exprs) { watcher$capture_plot_and_output()SweepRho(SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp, ev <- withVisible(eval(expr, envir)) knn = knn, tau = tau, theta = th, exclusionRadius = exclusionRadius, watcher$capture_plot_and_output() embedded = embedded, validLib = validLib, noTime = noTime, watcher$print_value(ev$value, ev$visible, envir) ignoreNan = ignoreNan, backend = backend)$predictions) cnd <- sanitize_call(cnd)
watcher$push(cnd) } 6: TRUEFUN(X[[i]], ...) switch(on_error, continue = invokeRestart("eval_continue"), }, handlers) stop = invokeRestart("eval_stop"), error = NULL)
}) 7: 31: lapply(X = S, FUN = FUN, ...)
Traceback:
doWithOneRestart(return(expr), restart)28:
eval(call) 8:
1: doTryCatch(return(expr), name, parentenv, handler)32: RowCumsum(valid)withOneRestart(expr, restarts[[1L]])
29: 9:
eval(call)tryCatchOne(expr, names, parentenv, handlers[[1L]])
2: 30: 10: FindNeighbors(embedding, lib_i, pred_i, knn, exclusionRadius = exclusionRadius, with_handlers({33: for (expr in tle$exprs) {withRestartList(expr, restarts[-nr])tryCatchList(expr, classes, parentenv, handlers)
34: 11: ev <- withVisible(eval(expr, envir))doWithOneRestart(return(expr), restart) watcher$capture_plot_and_output()
validLib = validLib, libOverlap = idx$libOverlap, backend = backend, 35: tieBreak = FALSE, verbose = verbose) watcher$print_value(ev$value, ev$visible, envir)withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])tryCatch(expr, error = function(e) { }
call <- conditionCall(e) TRUE}, handlers)36:
if (!is.null(call)) { 3: SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp, knn = knn, if (identical(call[[1L]], quote(doTryCatch))) 31: withRestartList(expr, restarts) call <- sys.call(-4L)doWithOneRestart(return(expr), restart)
dcall <- deparse(call, nlines = 1L)37: withRestarts(with_handlers({
prefix <- paste("Error in", dcall, ": ")32: tau = tau, theta = th, exclusionRadius = exclusionRadius, LONG <- 75LwithOneRestart(expr, restarts[[1L]]) sm <- strsplit(conditionMessage(e), "\n")[[1L]]
embedded = embedded, validLib = validLib, noTime = noTime, 33: for (expr in tle$exprs) { ignoreNan = ignoreNan, backend = backend) w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")
if (is.na(w)) 4: withRestartList(expr, restarts[-nr]) w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],
ev <- withVisible(eval(expr, envir)) type = "b")ComputeError(predictions$Observations, predictions$Predictions) if (w > LONG)
prefix <- paste0(prefix, "\n ") watcher$capture_plot_and_output()34: 5: watcher$print_value(ev$value, ev$visible, envir) } } else prefix <- "Error : "doWithOneRestart(return(expr), restart)SweepRho(SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp, TRUE msg <- paste0(prefix, conditionMessage(e), "\n")
knn = knn, tau = tau, theta = th, exclusionRadius = exclusionRadius, .Internal(seterrmessage(msg[1L]))}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE) if (!silent && isTRUE(getOption("show.error.messages"))) {35:
cat(msg, file = outFile) embedded = embedded, validLib = validLib, noTime = noTime, 38: .Internal(printDeferredWarnings()) ignoreNan = ignoreNan, backend = backend)$predictions) }evaluate::evaluate(...)withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]]) invisible(structure(msg, class = "try-error", condition = e))
})
6: 12:
39: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)FUN(X[[i]], ...)evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 36:
keep_message = if (is.numeric(options$message)) TRUE else options$message, 13: withRestartList(expr, restarts)
stop_on_error = if (is.numeric(options$error)) options$error else {
7: 37: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE)) if (options$error && options$include) lapply(X = S, FUN = FUN, ...) 0L
14: else 2LwithRestarts(with_handlers({ }, output_handler = knit_handlers(options$render, options)) for (expr in tle$exprs) { ev <- withVisible(eval(expr, envir)) watcher$capture_plot_and_output() 8: watcher$print_value(ev$value, ev$visible, envir)
}FUN(X[[i]], ...) TRUE40:
}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)in_dir(input_dir(), expr)15:
41: doTryCatch(return(expr), name, parentenv, handler)38: lapply(seq_len(cores), inner.do)
in_input_dir(evaluate(code, envir = env, new_device = FALSE, 16: 9: keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, tryCatchOne(expr, names, parentenv, handlers[[1L]])evaluate::evaluate(...) keep_message = if (is.numeric(options$message)) TRUE else options$message,
parallel::mclapply(values, worker, mc.cores = cores, mc.preschedule = TRUE) stop_on_error = if (is.numeric(options$error)) options$error else {39: if (options$error && options$include) evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 0L10: else 2L keep_message = if (is.numeric(options$message)) TRUE else options$message, tryCatchList(expr, classes, parentenv, handlers) }, output_handler = knit_handlers(options$render, options)))
42: 17: stop_on_error = if (is.numeric(options$error)) options$error else {11: doTryCatch(return(expr), name, parentenv, handler) if (options$error && options$include) tryCatch(expr, error = function(e) {eng_r(options) call <- conditionCall(e)
0L18:
if (!is.null(call)) {43: tryCatchOne(expr, names, parentenv, handlers[[1L]]) else 2L if (identical(call[[1L]], quote(doTryCatch))) }, output_handler = knit_handlers(options$render, options)) call <- sys.call(-4L)block_exec(params)
dcall <- deparse(call, nlines = 1L)19:
tryCatchList(expr, classes, parentenv, handlers)40: prefix <- paste("Error in", dcall, ": ")44: in_dir(input_dir(), expr)call_block(x) LONG <- 75L
sm <- strsplit(conditionMessage(e), "\n")[[1L]]20: 41: w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")
tryCatch(parallel::mclapply(values, worker, mc.cores = cores, 45: if (is.na(w)) mc.preschedule = TRUE), error = function(e) NULL)process_group(group) w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],
in_input_dir(evaluate(code, envir = env, new_device = FALSE,
type = "b")46: if (w > LONG) keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), keep_message = if (is.numeric(options$message)) TRUE else options$message, error = function(e) { stop_on_error = if (is.numeric(options$error)) options$error else { prefix <- paste0(prefix, "\n ") if (progress && is.function(pb$interrupt)) }21: if (options$error && options$include) SweepApply(theta, worker, numProcess) else prefix <- "Error : "
pb$interrupt()22: 0L msg <- paste0(prefix, conditionMessage(e), "\n") if (is_R_CMD_build() || is_R_CMD_check()) .Internal(seterrmessage(msg[1L])) else 2L error <<- format(e) if (!silent && isTRUE(getOption("show.error.messages"))) { }) }, output_handler = knit_handlers(options$render, options)))unlist(SweepApply(theta, worker, numProcess))
cat(msg, file = outFile)47: 42: .Internal(printDeferredWarnings())with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 23: }eng_r(options) error = function(e) {
invisible(structure(msg, class = "try-error", condition = e))PredictNonlinear(dataFrame = Thrips, columns = "Thrips_imaginis", 43: if (progress && is.function(pb$interrupt)) target = "Thrips_imaginis", lib = "1 73", pred = "1 73", block_exec(params) pb$interrupt()}) if (is_R_CMD_build() || is_R_CMD_check())
E = E, showPlot = TRUE) error <<- format(e)12: }), list(rlang_trace_top_env = knit_global()))
48: 24: 44: xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), eval(expr, envir) error = function(e) {try(lapply(X = S, FUN = FUN, ...), silent = TRUE) if (progress && is.function(pb$interrupt))
13: call_block(x)sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE)) pb$interrupt()
if (is_R_CMD_build() || is_R_CMD_check())
error <<- format(e)14: }), list(rlang_trace_top_env = knit_global())), function(loc) {45: setwd(wd)FUN(X[[i]], ...) write_utf8(res, output %n% stdout())
process_group(group)25:
paste0("\nQuitting from ", loc, if (!is.null(error)) 46: eval(expr, envir)withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),
paste0("\n", rule(), error, "\n", rule()))26: 15: error = function(e) {}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc) if (progress && is.function(pb$interrupt)) withVisible(eval(expr, envir))lapply(seq_len(cores), inner.do)
27: pb$interrupt()
if (is_R_CMD_build() || is_R_CMD_check()) withCallingHandlers(code, error = function (e) 16: 49: parallel::mclapply(values, worker, mc.cores = cores, mc.preschedule = TRUE) error <<- format(e)
rlang::entrace(e), message = function (cnd) })17: {doTryCatch(return(expr), name, parentenv, handler)
watcher$capture_plot_and_output()18: process_file(text, output)tryCatchOne(expr, names, parentenv, handlers[[1L]]) if (on_message$capture) {
watcher$push(cnd)19: }47: tryCatchList(expr, classes, parentenv, handlers)
with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), if (on_message$silence) {50: error = function(e) { invokeRestart("muffleMessage")knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet) } if (progress && is.function(pb$interrupt))
}, warning = function (cnd) 51: pb$interrupt()rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),
output_dir = getwd(), ...) if (is_R_CMD_build() || is_R_CMD_check()) 20: {tryCatch(parallel::mclapply(values, worker, mc.cores = cores, error <<- format(e) if (getOption("warn") >= 2 || getOption("warn") < 0) { }), list(rlang_trace_top_env = knit_global())) return()
}52: vweave_rmarkdown(...) mc.preschedule = TRUE), error = function(e) NULL)
watcher$capture_plot_and_output()
53: 21: 48: engine$weave(file, quiet = quiet, encoding = enc) if (on_warning$capture) {SweepApply(theta, worker, numProcess)xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), cnd <- sanitize_call(cnd)
watcher$push(cnd)22:
error = function(e) { }54: if (on_warning$silence) { if (progress && is.function(pb$interrupt)) unlist(SweepApply(theta, worker, numProcess)) invokeRestart("muffleWarning") pb$interrupt() }doTryCatch(return(expr), name, parentenv, handler) if (is_R_CMD_build() || is_R_CMD_check()) }, error = function (cnd) error <<- format(e)
}), list(rlang_trace_top_env = knit_global())), function(loc) {{55: 23: watcher$capture_plot_and_output()tryCatchOne(expr, names, parentenv, handlers[[1L]]) setwd(wd)
PredictNonlinear(dataFrame = Thrips, columns = "Thrips_imaginis", write_utf8(res, output %n% stdout()) cnd <- sanitize_call(cnd) paste0("\nQuitting from ", loc, if (!is.null(error)) 56: watcher$push(cnd)tryCatchList(expr, classes, parentenv, handlers) paste0("\n", rule(), error, "\n", rule())) target = "Thrips_imaginis", lib = "1 73", pred = "1 73",
}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc) E = E, showPlot = TRUE)
57: 24: 49: tryCatch({eval(expr, envir) switch(on_error, continue = invokeRestart("eval_continue"),
stop = invokeRestart("eval_stop"), error = NULL) engine$weave(file, quiet = quiet, encoding = enc)process_file(text, output) setwd(startdir)25: output <- find_vignette_product(name, by = "weave", engine = engine)})eval(expr, envir)
if (!have.makefile && vignette_is_tex(output)) {28: eval(call)
texi2pdf(file = output, clean = FALSE, quiet = quiet)50: output <- find_vignette_product(name, by = "texi2pdf", knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)26:
withVisible(eval(expr, envir))
engine = engine)51:
rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(), 29: output_dir = getwd(), ...)
27: }withCallingHandlers(code, error = function (e) 52: outputs <- c(outputs, output)rlang::entrace(e), message = function (cnd) }, error = function(e) {eval(call) thisOK <<- FALSE{vweave_rmarkdown(...) fails <<- c(fails, file) watcher$capture_plot_and_output() message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s", file, conditionMessage(e)))
}) if (on_message$capture) {
watcher$push(cnd)30: 53: }with_handlers({ for (expr in tle$exprs) {engine$weave(file, quiet = quiet, encoding = enc) ev <- withVisible(eval(expr, envir))58: if (on_message$silence) { watcher$capture_plot_and_output() invokeRestart("muffleMessage")
watcher$print_value(ev$value, ev$visible, envir)tools::buildVignettes(dir = "/Volumes/Builds/packages/big-sur-arm64/results/4.5/rEDM.Rcheck/vign_test/rEDM", 54: }doTryCatch(return(expr), name, parentenv, handler) TRUE skip = TRUE, ser_elibs = "/Volumes/Temp/tmp/RtmpAeWUwr/file93fb63a83378.rds")
}, handlers) }
55: An irrecoverable exception occurred. R is aborting now ...
}, warning = function (cnd) 31: {doWithOneRestart(return(expr), restart) if (getOption("warn") >= 2 || getOption("warn") < 0) {
return()32: withOneRestart(expr, restarts[[1L]])tryCatchOne(expr, names, parentenv, handlers[[1L]]) }
watcher$capture_plot_and_output()33: withRestartList(expr, restarts[-nr])
if (on_warning$capture) {56: tryCatchList(expr, classes, parentenv, handlers)
cnd <- sanitize_call(cnd)34:
watcher$push(cnd)doWithOneRestart(return(expr), restart) }
if (on_warning$silence) {35: 57: invokeRestart("muffleWarning")tryCatch({withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]]) engine$weave(file, quiet = quiet, encoding = enc)
}36: setwd(startdir)}, error = function (cnd) withRestartList(expr, restarts) output <- find_vignette_product(name, by = "weave", engine = engine){
watcher$capture_plot_and_output()37: if (!have.makefile && vignette_is_tex(output)) { cnd <- sanitize_call(cnd) texi2pdf(file = output, clean = FALSE, quiet = quiet) output <- find_vignette_product(name, by = "texi2pdf", withRestarts(with_handlers({ engine = engine) watcher$push(cnd) } for (expr in tle$exprs) { switch(on_error, continue = invokeRestart("eval_continue"), outputs <- c(outputs, output) ev <- withVisible(eval(expr, envir))}, error = function(e) { watcher$capture_plot_and_output() thisOK <<- FALSE watcher$print_value(ev$value, ev$visible, envir) stop = invokeRestart("eval_stop"), error = NULL) } fails <<- c(fails, file) TRUE message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s", })}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE) file, conditionMessage(e)))
38: })28:
evaluate::evaluate(...)eval(call)
58: 29: 39: tools::buildVignettes(dir = "/Volumes/Builds/packages/big-sur-arm64/results/4.5/rEDM.Rcheck/vign_test/rEDM", evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, skip = TRUE, ser_elibs = "/Volumes/Temp/tmp/RtmpAeWUwr/file93fb63a83378.rds")eval(call) keep_message = if (is.numeric(options$message)) TRUE else options$message,
stop_on_error = if (is.numeric(options$error)) options$error else {
if (options$error && options$include) 30: An irrecoverable exception occurred. R is aborting now ...
0Lwith_handlers({ else 2L for (expr in tle$exprs) { }, output_handler = knit_handlers(options$render, options)) ev <- withVisible(eval(expr, envir))
watcher$capture_plot_and_output() watcher$print_value(ev$value, ev$visible, envir)40: in_dir(input_dir(), expr) }
TRUE41: }, handlers)in_input_dir(evaluate(code, envir = env, new_device = FALSE,
keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 31: keep_message = if (is.numeric(options$message)) TRUE else options$message, doWithOneRestart(return(expr), restart) stop_on_error = if (is.numeric(options$error)) options$error else {
if (options$error && options$include) 32: 0LwithOneRestart(expr, restarts[[1L]]) else 2L
}, output_handler = knit_handlers(options$render, options)))33:
withRestartList(expr, restarts[-nr])42:
eng_r(options)34:
doWithOneRestart(return(expr), restart)43:
block_exec(params)35:
44: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])call_block(x)
36: 45: withRestartList(expr, restarts)process_group(group)
37: 46: withRestarts(with_handlers({withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), for (expr in tle$exprs) { error = function(e) { ev <- withVisible(eval(expr, envir)) watcher$capture_plot_and_output() if (progress && is.function(pb$interrupt)) watcher$print_value(ev$value, ev$visible, envir) pb$interrupt() } if (is_R_CMD_build() || is_R_CMD_check()) error <<- format(e) }) TRUE
}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)47:
with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 38: error = function(e) {evaluate::evaluate(...) if (progress && is.function(pb$interrupt))
pb$interrupt()39: if (is_R_CMD_build() || is_R_CMD_check()) evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, error <<- format(e) keep_message = if (is.numeric(options$message)) TRUE else options$message, }), list(rlang_trace_top_env = knit_global())) stop_on_error = if (is.numeric(options$error)) options$error else {
if (options$error && options$include) 0L48: else 2Lxfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), }, output_handler = knit_handlers(options$render, options)) error = function(e) {
if (progress && is.function(pb$interrupt)) 40: pb$interrupt()in_dir(input_dir(), expr) if (is_R_CMD_build() || is_R_CMD_check())
error <<- format(e)41: }), list(rlang_trace_top_env = knit_global())), function(loc) {in_input_dir(evaluate(code, envir = env, new_device = FALSE, setwd(wd) keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, write_utf8(res, output %n% stdout()) keep_message = if (is.numeric(options$message)) TRUE else options$message, paste0("\nQuitting from ", loc, if (!is.null(error)) stop_on_error = if (is.numeric(options$error)) options$error else { paste0("\n", rule(), error, "\n", rule())) if (options$error && options$include) }, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc) 0L
49: else 2Lprocess_file(text, output) }, output_handler = knit_handlers(options$render, options)))
50: 42: eng_r(options)knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
43: 51: block_exec(params)rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),
output_dir = getwd(), ...)44:
call_block(x)52:
vweave_rmarkdown(...)45:
process_group(group)53:
engine$weave(file, quiet = quiet, encoding = enc)46:
withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 54: error = function(e) {doTryCatch(return(expr), name, parentenv, handler) if (progress && is.function(pb$interrupt))
55: pb$interrupt()tryCatchOne(expr, names, parentenv, handlers[[1L]]) if (is_R_CMD_build() || is_R_CMD_check())
56: error <<- format(e)tryCatchList(expr, classes, parentenv, handlers) })
57: 47: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), tryCatch({ error = function(e) { engine$weave(file, quiet = quiet, encoding = enc) if (progress && is.function(pb$interrupt)) pb$interrupt() setwd(startdir) if (is_R_CMD_build() || is_R_CMD_check()) output <- find_vignette_product(name, by = "weave", engine = engine) error <<- format(e) if (!have.makefile && vignette_is_tex(output)) { }), list(rlang_trace_top_env = knit_global())) texi2pdf(file = output, clean = FALSE, quiet = quiet)
output <- find_vignette_product(name, by = "texi2pdf", 48: xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), error = function(e) { engine = engine) if (progress && is.function(pb$interrupt)) } pb$interrupt() outputs <- c(outputs, output) if (is_R_CMD_build() || is_R_CMD_check()) error <<- format(e)}, error = function(e) { thisOK <<- FALSE }), list(rlang_trace_top_env = knit_global())), function(loc) { fails <<- c(fails, file) setwd(wd) message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s", write_utf8(res, output %n% stdout()) paste0("\nQuitting from ", loc, if (!is.null(error)) file, conditionMessage(e))) paste0("\n", rule(), error, "\n", rule()))})}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)
58: 49: tools::buildVignettes(dir = "/Volumes/Builds/packages/big-sur-arm64/results/4.5/rEDM.Rcheck/vign_test/rEDM", process_file(text, output) skip = TRUE, ser_elibs = "/Volumes/Temp/tmp/RtmpAeWUwr/file93fb63a83378.rds")
50: An irrecoverable exception occurred. R is aborting now ...
knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
51: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(), output_dir = getwd(), ...)
52: vweave_rmarkdown(...)
53: engine$weave(file, quiet = quiet, encoding = enc)
54: doTryCatch(return(expr), name, parentenv, handler)
55: tryCatchOne(expr, names, parentenv, handlers[[1L]])
56: tryCatchList(expr, classes, parentenv, handlers)
57: tryCatch({ engine$weave(file, quiet = quiet, encoding = enc) setwd(startdir) output <- find_vignette_product(name, by = "weave", engine = engine) if (!have.makefile && vignette_is_tex(output)) { texi2pdf(file = output, clean = FALSE, quiet = quiet) output <- find_vignette_product(name, by = "texi2pdf", engine = engine) } outputs <- c(outputs, output)}, error = function(e) { thisOK <<- FALSE fails <<- c(fails, file) message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s", file, conditionMessage(e)))})
58: tools::buildVignettes(dir = "/Volumes/Builds/packages/big-sur-arm64/results/4.5/rEDM.Rcheck/vign_test/rEDM", skip = TRUE, ser_elibs = "/Volumes/Temp/tmp/RtmpAeWUwr/file93fb63a83378.rds")
An irrecoverable exception occurred. R is aborting now ...
Quitting from rEDM-tutorial.Rmd:466-469 [smap_thrips]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
<error/rlang_error>
Error in `data.frame()`:
! arguments imply differing number of rows: 15, 0
---
Backtrace:
▆
1. └─rEDM::PredictNonlinear(...)
2. └─base::data.frame(Theta = theta, rho = rho)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Error: processing vignette 'rEDM-tutorial.Rmd' failed with diagnostics:
arguments imply differing number of rows: 15, 0
--- failed re-building ‘rEDM-tutorial.Rmd’
SUMMARY: processing the following file failed:
‘rEDM-tutorial.Rmd’
Error: Vignette re-building failed.
Execution halted
Flavor: r-oldrel-macos-arm64