Changeset 3046 in josm for trunk


Ignore:
Timestamp:
2010-02-26T18:55:43+01:00 (10 years ago)
Author:
mjulius
Message:

fixes #4597 - Search for timestamp:2010-02 no longer works

Searching for strings starting with digits should not require quotes anymore.

Location:
trunk/src/org/openstreetmap/josm/actions/search
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/org/openstreetmap/josm/actions/search/PushbackTokenizer.java

    r2993 r3046  
    77import java.io.IOException;
    88import java.io.Reader;
     9import java.util.Arrays;
     10import java.util.List;
    911
    1012import org.openstreetmap.josm.actions.search.SearchCompiler.ParseError;
     
    3436    private Token currentToken;
    3537    private String currentText;
    36     private long currentNumber;
    37     private long currentRange;
     38    private Long currentNumber;
     39    private Long currentRange;
    3840    private int c;
    3941
     
    4648        NOT(marktr("<not>")), OR(marktr("<or>")), LEFT_PARENT(marktr("<left parent>")),
    4749        RIGHT_PARENT(marktr("<right parent>")), COLON(marktr("<colon>")), EQUALS(marktr("<equals>")),
    48         KEY(marktr("<key>")), QUESTION_MARK(marktr("<question mark>")), NUMBER(marktr("<number>")),
    49         RANGE(marktr("range")), EOF(marktr("<end-of-file>"));
     50        KEY(marktr("<key>")), QUESTION_MARK(marktr("<question mark>")),
     51        EOF(marktr("<end-of-file>"));
    5052
    5153        private Token(String name) {
     
    7779        }
    7880        return result;
     81    }
     82
     83    private static final List<Integer> specialChars = Arrays.asList(new Integer[] {'"', ':', '(', ')', '|', '=', '?'});
     84    private static final List<Integer> specialCharsQuoted = Arrays.asList(new Integer[] {'"'});
     85
     86    private String getString(boolean quoted) {
     87        List<Integer> sChars = quoted ? specialCharsQuoted : specialChars;
     88        StringBuilder s = new StringBuilder();
     89        boolean escape = false;
     90        while (c != -1 && (escape || (!sChars.contains(c) && (quoted || !Character.isWhitespace(c))))) {
     91            if (c == '\\' && !escape) {
     92                escape = true;
     93            } else {
     94                s.append((char)c);
     95                escape = false;
     96            }
     97            getChar();
     98        }
     99        return s.toString();
     100    }
     101
     102    private String getString() {
     103        return getString(false);
    79104    }
    80105
     
    107132            getChar();
    108133            return Token.EQUALS;
    109         case '-':
    110             getChar();
    111             if (Character.isDigit(c)) {
    112                 currentNumber = -1 * getNumber();
    113                 return Token.NUMBER;
    114             } else
    115                 return Token.NOT;
    116134        case '(':
    117135            getChar();
     
    127145            return Token.QUESTION_MARK;
    128146        case '"':
    129         {
    130             getChar();
    131             StringBuilder s = new StringBuilder();
    132             boolean escape = false;
    133             while (c != -1 && (c != '"' || escape)) {
    134                 if (c == '\\' && !escape) {
    135                     escape = true;
    136                 } else {
    137                     s.append((char)c);
    138                     escape = false;
    139                 }
     147            getChar();
     148            currentText = getString(true);
     149            getChar();
     150            return Token.KEY;
     151        default:
     152            String prefix = "";
     153            if (c == '-') {
    140154                getChar();
    141             }
    142             getChar();
    143             currentText = s.toString();
    144             return Token.KEY;
    145         }
    146         default:
    147         {
    148             if (Character.isDigit(c)) {
    149                 currentNumber = getNumber();
    150                 if (c == '-') {
    151                     getChar();
    152                     currentRange = getNumber();
    153                     return Token.RANGE;
    154                 } else
    155                     return Token.NUMBER;
    156 
    157             }
    158 
    159             StringBuilder s = new StringBuilder();
    160             while (!(c == -1 || Character.isWhitespace(c) || c == '"'|| c == ':' || c == '(' || c == ')' || c == '|' || c == '=' || c == '?')) {
    161                 s.append((char)c);
    162                 getChar();
    163             }
    164             currentText = s.toString();
     155                if (!Character.isDigit(c))
     156                    return Token.NOT;
     157                prefix = "-";
     158            }
     159            currentText = prefix + getString();
    165160            if ("or".equals(currentText))
    166161                return Token.OR;
    167             else
    168                 return Token.KEY;
    169         }
     162            try {
     163                currentNumber = Long.parseLong(currentText);
     164            } catch (NumberFormatException e) {
     165                currentNumber = null;
     166            }
     167            int pos = currentText.indexOf('-', 1);
     168            if (pos > 0) {
     169                try {
     170                    currentNumber = Long.parseLong(currentText.substring(0, pos));
     171                    currentRange = Long.parseLong(currentText.substring(pos + 1));
     172                } catch (NumberFormatException e) {
     173                    currentNumber = null;
     174                    currentRange = null;
     175                }
     176            }
     177            return Token.KEY;
    170178        }
    171179    }
     
    183191        if (nextTok == Token.KEY)
    184192            return currentText;
    185         if (nextTok == Token.NUMBER)
    186             return String.valueOf(currentNumber);
    187193        currentToken = nextTok;
    188194        return null;
     
    190196
    191197    public long readNumber(String errorMessage) throws ParseError {
    192         if (nextToken() == Token.NUMBER)
     198        if ((nextToken() == Token.KEY) && (currentNumber != null))
    193199            return currentNumber;
    194200        else
     
    197203
    198204    public long getReadNumber() {
    199         return currentNumber;
    200     }
    201 
    202     public Range readRange() throws ParseError {
    203         Token token = nextToken();
    204         if (token == Token.NUMBER)
    205             return new Range(currentNumber, currentNumber);
    206         else if (token == Token.RANGE)
    207             return new Range(currentNumber, currentRange);
    208         else
    209             throw new ParseError(Token.NUMBER, token);
     205        return (currentNumber != null) ? currentNumber : 0;
     206    }
     207
     208    public Range readRange(String errorMessage) throws ParseError {
     209        if ((nextToken() == Token.KEY) && (currentNumber != null)) {
     210            if (currentRange == null)
     211                return new Range(currentNumber, currentNumber);
     212            else
     213                return new Range(currentNumber, currentRange);
     214        } else
     215            throw new ParseError(errorMessage);
    210216    }
    211217
  • trunk/src/org/openstreetmap/josm/actions/search/SearchCompiler.java

    r2995 r3046  
    653653                    return new Id(tokenizer.readNumber(tr("Primitive id expected")));
    654654                else if ("tags".equals(key)) {
    655                     Range range = tokenizer.readRange();
     655                    Range range = tokenizer.readRange(tr("Range of numbers expected"));
    656656                    return new TagCountRange((int)range.getStart(), (int)range.getEnd());
    657657                } else if ("nodes".equals(key)) {
    658                     Range range = tokenizer.readRange();
     658                    Range range = tokenizer.readRange(tr("Range of numbers expected"));
    659659                    return new NodeCountRange((int)range.getStart(), (int)range.getEnd());
    660660                } else if ("changeset".equals(key))
Note: See TracChangeset for help on using the changeset viewer.