Method matchNodes

CodenameOne/src/com/codename1/util/regex/RE.java:765–1250

(int firstNode, int lastNode, int idxStart)

    ///
    /// Final input array index if match succeeded.  -1 if not.
    @SuppressWarnings("PMD.SwitchStmtsShouldHaveDefault")
    protected int matchNodes(int firstNode, int lastNode, int idxStart) {
        // Our current place in the string
        int idx = idxStart;

        // Loop while node is valid
        int next;
        int opcode;
        int opdata;
        int idxNew;
        char[] instruction = program.instruction;
        for (int node = firstNode; node < lastNode; ) {
            opcode = instruction[node /* + offsetOpcode */];
            next = node + (short) instruction[node + offsetNext];
            opdata = instruction[node + offsetOpdata];

            switch (opcode) {
                case OP_MAYBE:
                case OP_STAR: {
                    // Try to match the following subexpr. If it matches:
                    //   MAYBE:  Continues matching rest of the expression
                    //    STAR:  Points back here to repeat subexpr matching
                    if ((idxNew = matchNodes(node + nodeSize, maxNode, idx)) != -1) { //NOPMD AssignmentInOperand
                        return idxNew;
                    }

                    // If failed, just continue with the rest of expression
                    break;
                }

                case OP_PLUS: {
                    // Try to match the subexpr again (and again (and ...
                    if ((idxNew = matchNodes(next, maxNode, idx)) != -1) { //NOPMD AssignmentInOperand
                        return idxNew;
                    }

                    // If failed, just continue with the rest of expression
                    // Rest is located at the next pointer of the next instruction
                    // (which must be OP_CONTINUE)
                    node = next + (short) instruction[next + offsetNext];
                    continue;
                }

                case OP_RELUCTANTMAYBE:
                case OP_RELUCTANTSTAR: {
                    // Try to match the rest without using the reluctant subexpr
                    if ((idxNew = matchNodes(next, maxNode, idx)) != -1) { //NOPMD AssignmentInOperand
                        return idxNew;
                    }

                    // Try reluctant subexpr. If it matches:
                    //   RELUCTANTMAYBE: Continues matching rest of the expression
                    //    RELUCTANTSTAR: Points back here to repeat reluctant star matching
                    return matchNodes(node + nodeSize, next, idx);
                }

                case OP_RELUCTANTPLUS: {
                    // Continue matching the rest without using the reluctant subexpr