Method simplify

java/com/google/re2j/Simplify.java:24–137

(Regexp re)

  // /(x)(x)?/ but both parentheses capture as $1.  The returned regexp
  // may share structure with or be the original.
  static Regexp simplify(Regexp re) {
    if (re == null) {
      return null;
    }
    switch (re.op) {
      case CAPTURE:
      case CONCAT:
      case ALTERNATE:
        {
          // Simplify children, building new Regexp if children change.
          Regexp nre = re;
          for (int i = 0; i < re.subs.length; ++i) {
            Regexp sub = re.subs[i];
            Regexp nsub = simplify(sub);
            if (nre == re && nsub != sub) {
              // Start a copy.
              nre = new Regexp(re); // shallow copy
              nre.runes = null;
              nre.subs = Parser.subarray(re.subs, 0, re.subs.length); // clone
            }
            if (nre != re) {
              nre.subs[i] = nsub;
            }
          }
          return nre;
        }
      case STAR:
      case PLUS:
      case QUEST:
        {
          Regexp sub = simplify(re.subs[0]);
          return simplify1(re.op, re.flags, sub, re);
        }
      case REPEAT:
        {
          // Special special case: x{0} matches the empty string
          // and doesn't even need to consider x.
          if (re.min == 0 && re.max == 0) {
            return new Regexp(Regexp.Op.EMPTY_MATCH);
          }

          // The fun begins.
          Regexp sub = simplify(re.subs[0]);

          // x{n,} means at least n matches of x.
          if (re.max == -1) {
            // Special case: x{0,} is x*.
            if (re.min == 0) {
              return simplify1(Regexp.Op.STAR, re.flags, sub, null);
            }

            // Special case: x{1,} is x+.
            if (re.min == 1) {
              return simplify1(Regexp.Op.PLUS, re.flags, sub, null);
            }

            // General case: x{4,} is xxxx+.
            Regexp nre = new Regexp(Regexp.Op.CONCAT);