xapian-core/api/valuerangeproc.cc

   1 /** @file valuerangeproc.cc
   2  * @brief Standard ValueRangeProcessor subclass implementations
   3  */
   4 /* Copyright (C) 2007,2008,2009,2010,2012 Olly Betts
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  19  */
  20
  21 #include <config.h>
  22
  23 #include <xapian/queryparser.h>
  24
  25 #include <cstdio> // For sprintf().
  26 #include <cstdlib> // For atoi().
  27 #include "safeerrno.h"
  28
  29 #include <string>
  30 #include "stringutils.h"
  31
  32 using namespace std;
  33
  34 namespace Xapian {
  35
  36 Xapian::valueno
  37 StringValueRangeProcessor::operator()(string &begin, string &end)
  38 {
  39     if (str.size()) {
  40         if (prefix) {
  41             // If there's a prefix, require it on the start of the range.
  42             if (!startswith(begin, str)) {
  43                 // Prefix not given.
  44                 return Xapian::BAD_VALUENO;
  45             }
  46             begin.erase(0, str.size());
  47             // But it's optional on the end of the range, e.g. $10..50
  48             if (startswith(end, str)) {
  49                 end.erase(0, str.size());
  50             }
  51         } else {
  52             // If there's a suffix, require it on the end of the range.
  53             if (!endswith(end, str)) {
  54                 // Suffix not given.
  55                 return Xapian::BAD_VALUENO;
  56             }
  57             end.resize(end.size() - str.size());
  58             // But it's optional on the start of the range, e.g. 10..50kg
  59             if (endswith(begin, str)) {
  60                 begin.resize(begin.size() - str.size());
  61             }
  62         }
  63     }
  64     return valno;
  65 }
  66
  67 static bool
  68 decode_xxy(const string & s, int & x1, int &x2, int &y)
  69 {
  70     if (s.size() == 0) {
  71         x1 = x2 = y = -1;
  72         return true;
  73     }
  74     if (s.size() < 5 || s.size() > 10) return false;
  75     size_t i = s.find_first_not_of("0123456789");
  76     if (i < 1 || i > 2 || !(s[i] == '/' || s[i] == '-' || s[i] == '.'))
  77         return false;
  78     size_t j = s.find_first_not_of("0123456789", i + 1);
  79     if (j - (i + 1) < 1 || j - (i + 1) > 2 ||
  80         !(s[j] == '/' || s[j] == '-' || s[j] == '.'))
  81         return false;
  82     if (s.size() - j > 4 + 1) return false;
  83     if (s.find_first_not_of("0123456789", j + 1) != string::npos)
  84         return false;
  85     x1 = atoi(s.c_str());
  86     if (x1 < 1 || x1 > 31) return false;
  87     x2 = atoi(s.c_str() + i + 1);
  88     if (x2 < 1 || x2 > 31) return false;
  89     y = atoi(s.c_str() + j + 1);
  90     return true;
  91 }
  92
  93 // We just use this to decide if an ambiguous aa/bb/cc date could be a
  94 // particular format, so there's no need to be anal about the exact number of
  95 // days in February.  The most useful check is that the month field is <= 12
  96 // so we could just check the day is <= 31 really.
  97 static const char max_month_length[12] = {
  98     31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
  99 };
 100
 101 static bool
 102 vet_dm(int d, int m)
 103 {
 104     if (m == -1) return true;
 105     if (m > 12 || m < 1) return false;
 106     if (d < 1 || d > max_month_length[m - 1]) return false;
 107     return true;
 108 }
 109
 110 // NB Assumes the length has been checked to be 10 already.
 111 static bool
 112 is_yyyy_mm_dd(const string &s)
 113 {
 114     return (s.find_first_not_of("0123456789") == 4 &&
 115             s.find_first_not_of("0123456789", 5) == 7 &&
 116             s.find_first_not_of("0123456789", 8) == string::npos &&
 117             s[4] == s[7] &&
 118             (s[4] == '-' || s[4] == '.' || s[4] == '/'));
 119 }
 120
 121 Xapian::valueno
 122 DateValueRangeProcessor::operator()(string &begin, string &end)
 123 {
 124     if (StringValueRangeProcessor::operator()(begin, end) == BAD_VALUENO)
 125         return BAD_VALUENO;
 126
 127     if ((begin.size() == 8 || begin.size() == 0) &&
 128         (end.size() == 8 || end.size() == 0) &&
 129         begin.find_first_not_of("0123456789") == string::npos &&
 130         end.find_first_not_of("0123456789") == string::npos) {
 131         // YYYYMMDD
 132         return valno;
 133     }
 134     if ((begin.size() == 10 || begin.size() == 0) &&
 135         (end.size() == 10 || end.size() == 0)) {
 136         if ((begin.empty() || is_yyyy_mm_dd(begin)) &&
 137             (end.empty() || is_yyyy_mm_dd(end))) {
 138             // YYYY-MM-DD
 139             if (!begin.empty()) {
 140                 begin.erase(7, 1);
 141                 begin.erase(4, 1);
 142             }
 143             if (!end.empty()) {
 144                 end.erase(7, 1);
 145                 end.erase(4, 1);
 146             }
 147             return valno;
 148         }
 149     }
 150
 151     int b_d, b_m, b_y;
 152     int e_d, e_m, e_y;
 153     if (!decode_xxy(begin, b_d, b_m, b_y) || !decode_xxy(end, e_d, e_m, e_y))
 154         return Xapian::BAD_VALUENO;
 155
 156     // Check that the month and day are within range.  Also assume "start" <=
 157     // "end" to help decide ambiguous cases.
 158     if (!prefer_mdy && vet_dm(b_d, b_m) && vet_dm(e_d, e_m) &&
 159         (b_y != e_y || b_m < e_m || (b_m == e_m && b_d <= e_d))) {
 160         // OK.
 161     } else if (vet_dm(b_m, b_d) && vet_dm(e_m, e_d) &&
 162         (b_y != e_y || b_d < e_d || (b_d == e_d && b_m <= e_m))) {
 163         swap(b_m, b_d);
 164         swap(e_m, e_d);
 165     } else if (prefer_mdy && vet_dm(b_d, b_m) && vet_dm(e_d, e_m) &&
 166                (b_y != e_y || b_m < e_m || (b_m == e_m && b_d <= e_d))) {
 167         // OK.
 168     } else {
 169         return Xapian::BAD_VALUENO;
 170     }
 171
 172     if (b_y < 100) {
 173         b_y += 1900;
 174         if (b_y < epoch_year) b_y += 100;
 175     }
 176     if (e_y < 100) {
 177         e_y += 1900;
 178         if (e_y < epoch_year) e_y += 100;
 179     }
 180
 181 #ifdef SNPRINTF
 182     char buf[9];
 183     if (!begin.empty()) {
 184         SNPRINTF(buf, sizeof(buf), "%08d", b_y * 10000 + b_m * 100 + b_d);
 185         begin.assign(buf, 8);
 186     }
 187     if (!end.empty()) {
 188         SNPRINTF(buf, sizeof(buf), "%08d", e_y * 10000 + e_m * 100 + e_d);
 189         end.assign(buf, 8);
 190     }
 191 #else
 192     char buf[100];
 193     buf[sizeof(buf) - 1] = '\0';
 194     if (!begin.empty()) {
 195         sprintf(buf, "%08d", b_y * 10000 + b_m * 100 + b_d);
 196         if (buf[sizeof(buf) - 1]) abort(); // Buffer overrun!
 197         begin.assign(buf, 8);
 198     }
 199     if (!end.empty()) {
 200         sprintf(buf, "%08d", e_y * 10000 + e_m * 100 + e_d);
 201         if (buf[sizeof(buf) - 1]) abort(); // Buffer overrun!
 202         end.assign(buf, 8);
 203     }
 204 #endif
 205     return valno;
 206 }
 207
 208 Xapian::valueno
 209 NumberValueRangeProcessor::operator()(string &begin, string &end)
 210 {
 211     if (StringValueRangeProcessor::operator()(begin, end) == BAD_VALUENO)
 212         return BAD_VALUENO;
 213
 214     // Parse the numbers to floating point.
 215     double beginnum;
 216
 217     if (!begin.empty()) {
 218         errno = 0;
 219         const char * startptr = begin.c_str();
 220         char * endptr;
 221         beginnum = strtod(startptr, &endptr);
 222         if (endptr != startptr + begin.size())
 223             // Invalid characters in string
 224             return Xapian::BAD_VALUENO;
 225         if (errno)
 226             // Overflow or underflow
 227             return Xapian::BAD_VALUENO;
 228     } else {
 229         // Silence GCC warning.
 230         beginnum = 0.0;
 231     }
 232
 233     if (!end.empty()) {
 234         errno = 0;
 235         const char * startptr = end.c_str();
 236         char * endptr;
 237         double endnum = strtod(startptr, &endptr);
 238         if (endptr != startptr + end.size())
 239             // Invalid characters in string
 240             return Xapian::BAD_VALUENO;
 241         if (errno)
 242             // Overflow or underflow
 243             return Xapian::BAD_VALUENO;
 244         end.assign(Xapian::sortable_serialise(endnum));
 245     }
 246
 247     if (!begin.empty()) {
 248         begin.assign(Xapian::sortable_serialise(beginnum));
 249     }
 250
 251     return valno;
 252 }
 253
 254 }