Ejemplo n.º 1
1
 /**
  * Starts a native process on the server
  *
  * @param command the command to start the process
  * @param dir the dir in which the process starts
  */
 static String startProcess(String command, String dir) throws IOException {
   StringBuffer ret = new StringBuffer();
   String[] comm = new String[3];
   comm[0] = COMMAND_INTERPRETER[0];
   comm[1] = COMMAND_INTERPRETER[1];
   comm[2] = command;
   long start = System.currentTimeMillis();
   try {
     // Start process
     Process ls_proc = Runtime.getRuntime().exec(comm, null, new File(dir));
     // Get input and error streams
     BufferedInputStream ls_in = new BufferedInputStream(ls_proc.getInputStream());
     BufferedInputStream ls_err = new BufferedInputStream(ls_proc.getErrorStream());
     boolean end = false;
     while (!end) {
       int c = 0;
       while ((ls_err.available() > 0) && (++c <= 1000)) {
         ret.append(conv2Html(ls_err.read()));
       }
       c = 0;
       while ((ls_in.available() > 0) && (++c <= 1000)) {
         ret.append(conv2Html(ls_in.read()));
       }
       try {
         ls_proc.exitValue();
         // if the process has not finished, an exception is thrown
         // else
         while (ls_err.available() > 0) ret.append(conv2Html(ls_err.read()));
         while (ls_in.available() > 0) ret.append(conv2Html(ls_in.read()));
         end = true;
       } catch (IllegalThreadStateException ex) {
         // Process is running
       }
       // The process is not allowed to run longer than given time.
       if (System.currentTimeMillis() - start > MAX_PROCESS_RUNNING_TIME) {
         ls_proc.destroy();
         end = true;
         ret.append("!!!! Process has timed out, destroyed !!!!!");
       }
       try {
         Thread.sleep(50);
       } catch (InterruptedException ie) {
       }
     }
   } catch (IOException e) {
     ret.append("Error: " + e);
   }
   return ret.toString();
 }
  /**
   * Take a process, record its standard error and standard out streams, wait for it to finish
   *
   * @param process process to watch
   * @throws SecurityException if a security manager exists and its checkExec method doesn't allow
   *     creation of a sub process.
   * @throws IOException - if an I/O error occurs
   * @throws NullPointerException - if cmdarray is null
   * @throws IndexOutOfBoundsException - if cmdarray is an empty array (has length 0).
   * @since ostermillerutils 1.06.00
   */
  private ExecHelper(Process process, String charset) throws IOException {
    StringBuffer output = new StringBuffer();
    StringBuffer error = new StringBuffer();

    Reader stdout;
    Reader stderr;

    if (charset == null) {
      // This is one time that the system charset is appropriate,
      // don't specify a character set.
      stdout = new InputStreamReader(process.getInputStream());
      stderr = new InputStreamReader(process.getErrorStream());
    } else {
      stdout = new InputStreamReader(process.getInputStream(), charset);
      stderr = new InputStreamReader(process.getErrorStream(), charset);
    }
    char[] buffer = new char[1024];

    boolean done = false;
    boolean stdoutclosed = false;
    boolean stderrclosed = false;
    while (!done) {
      boolean readSomething = false;
      // read from the process's standard output
      if (!stdoutclosed && stdout.ready()) {
        readSomething = true;
        int read = stdout.read(buffer, 0, buffer.length);
        if (read < 0) {
          readSomething = true;
          stdoutclosed = true;
        } else if (read > 0) {
          readSomething = true;
          output.append(buffer, 0, read);
        }
      }
      // read from the process's standard error
      if (!stderrclosed && stderr.ready()) {
        int read = stderr.read(buffer, 0, buffer.length);
        if (read < 0) {
          readSomething = true;
          stderrclosed = true;
        } else if (read > 0) {
          readSomething = true;
          error.append(buffer, 0, read);
        }
      }
      // Check the exit status only we haven't read anything,
      // if something has been read, the process is obviously not dead yet.
      if (!readSomething) {
        try {
          this.status = process.exitValue();
          done = true;
        } catch (IllegalThreadStateException itx) {
          // Exit status not ready yet.
          // Give the process a little breathing room.
          try {
            Thread.sleep(100);
          } catch (InterruptedException ix) {
            process.destroy();
            throw new IOException("Interrupted - processes killed");
          }
        }
      }
    }

    this.output = output.toString();
    this.error = error.toString();
  }
Ejemplo n.º 3
0
  public static String getArchName() throws Exception {
    if (archName == null) {
      archName = "lin";

      // bits
      Process process = Runtime.getRuntime().exec("uname -m");
      process.waitFor();
      if (process.exitValue() != 0) throw new Exception("Error arch");
      BufferedReader inStream = new BufferedReader(new InputStreamReader(process.getInputStream()));
      String arch = inStream.readLine();
      if (arch.equals("i686")) archName += "32";
      else archName += "64";
      process.destroy();

      // SSE
      process = Runtime.getRuntime().exec("cat /proc/cpuinfo");
      process.waitFor();
      if (process.exitValue() != 0) throw new Exception("Error /proc/cpuinfo");
      inStream = new BufferedReader(new InputStreamReader(process.getInputStream()));
      String line, cpuinfo = "";
      while ((line = inStream.readLine()) != null) cpuinfo += line;

      String bestSSE = "sse";
      String[] sses = {"sse2", "sse3", "ssse3", "sse4", "avx"};
      for (int i = 0; i < sses.length; i++) {
        if (cpuinfo.indexOf(sses[i]) >= 0) bestSSE = sses[i];
      }
      archName += bestSSE;
      process.destroy();
    }
    return archName;
  }
Ejemplo n.º 4
0
  /**
   * Gives the same basic functionality of File.exists but can be used to look for removable media
   * without showing a system dialog if the media is not present. Workaround pulled from the <A
   * HREF="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4089199"> bug report</A> on
   * bugs.sun.com. This bug was fixed in Java 6, and we can remove the workaround when we start
   * requiring Java 6.
   */
  protected static boolean fileExists(File file) {
    try {
      Process process =
          Runtime.getRuntime().exec(new String[] {"cmd.exe", "/c", "dir", file.getAbsolutePath()});

      // We need to consume all available output or the process will block.
      boolean haveExitCode = false;
      int exitCode = -1;
      InputStream out = process.getInputStream();
      InputStream err = process.getErrorStream();

      while (!haveExitCode) {
        while (out.read() >= 0) {}
        while (err.read() >= 0) {}

        try {
          exitCode = process.exitValue();
          haveExitCode = true;
        } catch (IllegalThreadStateException e) {
          // Not yet complete.
          Thread.sleep(100);
        }
      }
      // int exitCode = process.waitFor();
      return exitCode == 0;

    } catch (IOException e) {
      System.out.println("Unable to check for file: " + file + " : " + e);
      return false;

    } catch (InterruptedException e) {
      System.out.println("Unable to check for file.  Interrupted: " + file + " : " + e);
      return false;
    }
  }
Ejemplo n.º 5
0
 public static void logFile(String file, boolean isWrite) {
   ArrayList<String> cmds = new ArrayList<String>();
   cmds.add(Dependencies.getPythonLocation());
   cmds.add(Dependencies.getCLILocation());
   cmds.add("--file");
   cmds.add(file);
   String project = WakaTime.getProjectName();
   if (project != null) {
     cmds.add("--project");
     cmds.add(project);
   }
   cmds.add("--plugin");
   cmds.add(IDE_NAME + "/" + IDE_VERSION + " " + IDE_NAME + "-wakatime/" + VERSION);
   if (isWrite) cmds.add("--write");
   try {
     log.debug("Executing CLI: " + Arrays.toString(cmds.toArray()));
     Process proc = Runtime.getRuntime().exec(cmds.toArray(new String[cmds.size()]));
     if (WakaTime.DEBUG) {
       BufferedReader stdInput = new BufferedReader(new InputStreamReader(proc.getInputStream()));
       BufferedReader stdError = new BufferedReader(new InputStreamReader(proc.getErrorStream()));
       proc.waitFor();
       String s;
       while ((s = stdInput.readLine()) != null) {
         log.debug(s);
       }
       while ((s = stdError.readLine()) != null) {
         log.debug(s);
       }
       log.debug("Command finished with return value: " + proc.exitValue());
     }
   } catch (Exception e) {
     log.error(e);
   }
 }
Ejemplo n.º 6
0
  @Test
  public void testUnpack() {

    String type = "unpack";
    String path = "P:\\Ruby22-x64\\bin";
    String dir = "P:\\temp-workspace\\RPGTestProject1";
    try {
      Process process =
          Runtime.getRuntime()
              .exec(path + "\\rvpacker.bat --verbose -f -d " + dir + " -t ace -a " + type);

      new Thread(
              () -> {
                String line = null;
                int i = 0;
                try {
                  BufferedReader bR =
                      new BufferedReader(new InputStreamReader(process.getInputStream()));
                  while ((line = bR.readLine()) != null) {
                    if (line.isEmpty()) {
                      System.out.print("{E}");
                    }
                    System.out.println(++i + ": " + line);
                  }
                  System.out.println("NULL got | Closing");
                } catch (Exception e) {
                  e.printStackTrace();
                  fail("Exception");
                }
              })
          .start();
      new Thread(
              () -> {
                String line = null;
                try {
                  BufferedReader bR =
                      new BufferedReader(new InputStreamReader(process.getErrorStream()));
                  while ((line = bR.readLine()) != null) {
                    System.out.println("Err " + line);
                  }
                  System.out.println("NULL got");
                } catch (Exception e) {
                  e.printStackTrace();
                  fail("Exception");
                }
              })
          .start();
      ;

      process.waitFor();
      assertEquals(0, process.exitValue());
    } catch (IOException e) {
      e.printStackTrace();
      fail("Exception");
    } catch (InterruptedException e) {
      e.printStackTrace();
      fail("Exception");
    }
  }
Ejemplo n.º 7
0
  protected boolean compile(String fileName) {
    String compiler = "javac";
    String classpathOption = "-classpath";

    if (jikes != null) {
      compiler = jikes;
      classpathOption = "-bootclasspath";
    }

    String[] args =
        new String[] {
          compiler,
          "-d",
          tmpdir,
          classpathOption,
          tmpdir + pathSep + CLASSPATH,
          tmpdir + "/" + fileName
        };
    String cmdLine =
        compiler
            + " -d "
            + tmpdir
            + " "
            + classpathOption
            + " "
            + tmpdir
            + pathSep
            + CLASSPATH
            + " "
            + fileName;
    // System.out.println("compile: "+cmdLine);
    File outputDir = new File(tmpdir);
    try {
      Process process = Runtime.getRuntime().exec(args, null, outputDir);
      StreamVacuum stdout = new StreamVacuum(process.getInputStream());
      StreamVacuum stderr = new StreamVacuum(process.getErrorStream());
      stdout.start();
      stderr.start();
      process.waitFor();
      stdout.join();
      stderr.join();
      if (stdout.toString().length() > 0) {
        System.err.println("compile stdout from: " + cmdLine);
        System.err.println(stdout);
      }
      if (stderr.toString().length() > 0) {
        System.err.println("compile stderr from: " + cmdLine);
        System.err.println(stderr);
      }
      int ret = process.exitValue();
      return ret == 0;
    } catch (Exception e) {
      System.err.println("can't exec compilation");
      e.printStackTrace(System.err);
      return false;
    }
  }
Ejemplo n.º 8
0
  /** @param directory Directory where we list tags */
  @Override
  protected void buildTagList(File directory) {
    this.tagList = new TreeSet<TagEntry>();
    ArrayList<String> argv = new ArrayList<String>();
    ensureCommand(CMD_PROPERTY_KEY, CMD_FALLBACK);
    argv.add(cmd);
    argv.add("tags");
    ProcessBuilder pb = new ProcessBuilder(argv);
    pb.directory(directory);
    Process process = null;
    BufferedReader in = null;

    try {
      process = pb.start();
      in = new BufferedReader(new InputStreamReader(process.getInputStream()));
      String line;
      while ((line = in.readLine()) != null) {
        String parts[] = line.split("  *");
        if (parts.length < 2) {
          throw new HistoryException("Tag line contains more than 2 columns: " + line);
        }
        // Grrr, how to parse tags with spaces inside?
        // This solution will loose multiple spaces;-/
        String tag = parts[0];
        for (int i = 1; i < parts.length - 1; ++i) {
          tag += " " + parts[i];
        }
        TagEntry tagEntry = new BazaarTagEntry(Integer.parseInt(parts[parts.length - 1]), tag);
        // Bazaar lists multiple tags on more lines. We need to merge those into single TagEntry
        TagEntry higher = this.tagList.ceiling(tagEntry);
        if (higher != null && higher.equals(tagEntry)) {
          // Found in the tree, merge tags
          this.tagList.remove(higher);
          tagEntry.setTags(higher.getTags() + ", " + tag);
        }
        this.tagList.add(tagEntry);
      }
    } catch (IOException e) {
      OpenGrokLogger.getLogger().log(Level.WARNING, "Failed to read tag list: {0}", e.getMessage());
      this.tagList = null;
    } catch (HistoryException e) {
      OpenGrokLogger.getLogger()
          .log(Level.WARNING, "Failed to parse tag list: {0}", e.getMessage());
      this.tagList = null;
    }

    IOUtils.close(in);
    if (process != null) {
      try {
        process.exitValue();
      } catch (IllegalThreadStateException e) {
        // the process is still running??? just kill it..
        process.destroy();
      }
    }
  }
Ejemplo n.º 9
0
 public static String getCCName() throws Exception {
   if (ccName == null) {
     Process process = Runtime.getRuntime().exec("gcc -dumpversion");
     process.waitFor();
     if (process.exitValue() != 0) throw new Exception("Error gcc -dumpversion");
     BufferedReader inStream = new BufferedReader(new InputStreamReader(process.getInputStream()));
     String[] list = inStream.readLine().split("\\.");
     ccName = "gcc" + list[0] + list[1] + "-mt";
     process.destroy();
   }
   return ccName;
 }
Ejemplo n.º 10
0
  static int exec(String line, boolean showOutput, File dir) throws Exception {
    Process process = null;

    if (showOutput) {
      System.out.println("exec: " + line);
    }

    process = Runtime.getRuntime().exec("cmd /c " + line, null, dir);
    InputStream stdin = process.getInputStream();
    InputStream stderr = process.getErrorStream();

    StreamGobbler stdinGobbler = new StreamGobbler(stdin, "stdin: ");
    StreamGobbler stderrGobbler = new StreamGobbler(stderr, "stderr: ");
    stdinGobbler.start();
    stderrGobbler.start();
    process.waitFor();
    if (showOutput) {
      System.out.println("exec \"" + line + "\" returned " + process.exitValue());
    }
    return process.exitValue();
  }
Ejemplo n.º 11
0
 public static int ensureNTServiceIsRunning(String serviceName, String service) throws Exception {
   ArrayList<String> serviceList = getRunningNTServices();
   if (serviceList == null) return -1; // not NT kernel?
   for (String svc : serviceList) {
     if (serviceName.equals(svc.trim())) return 0; // service already running
   }
   Process process = RUNTIME.exec(comSpec + "net start \"" + service + "\"");
   process.waitFor(); // wait for the process to complete
   int rc = process.exitValue(); // pick up its return code
   boolean success = (rc == 0);
   if (success) System.out.println("Successfully started service '" + serviceName + "'.");
   return (success ? 1 : -1);
 }
 /*
  * Run the given command.
  */
 protected static int run(String message, String[] commandArray) {
   try {
     Process process = Runtime.getRuntime().exec(commandArray, null, output);
     StreamProcessor.start(process.getErrorStream(), StreamProcessor.STDERR, true);
     StreamProcessor.start(process.getInputStream(), StreamProcessor.STDOUT, true);
     process.waitFor();
     return process.exitValue();
   } catch (IOException e) {
     fail(message, e);
   } catch (InterruptedException e) {
     fail(message, e);
   }
   return -1;
 }
Ejemplo n.º 13
0
  @Override
  public boolean isAlive() {
    if (currentProcess == null) {
      return false;
    }

    // FIXME: Usage of exceptions isn't good approach
    try {
      int exitValue = currentProcess.exitValue();
      return false;
    } catch (IllegalThreadStateException ex) {
      return false;
    }
  }
Ejemplo n.º 14
0
 /**
  * Copies sourceFile into targetDir.
  *
  * @param sourceFile the full path name of the source file to be copied
  * @param targetDir the full path name of the target directory
  * @return the full path of the file in the new location, if the "copy" operation is successfull.
  *     Otherwise, it returns null.
  */
 public static String copyFile(String sourceFile, String targetDir) {
   String[] cmdArray = new String[3];
   cmdArray[0] = "cp";
   cmdArray[1] = sourceFile;
   cmdArray[2] = targetDir;
   Process p = OCSSWRunner.executeLocal(cmdArray, new File(targetDir));
   if (p.exitValue() == 0) {
     return targetDir
         + sourceFile.substring(sourceFile.lastIndexOf(System.getProperty("file.separator")));
   } else {
     System.out.println("This should not happen!");
     return null;
   }
 }
Ejemplo n.º 15
0
  /**
   * This method invokes wmic outside of the normal environment collection routines.
   *
   * <p>An initial call to wmic can be costly in terms of time. <code>
   * Details of why the first call is costly can be found at:
   *
   * http://support.microsoft.com/kb/290216/en-us
   *
   * "When you run the Wmic.exe utility for the first time, the utility
   * compiles its .mof files into the repository. To save time during
   * Windows installation, this operation takes place as necessary."
   * </code>
   */
  private String getWmicResult(String alias, String verb, String property) {
    String res = "";
    BufferedReader in = null;
    BufferedWriter bw = null;
    try {
      ProcessBuilder pb = new ProcessBuilder("cmd", "/C", "WMIC", alias, verb, property);
      Process p = pb.start();
      // need this for executing windows commands (at least
      // needed for executing wmic command)
      bw = new BufferedWriter(new OutputStreamWriter(p.getOutputStream()));
      bw.write(13);

      p.waitFor();
      if (p.exitValue() == 0) {
        in = new BufferedReader(new InputStreamReader(p.getInputStream()));
        String line = null;
        while ((line = in.readLine()) != null) {
          line = line.trim();
          if (line.length() == 0) {
            continue;
          }
          res = line;
        }
        // return the *last* line read
        return res;
      }

    } catch (Exception e) {
      // ignore the exception
    } finally {
      if (in != null) {
        try {
          in.close();
        } catch (IOException e) {
          // ignore
        }
      }
      if (bw != null) {
        try {
          bw.flush();
        } catch (Exception ex) { // ignore...
        }
        try {
          bw.close();
        } catch (Exception ex) { // ignore...
        }
      }
    }
    return res.trim();
  }
Ejemplo n.º 16
0
  private String getFullWmicResult(String alias, String verb, String property) {
    StringBuilder res = new StringBuilder();
    BufferedReader in = null;
    BufferedWriter bw = null;
    try {
      ProcessBuilder pb = new ProcessBuilder("cmd", "/C", "WMIC", alias, verb, property);
      Process p = pb.start();
      // need this for executing windows commands (at least
      // needed for executing wmic command)
      bw = new BufferedWriter(new OutputStreamWriter(p.getOutputStream()));
      bw.write(13);
      bw.flush();

      p.waitFor();
      if (p.exitValue() == 0) {
        in = new BufferedReader(new InputStreamReader(p.getInputStream()));
        String line = null;
        while ((line = in.readLine()) != null) {
          line = line.trim();
          if (line.length() == 0) {
            continue;
          }
          if (line.toLowerCase(Locale.US).indexOf(property.toLowerCase(Locale.US)) != -1) {
            continue;
          }
          res.append(line).append("\n");
        }
      }

    } catch (Exception e) {
      // ignore the exception
    } finally {
      if (in != null) {
        try {
          in.close();
        } catch (IOException e) {
          // ignore
        }
      }

      if (bw != null) {
        try {
          bw.close();
        } catch (IOException e) {
          // ignore
        }
      }
    }
    return res.toString();
  }
Ejemplo n.º 17
0
  static void realMain(String[] args) throws Throwable {
    // jmap doesn't work on Windows
    if (System.getProperty("os.name").startsWith("Windows")) return;

    final String childClassName = Job.class.getName();
    final String classToCheckForLeaks = Job.classToCheckForLeaks();
    final String uniqueID = String.valueOf(new Random().nextInt(Integer.MAX_VALUE));

    final String[] jobCmd = {
      java,
      "-Xmx8m",
      "-classpath",
      System.getProperty("test.classes", "."),
      childClassName,
      uniqueID
    };
    final Process p = new ProcessBuilder(jobCmd).start();

    final String childPid =
        match(
            commandOutputOf(jps, "-m"),
            "(?m)^ *([0-9]+) +\\Q" + childClassName + "\\E *" + uniqueID + "$",
            1);

    final int n0 = objectsInUse(p, childPid, classToCheckForLeaks);
    final int n1 = objectsInUse(p, childPid, classToCheckForLeaks);
    equal(p.waitFor(), 0);
    equal(p.exitValue(), 0);
    failed += p.exitValue();

    // Check that no objects were leaked.
    System.out.printf("%d -> %d%n", n0, n1);
    check(Math.abs(n1 - n0) < 2); // Almost always n0 == n1
    check(n1 < 20);
    drainers.shutdown();
  }
Ejemplo n.º 18
0
 static String outputOf(final Process p) {
   try {
     Future<String> outputFuture = futureOutputOf(p.getInputStream());
     Future<String> errorFuture = futureOutputOf(p.getErrorStream());
     final String output = outputFuture.get();
     final String error = errorFuture.get();
     // Check for successful process completion
     equal(error, "");
     equal(p.waitFor(), 0);
     equal(p.exitValue(), 0);
     return output;
   } catch (Throwable t) {
     unexpected(t);
     throw new Error(t);
   }
 }
Ejemplo n.º 19
0
  /** Execute the process and return when the process is complete. */
  public void exec() throws IOException {
    Runtime rt = Runtime.getRuntime();

    try {
      Process proc = rt.exec(commandLine);
      OutputStream os = rt.getLocalizedOutputStream(proc.getOutputStream());

      if (this.observer instanceof RefEnv) {
        os.write("quit();\n".getBytes());
      }

      os.flush();
      os.close();

      InputStreamReader is;

      is = new InputStreamReader(proc.getErrorStream());
      (new Thread(new StreamReader(error, is))).start();

      is = new InputStreamReader(proc.getInputStream());
      (new Thread(new StreamReader(input, is))).start();

      proc.waitFor();
      exitValue = proc.exitValue();

      // unfortunately the following pause seems to
      // need to be here otherwise we get a crash

      // On AIX, Process.waitFor() doesn't seem to wait for
      // the process to complete before continuing.  Bad.
      // Need to find a workaround.

      if (System.getProperty("os.name").startsWith("AIX")
          || System.getProperty("os.name").startsWith("HP")) {
        pause(20000);
      } else {
        pause(10000);
      }

    } catch (Exception e) {
      java.lang.System.out.println(e);
      e.printStackTrace();
    }
  }
Ejemplo n.º 20
0
  @Override
  public InputStream getHistoryGet(String parent, String basename, String rev) {
    InputStream ret = null;

    File directory = new File(directoryName);

    Process process = null;
    try {
      String filename =
          (new File(parent, basename)).getCanonicalPath().substring(directoryName.length() + 1);
      ensureCommand(CMD_PROPERTY_KEY, CMD_FALLBACK);
      String argv[] = {cmd, "cat", "-r", rev, filename};
      process = Runtime.getRuntime().exec(argv, null, directory);

      ByteArrayOutputStream out = new ByteArrayOutputStream();
      byte[] buffer = new byte[32 * 1024];
      InputStream in = process.getInputStream();
      int len;

      while ((len = in.read(buffer)) != -1) {
        if (len > 0) {
          out.write(buffer, 0, len);
        }
      }

      ret = new ByteArrayInputStream(out.toByteArray());
    } catch (Exception exp) {
      OpenGrokLogger.getLogger()
          .log(Level.SEVERE, "Failed to get history: " + exp.getClass().toString(), exp);
    } finally {
      // Clean up zombie-processes...
      if (process != null) {
        try {
          process.exitValue();
        } catch (IllegalThreadStateException exp) {
          // the process is still running??? just kill it..
          process.destroy();
        }
      }
    }

    return ret;
  }
Ejemplo n.º 21
0
  /**
   * Checks if address can be reached using one argument InetAddress.isReachable() version or ping
   * command if failed.
   *
   * @param addr Address to check.
   * @param reachTimeout Timeout for the check.
   * @return {@code True} if address is reachable.
   */
  public static boolean reachableByPing(InetAddress addr, int reachTimeout) {
    try {
      if (addr.isReachable(reachTimeout)) return true;

      String cmd = String.format("ping -%s 1 %s", U.isWindows() ? "n" : "c", addr.getHostAddress());

      Process myProc = Runtime.getRuntime().exec(cmd);

      myProc.waitFor();

      return myProc.exitValue() == 0;
    } catch (IOException ignore) {
      return false;
    } catch (InterruptedException ignored) {
      Thread.currentThread().interrupt();

      return false;
    }
  }
Ejemplo n.º 22
0
  private static String retrieveOFileNameLocal(String[] cmdArray, String ifileDir) {
    Process process = OCSSWRunner.execute(cmdArray, new File(ifileDir));

    if (process == null) {
      return "output";
    }
    int exitCode = process.exitValue();
    InputStream is;
    if (exitCode == 0) {
      is = process.getInputStream();
    } else {
      is = process.getErrorStream();
    }

    InputStreamReader isr = new InputStreamReader(is);
    BufferedReader br = new BufferedReader(isr);

    try {

      if (exitCode == 0) {
        String line;
        while ((line = br.readLine()) != null) {
          if (line.startsWith(NEXT_LEVEL_FILE_NAME_TOKEN)) {
            return (line.substring(NEXT_LEVEL_FILE_NAME_TOKEN.length())).trim();
          }
        }

      } else {
        debug("Failed exit code on program '" + NEXT_LEVEL_NAME_FINDER_PROGRAM_NAME + "'");
      }

    } catch (IOException ioe) {

      VisatApp.getApp().showErrorDialog(ioe.getMessage());
    }

    //        int choice = VisatApp.getApp().showQuestionDialog("ofile computation", "ofile name is
    // not found", true, "continue");
    //
    //        return String.valueOf(choice);
    return "output";
  }
Ejemplo n.º 23
0
  public int compileJavaProgram(JavaProgram jp, String writeDirectory, String classpath)
      throws Exception {
    if (!jp.isTypeResolved()) {
      System.out.println(
          "Compilation will not take place since there were type resolution errors.");
      return -1;
    }

    String fileList = jp.getFilesAsString();
    String command = "javac -d " + writeDirectory + " -classpath " + classpath + " " + fileList;
    // System.out.println(command);
    System.out.print("Compiling...");

    Process p = Runtime.getRuntime().exec(command);
    // need to squirt the output into the
    InputStream is = p.getErrorStream();

    Util.read(is, "compiler"); // blocks here
    int exitValue = p.exitValue();
    return exitValue;
  }
Ejemplo n.º 24
0
  private static String getNextLevelFileName(String ifileName, String[] cmdArray) {

    String ifileDir =
        ifileName.substring(0, ifileName.lastIndexOf(System.getProperty("file.separator")));
    Process process = OCSSWRunner.execute(cmdArray, new File(ifileDir));
    if (process == null) {
      return null;
    }

    int exitCode = process.exitValue();
    InputStream is;
    if (exitCode == 0) {
      is = process.getInputStream();
    } else {
      is = process.getErrorStream();
    }

    InputStreamReader isr = new InputStreamReader(is);
    BufferedReader br = new BufferedReader(isr);

    try {

      if (exitCode == 0) {
        String line;
        while ((line = br.readLine()) != null) {
          if (line.startsWith(NEXT_LEVEL_FILE_NAME_TOKEN)) {
            return (line.substring(NEXT_LEVEL_FILE_NAME_TOKEN.length())).trim();
          }
        }

      } else {
        debug("Failed exit code on program '" + cmdArray[5] + "'");
      }

    } catch (IOException ioe) {

      VisatApp.getApp().showErrorDialog(ioe.getMessage());
    }
    return null;
  }
Ejemplo n.º 25
0
  public static int executeCommand(String completeCommand, PrintWriter out) {
    try {
      Process p = Runtime.getRuntime().exec(completeCommand);
      if (out != null) {
        BufferedReader in = new BufferedReader(new InputStreamReader(p.getInputStream()));
        String line = in.readLine();
        while (line != null) {
          out.println(line);
          line = in.readLine();
        }
        in.close();
        out.flush();
      }
      p.waitFor();
      int status = p.exitValue();
      p.destroy();
      return status;

    } catch (Exception e) {
      e.printStackTrace();
      System.exit(1);
      return -1;
    }
  }
Ejemplo n.º 26
0
  public static void main(String args[]) {
    int PC, SP, IR, AC, X, Y;
    int[] memory = new int[1000];
    SP = IR = AC = X = Y = 0;
    PC = -1;

    // Gets "MainMemory" class from working directory.
    String directory = System.getProperty("user.dir") + "\\bin\\ MainMemory";

    Scanner in = new Scanner(System.in);

    try {
      int x, y, index = 0;
      String z = "";
      Runtime rt = Runtime.getRuntime();

      Process proc = rt.exec("java -cp " + directory);
      // Process proc = rt.exec("cat Hello.java");

      InputStream os = proc.getInputStream();

      IR = 0;

      // GRABS INSTRUCTION OUT OF STREAM
      while ((x = os.read()) != -1) {

        try {
          if (x > 47 && x < 58) {
            y = Character.getNumericValue(x);

            z += y;

          } else if (x == 10 && z != "") {

            x = Integer.parseInt(z);
            y = 0;
            z = "";
            // System.out.println(x);

            memory[index] = x;
            index++;
          } else if (x == 13) {
            break;
          }
        } catch (Exception e) {
          System.out.println("ERROR: Error while reading instructions.");
          System.exit(1);
        }
      }

      // PERFORMS INSTRUCTIONS
      for (int k = 0; k < index; k++) {

        // System.out.println(k + " == " + memory[k]);
        IR = memory[k];

        switch (IR) {
          case 1:
            // System.out.println("LOAD VALUE"); //READS IN THE VALUE
            PC++;
            k++;
            AC = memory[k];
            PC++;
            break;

          case 2:
            // System.out.println("LOAD ADDR"); //READS VALUE FROM AN ADDRESS
            PC++;

            AC = memory[memory[k + 1]];

            k++;

            break;

          case 3:
            // System.out.println("STORE ADDR"); //WRITES THE VALUE OF AC TO THE ADDRESS
            PC++;

            memory[memory[k + 1]] = AC;

            k++;

            try {
              File file = new File(System.getProperty("user.dir") + "\\src\\program.txt");
              FileWriter fw = new FileWriter(file);
              BufferedWriter out = new BufferedWriter(fw);

              for (int i = 0; i < index; i++) {
                out.write("" + memory[i]);
                out.newLine();
              }
              out.flush();
              out.close();
            } catch (IOException e) {
              System.out.println("ERROR: Could not rewrite program");
            }

            break;

          case 4:
            // System.out.println("ADD X"); //ADDS X TO AC
            PC++;
            AC += X;
            break;

          case 5:
            // System.out.println("ADD Y"); //ADDS Y TO AC
            PC++;
            AC += Y;
            break;

          case 6:
            // System.out.println("SUB X"); //SUBSTRACTS X FROM AC
            PC++;
            AC -= X;
            break;

          case 7:
            // System.out.println("SUB Y"); //SUBTRACTS Y FROM AC
            PC++;
            AC -= Y;
            break;

          case 8:
            // System.out.println("GET PORT"); //RECEIVES EITHER INTEGER OR CHARACTER DEPENDING ON
            // PORT NUMBER, 1 OR 2
            PC++;
            k++;
            if (memory[k] == 1) {
              PC++;
              // System.out.println("PORT = READ INT"); //RECEIVES INTEGER FROM USER AND PLACES IT
              // INTO AC
              AC = in.nextInt();
            } else if (memory[k] == 2) // RECEIVES CHARACTER FROM USER AND PLACES IT INTO AC
            {
              PC++;
              // System.out.println("PORT = READ CHAR");
              AC = (int) in.next(".{1}").charAt(0);
            }

            break;

          case 9:
            // System.out.println("PUT PORT"); //PRINTS EITHER INTEGER OR CHARACTER DEPENDING ON
            // PORT NUMBER, 1 OR 2
            PC++;
            k++;
            if (memory[k] == 1) {
              // System.out.println("PORT = WRITE INT"); PRINTS OUT INTEGER VALUE FROM AC
              PC++;
              System.out.print(AC);

            } else if (memory[k] == 2) {
              // System.out.println("PORT = WRITE CHAR"); //PRINTS OUT CHARACTER VALUE FROM AC
              PC++;

              System.out.print((char) AC);
            }

            break;

          case 10:
            // System.out.println("COPYTO X"); //COPIES VALUE FROM X INTO AC
            PC++;
            X = AC;
            break;

          case 11:
            // System.out.println("COPYTO Y"); //COPIES VALUE FROM Y INTO AC
            PC++;
            Y = AC;
            break;

          case 12:
            // System.out.println("COPYFROM X"); //COPIES VALUE FROM X INTO AC
            PC++;
            AC = X;
            break;

          case 13:
            // System.out.println("COPYFROM Y"); //COPIES VALUE FROM Y INTO AC
            PC++;
            AC = Y;
            break;

          case 14:
            // System.out.println("JUMP ADDR"); //JUMPS TO AN ADDRESS
            PC++;

            k = memory[k + 1] - 1;

            break;

          case 15:
            // System.out.println("JUMPIFEQUAL ADDR"); //JUMPS TO AN ADDRESS IF AC IS EQUAL TO ZERO
            PC++;

            if (AC == 0) {
              PC++;
              k = memory[k + 1] - 1;
            } else {
              PC++;
              k++;
            }

            break;

          case 16:
            // System.out.println("JUMPIFNOTEQUAL ADDR"); //JUMPS TO AN ADDRESS IF AC IS NOT EQUAL
            // TO ZERO
            PC++;

            if (AC != 0) {
              PC++;
              k = memory[k + 1] - 1;

            } else {
              PC++;
              k++;
            }

            break;

          case 17:
            // System.out.println("CALL ADDR"); // PUSH RETURN ADDRESS INTO STACK, AND JUMPS AN
            // ADDRESS
            PC++;

            SP = PC;

            k = memory[k + 1] - 1;

            PC++;

            break;

          case 18:
            // System.out.println("RETURN"); //POPS RETURN ADDRESS FROM STACK, AND JUMPS TO IT
            PC++;

            k = SP + 1;
            break;

          case 19:
            // System.out.println("INC X"); //INCREMENTS VALUE IN X BY ONE
            PC++;
            X++;
            break;

          case 20:
            // System.out.println("DEC X"); //DECREMENTS VALUE IN X BY ONE
            PC++;
            X--;
            break;

          case 30:
            // System.out.println("END"); //ENDS PROCESS
            PC++;
            X = 0;
            Y = 0;
            AC = 0;

            k = index;

            try {
              os.close();

            } catch (Exception e) {

            }
            break;
        }
        // System.out.println("\nProgram Counter: " + PC);
      }

      // PROCESS ENDS

      proc.waitFor();

      in.close();

      int exitVal = proc.exitValue();

      System.out.println("\nProcess exited: " + exitVal);

    } catch (Throwable t) {

      t.printStackTrace();
    }

    System.exit(1);
  }
Ejemplo n.º 27
0
  /**
   * Reads the next line from the process. This method will be used only if the supporting Java
   * Native Interface library could not be loaded.
   */
  private synchronized String pure_readLine() {
    String line;
    long current, timeout = ((new Date()).getTime()) + threshold;

    if (null == p || null == in || null == err) return null;
    // Debug.verbose("P4Process.readLine()");
    try {
      for (; ; ) {
        if (null == p || null == in || null == err) {
          Debug.error("P4Process.readLine(): Something went null");
          return null;
        }

        current = (new Date()).getTime();
        if (current >= timeout) {
          Debug.error("P4Process.readLine(): Timeout");
          // If this was generating a new object from stdin, return an
          // empty string. Otherwise, return null.
          for (int i = 0; i < new_cmd.length; i++) {
            if (new_cmd[i].equals("-i")) return "";
          }
          return null;
        }

        // Debug.verbose("P4Process.readLine().in: "+in);
        try {
          /**
           * If there's something coming in from stdin, return it. We assume that the p4 command was
           * called with -s which sends all messages to standard out pre-pended with a string that
           * indicates what kind of messsage it is error warning text info exit
           */
          // Some errors still come in on Standard error
          while (err.ready()) {
            line = err.readLine();
            if (null != line) {
              addP4Error(line + "\n");
            }
          }

          if (in.ready()) {
            line = in.readLine();
            Debug.verbose("From P4:" + line);
            if (line.startsWith("error")) {
              if (!line.trim().equals("")
                  && (-1 == line.indexOf("up-to-date"))
                  && (-1 == line.indexOf("no file(s) to resolve"))) {
                addP4Error(line);
              }
            } else if (line.startsWith("warning")) {
            } else if (line.startsWith("text")) {
            } else if (line.startsWith("info")) {
            } else if (line.startsWith("exit")) {
              int exit_code =
                  new Integer(line.substring(line.indexOf(" ") + 1, line.length())).intValue();
              if (0 == exit_code) {
                Debug.verbose("P4 Exec Complete.");
              } else {
                Debug.error("P4 exited with an Error!");
              }
              return null;
            }
            if (!raw) line = line.substring(line.indexOf(":") + 1).trim();
            Debug.verbose("P4Process.readLine(): " + line);
            return line;
          }
        } catch (NullPointerException ne) {
        }
        // If there's nothing on stdin or stderr, check to see if the
        // process has exited. If it has, return null.
        try {
          exit_code = p.exitValue();
          return null;
        } catch (IllegalThreadStateException ie) {
          Debug.verbose("P4Process: Thread is not done yet.");
        }
        // Sleep for a second, so this thread can't become a CPU hog.
        try {
          Debug.verbose("P4Process: Sleeping...");
          Thread.sleep(100); // Sleep for 1/10th of a second.
        } catch (InterruptedException ie) {
        }
      }
    } catch (IOException ex) {
      return null;
    }
  }
Ejemplo n.º 28
0
  public synchronized RenderedImage runDCRaw(dcrawMode mode, boolean secondaryPixels)
      throws IOException, UnknownImageTypeException, BadImageFileException {
    if (!m_decodable || (mode == dcrawMode.full && m_rawColors != 3))
      throw new UnknownImageTypeException("Unsuported Camera");

    RenderedImage result = null;

    File of = null;

    try {
      if (mode == dcrawMode.preview) {
        if (m_thumbWidth >= 1024 && m_thumbHeight >= 768) {
          mode = dcrawMode.thumb;
        }
      }

      long t1 = System.currentTimeMillis();

      of = File.createTempFile("LZRAWTMP", ".ppm");

      boolean four_colors = false;
      final String makeModel = m_make + ' ' + m_model;
      for (String s : four_color_cameras)
        if (s.equalsIgnoreCase(makeModel)) {
          four_colors = true;
          break;
        }

      if (secondaryPixels) runDCRawInfo(true);

      String cmd[];
      switch (mode) {
        case full:
          if (four_colors)
            cmd =
                new String[] {
                  DCRAW_PATH,
                  "-F",
                  of.getAbsolutePath(),
                  "-v",
                  "-f",
                  "-H",
                  "1",
                  "-t",
                  "0",
                  "-o",
                  "0",
                  "-4",
                  m_fileName
                };
          else if (m_filters == -1 || (m_make != null && m_make.equalsIgnoreCase("SIGMA")))
            cmd =
                new String[] {
                  DCRAW_PATH,
                  "-F",
                  of.getAbsolutePath(),
                  "-v",
                  "-H",
                  "1",
                  "-t",
                  "0",
                  "-o",
                  "0",
                  "-4",
                  m_fileName
                };
          else if (secondaryPixels)
            cmd =
                new String[] {
                  DCRAW_PATH,
                  "-F",
                  of.getAbsolutePath(),
                  "-v",
                  "-j",
                  "-H",
                  "1",
                  "-t",
                  "0",
                  "-s",
                  "1",
                  "-d",
                  "-4",
                  m_fileName
                };
          else
            cmd =
                new String[] {
                  DCRAW_PATH,
                  "-F",
                  of.getAbsolutePath(),
                  "-v",
                  "-j",
                  "-H",
                  "1",
                  "-t",
                  "0",
                  "-d",
                  "-4",
                  m_fileName
                };
          break;
        case preview:
          cmd =
              new String[] {
                DCRAW_PATH,
                "-F",
                of.getAbsolutePath(),
                "-v",
                "-t",
                "0",
                "-o",
                "1",
                "-w",
                "-h",
                m_fileName
              };
          break;
        case thumb:
          cmd = new String[] {DCRAW_PATH, "-F", of.getAbsolutePath(), "-v", "-e", m_fileName};
          break;
        default:
          throw new IllegalArgumentException("Unknown mode " + mode);
      }

      String ofName = null;

      synchronized (DCRaw.class) {
        Process p = null;
        InputStream dcrawStdErr;
        InputStream dcrawStdOut;
        if (ForkDaemon.INSTANCE != null) {
          ForkDaemon.INSTANCE.invoke(cmd);
          dcrawStdErr = ForkDaemon.INSTANCE.getStdErr();
          dcrawStdOut = ForkDaemon.INSTANCE.getStdOut();
        } else {
          p = Runtime.getRuntime().exec(cmd);
          dcrawStdErr = new BufferedInputStream(p.getErrorStream());
          dcrawStdOut = p.getInputStream();
        }

        String line, args;
        // output expected on stderr
        while ((line = readln(dcrawStdErr)) != null) {
          // System.out.println(line);

          if ((args = match(line, DCRAW_OUTPUT)) != null)
            ofName = args.substring(0, args.indexOf(" ..."));
        }

        // Flush stdout just in case...
        while ((line = readln(dcrawStdOut)) != null) ; // System.out.println(line);

        if (p != null) {
          dcrawStdErr.close();

          try {
            p.waitFor();
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
          m_error = p.exitValue();
          p.destroy();
        } else m_error = 0;
      }

      System.out.println("dcraw value: " + m_error);

      if (m_error > 0) {
        of.delete();
        throw new BadImageFileException(of);
      }

      if (!ofName.equals(of.getPath())) {
        of.delete();
        of = new File(ofName);
      }

      if (of.getName().endsWith(".jpg") || of.getName().endsWith(".tiff")) {
        if (of.getName().endsWith(".jpg")) {
          try {
            LCJPEGReader jpegReader = new LCJPEGReader(of.getPath());
            result = jpegReader.getImage();
          } catch (Exception e) {
            e.printStackTrace();
          }
        } else {
          try {
            LCTIFFReader tiffReader = new LCTIFFReader(of.getPath());
            result = tiffReader.getImage(null);
          } catch (Exception e) {
            e.printStackTrace();
          }
        }
        long t2 = System.currentTimeMillis();

        int totalData =
            result.getWidth()
                * result.getHeight()
                * result.getColorModel().getNumColorComponents()
                * (result.getColorModel().getTransferType() == DataBuffer.TYPE_BYTE ? 1 : 2);

        System.out.println("Read " + totalData + " bytes in " + (t2 - t1) + "ms");
      } else {
        ImageData imageData;
        try {
          imageData = readPPM(of);
        } catch (Exception e) {
          e.printStackTrace();
          throw new BadImageFileException(of, e);
        }

        // do not change the initial image geometry
        // m_width = Math.min(m_width, imageData.width);
        // m_height = Math.min(m_height, imageData.height);

        long t2 = System.currentTimeMillis();

        int totalData =
            imageData.width
                * imageData.height
                * imageData.bands
                * (imageData.dataType == DataBuffer.TYPE_BYTE ? 1 : 2);

        System.out.println("Read " + totalData + " bytes in " + (t2 - t1) + "ms");

        final ColorModel cm;
        if (mode == dcrawMode.full) {
          if (imageData.bands == 1) {
            cm =
                new ComponentColorModel(
                    ColorSpace.getInstance(ColorSpace.CS_GRAY),
                    false,
                    false,
                    Transparency.OPAQUE,
                    DataBuffer.TYPE_USHORT);
          } else {
            cm = JAIContext.colorModel_linear16;
          }
        } else {
          if (imageData.bands == 3)
            cm =
                new ComponentColorModel(
                    JAIContext.sRGBColorSpace,
                    false,
                    false,
                    Transparency.OPAQUE,
                    DataBuffer.TYPE_BYTE);
          else if (imageData.bands == 4)
            cm =
                new ComponentColorModel(
                    JAIContext.CMYKColorSpace,
                    false,
                    false,
                    Transparency.OPAQUE,
                    imageData.dataType);
          else throw new UnknownImageTypeException("Weird number of bands: " + imageData.bands);
        }

        final DataBuffer buf =
            imageData.dataType == DataBuffer.TYPE_BYTE
                ? new DataBufferByte(
                    (byte[]) imageData.data, imageData.bands * imageData.width * imageData.height)
                : new DataBufferUShort(
                    (short[]) imageData.data, imageData.bands * imageData.width * imageData.height);

        final WritableRaster raster =
            Raster.createInterleavedRaster(
                buf,
                imageData.width,
                imageData.height,
                imageData.bands * imageData.width,
                imageData.bands,
                imageData.bands == 3 ? new int[] {0, 1, 2} : new int[] {0},
                null);

        result = new BufferedImage(cm, raster, false, null);
      }
    } catch (IOException e) {
      if (of != null) of.delete();
      throw e;
    } finally {
      if (of != null) of.delete();
    }
    return result;
  }
Ejemplo n.º 29
0
  /**
   * The first invocation of this test starts a loop which exhaustively tests the object tree with
   * all of its different settings. There are 7 test objects in a tree that has 7 different places
   * to set assertions untouched/on/off so this tests 3^7 or 2187 different configurations.
   *
   * <p>This test spawns a new VM for each run because assertions are set on or off at class load
   * time. Once the class is loaded its assertion status does not change.
   */
  public static void main(String[] args) throws Exception {

    // Switch values: 0=don't touch, 1=off, 2 = on
    int[] switches = new int[7];

    int switchSource = 0;
    if (args.length == 0) { // This is master version

      // This code is for an exhaustive test
      // while(switchSource < 2187) {
      //    int temp = switchSource++;

      // This code is for a weaker but faster test
      for (int x = 0; x < 100; x++) {
        int temp = generator.nextInt(2187);
        for (int i = 0; i < 7; i++) {
          switches[i] = temp % 3;
          temp = temp / 3;
        }

        // Spawn new VM and load classes
        String command =
            System.getProperty("java.home")
                + File.separator
                + "bin"
                + File.separator
                + "java Assert";

        StringBuffer commandString = new StringBuffer(command);
        for (int j = 0; j < 7; j++) commandString.append(" " + switches[j]);

        Process p = null;
        p = Runtime.getRuntime().exec(commandString.toString());

        if (debug) { // See output of test VMs
          BufferedReader blah = new BufferedReader(new InputStreamReader(p.getInputStream()));
          String outString = blah.readLine();
          while (outString != null) {
            System.out.println("from slave:" + outString);
            outString = blah.readLine();
          }
        }

        p.waitFor();
        int result = p.exitValue();
        if (debug) { // See which switch configs failed
          if (result == 0) {
            for (int k = 6; k >= 0; k--) System.out.print(switches[k]);
            System.out.println();
          } else {
            System.out.print("Nonzero Exit: ");
            for (int k = 6; k >= 0; k--) System.out.print(switches[k]);
            System.out.println();
          }
        } else {
          if (result != 0) {
            System.err.print("Nonzero Exit: ");
            for (int k = 6; k >= 0; k--) System.err.print(switches[k]);
            System.err.println();
            throw new RuntimeException("Assertion test failure.");
          }
        }
      }
    } else { // This is a test spawn
      for (int i = 0; i < 7; i++) switches[i] = Integer.parseInt(args[i]);

      SetAssertionSwitches(switches);
      ConstructClassTree();
      TestClassTree(switches);
    }
  }
Ejemplo n.º 30
0
  private void runDCRawInfo(boolean secondary) throws IOException {
    String info[] = {DCRAW_PATH, "-v", "-i", "-t", "0", m_fileName};
    String secondaryInfo[] = {DCRAW_PATH, "-v", "-i", "-s", "1", "-t", "0", m_fileName};

    synchronized (DCRaw.class) {
      Process p = null;
      InputStream dcrawStdOut;
      InputStream dcrawStdErr;
      if (ForkDaemon.INSTANCE != null) {
        ForkDaemon.INSTANCE.invoke(secondary ? secondaryInfo : info);
        dcrawStdOut = ForkDaemon.INSTANCE.getStdOut();
        dcrawStdErr = ForkDaemon.INSTANCE.getStdErr();
      } else {
        p = Runtime.getRuntime().exec(secondary ? secondaryInfo : info);
        dcrawStdOut = p.getInputStream();
        dcrawStdErr = new BufferedInputStream(p.getErrorStream());
      }

      // output expected on stdout
      String line, args;
      while ((line = readln(dcrawStdOut)) != null) {
        // System.out.println(line);

        String search;

        if (secondary) {
          if (line.startsWith(search = CAMERA_MULTIPLIERS)) {
            String multipliers[] = line.substring(search.length()).split("\\s");
            m_secondary_cam_mul[0] = Float.parseFloat(multipliers[0]);
            m_secondary_cam_mul[1] = Float.parseFloat(multipliers[1]);
            m_secondary_cam_mul[2] = Float.parseFloat(multipliers[2]);
            m_secondary_cam_mul[3] = Float.parseFloat(multipliers[3]);
          }
        } else {
          // if (line.startsWith(search = FILENAME)) {
          //     String filename = line.substring(search.length());
          // } else
          if (line.startsWith(search = TIMESTAMP)) {
            String timestamp = line.substring(search.length());
            try {
              m_captureDateTime = new SimpleDateFormat().parse(timestamp).getTime();
            } catch (ParseException e) {
              m_captureDateTime = 0;
            }
          } else if (line.startsWith(search = CAMERA)) {
            String camera = line.substring(search.length());
            m_make = camera.substring(0, camera.indexOf(' '));
            m_model = camera.substring(m_make.length() + 1);
          } else if (line.startsWith(search = ISO)) {
            String iso = line.substring(search.length());
            m_iso = Integer.decode(iso);
          } else if (line.startsWith(search = SHUTTER)) {
            String shutterSpeed = line.substring(search.length() + 2);
            float exposureTime = 0;
            try {
              exposureTime = Float.valueOf(shutterSpeed.substring(0, shutterSpeed.indexOf(" sec")));
              if (exposureTime != 0) m_shutterSpeed = 1 / exposureTime;
            } catch (NumberFormatException e) {
            }
          } else if (line.startsWith(search = APERTURE)) {
            String aperture = line.substring(search.length() + 2);
            try {
              m_aperture = Float.valueOf(aperture);
            } catch (NumberFormatException e) {
            }
          } else if (line.startsWith(search = FOCAL_LENGTH)) {
            String focalLenght = line.substring(search.length());
            try {
              m_focalLength = Float.valueOf(focalLenght.substring(0, focalLenght.indexOf(" mm")));
            } catch (NumberFormatException e) {
            }
            // } else if (line.startsWith(search = NUM_RAW_IMAGES)) {
            //     String numRawImages = line.substring(search.length());
            // } else if (line.startsWith(search = EMBEDDED_ICC_PROFILE)) {
            //     String embeddedICCProfile = line.substring(search.length());
          } else if (line.startsWith(CANNOT_DECODE)) {
            m_decodable = false;
          } else if ((args = match(line, THUMB_SIZE)) != null) {
            String sizes[] = args.split(" x ");
            m_thumbWidth = Integer.decode(sizes[0]);
            m_thumbHeight = Integer.decode(sizes[1]);
          } else if ((args = match(line, FULL_SIZE)) != null) {
            String sizes[] = args.split(" x ");
            m_fullWidth = Integer.decode(sizes[0]);
            m_fullHeight = Integer.decode(sizes[1]);
          } else if ((args = match(line, IMAGE_SIZE)) != null) {
            String sizes[] = args.split(" x ");
            m_rawWidth = Integer.decode(sizes[0]);
            m_rawHeight = Integer.decode(sizes[1]);
          } else if ((args = match(line, OUTPUT_SIZE)) != null) {
            String sizes[] = args.split(" x ");
            m_width = Integer.decode(sizes[0]);
            m_height = Integer.decode(sizes[1]);
          } else if (line.startsWith(search = RAW_COLORS)) {
            String rawColors = line.substring(search.length());
            m_rawColors = Integer.decode(rawColors);
          } else if (line.startsWith(search = FILTER_PATTERN)) {
            String pattern = line.substring(search.length());
            if (pattern.length() >= 8 && !pattern.substring(0, 4).equals(pattern.substring(4, 8)))
              m_filters = -1;
            else if (pattern.startsWith("BGGR")) m_filters = 0x16161616;
            else if (pattern.startsWith("GRBG")) m_filters = 0x61616161;
            else if (pattern.startsWith("GBRG")) m_filters = 0x49494949;
            else if (pattern.startsWith("RGGB")) m_filters = 0x94949494;
            else m_filters = -1;
          } else if (line.startsWith(search = DAYLIGHT_MULTIPLIERS)) {
            String multipliers[] = line.substring(search.length()).split("\\s");
            m_pre_mul[0] = Float.parseFloat(multipliers[0]);
            m_pre_mul[1] = Float.parseFloat(multipliers[1]);
            m_pre_mul[2] = Float.parseFloat(multipliers[2]);
            m_pre_mul[3] = m_pre_mul[1];
          } else if (line.startsWith(search = CAMERA_MULTIPLIERS)) {
            String multipliers[] = line.substring(search.length()).split("\\s");
            m_cam_mul[0] = Float.parseFloat(multipliers[0]);
            m_cam_mul[1] = Float.parseFloat(multipliers[1]);
            m_cam_mul[2] = Float.parseFloat(multipliers[2]);
            m_cam_mul[3] = Float.parseFloat(multipliers[3]);
          } else if (line.startsWith(CAMERA_RGB_PROFILE)) {
            String rgb_cam[] = line.substring(CAMERA_RGB_PROFILE.length()).split("\\s");
            m_rgb_cam = new float[9];
            for (int i = 0; i < 9; i++) {
              m_rgb_cam[i] = Float.parseFloat(rgb_cam[i]);
            }
          } else if (line.startsWith(CAMERA_XYZ_PROFILE)) {
            String xyz_cam[] = line.substring(CAMERA_XYZ_PROFILE.length()).split("\\s");
            m_xyz_cam = new float[9];
            for (int i = 0; i < 9; i++) {
              m_xyz_cam[i] = Float.parseFloat(xyz_cam[i]);
            }
          }
        }
      }

      // Flush stderr just in case...
      while ((line = readln(dcrawStdErr)) != null) ; // System.out.println(line);

      if (p != null) {
        dcrawStdOut.close();
        try {
          p.waitFor();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        m_error = p.exitValue();
        p.destroy();
      } else m_error = 0;
    }
  }