1 /*

     2  * reserved comment block

     3  * DO NOT REMOVE OR ALTER!

     4  */

     5 /*

     6  * Copyright 1999-2004 The Apache Software Foundation.

     7  *

     8  * Licensed under the Apache License, Version 2.0 (the "License");

     9  * you may not use this file except in compliance with the License.

    10  * You may obtain a copy of the License at

    11  *

    12  *     http://www.apache.org/licenses/LICENSE-2.0

    13  *

    14  * Unless required by applicable law or agreed to in writing, software

    15  * distributed under the License is distributed on an "AS IS" BASIS,

    16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

    17  * See the License for the specific language governing permissions and

    18  * limitations under the License.

    19  */

    20 

    21 package com.sun.org.apache.regexp.internal;

    22 

    23 import java.io.Serializable;

    24 

    25 /**

    26  * A class that holds compiled regular expressions.  This is exposed mainly

    27  * for use by the recompile utility (which helps you produce precompiled

    28  * REProgram objects). You should not otherwise need to work directly with

    29  * this class.

    30 *

    31  * @see RE

    32  * @see RECompiler

    33  *

    34  * @author <a href="mailto:jonl@muppetlabs.com">Jonathan Locke</a>

    35  */

    36 public class REProgram implements Serializable

    37 {

    38     static final int OPT_HASBACKREFS = 1;

    39 

    40     char[] instruction;         // The compiled regular expression 'program'

    41     int lenInstruction;         // The amount of the instruction buffer in use

    42     char[] prefix;              // Prefix string optimization

    43     int flags;                  // Optimization flags (REProgram.OPT_*)

    44     int maxParens = -1;

    45 

    46     /**

    47      * Constructs a program object from a character array

    48      * @param instruction Character array with RE opcode instructions in it

    49      */

    50     public REProgram(char[] instruction)

    51     {

    52         this(instruction, instruction.length);

    53     }

    54 

    55     /**

    56      * Constructs a program object from a character array

    57      * @param parens Count of parens in the program

    58      * @param instruction Character array with RE opcode instructions in it

    59      */

    60     public REProgram(int parens, char[] instruction)

    61     {

    62         this(instruction, instruction.length);

    63         this.maxParens = parens;

    64     }

    65 

    66     /**

    67      * Constructs a program object from a character array

    68      * @param instruction Character array with RE opcode instructions in it

    69      * @param lenInstruction Amount of instruction array in use

    70      */

    71     public REProgram(char[] instruction, int lenInstruction)

    72     {

    73         setInstructions(instruction, lenInstruction);

    74     }

    75 

    76     /**

    77      * Returns a copy of the current regular expression program in a character

    78      * array that is exactly the right length to hold the program.  If there is

    79      * no program compiled yet, getInstructions() will return null.

    80      * @return A copy of the current compiled RE program

    81      */

    82     public char[] getInstructions()

    83     {

    84         // Ensure program has been compiled!

    85         if (lenInstruction != 0)

    86         {

    87             // Return copy of program

    88             char[] ret = new char[lenInstruction];

    89             System.arraycopy(instruction, 0, ret, 0, lenInstruction);

    90             return ret;

    91         }

    92         return null;

    93     }

    94 

    95     /**

    96      * Sets a new regular expression program to run.  It is this method which

    97      * performs any special compile-time search optimizations.  Currently only

    98      * two optimizations are in place - one which checks for backreferences

    99      * (so that they can be lazily allocated) and another which attempts to

   100      * find an prefix anchor string so that substantial amounts of input can

   101      * potentially be skipped without running the actual program.

   102      * @param instruction Program instruction buffer

   103      * @param lenInstruction Length of instruction buffer in use

   104      */

   105     public void setInstructions(char[] instruction, int lenInstruction)

   106     {

   107         // Save reference to instruction array

   108         this.instruction = instruction;

   109         this.lenInstruction = lenInstruction;

   110 

   111         // Initialize other program-related variables

   112         flags = 0;

   113         prefix = null;

   114 

   115         // Try various compile-time optimizations if there's a program

   116         if (instruction != null && lenInstruction != 0)

   117         {

   118             // If the first node is a branch

   119             if (lenInstruction >= RE.nodeSize && instruction[0 + RE.offsetOpcode] == RE.OP_BRANCH)

   120             {

   121                 // to the end node

   122                 int next = instruction[0 + RE.offsetNext];

   123                 if (instruction[next + RE.offsetOpcode] == RE.OP_END)

   124                 {

   125                     // and the branch starts with an atom

   126                     if (lenInstruction >= (RE.nodeSize * 2) && instruction[RE.nodeSize + RE.offsetOpcode] == RE.OP_ATOM)

   127                     {

   128                         // then get that atom as an prefix because there's no other choice

   129                         int lenAtom = instruction[RE.nodeSize + RE.offsetOpdata];

   130                         prefix = new char[lenAtom];

   131                         System.arraycopy(instruction, RE.nodeSize * 2, prefix, 0, lenAtom);

   132                     }

   133                 }

   134             }

   135 

   136             BackrefScanLoop:

   137 

   138             // Check for backreferences

   139             for (int i = 0; i < lenInstruction; i += RE.nodeSize)

   140             {

   141                 switch (instruction[i + RE.offsetOpcode])

   142                 {

   143                     case RE.OP_ANYOF:

   144                         i += (instruction[i + RE.offsetOpdata] * 2);

   145                         break;

   146 

   147                     case RE.OP_ATOM:

   148                         i += instruction[i + RE.offsetOpdata];

   149                         break;

   150 

   151                     case RE.OP_BACKREF:

   152                         flags |= OPT_HASBACKREFS;

   153                         break BackrefScanLoop;

   154                 }

   155             }

   156         }

   157     }

   158 }