/* * 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 */ public class Regexp {    /** 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:        <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. */    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. */    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;    } }