Brad Arant
9f3349b671
expansion terminated the whole process instead of reporting cleanly Found while verifying documentation for #[name] vs $[%name] (writing the new tag-hierarchy section surfaced that my own published example was factually wrong about which sigil reads a keyword attribute - #[name] actually reads local->variables, a separate store; $[%name] is the real keyword sigil, confirmed against Tag::getVariable directly). Referencing an uninitialized #[name] from inside a custom tag's own template crashed the process outright (SIGABRT) rather than reporting a normal error - confirmed via a real gdb backtrace, not guessed: 1. Tag::getVariable's "#[" branch and Tag::assignVariable's "local"/ "parent" scope branches all dereferenced `local` unconditionally. `local` is genuinely NULL at the true top level (jet-2.0.cpp's own `new jet::__jet(data, out, global, NULL, NULL)`) and stays NULL through any tag that doesn't establish its own local scope (most don't - <if>/<while>/<until> are the exception, passing `this` as local via their splitTagName constructor path). Added NULL checks with clear messages instead of an unconditional dereference. 2. The real root cause of the actual crash observed, though: jet-2.0.cpp's own top-level catch(coreutils::Exception) handler unconditionally calls data.setCursor(global.errorCursor) to show precise source-line context - but global.errorCursor is updated by every Tag's own construction, so it can (and, for an error originating inside a custom tag's own expanded template - container3 in __dotag.cpp - always does) point into a completely different ZString buffer than `data` (the top-level script). ZString::setCursor() correctly rejects a cursor outside its own buffer by throwing - but that throw happens while the ORIGINAL exception is still being handled inside this same catch block, and a second exception escaping an active catch block calls std::terminate() immediately, regardless of any enclosing try/catch. Confirmed via gdb: the abort's own stack showed __cxa_throw called from ZString::setCursor, called from the catch block itself. Fixed by wrapping the precise-location diagnostics in their own try/catch, falling back to just the error text (already printed first) plus a note that precise context isn't available, rather than crashing the whole process. The error text is the useful part either way - the line-context is a bonus only available when the cursor genuinely belongs to the top-level buffer. Verified via a full regression pass (9 real jet-2.0 runs covering custom tag scoping at 1/2/3 nesting levels, the dump tag tree, <try>/<catch>, <if>/<else>, and the corrected $[%name] keyword sigil) - all still work, plus the specific crash reproduction now reports a clean error instead of aborting.
60 lines
2.4 KiB
C++
60 lines
2.4 KiB
C++
#include <iostream>
|
|
#include <sstream>
|
|
#include "File.h"
|
|
#include "Global.h"
|
|
#include "Exception.h"
|
|
#include "__jet.h"
|
|
|
|
int main(int argc, char **argv, char **envp) {
|
|
|
|
coreutils::File script(argv[1]);
|
|
script.read();
|
|
coreutils::ZString data = script.asZString();
|
|
data.goeol();
|
|
|
|
jet::Global global(envp);
|
|
|
|
try {
|
|
coreutils::MString out;
|
|
global.errorCursor = data.getCursor();
|
|
jet::__jet *jet = new jet::__jet(data, out, global, NULL, NULL);
|
|
delete jet;
|
|
global.outputHeaders();
|
|
std::cout << out;
|
|
}
|
|
catch(coreutils::Exception e) {
|
|
std::cout << "-----------------------------" << std::endl;
|
|
std::cout << "Error text: " << e.text << std::endl;
|
|
// global.errorCursor is updated by every Tag's own construction, so
|
|
// it can point into a completely different buffer than `data` (the
|
|
// top-level script) - most commonly, a custom tag's own expanded
|
|
// template body (container3 in __dotag.cpp) when the error actually
|
|
// happened while that was being processed, not the top-level script
|
|
// directly. ZString::setCursor() correctly rejects a cursor that
|
|
// isn't within its own buffer, but that rejection is itself a throw
|
|
// - uncaught here, a SECOND exception escaping while this catch
|
|
// block is still handling the first one calls std::terminate()
|
|
// immediately, crashing the whole process instead of reporting a
|
|
// normal error. Confirmed via a real crash + gdb backtrace while
|
|
// testing an error thrown from inside a custom tag's own body.
|
|
// Degrade gracefully instead: the error text above is already the
|
|
// important part; the precise source-line context is a bonus only
|
|
// available when the cursor genuinely belongs to this buffer.
|
|
try {
|
|
data.setCursor(global.errorCursor);
|
|
data.moveBackToLineStart();
|
|
std::cout << "Error in jet script '" << argv[1] << "' at line " << data.getLineNumberAtCursor() << std::endl;
|
|
std::cout << "-----------------------------" << std::endl;
|
|
std::cout << data.parsed() << std::endl;
|
|
std::cout << "******** Error caught: " << e.text << std::endl;
|
|
std::cout << data.unparsed() << std::endl;
|
|
} catch(coreutils::Exception) {
|
|
std::cout << "(error originated inside a custom tag's own expansion - "
|
|
<< "no precise source-line context available for it)" << std::endl;
|
|
std::cout << "-----------------------------" << std::endl;
|
|
}
|
|
global.dump();
|
|
}
|
|
|
|
}
|