regexp.java

来自「This is a resource based on j2me embedde」· Java 代码 · 共 151 行

/*
 * @(#)Regexp.java	1.16 06/10/10
 *
 * Copyright  1990-2008 Sun Microsystems, Inc. All Rights Reserved.  
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER  
 *   
 * This program 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.   
 *   
 * This program 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 at /legal/license.txt).   
 *   
 * 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 Sun Microsystems, Inc., 4150 Network Circle, Santa  
 * Clara, CA 95054 or visit www.sun.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 seperated 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 seperated 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;
    }

    static public void main(String argv[]) {
        Regexp r = new Regexp(argv[0]);
        System.out.print("re="+r+"\n");
        r.ignoreCase = true;
        for (int i = 1; i<argv.length; i++)
            System.out.print("<"+argv[i]+"> "+r.matches(argv[i])+"\n");
    }
}