design reload implemented

Author: pieter3d

src/design_tree_panel.cc

@@ -11,7 +11,23 @@
 namespace sv {
 
 DesignTreePanel::DesignTreePanel() {
-  // Populate an intial list of instances, top modules really.
+  Initialize();
+}
+
+void DesignTreePanel::HandleReloadedDesign() {
+  roots_.clear();
+  data_.Clear();
+  line_idx_ = 0;
+  // TODO: This resets the tree, which causes the full tree to collapse when a design-reload
+  // happens. Instead, the tree should be expanded to match the prior expansion a much as possible
+  // with the new design hierarchy after reload. Right now this is accomplished when source is
+  // loaded via the source-to-design-tree mechanism, but that only works if the source panel is
+  // focused.
+  Initialize();
+}
+
+void DesignTreePanel::Initialize() {
+  // Populate an initial list of instances, top modules really.
   for (const slang::ast::InstanceSymbol *top : Workspace::Get().Design()->topInstances) {
     roots_.push_back(std::make_unique<DesignTreeItem>(top));
   }

src/design_tree_panel.h

@@ -11,13 +11,15 @@ namespace sv {
 class DesignTreePanel : public TreePanel {
  public:
   DesignTreePanel();
+  void Initialize();
   void UIChar(int ch) final;
   std::vector<Tooltip> Tooltips() const final;
   // Get the item that should be shown in the source panel, if any.
   std::optional<const slang::ast::Symbol *> ItemForSource();
   // Opens the tree to the selected item.
   void SetItem(const slang::ast::Symbol *item);
   bool Searchable() const final { return true; }
+  void HandleReloadedDesign() final;
 
  private:
   std::vector<std::unique_ptr<DesignTreeItem>> roots_;

src/main.cc

@@ -10,6 +10,9 @@ int main(int argc, char *argv[]) {
   // Start the UI and the event loop.
   sv::UI ui;
   ui.EventLoop();
+  if (!ui.FinalMessage().empty()) {
+    std::cout << ui.FinalMessage() << "\n";
+  }
 
   return 0;
 }

src/panel.h

@@ -48,6 +48,8 @@ class Panel : public TextReceiver {
   std::string Error() const;
   virtual void PrepareForWaveDataReload() {}
   virtual void HandleReloadedWaves() {}
+  virtual void PrepareForDesignReload() {}
+  virtual void HandleReloadedDesign() {}
 
  protected:
   virtual int NumLines() const = 0;

src/source_panel.cc

@@ -4,6 +4,7 @@
 #include "color.h"
 #include "radix.h"
 #include "slang/ast/ASTVisitor.h"
+#include "slang/ast/Compilation.h"
 #include "slang/ast/Expression.h"
 #include "slang/ast/Symbol.h"
 #include "slang/ast/expressions/CallExpression.h"
@@ -897,4 +898,56 @@ std::vector<Tooltip> SourcePanel::Tooltips() const {
   return tt;
 }
 
+void SourcePanel::PrepareForDesignReload() {
+  stack_idx_ = 0;
+  state_stack_.clear();
+  reload_path_.clear();
+  drivers_or_loads_.clear();
+  src_info_.clear();
+  reload_line_idx_ = line_idx_;
+  if (scope_ != nullptr) reload_path_ = scope_->asSymbol().getHierarchicalPath();
+  scope_ = nullptr;
+}
+
+void SourcePanel::HandleReloadedDesign() {
+  if (reload_path_.empty()) return;
+  size_t limit = reload_path_.size();
+  // This is kinda heavy-handed. It would be better to search level by level, but this works well
+  // enough. Going level by level is complicated with instance indicies, it would require parsing
+  // things like "top.block_a.block_b[4].block_c[2].block_d", the square brackets. But identifiers
+  // could be escaped and contain square brackets that are not real index operations.
+  while (true) {
+    std::string_view path(reload_path_.data(), limit);
+    auto visitor = slang::ast::makeVisitor(
+        [&](auto &visitor, const slang::ast::InstanceSymbol &inst) {
+          if (inst.getHierarchicalPath() == path) {
+            scope_ = &inst.body;
+          } else {
+            visitor.visitDefault(inst);
+          }
+        },
+        [&](auto &visitor, const slang::ast::GenerateBlockSymbol &gen) {
+          if (gen.isUninstantiated) return;
+          if (gen.getHierarchicalPath() == path) {
+            scope_ = &gen;
+          } else {
+            visitor.visitDefault(gen);
+          }
+        });
+    Workspace::Get().Design()->visit(visitor);
+    if (scope_ != nullptr) break;
+    // No design was found, trim the path back to the next hierarchy level and try again.
+    limit = path.find_last_of('.');
+    // If there is no more trimming to be done then give up and leave a null scope.
+    if (limit == std::string_view::npos) break;
+  }
+
+  if (scope_ == nullptr) return;
+
+  SetItem(&scope_->asSymbol());
+  SetLineAndScroll(reload_line_idx_);
+  // This causes the design tree to be properly re-traversed on reload.
+  item_for_design_tree_ = &scope_->asSymbol();
+}
+
 } // namespace sv

src/source_panel.h

@@ -30,6 +30,8 @@ class SourcePanel : public Panel {
   // Need to look for stuff under the cursor when changing lines.
   void SetLineAndScroll(int l) final;
   void Resized() final;
+  void PrepareForDesignReload() final;
+  void HandleReloadedDesign() final;
 
  private:
   void SaveState();
@@ -99,6 +101,10 @@ class SourcePanel : public Panel {
   };
   std::deque<State> state_stack_;
   int stack_idx_ = 0;
+  // When reloading the design, save the current scope as a textual path, so it can be re-found
+  // after the reload has finished.
+  std::string reload_path_;
+  int reload_line_idx_ = 0;
 };
 
 } // namespace sv

src/ui.cc

@@ -63,14 +63,14 @@ void UI::UpdateTooltips() {
   tooltips_.clear();
   // Add the tooltips that are always present.
   tooltips_.push_back({"C-q", "quit"});
+  tooltips_.push_back({.hotkeys = "C-r", .description = "Reload"});
   if (layout_.has_waves && (panels_[focused_panel_idx_] == waves_panel_.get() ||
                             panels_[focused_panel_idx_] == wave_tree_panel_.get() ||
                             panels_[focused_panel_idx_] == wave_signals_panel_.get())) {
     tooltips_.push_back(
         {.hotkeys = "C-p",
          .description =
              std::string(layout_.show_wave_picker ? "SHOW/hide" : "show/HIDE") + " picker"});
-    tooltips_.push_back({.hotkeys = "C-r", .description = "Reload waves"});
   }
   if (panels_[focused_panel_idx_]->Searchable()) {
     tooltips_.push_back({"/nN", "search"});
@@ -148,24 +148,36 @@ UI::UI() : search_box_("/") {
   Draw();
 }
 
-UI::~UI() {
-  // Cleanup ncurses
-  endwin();
-}
-
-void UI::ReloadWaves() {
+bool UI::Reload() {
   for (Panel *p : panels_) {
-    p->PrepareForWaveDataReload();
+    if (layout_.has_design) p->PrepareForDesignReload();
+    if (layout_.has_waves) p->PrepareForWaveDataReload();
+  }
+  if (layout_.has_waves) Workspace::Get().Waves()->Reload();
+  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();
+    if (!success) {
+      error_message_ = "Errors reading design.";
+    }
+    // Something went badly wrong if there is no design at all now.
+    if (Workspace::Get().Design() == nullptr) {
+      final_message_ = "Fatal error re-parsing design. Check the design for syntax errors.";
+      return false;
+    }
   }
-  Workspace::Get().Waves()->Reload();
-  Workspace::Get().TryMatchDesignWithWaves();
+  if (layout_.has_design && layout_.has_waves) Workspace::Get().TryMatchDesignWithWaves();
   for (Panel *p : panels_) {
-    p->HandleReloadedWaves();
+    if (layout_.has_design) p->HandleReloadedDesign();
+    if (layout_.has_waves) p->HandleReloadedWaves();
   }
-  //  Force a refresh on the signals in the refreshed wave data tree.
-  if (const auto scope = wave_tree_panel_->ScopeForSignals()) {
-    wave_signals_panel_->SetScope(*scope);
+  if (layout_.has_waves) {
+    //  Force a refresh on the signals in the refreshed wave data tree.
+    if (const auto scope = wave_tree_panel_->ScopeForSignals()) {
+      wave_signals_panel_->SetScope(*scope);
+    }
   }
+  return true;
 }
 
 void UI::EventLoop() {
@@ -282,11 +294,7 @@ void UI::EventLoop() {
           }
           break;
         case 0x12: // ctrl-R
-          if (layout_.has_waves && (panels_[focused_panel_idx_] == waves_panel_.get() ||
-                                    panels_[focused_panel_idx_] == wave_tree_panel_.get() ||
-                                    panels_[focused_panel_idx_] == wave_signals_panel_.get())) {
-            ReloadWaves();
-          }
+          quit = !Reload();
           break;
         case 0x9:     // tab
         case 0x161: { // shift-tab
@@ -358,6 +366,8 @@ void UI::EventLoop() {
     if (quit) break;
     Draw();
   }
+  // Cleanup ncurses
+  endwin();
 }
 
 void UI::DrawHelp(int panel_idx) const {
@@ -550,7 +560,7 @@ void UI::Draw() const {
     move(row, col);
     curs_set(1);
   } else {
-    if (focused_panel->CursorLocation()) {
+    if (focused_panel->CursorLocation() && error_message_.empty()) {
       const auto [row, col] = *focused_panel->CursorLocation();
       int x, y;
       getbegyx(focused_panel->Window(), y, x);

src/ui.h

@@ -10,18 +10,17 @@
 
 namespace sv {
 
-// This is the main UI. It owns all UI sub elements, all of which decend from
-// sv::Panel. It responds to terminal resizing and attempts to keep the layout
-// properly balanced.
+// This is the main UI. It owns all UI sub elements, all of which decend from sv::Panel. It responds
+// to terminal resizing and attempts to keep the layout properly balanced.
 class UI {
  public:
   // Constructor enters NCurses mode.
   UI();
-  ~UI();
 
-  // This is the main event loop. This function doesn't return until the user
-  // has pressed Ctrl-Q to exit the UI.
+  // This is the main event loop. This function doesn't return until the user has pressed Ctrl-Q to
+  // exit the UI. A closing message is returned, in case of some kind of error.
   void EventLoop();
+  const std::string &FinalMessage() const { return final_message_; }
 
  private:
   void CalcLayout(bool update_frac = false);
@@ -30,7 +29,8 @@ class UI {
   void UpdateTooltips();
   void Draw() const;
   void DrawHelp(int panel_idx) const;
-  void ReloadWaves();
+  // False if some fatal error requires abort.
+  bool Reload();
 
   std::unique_ptr<DesignTreePanel> design_tree_panel_;
   std::unique_ptr<SourcePanel> source_panel_;
@@ -65,6 +65,9 @@ class UI {
   // Search state.
   bool searching_ = false;
   TextInput search_box_;
+
+  // Terminating message for the user after the UI exits.
+  std::string final_message_;
 };
 
 } // namespace sv

src/workspace.cc

@@ -25,10 +25,25 @@ const slang::SourceManager *Workspace::SourceManager() const {
   return slang_compilation_->getSourceManager();
 }
 
+bool Workspace::ReParse() {
+  slang_compilation_ = nullptr;
+  design_root_ = nullptr;
+  const bool parse_ok = ParseDesign(/*initial*/ false);
+  const bool success = slang_driver_->diagEngine.getNumErrors() == 0;
+  return parse_ok && success;
+}
+
 bool Workspace::ParseDesign(int argc, char *argv[]) {
+  command_line_.argc = argc;
+  command_line_.argv = argv;
+  return ParseDesign(/*initial*/ true);
+}
+
+bool Workspace::ParseDesign(bool initial) {
   // Avoid invoking the slang compiler if only wave-reading options are specified.
   const bool try_read_design =
-      !(argc == 3 && (std::strcmp(argv[1], "-w") == 0 || std::strcmp(argv[1], "--waves") == 0));
+      !(command_line_.argc == 3 && (std::strcmp(command_line_.argv[1], "-w") == 0 ||
+                                    std::strcmp(command_line_.argv[1], "--waves") == 0));
   slang_driver_ = std::make_unique<slang::driver::Driver>();
   // Additional options from simview:
   std::optional<bool> show_help;
@@ -41,36 +56,36 @@ bool Workspace::ParseDesign(int argc, char *argv[]) {
                              "Retain 0-time transitions in the wave data. Normally pruned.");
 
   slang_driver_->addStandardArgs();
-  if (!slang_driver_->parseCommandLine(argc, argv)) return false;
-  if (show_help == true) {
+  if (!slang_driver_->parseCommandLine(command_line_.argc, command_line_.argv)) return false;
+  if (show_help == true && initial) {
     std::cout << slang_driver_->cmdLine.getHelpText(
                      "simview: a terminal-based verilog design browser and waves viewer.")
               << "\n";
     return 0;
   }
   bool design_ok = false;
   if (try_read_design && slang_driver_->processOptions()) {
-    std::cout << "Parsing files...\n";
+    if (initial) std::cout << "Parsing files...\n";
     if (!slang_driver_->parseAllSources()) return false;
-    std::cout << "Elaborating...\n";
+    if (initial) std::cout << "Elaborating...\n";
     slang_compilation_ = slang_driver_->createCompilation();
-    // TODO: This freezes the design and somehow makes traversal throw exceptions.
-    // std::cout << "Analyzing...\n";
-    // slang_analysis_ = slang_driver_->runAnalysis(*slang_compilation_);
     // This print all tops, and collects diagnostics.
-    slang_driver_->reportCompilation(*slang_compilation_, /* quiet */ false);
-    const bool success = slang_driver_->reportDiagnostics(/* quiet */ false);
-    // Give the user a chance to see any errors before proceeding.
-    if (!success) {
-      std::cout << "Errors encountered, press Enter to continue anyway...\n";
-      std::cin.get();
+    slang_driver_->reportCompilation(*slang_compilation_, /* quiet */ !initial);
+    if (initial) {
+      const bool success = slang_driver_->reportDiagnostics(/* quiet */ !initial);
+      // Give the user a chance to see any errors before proceeding.
+      if (!success) {
+        std::cout << "Errors encountered, press Enter to continue anyway...\n";
+        std::cin.get();
+      }
     }
     design_root_ = &slang_compilation_->getRoot();
     design_ok = true;
   }
 
   bool waves_ok = false;
-  if (waves_file) {
+  // Waves are only read on initial load. There's a separate mechanism that triggers wave reload.
+  if (initial && waves_file) {
     try {
       wave_data_ = WaveData::ReadWaveFile(*waves_file, *keep_glitches);
       waves_ok = true;

src/workspace.h

@@ -34,6 +34,7 @@ class Workspace {
 
   // Parse the design and/or waves using command line arguments. Return true on success.
   bool ParseDesign(int argc, char *argv[]);
+  bool ReParse();
 
   const slang::ast::RootSymbol *Design() const { return design_root_; }
 
@@ -67,6 +68,8 @@ class Workspace {
   Workspace();
   ~Workspace();
 
+  bool ParseDesign(bool initial);
+
   std::unique_ptr<slang::driver::Driver> slang_driver_;
   std::unique_ptr<slang::ast::Compilation> slang_compilation_;
   std::unique_ptr<slang::analysis::AnalysisManager> slang_analysis_;
@@ -76,6 +79,10 @@ class Workspace {
   const WaveData::SignalScope *matched_signal_scope_ = nullptr;
   // Wave time is used in source too, so it's held here.
   uint64_t wave_cursor_time_ = 0;
+  struct {
+    int argc;
+    char **argv;
+  } command_line_;
 };
 
 } // namespace sv