Method matches

classpath/java/util/regex/PikeVM.java:290–457

Executes the Pike VM defined by the program. The idea is to execute threads in parallel, at each step executing them from the highest priority thread to the lowest one. In contrast to most regular expression engines, the Thompson/Pike one gets away with linear complexity because the string is ma

(char[] characters, int start, int end,
      boolean anchorStart, boolean anchorEnd, Result result)

   * @return whether a match was found
   */
  public boolean matches(char[] characters, int start, int end,
      boolean anchorStart, boolean anchorEnd, Result result)
  {
    ThreadQueue current = new ThreadQueue();
    ThreadQueue next = new ThreadQueue();

    // initialize the first thread
    int startPC = anchorStart ? findPrefixLength : 0;
    ThreadQueue queued = new ThreadQueue(startPC);

    boolean foundMatch = false;
    int step = end > start ? +1 : -1;
    for (int i = start; i != end + step; i += step) {
      if (queued.isEmpty()) {
        // no threads left
        return foundMatch;
      }

      char c = i != end ? characters[i] : 0;
      int pc = -1;
      for (;;) {
        pc = current.next(pc);
        if (pc < 0) {
          pc = queued.queueOneImmediately(current);
        }
        if (pc < 0) {
          break;
        }

        // pc == program.length is a match!
        if (pc == program.length) {
          if (anchorEnd && i != end) {
            continue;
          }
          if (result == null) {
            // only interested in a match, no need to go on
            return true;
          }
          current.setResult(result);

          // now that we found a match, even higher-priority matches must match
          // at the same start offset
          if (!anchorStart) {
            next.mustStartMatchAt(current.startOffset(pc));
          }
          foundMatch = true;
          break;
        }

        int opcode = program[pc];
        switch (opcode) {
        case DOT:
          if (c != '\0' && c != '\r' && c != '\n') {
            current.queueNext(pc, pc + 1, next);
          }
          break;
        case DOTALL:
          current.queueNext(pc, pc + 1, next);