CompileLoadModel.cpp

Go to the documentation of this file.

#include <gtkmm/filechooserdialog.h>
#include <sys/wait.h>
#include <unistd.h>
#include <iostream>
#include <regex>
#include <string>
#include "../views/MainWindowView.h"
#include "KoMo2Model.h"

CompileLoadModel::CompileLoadModel(CompileLoadView* const view,
                                   KoMo2Model* const parent)
    : Model(parent), view(view) {
  // Set the onClick events for the browse and compile and load buttons to
  // be wired to CompileLoadModel member functions.
  setButtonListener(view->getBrowseButton(), this,
                    &CompileLoadModel::onBrowseClick);

  setButtonListener(view->getCompileAndLoadButton(), this,
                    &CompileLoadModel::onCompileLoadClick);

  // Set's the views model & updates the compile load models inner state.
  view->setModel(this);
  setInnerState(CompileLoadInnerState::NO_FILE);
}

void CompileLoadModel::onCompileLoadClick() const {
  // If the length is zero, invalid path
  if (not getAbsolutePathToSelectedFile().length()) {
    // should not be reachable
    return;
  }

  // The code within this if block is executed by the child process.
  if (not fork()) {
    // Compile the .s program to .kmd
    Jimulator::compileJimulator(
        (getParent()->getAbsolutePathToProjectRoot() + "/bin/aasm").c_str(),
        getAbsolutePathToSelectedFile().c_str(),
        makeKmdPath(getAbsolutePathToSelectedFile()).c_str());
    _exit(0);
  }

  // parent process
  else {
    int status = 0;
    wait(&status);  // Wait for the child to return

    // If child process failed
    if (status) {
      return;
    }

    // Perform the load
    Jimulator::resetJimulator();

    // If load function failed
    if (not Jimulator::loadJimulator(
            makeKmdPath(getAbsolutePathToSelectedFile()).c_str())) {
      std::cout << "Error loading file into KoMo2." << std::endl;
      return;
    }

    getParent()->changeJimulatorState(JimulatorState::LOADED);
  }
}

void CompileLoadModel::onBrowseClick() {
  // Creates a new file browser dialogue box
  Gtk::FileChooserDialog dialog("File explorer", Gtk::FILE_CHOOSER_ACTION_OPEN);

  // Gets the parent of the dialogue box
  dialog.set_transient_for(*getParent()->getMainWindow());

  // Add response buttons the the dialog:
  dialog.add_button("_Cancel", Gtk::RESPONSE_CANCEL);
  dialog.add_button("_Open", Gtk::RESPONSE_OK);

  // Creates a filter for what type of files can be selected
  auto assemblyFilter = Gtk::FileFilter::create();
  assemblyFilter->set_name("ARM assembly files");
  assemblyFilter->add_pattern("*.s");
  dialog.add_filter(assemblyFilter);

  // Show the dialog and wait for a user response, then handle the result
  handleResultFromFileBrowser(dialog.run(), &dialog);
}

void CompileLoadModel::handleResultFromFileBrowser(
    const int result,
    const Gtk::FileChooserDialog* const dialog) {
  switch (result) {
    // A file was selected - update inner state and overall state
    case (Gtk::RESPONSE_OK): {
      setAbsolutePathToSelectedFile(dialog->get_filename());
      setInnerState(CompileLoadInnerState::FILE_SELECTED);
      getParent()->changeJimulatorState(JimulatorState::UNLOADED);
      return;
    }
    // Dialog was cancelled - update inner state but not overall state
    case (Gtk::RESPONSE_CANCEL): {
      setAbsolutePathToSelectedFile("");
      setInnerState(CompileLoadInnerState::NO_FILE);
      return;
    }
    default: {
      // Some unexpected behaviour - update inner state but not overall state
      setAbsolutePathToSelectedFile("");
      setInnerState(CompileLoadInnerState::NO_FILE);
      return;
    }
  }
}

const std::string CompileLoadModel::makeKmdPath(
    const std::string absolutePath) const {
  return absolutePath.substr(0, absolutePath.size() - 1).append("kmd");
}

void CompileLoadModel::changeJimulatorState(const JimulatorState newState) {
  // Sets the default button state for compileLoadButton
  if (getInnerState() == CompileLoadInnerState::NO_FILE) {
    setButtonState(view->getCompileAndLoadButton(), false);
  } else {
    setButtonState(view->getCompileAndLoadButton(), true);
  }

  // Sets the state of the browseButton
  switch (newState) {
    // some unloaded state
    case JimulatorState::UNLOADED:
      setButtonState(view->getBrowseButton(), true);
      break;

    // loaded, not yet run state
    case JimulatorState::LOADED:
      setButtonState(view->getBrowseButton(), true);
      setButtonState(view->getCompileAndLoadButton(), false);
      break;

    // Currently running
    case JimulatorState::RUNNING:
      setButtonState(view->getBrowseButton(), false);
      setButtonState(view->getCompileAndLoadButton(), false);
      break;

    // Has been running; is paused
    case JimulatorState::PAUSED:
      setButtonState(view->getBrowseButton(), true);
      break;
    // Error state
    default:
      // TODO: Handle some error state gracefully
      break;
  }
}

const bool CompileLoadModel::handleKeyPress(const GdkEventKey* const e) {
  // If ctrl is not pressed, return false
  if ((e->state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK | GDK_MOD1_MASK)) !=
      GDK_CONTROL_MASK) {
    return false;
  }

  switch (e->keyval) {
    // Ctrl + (lower- & upper-case l)
    case GDK_KEY_L:
    case GDK_KEY_l:
      if (getJimulatorState() != JimulatorState::RUNNING) {
        onBrowseClick();
      }
      return true;
    // Ctrl + (lower- & upper-case r)
    case GDK_KEY_R:
    case GDK_KEY_r:
      if (getJimulatorState() != JimulatorState::RUNNING &&
          getInnerState() != CompileLoadInnerState::NO_FILE) {
        onCompileLoadClick();
      }
      return true;
    default:
      return false;
  }

  return false;
}

// ! Getters and setters!

void CompileLoadModel::setInnerState(const CompileLoadInnerState val) {
  // This regex matches any length of characters up to a `/` character. The
  // regex_replace replaces them with "". So if we have `/user/demo/someFile.s`
  // it will resolve to simply become `someFile.s`
  std::string filename =
      regex_replace(getAbsolutePathToSelectedFile(), std::regex("(.*\\/)"), "");

  // Sets the label text to the filename
  view->setSelectedFileLabelText("File: " + filename);

  innerState = val;

  switch (val) {
    case CompileLoadInnerState::FILE_SELECTED:
      setButtonState(view->getCompileAndLoadButton(), true);
      getParent()->getMainWindow()->set_title(" KoMo2 - " + filename);
      break;
    case CompileLoadInnerState::NO_FILE:
      setButtonState(view->getCompileAndLoadButton(), false);
      getParent()->getMainWindow()->set_title(" KoMo2");
      break;
    default:
      // Error state
      break;
  }
}
void CompileLoadModel::setAbsolutePathToSelectedFile(const std::string val) {
  absolutePathToSelectedFile = val;
}
const std::string CompileLoadModel::getAbsolutePathToSelectedFile() const {
  return absolutePathToSelectedFile;
}
const CompileLoadInnerState CompileLoadModel::getInnerState() const {
  return innerState;
}