globpattern.java

用JAVA写的shell程序

// JShell
// Copyright (C) 2000 Jack A. Orenstein
// 
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
// published by the Free Software Foundation; either version 2 of
// the License, or (at your option) any later version.
// 
// 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 for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
// 02111-1307, USA.
// 
// Jack A. Orenstein  [e-mail]

package jshell.util;

import java.util.*;
import jshell.*;

public abstract class GlobPattern
{
    public final static int CASE_SENSITIVE   = 1;
    public final static int CASE_INSENSITIVE = 2;

    public static GlobPattern create(String pattern_string)
    {
        int case_sensitivity =
            JShell.os().caseSensitive()
            ? CASE_SENSITIVE
            : CASE_INSENSITIVE;
        return create(pattern_string, case_sensitivity);
    }

    public static GlobPattern create(String pattern_string,
                                     int case_sensitivity)
    {
        int first_star = pattern_string.indexOf("*");
        int last_star = pattern_string.lastIndexOf("*");
        GlobPattern pattern;
        if (no_glob_characters(pattern_string))
            pattern = 
                new StringPattern(pattern_string, 
                                  case_sensitivity);
        else if (pattern_string.equals("*"))
            pattern = new EverythingPattern();
        else if (first_star == 0 && 
                 last_star == 0 &&
                 no_glob_characters(pattern_string.substring(1)))
            pattern = 
                new SuffixPattern(pattern_string, 
                                  case_sensitivity);
        else if (first_star == pattern_string.length() - 1 &&
                 last_star == first_star &&
                 no_glob_characters(pattern_string.substring
                                    (0, pattern_string.length() - 1)))
        {
            if (pattern_string.charAt
                (pattern_string.length() - 2) == '\\')
                pattern = new StringPattern(pattern_string, 
                                            case_sensitivity);
            else
                pattern = new PrefixPattern(pattern_string, 
                                            case_sensitivity);
        }
        else
            pattern = new GeneralPattern(pattern_string);
        return pattern;
    }

    public abstract boolean match(String string);

    public boolean hasWildcards()
    {
        return true;
    }

    private static boolean no_glob_characters(String s)
    {
        char[] chars = s.toCharArray();
        int i = 0;
        while (i < chars.length)
        {
            char c = chars[i++];
            if (c == '\\')
                i++;
            else if (glob_character(c))
                return false;
        }
        return true;
    }

    private static boolean glob_character(char c)
    {
        boolean glob;
        switch (c)
        {
        case '*':
        case '?':
        case '-':
        case ',':
        case '{':
        case '}':
        case '[':
        case ']':
            glob = true;
            break;
            
        default:
            glob = false;
            break;
        }
        return glob;
    }

    private static boolean glob_start_character(char c)
    {
        boolean glob;
        switch (c)
        {
        case '*':
        case '?':
        case '{':
        case '}':
        case '[':
        case ']':
            glob = true;
            break;
            
        default:
            glob = false;
            break;
        }
        return glob;
    }

    //------------------------------------------------------------

    static final class StringPattern extends GlobPattern
    {
        public String toString()
        {
            return "StringPattern "+_string;
        }

        public StringPattern(String string, int case_sensitivity)
        {
            _string = Util.removeEscapes(string);
            _case_sensitivity = case_sensitivity;
        }

        public boolean match(String string)
        {
            return 
                _case_sensitivity == CASE_SENSITIVE
                ? string.equals(_string)
                : string.equalsIgnoreCase(_string);
        }

        public boolean hasWildcards()
        {
            return false;
        }

        private String _string;
        private int _case_sensitivity;
    }

    //------------------------------------------------------------

    static final class EverythingPattern extends GlobPattern
    {
        public String toString()
        {
            return "EverythingPattern";
        }

        public boolean match(String string)
        {
            return true;
        }
    }

    //------------------------------------------------------------

    static final class SuffixPattern extends GlobPattern
    {
        public String toString()
        {
            return "SuffixPattern: *"+_suffix;
        }

        SuffixPattern(String pattern, int case_sensitivity)
        {
            _suffix = pattern.substring(1);
            if (case_sensitivity == CASE_INSENSITIVE)
                _suffix = _suffix.toLowerCase();
            _case_sensitivity = case_sensitivity;
        }

        public boolean match(String string)
        {
            return 
                _case_sensitivity == CASE_SENSITIVE
                ? string.endsWith(_suffix)
                : string.toLowerCase().endsWith(_suffix);
        }

        private String _suffix;
        private int _case_sensitivity;
    }

    //------------------------------------------------------------

    static final class PrefixPattern extends GlobPattern
    {
        public String toString()
        {
            return "PrefixPattern: "+_prefix+"*";
        }

        PrefixPattern(String pattern, int case_sensitivity)
        {
            _prefix = pattern.substring(0, pattern.length() - 1);
            if (case_sensitivity == CASE_INSENSITIVE)
                _prefix = _prefix.toLowerCase();
            _case_sensitivity = case_sensitivity;
        }

        public boolean match(String string)
        {
            return 
                _case_sensitivity == CASE_SENSITIVE
                ? string.startsWith(_prefix)
                : string.toLowerCase().startsWith(_prefix);
        }

        private String _prefix;
        private int _case_sensitivity;
    }

    //------------------------------------------------------------

    static final class GeneralPattern extends GlobPattern
    {
        public String toString()
        {
            StringBuffer buffer = new StringBuffer();
            buffer.append("GeneralPattern:");
            for (Enumeration element_scan = _elements.elements();
                 element_scan.hasMoreElements();)
            {
                buffer.append('\n');
                PatternElement element =
                    (PatternElement) element_scan.nextElement();
                buffer.append("   ");
                buffer.append(element.toString());
            }
            return buffer.toString();
        }

        GeneralPattern(String pattern)
        {
            _pattern = new StringWithEscapes(pattern.toLowerCase());
            _elements = new Vector();
            parse();
        }

        public boolean match(String string)
        {
            _string = string.toLowerCase().toCharArray();
            _string_end = _string.length;
            PatternElement first_pattern_element = 
                (PatternElement)
                _elements.elementAt(0);
            return first_pattern_element.match(0);
        }


        //............................................................

        // Parse pattern -> Vector of PatternElements

        private void parse()
        {
            _pattern_position = 0;
            while (_pattern_position < _pattern.length())
            {
                boolean b =
                    star() ||
                    bracket() ||
                    brace() ||
                    question_mark() ||
                    text();
            }
            pattern_end();
        }

        private boolean star()
        {
            boolean consumed;
            if (_pattern.charAt(_pattern_position) == '*' &&
                !_pattern.escaped(_pattern_position))
            {
                _elements.addElement(new ZeroOrMoreChars());
                _pattern_position++;
                consumed = true;
            }
            else
                consumed = false;
            return consumed;
        }

        private boolean bracket()
        {
            boolean consumed;
            if (_pattern.charAt(_pattern_position) == '[' &&
                !_pattern.escaped(_pattern_position))
            {
                char c;
                OneChar one_char = new OneChar();
                while (!((c = _pattern.charAt(++_pattern_position)) 
                         == ']' && 
                         !_pattern.escaped(_pattern_position)))
                {
                    if (c == '-' &&
                        !_pattern.escaped(_pattern_position))
                    {
                        c = _pattern.charAt(++_pattern_position);
                        one_char.defineRange(c);
                    }
                    else
                        one_char.addChar(c);