/*
 * Copyright (c) 1995, 2004, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package sun.misc;

A class to represent a regular expression.  Only handles '*'s.
Author:
 James Gosling/**
 * A class to represent a regular expression.  Only handles '*'s.
 * @author  James Gosling
 */

public class Regexp {
    
if true then the matching process ignores case. /** if true then the matching process ignores case. */
    public boolean ignoreCase;

    /*
     * regular expressions are carved into three regions: a constant string
     * prefix, a constant string suffix, and a series of floating strings in
     * between.  In the input regular expression, they are separated by *s
     */
    public String exp;
    public String prefix, suffix;
    public boolean exact;
    public int prefixLen, suffixLen, totalLen;
    public String mids[];

    
Create a new regular expression object.  The regular expression
is a series of constant strings separated by *s.  For example:

*.gif       
Matches any string that ends in ".gif".
/tmp/*      
Matches any string that starts with "/tmp/".
/tmp/*.gif  
Matches any string that starts with "/tmp/" and ends
with ".gif".
/tmp/*new*.gif 
Matches any string that starts with "/tmp/"
and ends with ".gif" and has "new" somewhere in between.

/** Create a new regular expression object.  The regular expression
        is a series of constant strings separated by *s.  For example:
        <dl>
        <dt>*.gif       <dd>Matches any string that ends in ".gif".
        <dt>/tmp/*      <dd>Matches any string that starts with "/tmp/".
        <dt>/tmp/*.gif  <dd>Matches any string that starts with "/tmp/" and ends
                        with ".gif".
        <dt>/tmp/*new*.gif <dd>Matches any string that starts with "/tmp/"
                        and ends with ".gif" and has "new" somewhere in between.
        </dl>
     */
    public Regexp (String s) {
        exp = s;
        int firstst = s.indexOf('*');
        int lastst = s.lastIndexOf('*');
        if (firstst < 0) {
            totalLen = s.length();
            exact = true;       // no * s
        } else {
            prefixLen = firstst;
            if (firstst == 0)
                prefix = null;
            else
                prefix = s.substring(0, firstst);
            suffixLen = s.length() - lastst - 1;
            if (suffixLen == 0)
                suffix = null;
            else
                suffix = s.substring(lastst + 1);
            int nmids = 0;
            int pos = firstst;
            while (pos < lastst && pos >= 0) {
                nmids++;
                pos = s.indexOf('*', pos + 1);
            }
            totalLen = prefixLen + suffixLen;
            if (nmids > 0) {
                mids = new String[nmids];
                pos = firstst;
                for (int i = 0; i < nmids; i++) {
                    pos++;
                    int npos = s.indexOf('*', pos);
                    if (pos < npos) {
                        mids[i] = s.substring(pos, npos);
                        totalLen += mids[i].length();
                    }
                    pos = npos;
                }
            }
        }
    }

    
Returns true iff the String s matches this regular expression. /** Returns true iff the String s matches this regular expression. */
    final boolean matches(String s) {
        return matches(s, 0, s.length());
    }

    
Returns true iff the substring of s from offset for len characters
matches this regular expression. /** Returns true iff the substring of s from offset for len characters
        matches this regular expression. */
    boolean matches(String s, int offset, int len) {
        if (exact)
            return len == totalLen &&
                exp.regionMatches(ignoreCase, 0, s, offset, len);
        if (len < totalLen)
            return false;
        if (prefixLen > 0 &&
                !prefix.regionMatches(ignoreCase,
                                      0, s, offset, prefixLen)
                ||
                suffixLen > 0 &&
                !suffix.regionMatches(ignoreCase,
                                      0, s, offset + len - suffixLen,
                                      suffixLen))
            return false;
        if (mids == null)
            return true;
        int nmids = mids.length;
        int spos = offset + prefixLen;
        int limit = offset+len-suffixLen;
        for (int i = 0; i<nmids; i++) {
            String ms = mids[i];
            int ml = ms.length();
            while (spos+ml<=limit &&
                   !ms.regionMatches(ignoreCase,
                                     0, s, spos, ml))
                spos++;
            if (spos+ml>limit)
                return false;
            spos+=ml;
        }
        return true;
    }

}