globpattern.java

用JAVA写的shell程序

                }
                // Get past ]
                _pattern_position++;

                _elements.addElement(one_char);
                consumed = true;
            }
            else
                consumed = false;
            return consumed;
        }

        private boolean brace()
        {
            boolean consumed;
            if (_pattern.charAt(_pattern_position) == '{' &&
                !_pattern.escaped(_pattern_position))
            {
                char c;
                Alternatives alternatives = new Alternatives();
                StringBuffer buffer = new StringBuffer();
                while (!((c = _pattern.charAt(++_pattern_position))
                         == '}' &&
                         !_pattern.escaped(_pattern_position)))
                {
                    if (c == ',')
                    {
                        alternatives.add(buffer.toString());
                        buffer.setLength(0);
                    }
                    else
                        buffer.append(c);
                }
                // Get past }
                _pattern_position++;

                alternatives.add(buffer.toString());
                _elements.addElement(alternatives);
                consumed = true;
            }
            else
                consumed = false;
            return consumed;
        }

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

        private boolean text()
        {
            char c;
            StringBuffer buffer = new StringBuffer();
            while (_pattern_position < _pattern.length() &&
                   !GlobPattern.glob_start_character
                   (c = _pattern.charAt(_pattern_position)))
            {
                _pattern_position++;
                buffer.append(c);
            }
            _elements.addElement(new Text(buffer.toString()));
            return true;
        }

        private void pattern_end()
        {
            _elements.addElement(new PatternEnd());
        }

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

        private StringWithEscapes _pattern;
        private int _pattern_position;
        private Vector _elements;
        private int _n_elements = 0;
        private char[] _string;
        private int _string_end;

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

        abstract class PatternElement
        {
            protected PatternElement()
            {
                _element_id = _n_elements++;
            }

            protected PatternElement next_element()
            {
                int next_id = _element_id + 1;
                if (_next_element == null && next_id < _n_elements)
                    _next_element = 
                        (PatternElement) _elements.elementAt(next_id);
                return _next_element;
            }

            public abstract boolean match(int string_position);

            protected int _element_id;
            protected PatternElement _next_element;
        }

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

        class ZeroOrMoreChars extends PatternElement
        {
            public String toString()
            {
                return "ZeroOrMoreChars: *";
            }

            public boolean match(int string_position)
            {
                PatternElement next_element = next_element();
                if (next_element instanceof PatternEnd)
                    return true;
                while (string_position < _string_end)
                {
                    if (next_element.match(string_position))
                        return true;
                    string_position++;
                }
                return false;
            }
        }

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

        class OneChar extends PatternElement
        {
            public String toString()
            {
                StringBuffer buffer = new StringBuffer();
                buffer.append("OneChar: [");
                int i = 0;
                while (i < lo().length)
                {
                    char lo = lo()[i];
                    char hi = hi()[i];
                    buffer.append(lo);
                    if (lo != hi)
                    {
                        buffer.append('-');
                        buffer.append(hi);
                    }
                    i++;
                }
                buffer.append(']');
                return buffer.toString();
            }

            public boolean match(int string_position)
            {
                char c = _string[string_position++];
                char[] lo = lo();
                char[] hi = hi();
                for (int i = 0; i < lo.length; i++)
                    if (lo[i] <= c && c <= hi[i] &&
                        next_element().match(string_position))
                        return true;
                return false;
            }

            public void addChar(char c)
            {
                Character character = new Character(c);
                _lo.addElement(character);
                _hi.addElement(character);
            }

            public void defineRange(char c)
            {
                Character character = new Character(c);
                _hi.setElementAt(character, _hi.size() - 1);
            }

            private char[] lo()
            {
                if (_lo_array == null)
                {
                    _lo_array = new char[_lo.size()];
                    for (int i = 0; i < _lo_array.length; i++)
                        _lo_array[i] =
                            ((Character)_lo.elementAt(i)).charValue();
                }
                return _lo_array;
            }

            private char[] hi()
            {
                if (_hi_array == null)
                {
                    _hi_array = new char[_hi.size()];
                    for (int i = 0; i < _hi_array.length; i++)
                        _hi_array[i] =
                            ((Character)_hi.elementAt(i)).charValue();
                }
                return _hi_array;
            }

            private Vector _lo = new Vector();
            private Vector _hi = new Vector();
            private char[] _lo_array;
            private char[] _hi_array;
        }

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

        class Alternatives extends PatternElement
        {
            public String toString()
            {
                StringBuffer buffer = new StringBuffer();
                buffer.append("Alternatives: {");
                char[][] alternatives = alternatives();
                for (int i = 0; i < alternatives.length; i++)
                {
                    if (i > 0)
                        buffer.append(',');
                    buffer.append(alternatives[i]);
                }
                buffer.append('}');
                return buffer.toString();
            }
            
            public boolean match(int string_position)
            {
                char[][] alternatives = alternatives();
                for (int i = 0; i < alternatives.length; i++)
                {
                    char[] alternative = alternatives[i];
                    int length = alternative.length;
                    if (string_position + length <= _string_end)
                    {
                        int s = string_position;
                        int a = 0;
                        boolean eq = true;
                        while (a < length && eq)
                            eq = _string[s++] == alternative[a++];
                        if (eq && 
                            next_element().match
                            (string_position + length))
                            return true;
                    }
                }
                return false;
            }

            public void add(String alternative)
            {
                _alternatives.addElement(alternative);
            }

            private char[][] alternatives()
            {
                if (_alternatives_array == null)
                {
                    int n = _alternatives.size();
                    _alternatives_array = new char[n][];
                    for (int i = 0; i < n; i++)
                    {
                        String alternative =
                            (String) _alternatives.elementAt(i);
                        int length = alternative.length();
                        _alternatives_array[i] =
                            alternative.toCharArray();
                    }
                }
                return _alternatives_array;
            }
             
            private Vector _alternatives = new Vector();
            private char[][] _alternatives_array;
        }

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

        class AnyChar extends PatternElement
        {
            public String toString()
            {
                return "AnyChar: ?";
            }

            public boolean match(int string_position)
            {
                if (++string_position <= _string_end)
                    return next_element().match(string_position);
                return false;
            }
        }

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

        class Text extends Alternatives
        {
            public String toString()
            {
                return "Text: '" + _text + "'";
            }

            public Text(String text)
            {
                add(text);
                _text = text;
            }

            private String _text;
        }

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

        class PatternEnd extends PatternElement
        {
            public String toString()
            {
                return "PatternEnd";
            }

            public boolean match(int string_position)
            {
                return string_position == _string_end;
            }
        }
    }
}