// appears on the screen (ie, the cursor should be at the start of the line).
//
// If the user presses CTRL-C during the operation, the next invocation of the
-// progress method with throw an std::string object indicating that the
-// operation was cancelled. As such, client code must be exception safe around
-// the progress method.
+// progress method return true indicating that the operation was cancelled.
//
// Because SlowOperationInformers fiddle around with signals, they cannot be
// nested, and interact poorly with threads. The SIGALRM handler is set back to
SlowOperationInformer(const std::string &Name);
~SlowOperationInformer();
- /// progress - Clients should periodically call this method when they are in
- /// an exception-safe state. The Amount variable should indicate how far
+ /// progress - Clients should periodically call this method when they can
+ /// handle cancellation. The Amount variable should indicate how far
/// along the operation is, given in 1/10ths of a percent (in other words,
- /// Amount should range from 0 to 1000).
- void progress(unsigned Amount);
+ /// Amount should range from 0 to 1000). If the user cancels the operation,
+ /// this returns true, false otherwise.
+ bool progress(unsigned Amount);
/// progress - Same as the method above, but this performs the division for
/// you, and helps you avoid overflow if you are dealing with largish
/// numbers.
- void progress(unsigned Current, unsigned Maximum) {
+ bool progress(unsigned Current, unsigned Maximum) {
assert(Maximum != 0 &&
"Shouldn't be doing work if there is nothing to do!");
- progress(Current*uint64_t(1000UL)/Maximum);
+ return progress(Current*uint64_t(1000UL)/Maximum);
}
};
} // end namespace llvm
// mapping.
for (unsigned i = 0, e = TranslationUnits.size(); i != e; ++i) {
getSourceFile(TranslationUnits[i]);
- SOI.progress(i+1, e);
+ if (SOI.progress(i+1, e))
+ throw "While building source files index, operation cancelled.";
}
// Ok, if we got this far, then we indexed the whole program.
// Loop over all of the functions found, building the SourceFunctions mapping.
for (unsigned i = 0, e = Functions.size(); i != e; ++i) {
getFunction(Functions[i]);
- SOI.progress(i+1, e);
+ if (SOI.progress(i+1, e))
+ throw "While functions index, operation cancelled.";
}
// Ok, if we got this far, then we indexed the whole program.
/// an exception-safe state. The Amount variable should indicate how far
/// along the operation is, given in 1/10ths of a percent (in other words,
/// Amount should range from 0 to 1000).
-void SlowOperationInformer::progress(unsigned Amount) {
+bool SlowOperationInformer::progress(unsigned Amount) {
int status = sys::AlarmStatus();
if (status == -1) {
std::cout << "\n";
LastPrintAmount = 0;
- throw "While " + OperationName + ", operation cancelled.";
+ return true;
}
// If we haven't spent enough time in this operation to warrant displaying the
// progress bar, don't do so yet.
if (status == 0)
- return;
+ return false;
// Delete whatever we printed last time.
std::string ToPrint = std::string(LastPrintAmount, '\b');
LastPrintAmount = OS.str().size();
std::cout << ToPrint+OS.str() << std::flush;
+ return false;
}