String charToString(char c) 
{
        // If it's unprintable, convert to '\###'
        if (c <  ' " || c  > 127)
        {
            return "\\" + (int) c;
        }
        // Return the character as a string
        return String.valueOf(c);
}

Return a string describing a (possibly unprintable) character.

 public  void dumpProgram() 
{
        PrintWriter w = new PrintWriter(System.out);
        dumpProgram(w);
        w.flush();
}

Dumps the current program to a System.out.

 public  void dumpProgram(PrintWriter p) 
{
        // Loop through the whole program
        for (int i = 0; i <  lenInstruction; )
        {
            // Get opcode, opdata and next fields of current program node
            char opcode =         instruction[i /* + RE.offsetOpcode */];
            char opdata =         instruction[i    + RE.offsetOpdata   ];
            int  next   = (short) instruction[i    + RE.offsetNext     ];
            // Display the current program node
            p.print(i + ". " + nodeToString(i) + ", next = ");
            // If there's no next, say 'none', otherwise give absolute index of next node
            if (next == 0)
            {
                p.print("none");
            }
            else
            {
                p.print(i + next);
            }
            // Move past node
            i += RE.nodeSize;
            // If character class
            if (opcode == RE.OP_ANYOF)
            {
                // Opening bracket for start of char class
                p.print(", [");
                // Show each range in the char class
                // int rangeCount = opdata;
                for (int r = 0; r <  opdata; r++)
                {
                    // Get first and last chars in range
                    char charFirst = instruction[i++];
                    char charLast  = instruction[i++];
                    // Print range as X-Y, unless range encompasses only one char
                    if (charFirst == charLast)
                    {
                        p.print(charToString(charFirst));
                    }
                    else
                    {
                        p.print(charToString(charFirst) + "-" + charToString(charLast));
                    }
                }
                // Annotate the end of the char class
                p.print("]");
            }
            // If atom
            if (opcode == RE.OP_ATOM)
            {
                // Open quote
                p.print(", \"");
                // Print each character in the atom
                for (int len = opdata; len-- != 0; )
                {
                    p.print(charToString(instruction[i++]));
                }
                // Close quote
                p.print("\"");
            }
            // Print a newline
            p.println("");
        }
}

Dumps the current program to a PrintWriter .

 String nodeToString(int node) 
{
        // Get opcode and opdata for node
        char opcode =       instruction[node /* + RE.offsetOpcode */];
        int opdata  = (int) instruction[node    + RE.offsetOpdata   ];
        // Return opcode as a string and opdata value
        return opcodeToString(opcode) + ", opdata = " + opdata;
}

Returns a descriptive string for a node in a regular expression program.

 String opcodeToString(char opcode) 
{
    
        hashOpcode.put(new Integer(RE.OP_RELUCTANTSTAR),    "OP_RELUCTANTSTAR");
        hashOpcode.put(new Integer(RE.OP_RELUCTANTPLUS),    "OP_RELUCTANTPLUS");
        hashOpcode.put(new Integer(RE.OP_RELUCTANTMAYBE),   "OP_RELUCTANTMAYBE");
        hashOpcode.put(new Integer(RE.OP_END),              "OP_END");
        hashOpcode.put(new Integer(RE.OP_BOL),              "OP_BOL");
        hashOpcode.put(new Integer(RE.OP_EOL),              "OP_EOL");
        hashOpcode.put(new Integer(RE.OP_ANY),              "OP_ANY");
        hashOpcode.put(new Integer(RE.OP_ANYOF),            "OP_ANYOF");
        hashOpcode.put(new Integer(RE.OP_BRANCH),           "OP_BRANCH");
        hashOpcode.put(new Integer(RE.OP_ATOM),             "OP_ATOM");
        hashOpcode.put(new Integer(RE.OP_STAR),             "OP_STAR");
        hashOpcode.put(new Integer(RE.OP_PLUS),             "OP_PLUS");
        hashOpcode.put(new Integer(RE.OP_MAYBE),            "OP_MAYBE");
        hashOpcode.put(new Integer(RE.OP_NOTHING),          "OP_NOTHING");
        hashOpcode.put(new Integer(RE.OP_GOTO),             "OP_GOTO");
        hashOpcode.put(new Integer(RE.OP_CONTINUE),         "OP_CONTINUE");
        hashOpcode.put(new Integer(RE.OP_ESCAPE),           "OP_ESCAPE");
        hashOpcode.put(new Integer(RE.OP_OPEN),             "OP_OPEN");
        hashOpcode.put(new Integer(RE.OP_CLOSE),            "OP_CLOSE");
        hashOpcode.put(new Integer(RE.OP_BACKREF),          "OP_BACKREF");
        hashOpcode.put(new Integer(RE.OP_POSIXCLASS),       "OP_POSIXCLASS");
        hashOpcode.put(new Integer(RE.OP_OPEN_CLUSTER),     "OP_OPEN_CLUSTER");
        hashOpcode.put(new Integer(RE.OP_CLOSE_CLUSTER),    "OP_CLOSE_CLUSTER");
        // Get string for opcode
        String ret = (String) hashOpcode.get(new Integer(opcode));
        // Just in case we have a corrupt program
        if (ret == null)
        {
            ret = "OP_????";
        }
        return ret;
}

Returns a descriptive string for an opcode.