Exemplo n.º 1
0
  private void setPrologInterface(PrologInterface newPif, boolean updateActivePif) {
    if (currentPif == newPif) {
      return;
    }
    if (currentPif != null) {
      viewerStates.put(currentPif, viewer.saveState());
    }
    currentPif = newPif;
    if (currentPif != null) {
      addHooks(currentPif);
      try {
        connect(currentPif);
      } catch (PrologInterfaceException e) {
        Debug.report(e);
      }
      reconfigureViewer(currentPif);
      getDefaultPrologConsoleService().fireActivePrologInterfaceChanged(this);
      if (updateActivePif) {
        PrologRuntimeUIPlugin.getDefault()
            .getPrologInterfaceService()
            .setActivePrologInterface(currentPif);
      }

    } else {
      Debug.debug("no pif (yet).");
    }
    if (automatedSelector != null) {
      automatedSelector.update();
    }
    writeCurrentProcessPortToFile();
  }
Exemplo n.º 2
0
  private void startServer(PrologInterface pif, PrologSession session) {
    try {
      String queryString =
          bT(
              PDTConsolePredicates.PDT_START_CONSOLE_SERVER,
              "Port",
              Util.quoteAtom(
                  PrologRuntimePlugin.getDefault().getPrologInterfaceRegistry().getKey(pif)));
      Debug.info("starting console server using: " + queryString);

      Map<String, ?> result = session.queryOnce(queryString);
      if (result == null) {
        Debug.info("starting server failed, which may mean that it is actualy running already.");
        result = session.queryOnce(bT(PDTConsolePredicates.PDT_CURRENT_CONSOLE_SERVER, "Port"));
        if (result == null) {
          throw new RuntimeException("No Server running.");
        }
      }

      int port = Integer.parseInt((String) result.get("Port"));
      Debug.debug("A server thread seems to be listinging at port " + port);
    } catch (Throwable e) {
      Debug.report(e);
      throw new RuntimeException(e);
    }
  }
Exemplo n.º 3
0
    @Override
    public void run() {

      boolean answer =
          MessageDialog.openQuestion(
              PrologConsoleView.this.getViewSite().getShell(),
              "Kill process",
              "Are you sure you want to kill the process? This will remove all breakpoints and will delete the list of consulted files");

      if (answer) {
        try {

          Job j =
              new UIJob("Stopping the PrologInterface") {

                @Override
                public IStatus runInUIThread(IProgressMonitor monitor) {
                  try {
                    monitor.beginTask("initializing...", IProgressMonitor.UNKNOWN);

                    PrologInterfaceRegistry registry =
                        PrologRuntimePlugin.getDefault().getPrologInterfaceRegistry();

                    PrologInterface oldPif = getPrologInterface();
                    if (oldPif != null) {
                      String currentKey = registry.getKey(oldPif);

                      oldPif.clearConsultedFiles();
                      oldPif.stop();

                      if ("true".equals(oldPif.getAttribute(KILLABLE))) {
                        Set<Subscription> subscriptionsForPif =
                            registry.getSubscriptionsForPif(currentKey);
                        for (Subscription s : subscriptionsForPif) {
                          registry.removeSubscription(s);
                        }
                        registry.removePrologInterface(currentKey);
                        getDefaultPrologConsoleService()
                            .fireConsoleVisibilityChanged(PrologConsoleView.this);
                        PrologRuntimeUIPlugin.getDefault()
                            .getPrologInterfaceService()
                            .setActivePrologInterface(null);
                      }
                    }
                  } catch (Throwable e) {
                    Debug.report(e);
                    return Status.CANCEL_STATUS;
                  } finally {
                    monitor.done();
                  }
                  return Status.OK_STATUS;
                }
              };
          j.schedule();
        } catch (Throwable t) {
          Debug.report(t);
        }
      }
    }
Exemplo n.º 4
0
 @Override
 public void run() {
   try {
     getPrologInterface().queryOnce(getQuery());
   } catch (PrologInterfaceException e) {
     Debug.report(e);
   }
 }
Exemplo n.º 5
0
 @Override
 public void ensureConnectionForCurrentPrologInterface() {
   try {
     connect(currentPif);
   } catch (PrologInterfaceException e) {
     Debug.report(e);
   }
 }
Exemplo n.º 6
0
 /*
  * (non-Javadoc)
  *
  * @see org.cs3.pl.prolog.LifeCycleHook#afterInit()
  */
 @Override
 public void afterInit(PrologInterface pif) {
   try {
     connect(pif);
   } catch (PrologInterfaceException e) {
     Debug.report(e);
   }
 }
 public DefaultResourceFileLocator(File root) {
   String rootPath = root.getAbsolutePath();
   try {
     this.root = rootPath.endsWith(File.separator) ? rootPath : rootPath + File.separator;
   } catch (Exception e) {
     Debug.report(e);
     throw new RuntimeException(e.getMessage());
   }
 }
Exemplo n.º 8
0
 @Override
 public void setFocus() {
   if (viewer == null) {
     Debug.warning("PrologConsoleView.setFocus(): View not instantiated yet.");
     return;
   }
   viewer.getControl().setFocus();
   getDefaultPrologConsoleService().fireConsoleRecievedFocus(this);
 }
Exemplo n.º 9
0
  private void loadHistory(ConsoleHistory history) {

    try {
      FileInputStream in = new FileInputStream(getHistoryFile());
      history.loadHistory(in);
      in.close();
    } catch (IOException e) {
      Debug.report(e);
    }
  }
Exemplo n.º 10
0
  @Override
  public void createPartControl(Composite parent) {

    try {
      createPartControl_impl(parent);
    } catch (Throwable t) {
      Debug.report(t);
      throw new RuntimeException(t.getLocalizedMessage(), t);
    }
  }
Exemplo n.º 11
0
 private void saveHistory(ConsoleHistory history) {
   if (history == null) {
     return;
   }
   try {
     FileOutputStream out = new FileOutputStream(getHistoryFile());
     history.saveHistory(out);
     out.close();
   } catch (IOException e) {
     Debug.report(e);
   }
 }
Exemplo n.º 12
0
    @Override
    public void run() {
      try {

        UIJob j =
            new UIJob(getToolTipText()) {

              @Override
              public IStatus runInUIThread(IProgressMonitor monitor) {
                try {
                  PrologConsole c = getConsole();
                  int caretOffset = c.getCaretOffset();
                  int offsetInLineBuffer = caretOffset - c.getStartOfInput();
                  ConsoleModel model = c.getModel();
                  String lineBuffer = model.getLineBuffer();
                  if (offsetInLineBuffer < 0) {
                    offsetInLineBuffer = lineBuffer.length();
                    caretOffset = c.getStartOfInput() + lineBuffer.length();
                  }

                  String textToInsert = getTextToInsert();
                  if (textToInsert == null) {
                    return Status.OK_STATUS;
                  }
                  lineBuffer =
                      lineBuffer.substring(0, offsetInLineBuffer)
                          + textToInsert
                          + lineBuffer.substring(offsetInLineBuffer);

                  model.setLineBuffer(lineBuffer);
                  c.setCaretOffset(caretOffset + textToInsert.length());

                } catch (Throwable e) {
                  Debug.report(e);
                  return Status.CANCEL_STATUS;
                } finally {
                  monitor.done();
                }
                return Status.OK_STATUS;
              }

              private PrologConsole getConsole() {
                return PrologConsoleView.this;
              }
            };

        j.schedule();
      } catch (Throwable t) {
        Debug.report(t);
      }
    }
Exemplo n.º 13
0
    @Override
    public void run() {
      try {

        Job j =
            new UIJob("Generating load file") {

              @Override
              public IStatus runInUIThread(IProgressMonitor monitor) {
                try {
                  monitor.beginTask("initializing...", IProgressMonitor.UNKNOWN);

                  if (getPrologInterface() != null) {
                    List<String> consultedFiles = getPrologInterface().getConsultedFiles();

                    // only create load file if there are consulted files
                    if (consultedFiles != null && consultedFiles.size() > 0) {
                      WizardDialog dialog =
                          new WizardDialog(
                              getViewSite().getShell(), new GenerateLoadFileWizard(consultedFiles));
                      dialog.open();
                    } else {
                      MessageDialog.openWarning(
                          PrologConsoleView.this.getViewSite().getShell(),
                          "Generate Load File",
                          "No need for a load file, since no files are consulted.");
                    }
                  }

                } catch (Throwable e) {
                  Debug.report(e);
                  return Status.CANCEL_STATUS;
                } finally {
                  monitor.done();
                }
                return Status.OK_STATUS;
              }
            };
        j.schedule();
      } catch (Throwable t) {
        Debug.report(t);
      }
    }
Exemplo n.º 14
0
 @Override
 public void dispose() {
   PrologConsolePlugin.getDefault().getPrologConsoleService().unregisterPrologConsole(this);
   PrologRuntimeUIPlugin.getDefault()
       .getPrologInterfaceService()
       .unRegisterActivePrologInterfaceListener(this);
   for (Iterator<PrologInterface> it = models.keySet().iterator(); it.hasNext(); ) {
     PrologInterface pif = it.next();
     try {
       disconnect(pif);
       removeHooks(pif);
     } catch (Throwable e) {
       Debug.report(e);
     }
   }
   models.clear();
   contextMenu.dispose();
   // viewer.getControl().dispose();
   super.dispose();
 }
Exemplo n.º 15
0
  private void ensureConnection(final PrologInterface pif, PrologSocketConsoleModel model)
      throws PrologInterfaceException {
    if (model.isConnected()) {
      return;
    }

    PrologSession session = pif.getSession(PrologInterface.NONE);
    //		FileSearchPathConfigurator.configureFileSearchPath(PrologRuntimeUIPlugin.getDefault()
    //				.getLibraryManager(), session,
    //				new String[] { PDTConsole.PL_LIBRARY });

    Map<String, ?> result = null;
    try {
      //			result = session.queryOnce( "consult(lib_pdt_console_pl(loader)).");
      result =
          session.queryOnce(
              bT(
                  PDTConsolePredicates.PDT_START_CONSOLE_SERVER,
                  "Port",
                  Util.quoteAtom(
                      PrologRuntimePlugin.getDefault().getPrologInterfaceRegistry().getKey(pif))));
      if (result == null) {
        startServer(pif, session);
        result = session.queryOnce(bT(PDTConsolePredicates.PDT_CURRENT_CONSOLE_SERVER, "Port"));
      }
      if (result == null) {
        throw new RuntimeException("could not install console server");
      }
    } catch (Exception e) {
      Debug.info(e.toString());
    } finally {
      if (session != null) {
        session.dispose();
      }
    }

    int port = Integer.parseInt(result.get("Port").toString());
    model.setPort(port);
    model.connect();
  }
Exemplo n.º 16
0
    private boolean ensureFileExists() {

      String msg = null;
      String value = getTextControl().getText();

      if (value == null) {
        msg = "History File must not be null";
      }
      if (value.length() == 0) {
        msg = "History File must not be empty";
      }
      File f = new File(value);
      if (!f.isAbsolute()) {
        msg = "History File must be an absolute path";
      }
      if (f.isDirectory()) {
        msg = "History File exists, but is a directory";
      }
      if (!f.exists()) {
        try {
          if (!f.createNewFile()) {}

        } catch (IOException e) {
          Debug.report(e);
          msg = "could not create History File";
        }
      }
      if (!f.canWrite()) {
        msg = "History File exists, but is not writable";
      }

      if (msg != null) { // error
        showErrorMessage(msg);
        return false;
      }

      // OK!
      clearErrorMessage();
      return true;
    }
Exemplo n.º 17
0
    @Override
    public void run() {
      try {

        Job j =
            new Job("Restarting the PrologInterface") {

              @Override
              public IStatus run(IProgressMonitor monitor) {
                try {
                  monitor.beginTask("initializing...", 2);

                  try {
                    if (getPrologInterface() != null) {
                      getPrologInterface().stop();
                      monitor.worked(1);
                    }
                    // setPrologInterface(getEditorPrologInterface());
                  } finally {
                    if (getPrologInterface() != null) {
                      if (!getPrologInterface().isDown()) {
                        getPrologInterface().reset();
                        Thread.sleep(1000);
                      }
                      final String reconsultFiles =
                          PrologConsolePlugin.getDefault()
                              .getPreferenceValue(
                                  PDTConsole.PREF_RECONSULT_ON_RESTART, PDTConsole.RECONSULT_NONE);

                      getPrologInterface().start();
                      if (reconsultFiles.equals(PDTConsole.RECONSULT_NONE)) {
                        getPrologInterface().clearConsultedFiles();
                      } else {
                        PDTCommonPlugin.getDefault()
                            .reconsultFiles(
                                getPrologInterface(),
                                reconsultFiles.equals(PDTConsole.RECONSULT_ENTRY));
                      }

                      Display.getDefault()
                          .asyncExec(
                              new Runnable() {
                                @Override
                                public void run() {
                                  getDefaultPrologConsoleService()
                                      .fireConsoleVisibilityChanged(PrologConsoleView.this);
                                }
                              });
                      writeCurrentProcessPortToFile();
                    }
                  }
                } catch (Throwable e) {
                  Debug.report(e);
                  return Status.CANCEL_STATUS;
                } finally {
                  monitor.done();
                }
                return Status.OK_STATUS;
              }
            };
        j.schedule();
      } catch (Throwable t) {
        Debug.report(t);
      }
    }
Exemplo n.º 18
0
  @Override
  public void run(IMarker marker) {

    IFile file = (IFile) marker.getResource();
    TextFileChange textFileChange = new TextFileChange(file.getName(), file);
    MultiTextEdit fileChangeRootEdit = new MultiTextEdit();

    // a file change contains a tree of edits, first add the root of them
    textFileChange.setEdit(fileChangeRootEdit);
    int offset;
    try {
      offset = marker.getAttribute(IMarker.CHAR_START, -1);
      if (offset == -1) {
        int line = marker.getAttribute(IMarker.LINE_NUMBER, -1);
        if (line == -1) {
          return;
        }
        offset = UIUtils.getDocument(file).getLineOffset(line - 1);
      }
      InsertEdit quickfix =
          new InsertEdit(offset, marker.getAttribute(PDTMarker.QUICKFIX_ACTION).toString());

      fileChangeRootEdit.addChild(quickfix);

      if (showWizard) {
        final TextFileChange fChange = textFileChange;
        Refactoring ref =
            new Refactoring() {

              @Override
              public String getName() {
                return "PDT Refactoring";
              }

              @Override
              public Change createChange(IProgressMonitor pm)
                  throws CoreException, OperationCanceledException {
                return fChange;
              }

              @Override
              public RefactoringStatus checkInitialConditions(IProgressMonitor pm)
                  throws CoreException, OperationCanceledException {
                return new RefactoringStatus();
              }

              @Override
              public RefactoringStatus checkFinalConditions(IProgressMonitor pm)
                  throws CoreException, OperationCanceledException {
                return new RefactoringStatus();
              }
            };
        RefactoringWizard wizard =
            new RefactoringWizard(ref, RefactoringWizard.WIZARD_BASED_USER_INTERFACE) {

              @Override
              protected void addUserInputPages() {}
            };
        Shell shell = UIUtils.getActiveShell();
        RefactoringWizardOpenOperation op = new RefactoringWizardOpenOperation(wizard);
        try {
          if (op.run(shell, "") != IDialogConstants.CANCEL_ID) {
            // changes are already performed by the dialog
            file.refreshLocal(IResource.DEPTH_INFINITE, null);
            PrologRuntimeUIPlugin.getDefault().getPrologInterfaceService().consultFile(file);
            //						PLMarkerUtils.updateFileMarkers(file);
          }
        } catch (InterruptedException e) {
        }
      } else {
        textFileChange.perform(new NullProgressMonitor());

        file.refreshLocal(IResource.DEPTH_INFINITE, null);
        PrologRuntimeUIPlugin.getDefault().getPrologInterfaceService().consultFile(file);
        //				PLMarkerUtils.updateFileMarkers(file);
      }
    } catch (NumberFormatException e1) {
      Debug.report(e1);
    } catch (CoreException e1) {
      Debug.report(e1);
    } catch (BadLocationException e) {
      Debug.report(e);
    }
  }