Removed all exceptions, using absl:Status instead now

Author: pieter3d

src/CMakeLists.txt

@@ -51,6 +51,8 @@ target_link_libraries(simview PRIVATE
   absl::str_format
   absl::time
   absl::flat_hash_map
+  absl::status
+  absl::statusor
   fst
   slang::slang
   ${NCURSES_LIBRARY_NAME}

src/fst_wave_data.cc

@@ -1,7 +1,7 @@
 #include "fst_wave_data.h"
+#include "absl/status/status.h"
 #include "external/fst/fstapi.h"
 #include <stack>
-#include <stdexcept>
 
 namespace sv {
 namespace {
@@ -24,15 +24,19 @@ std::string ParseSignalLsb(const std::string &s, int *lsb) {
 
 } // namespace
 
-FstWaveData::FstWaveData(const std::string &file_name, bool keep_glitches)
-    : WaveData(file_name, keep_glitches) {
-  reader_ = fstReaderOpen(file_name.c_str());
-  if (reader_ == nullptr) {
-    throw std::runtime_error("Unable to read wave file.");
-  }
-  ReadScopes();
+absl::StatusOr<std::unique_ptr<FstWaveData>> FstWaveData::Create(const std::string &file_name,
+                                                                 bool keep_glitches) {
+  void *reader = fstReaderOpen(file_name.c_str());
+  if (reader == nullptr) return absl::InternalError("Error opening wave file.");
+  std::unique_ptr<FstWaveData> waves(new FstWaveData(file_name, keep_glitches));
+  waves->reader_ = reader;
+  waves->ReadScopes();
+  return waves;
 }
 
+FstWaveData::FstWaveData(const std::string &file_name, bool keep_glitches)
+    : WaveData(file_name, keep_glitches) {}
+
 FstWaveData::~FstWaveData() { fstReaderClose(reader_); }
 
 int FstWaveData::Log10TimeUnits() const { return fstReaderGetTimescale(reader_); }
@@ -180,16 +184,14 @@ void FstWaveData::LoadSignalSamples(const std::vector<const Signal *> &signals,
   }
 }
 
-void FstWaveData::Reload() {
-  // First, re-create the reader.
+absl::Status FstWaveData::Reload() {
   fstReaderClose(reader_);
-  reader_ = fstReaderOpen(file_name_.c_str());
-  if (reader_ == nullptr) {
-    throw std::runtime_error("Unable to read wave file.");
-  }
   waves_.clear();
   roots_.clear();
+  reader_ = fstReaderOpen(file_name_.c_str());
+  if (reader_ == nullptr) return absl::InternalError("Unable to re-read wave file.");
   ReadScopes();
+  return absl::OkStatus();
 }
 
 } // namespace sv

src/fst_wave_data.h

@@ -7,15 +7,17 @@ namespace sv {
 // FST implementation of WaveData, based on the FST library from GTKWave.
 class FstWaveData : public WaveData {
  public:
-  FstWaveData(const std::string &file_name, bool keep_glitches);
+  static absl::StatusOr<std::unique_ptr<FstWaveData>> Create(const std::string &file_name,
+                                                             bool keep_glitches);
   ~FstWaveData() override;
   int Log10TimeUnits() const final;
   std::pair<uint64_t, uint64_t> TimeRange() const final;
   void LoadSignalSamples(const std::vector<const Signal *> &signals, uint64_t start_time,
                          uint64_t end_time) const final;
-  void Reload() final;
+  absl::Status Reload() final;
 
  private:
+  FstWaveData(const std::string &file_name, bool keep_glitches);
   void ReadScopes();
   // The FST library is written in C and uses a lot of untyped handles.
   void *reader_ = nullptr;

src/ui.cc

@@ -154,7 +154,13 @@ bool UI::Reload() {
     if (layout_.has_design) p->PrepareForDesignReload();
     if (layout_.has_waves) p->PrepareForWaveDataReload();
   }
-  if (layout_.has_waves) Workspace::Get().Waves()->Reload();
+  if (layout_.has_waves) {
+    const absl::Status status = Workspace::Get().Waves()->Reload();
+    if (!status.ok()) {
+      final_message_ = "Error re-reading waves. File may have been deleted or corrupted.";
+      return false;
+    }
+  }
   if (layout_.has_design) {
     // TODO: This can potentially take a long time. Find some way to show a busy message.
     const bool success = Workspace::Get().ReParse();

src/vcd_tokenizer.cc

@@ -1,26 +1,24 @@
 #include "vcd_tokenizer.h"
+#include "absl/status/status.h"
 #include <filesystem>
 #include <fstream>
 #include <memory>
 
 namespace sv {
 namespace {
-inline bool is_whitespace(char ch) {
-  return ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r';
-}
+inline bool is_whitespace(char ch) { return ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r'; }
 } // namespace
 
-VcdTokenizer::VcdTokenizer(const std::string &file_name) {
-  in_ = std::make_unique<std::ifstream>(file_name);
-  if (!in_->is_open()) {
-    throw std::runtime_error("Unable to read VCD file.");
-  }
-  file_size_ = std::filesystem::file_size(file_name);
+absl::StatusOr<std::unique_ptr<VcdTokenizer>> VcdTokenizer::Create(const std::string &file_name) {
+  auto in = std::make_unique<std::ifstream>(file_name);
+  if (!in->is_open()) return absl::InternalError("Unable to read VCD file.");
+  std::unique_ptr<VcdTokenizer> tk(new VcdTokenizer());
+  tk->in_ = std::move(in);
+  tk->file_size_ = std::filesystem::file_size(file_name);
+  return tk;
 }
 
-int VcdTokenizer::PosPercentage() const {
-  return 100 * chars_read_ / file_size_;
-}
+int VcdTokenizer::PosPercentage() const { return 100 * chars_read_ / file_size_; }
 
 bool VcdTokenizer::Eof() const { return in_->eof(); }
 

src/vcd_tokenizer.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "absl/status/statusor.h"
 #include <fstream>
 #include <memory>
 #include <string>
@@ -9,7 +10,7 @@ namespace sv {
 // Reads token from a VCD file.
 class VcdTokenizer {
  public:
-  explicit VcdTokenizer(const std::string &file_name);
+  static absl::StatusOr<std::unique_ptr<VcdTokenizer>> Create(const std::string &file_name);
   bool Eof() const;
   std::streampos Position() const;
   void SetPosition(const std::streampos &pos);
@@ -20,6 +21,7 @@ class VcdTokenizer {
   uint64_t file_size_;
   uint64_t chars_read_ = 0;
   std::unique_ptr<std::ifstream> in_;
+  VcdTokenizer() {}
 };
 
 } // namespace sv