Does all the processing.

@return The processed String.
@throws IOException
If an IO error occurred.
519847
private String process() throws IOException
    {
        final StringBuilder out = new StringBuilder();
        final Block parent = this.readLines();
        parent.removeSurroundingEmptyLines();

        this.recurse(parent, false);
        Block block = parent.blocks;
        while (block != null)
        {
            this.emitter.emit(out, block);
            block = block.next;
        }

        return out.toString();
    }
1321735
public IndexPreprocessResult process(final Document theInput)
            throws ProcessException {
        final DocumentBuilder documentBuilder = XMLUtils.getDocumentBuilder();
        final Document doc = documentBuilder.newDocument();

        final Node rootElement = theInput.getDocumentElement();


        final ArrayList<IndexEntry> indexes = new ArrayList<IndexEntry>();

        final IndexEntryFoundListener listener = new IndexEntryFoundListener() {
            public void foundEntry(final IndexEntry theEntry) {
                indexes.add(theEntry);
            }
        };

        final Node node = processCurrNode(rootElement, doc, listener)[0];

        doc.appendChild(node);

        doc.getDocumentElement().setAttribute(XMLNS_ATTRIBUTE + ":" + this.prefix, this.namespace_url);

        return new IndexPreprocessResult(doc, (IndexEntry[]) indexes.toArray(new IndexEntry[0]));
    }
1322011
@SuppressWarnings("unchecked")
    public T finish() throws IOException
    {
        if (_open) {
            _closeChild();
            _open = false;
            if (_closeGenerator) {
                _generator.close();
            } else if (Feature.FLUSH_AFTER_WRITE_VALUE.isEnabled(_features)) {
                _generator.flush();
            }
        }
        if (_result == null) {
            Object x;
            if (_stringWriter != null) {
                x = _stringWriter.getAndClear();
                _stringWriter = null;
            } else if (_byteWriter != null) {
                x = _byteWriter.toByteArray();
                _byteWriter = null;
            } else {
                x = _generator.getOutputTarget();
            }
            _result = (T) x;
        }
        return _result;
    }
970096
public String
getString() throws IOException {
	Token next = get();
	if (!next.isString()) {
		throw exception("expected a string");
	}
	return next.value;
}
346430
public String asString() throws IOException {
        StringWriter w = new StringWriter();
        writeRawTo(w);
        return w.toString();
    }
394890
int get() throws IOException {
		int c = in.read();

		if (c >= ' ' || c == '\n' || c == EOF) {
			return c;
		}

		if (c == '\r') {
			return '\n';
		}
		
		return ' ';
	}
1105880
public String asString() throws IOException {
        Charset charset = getCharset();
        if (charset == null) {
            charset = DEFAULT_CHARSET;
        }
        return asString(charset);
    }
683872
public String getMessage() {
    StringBuffer result = new StringBuffer();
    Iterator<IOException> itr = problems.iterator();
    while(itr.hasNext()) {
      result.append(itr.next().getMessage());
      if (itr.hasNext()) {
        result.append("\n");
      }
    }
    return result.toString();
  }
1137563
public ByteBuffer readAll() throws IOException {
    ByteBuffer bb = ByteBuffer.allocate((int) length);
    if (positionalReadMode) {
      read(0, bb.array(), 0, (int) length);
      return bb;
    } else {
      read(bb.array(), 0, (int) length);
      return bb;
    }
  }
1207465
public void finish() throws IOException {
    if (finished) {
      return;
    }
    finished = true;
    sum.writeValue(barray, 0, false);
    out.write (barray, 0, sum.getChecksumSize());
    out.flush();
  }
1357868
private Process launch() throws IOException {
		StringBuilder command = new StringBuilder(12 + (parameters.size() << 3));
		command.append(this.driver.getCommand()).append(" ");
		for (Entry<String, String> entry : parameters.entrySet()) {
			command.append("--").append(entry.getKey()).append(" ");
			if (entry.getValue() != null) {
				command.append(entry.getValue()).append(" ");
			}
		}

		String commandString = command.toString();
		if (LOGGER.isDebugEnabled()) {
			LOGGER.debug(commandString);
		}
		return Runtime.getRuntime().exec(commandString);
	}
729204
@Nonnull
    public Process exec() throws IOException {
        List<String> commandWords = toCommandWords();
        ProcessBuilder builder = new ProcessBuilder(commandWords);
        // TODO: Use Redirect to send the I/O somewhere useful.
        QEmuCommandLineUtils.redirectIO(builder);
        return builder.start();
    }
684925
public String process(String data){
		try {
			out.write(data);
			out.write((char)0);
			out.flush();
			
			//Get data from server
			String tagged = "";
			while (true){				
				int ch = in.read();
				
				if (ch == 0) break;
				tagged += (char) ch;			
			}
			return tagged;
		}
		catch (Exception e){
			System.out.println(e.getMessage());
			return "";
		}
		
	}
633
public void run() throws IOException {
    if (this.isStarted() || this.isComplete()) {
      throw new IllegalStateException("The process can only be used once.");
    }

    final ProcessBuilder builder = new ProcessBuilder(this.cmd);
    builder.directory(new File(this.workingDir));
    builder.environment().putAll(this.env);
    builder.redirectErrorStream(true);
    this.process = builder.start();
    try {
      this.processId = processId(this.process);
      if (this.processId == 0) {
        this.logger.debug("Spawned thread with unknown process id");
      } else {
        this.logger.debug("Spawned thread with process id " + this.processId);
      }

      this.startupLatch.countDown();

      final LogGobbler outputGobbler =
          new LogGobbler(
              new InputStreamReader(this.process.getInputStream(), StandardCharsets.UTF_8),
              this.logger, Level.INFO, 30);
      final LogGobbler errorGobbler =
          new LogGobbler(
              new InputStreamReader(this.process.getErrorStream(), StandardCharsets.UTF_8),
              this.logger, Level.ERROR, 30);

      outputGobbler.start();
      errorGobbler.start();
      int exitCode = -1;
      try {
        exitCode = this.process.waitFor();
      } catch (final InterruptedException e) {
        this.logger.info("Process interrupted. Exit code is " + exitCode, e);
      }

      this.completeLatch.countDown();

      // try to wait for everything to get logged out before exiting
      outputGobbler.awaitCompletion(5000);
      errorGobbler.awaitCompletion(5000);

      if (exitCode != 0) {
        throw new ProcessFailureException(exitCode);
      }

    } finally {
      IOUtils.closeQuietly(this.process.getInputStream());
      IOUtils.closeQuietly(this.process.getOutputStream());
      IOUtils.closeQuietly(this.process.getErrorStream());
    }
  }
166318
private void processFilterData() throws IOException
   {
      DirectoryEntry dir = (DirectoryEntry) m_viewDir.getEntry("CFilter");
      //FixedMeta fixedMeta = new FixedMeta(new DocumentInputStream(((DocumentEntry) dir.getEntry("FixedMeta"))), 9);
      //FixedData fixedData = new FixedData(fixedMeta, getEncryptableInputStream(dir, "FixedData"));
      InputStream stream = m_inputStreamFactory.getInstance(dir, "FixedData");
      int blockSize = stream.available() % 115 == 0 ? 115 : 110;
      FixedData fixedData = new FixedData(blockSize, stream, true);
      VarMeta varMeta = new VarMeta9(new DocumentInputStream(((DocumentEntry) dir.getEntry("VarMeta"))));
      Var2Data varData = new Var2Data(varMeta, new DocumentInputStream(((DocumentEntry) dir.getEntry("Var2Data"))));

      //System.out.println(fixedMeta);
      //System.out.println(fixedData);
      //System.out.println(varMeta);
      //System.out.println(varData);

      FilterReader reader = new FilterReader9();
      reader.process(m_file.getProjectProperties(), m_file.getFilters(), fixedData, varData);
   }
918581
public ReviewResult parseResults() throws IOException {
        ReviewResult result = new ReviewResult();
        ObjectMapper mapper = new ObjectMapper();
        JsonNode rootNode = mapper.readTree(new FileReader(resultFile));
        JsonNode issues = rootNode.path("issues");
        Iterator<JsonNode> issuesIterator = issues.iterator();
        Map<String, Component> components = getComponents(rootNode.path("components"));

        while (issuesIterator.hasNext()) {
            JsonNode issue = issuesIterator.next();
            boolean isNew = issue.path("isNew").asBoolean();
            if (!isNew) {
                log.debug("Skipping already indexed issue: {}", issue.toString());
                continue;
            }
            JsonNode lineNode = issue.path("line");
            if (lineNode.isMissingNode()) {
                log.debug("Skipping an issue with no line information: {}", issue.toString());
                continue;
            }
            int line = lineNode.asInt();
            String message = issue.path("message").asText();
            String file = getIssueFilePath(issue.path("component").asText(), components);
            String severity = issue.path("severity").asText();
            String rule = issue.path("rule").asText();
            result.add(new Violation(file, line, String.format("%s (Rule: %s)", message, rule), getSeverity(severity)));
        }
        return result;
    }
790477
private FileOutputStream fos() throws IOException {
        if (closed)
            throw new IOException("Output stream is already closed");
        if (os == null || currFileBytesWritten >= partSize) {
            if (os != null) {
                os.close();
                // notify about the new file ready for processing
                observer.onPartCreate(new PartCreationEvent(
                        getFile(filesCreated), filesCreated, false, this));
            }
            currFileBytesWritten = 0;
            filesCreated++;
            blockIfNecessary();
            final File file = getFile(filesCreated);
            os = new FileOutputStream(file);
        }
        return os;
    }