Changeset 335

Show
Ignore:
Timestamp:
08/10/06 00:45:40 (2 years ago)
Author:
alo
Message:

--

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • cherokee/branches/0.5/ChangeLog

    r334 r335  
     12006-08-09  A.D.F  <adefacc@tin.it> 
     2 
     3        * cherokee/tdate_parse.c: Quite big performance patch has been 
     4        applied. 
     5 
    162006-08-07  Alvaro Lopez Ortega  <alvaro@alobbs.com> 
    27 
  • cherokee/branches/0.5/cherokee/tdate_parse.c

    r114 r335  
    2626*/ 
    2727 
    28 /* This is a stripped-down version of date_parse.c, available at 
     28/* This is a stripped-down / modified version of date_parse.c, available at 
    2929** http://www.acme.com/software/date_parse/ 
    3030*/ 
     
    5858                                    *str = tolower( (int) *str ); 
    5959           } 
    60 } 
    61  
    62 static int 
    63 strlong_compare (void *v1, void *v2) 
    64 { 
    65            return strcmp( ((struct strlong*) v1)->s, ((struct strlong*) v2)->s ); 
    6660} 
    6761 
     
    9791{ 
    9892           static struct strlong wday_tab[] = { 
    99                          { "sun", 0 }, { "sunday", 0 }, 
    100                          { "mon", 1 }, { "monday", 1 }, 
    101                          { "tue", 2 }, { "tuesday", 2 }, 
    102                          { "wed", 3 }, { "wednesday", 3 }, 
    103                          { "thu", 4 }, { "thursday", 4 }, 
    104                          { "fri", 5 }, { "friday", 5 }, 
    105                          { "sat", 6 }, { "saturday", 6 }, 
    106            }; 
    107            static int sorted = 0; 
    108  
    109            if ( ! sorted ) 
    110            { 
    111                          (void) qsort( 
    112                                     wday_tab, sizeof(wday_tab)/sizeof(struct strlong), 
    113                                     sizeof(struct strlong), strlong_compare ); 
    114                          sorted = 1; 
    115            } 
     93                        { "fri",       5 }, 
     94                        { "friday",    5 }, 
     95                        { "mon",       1 }, 
     96                        { "monday",    1 }, 
     97                        { "sat",       6 }, 
     98                        { "saturday",  6 }, 
     99                        { "sun",       0 }, 
     100                        { "sunday",    0 }, 
     101                        { "thu",       4 }, 
     102                        { "thursday",  4 }, 
     103                        { "tue",       2 }, 
     104                        { "tuesday",   2 }, 
     105                        { "wed",       3 }, 
     106                        { "wednesday", 3 } 
     107                }; 
     108 
    116109           pound_case( str_wday ); 
    117110           return strlong_search( 
    118                         str_wday, wday_tab, sizeof(wday_tab)/sizeof(struct strlong), tm_wdayP ); 
     111                str_wday, wday_tab, sizeof(wday_tab)/sizeof(struct strlong), tm_wdayP ); 
    119112} 
    120113 
     
    124117{ 
    125118           static struct strlong mon_tab[] = { 
    126                          { "jan", 0 }, { "january", 0 }, 
    127                          { "feb", 1 }, { "february", 1 }, 
    128                          { "mar", 2 }, { "march", 2 }, 
    129                          { "apr", 3 }, { "april", 3 }, 
    130                          { "may", 4 }, 
    131                          { "jun", 5 }, { "june", 5 }, 
    132                          { "jul", 6 }, { "july", 6 }, 
    133                          { "aug", 7 }, { "august", 7 }, 
    134                          { "sep", 8 }, { "september", 8 }, 
    135                          { "oct", 9 }, { "october", 9 }, 
    136                          { "nov", 10 }, { "november", 10 }, 
    137                          { "dec", 11 }, { "december", 11 }, 
    138            }; 
    139            static int sorted = 0; 
    140  
    141            if ( ! sorted ) 
    142            { 
    143                          (void) qsort( 
    144                                     mon_tab, sizeof(mon_tab)/sizeof(struct strlong), 
    145                                     sizeof(struct strlong), strlong_compare ); 
    146                          sorted = 1; 
    147            } 
     119                        { "apr",       3 }, 
     120                        { "april",     3 }, 
     121                        { "aug",       7 }, 
     122                        { "august",    7 }, 
     123                        { "dec",      11 }, 
     124                        { "december", 11 }, 
     125                        { "feb",       1 }, 
     126                        { "february",  1 }, 
     127                        { "jan",       0 }, 
     128                        { "january",   0 }, 
     129                        { "jul",       6 }, 
     130                        { "july",      6 }, 
     131                        { "jun",       5 }, 
     132                        { "june",      5 }, 
     133                        { "mar",       2 }, 
     134                        { "march",     2 }, 
     135                        { "may",       4 }, 
     136                        { "nov",      10 }, 
     137                        { "november", 10 }, 
     138                        { "oct",       9 }, 
     139                        { "october",   9 }, 
     140                        { "sep",       8 }, 
     141                        { "september", 8 } 
     142                }; 
     143 
    148144           pound_case( str_mon ); 
    149145           return strlong_search( 
    150                         str_mon, mon_tab, sizeof(mon_tab)/sizeof(struct strlong), tm_monP ); 
     146                str_mon, mon_tab, sizeof(mon_tab)/sizeof(struct strlong), tm_monP ); 
    151147} 
    152148 
     
    187183 
    188184 
     185/* 
     186** Parse the date-time string and returns the equivalent time in seconds. 
     187*/ 
    189188time_t 
    190189tdate_parse( char* str ) 
     
    192191           struct tm tm; 
    193192           char* cp; 
    194            char str_mon[500], str_wday[500]; 
     193           char str_mon[64], str_wday[64]; 
     194           char str_sep1[8], str_sep2[8]; 
    195195           int tm_sec, tm_min, tm_hour, tm_mday, tm_year; 
    196196           long tm_mon, tm_wday; 
     
    203203           for ( cp = str; *cp == ' ' || *cp == '\t'; ++cp ) 
    204204                         continue; 
     205 
     206           /* If there is no date-time, then return now */ 
     207           if ( !*cp ) 
     208                    return (time_t) -1; 
    205209 
    206210           /* And do the sscanfs.  WARNING: you can add more formats here, 
     
    209213           */ 
    210214 
     215           /* wdy, DD mth YYYY HH:MM:SS GMT (RFC 822, 1123 - standard). */ 
     216           if ( sscanf( cp, "%60[a-zA-Z], %d %60[a-zA-Z] %d %d:%d:%d GMT", 
     217                        str_wday, &tm_mday, str_mon, &tm_year, 
     218                        &tm_hour, &tm_min, &tm_sec ) == 7 && 
     219                    scan_wday( str_wday, &tm_wday ) && 
     220                    scan_mon( str_mon, &tm_mon ) ) 
     221           { 
     222                        tm.tm_wday = tm_wday; 
     223                        tm.tm_mday = tm_mday; 
     224                        tm.tm_mon = tm_mon; 
     225                        tm.tm_year = tm_year; 
     226                        tm.tm_hour = tm_hour; 
     227                        tm.tm_min = tm_min; 
     228                        tm.tm_sec = tm_sec; 
     229           } 
     230 
     231           /* wdy, DD-mth-YY HH:MM:SS GMT  (RFC 850 - obsolete) */ 
     232           /* wdy, DD-mth-YYYY HH:MM:SS GMT (strange RFC 822) */ 
     233           else 
     234           if ( sscanf( cp, "%60[a-zA-Z], %d%2[ -]%60[a-zA-Z]%2[ -]%d %d:%d:%d GMT", 
     235                        str_wday, &tm_mday, str_sep1, str_mon, str_sep2, &tm_year, 
     236                        &tm_hour, &tm_min, &tm_sec ) == 9 && 
     237                    scan_wday( str_wday, &tm_wday ) && 
     238                    scan_mon( str_mon, &tm_mon ) ) 
     239           { 
     240                        tm.tm_wday = tm_wday; 
     241                        tm.tm_mday = tm_mday; 
     242                        tm.tm_mon = tm_mon; 
     243                        tm.tm_year = tm_year; 
     244                        tm.tm_hour = tm_hour; 
     245                        tm.tm_min = tm_min; 
     246                        tm.tm_sec = tm_sec; 
     247           } 
     248 
     249           /* wdy mth DD HH:MM:SS YYYY (ANSI C asctime() format - uncommon) */ 
     250           else 
     251           if ( sscanf( cp, "%60[a-zA-Z] %60[a-zA-Z] %d %d:%d:%d %d", 
     252                        str_wday, str_mon, &tm_mday, &tm_hour, &tm_min, &tm_sec, 
     253                        &tm_year ) == 7 && 
     254                    scan_wday( str_wday, &tm_wday ) && 
     255                    scan_mon( str_mon, &tm_mon ) ) 
     256           { 
     257                        tm.tm_wday = tm_wday; 
     258                        tm.tm_mon = tm_mon; 
     259                        tm.tm_mday = tm_mday; 
     260                        tm.tm_hour = tm_hour; 
     261                        tm.tm_min = tm_min; 
     262                        tm.tm_sec = tm_sec; 
     263                        tm.tm_year = tm_year; 
     264           } 
     265           /* other VERY VERY UNCOMMON formats */ 
     266 
     267           /* wdy mth DD HH:MM:SS GMT YY */ 
     268           else 
     269           if ( sscanf( cp, "%60[a-zA-Z] %60[a-zA-Z] %d %d:%d:%d GMT %d", 
     270                        str_wday, str_mon, &tm_mday, &tm_hour, &tm_min, &tm_sec, 
     271                        &tm_year ) == 7 && 
     272                    scan_wday( str_wday, &tm_wday ) && 
     273                    scan_mon( str_mon, &tm_mon ) ) 
     274           { 
     275                        tm.tm_wday = tm_wday; 
     276                        tm.tm_mon = tm_mon; 
     277                        tm.tm_mday = tm_mday; 
     278                        tm.tm_hour = tm_hour; 
     279                        tm.tm_min = tm_min; 
     280                        tm.tm_sec = tm_sec; 
     281                        tm.tm_year = tm_year; 
     282           } 
     283 
    211284           /* DD-mth-YY HH:MM:SS GMT */ 
    212            if ( sscanf( cp, "%d-%400[a-zA-Z]-%d %d:%d:%d GMT", 
    213                                  &tm_mday, str_mon, &tm_year, &tm_hour, &tm_min, 
    214                                  &tm_sec ) == 6 && 
    215                    scan_mon( str_mon, &tm_mon ) ) 
    216            { 
    217                          tm.tm_mday = tm_mday; 
    218                          tm.tm_mon = tm_mon; 
    219                          tm.tm_year = tm_year; 
    220                          tm.tm_hour = tm_hour; 
    221                          tm.tm_min = tm_min; 
    222                          tm.tm_sec = tm_sec; 
    223            } 
    224  
    225285           /* DD mth YY HH:MM:SS GMT */ 
    226            else if ( sscanf( cp, "%d %400[a-zA-Z] %d %d:%d:%d GMT", 
    227                                          &tm_mday, str_mon, &tm_year, &tm_hour, &tm_min, 
    228                                          &tm_sec) == 6 && 
    229                            scan_mon( str_mon, &tm_mon ) ) 
    230            { 
    231                          tm.tm_mday = tm_mday; 
    232                          tm.tm_mon = tm_mon; 
    233                          tm.tm_year = tm_year; 
    234                          tm.tm_hour = tm_hour; 
    235                          tm.tm_min = tm_min; 
    236                          tm.tm_sec = tm_sec; 
     286           else 
     287           if ( sscanf( cp, "%d%2[ -]%60[a-zA-Z]%2[ -]%d %d:%d:%d GMT", 
     288                        &tm_mday, str_sep1, str_mon, str_sep2, &tm_year, 
     289                        &tm_hour, &tm_min, &tm_sec ) == 8 && 
     290                    scan_mon( str_mon, &tm_mon ) ) 
     291           { 
     292                        tm.tm_mday = tm_mday; 
     293                        tm.tm_mon = tm_mon; 
     294                        tm.tm_year = tm_year; 
     295                        tm.tm_hour = tm_hour; 
     296                        tm.tm_min = tm_min; 
     297                        tm.tm_sec = tm_sec; 
    237298           } 
    238299 
    239300           /* HH:MM:SS GMT DD-mth-YY */ 
    240            else if ( sscanf( cp, "%d:%d:%d GMT %d-%400[a-zA-Z]-%d", 
    241                                          &tm_hour, &tm_min, &tm_sec, &tm_mday, str_mon, 
    242                                          &tm_year ) == 6 && 
    243                            scan_mon( str_mon, &tm_mon ) ) 
    244            { 
    245                          tm.tm_hour = tm_hour; 
    246                          tm.tm_min = tm_min; 
    247                          tm.tm_sec = tm_sec; 
    248                          tm.tm_mday = tm_mday; 
    249                          tm.tm_mon = tm_mon; 
    250                          tm.tm_year = tm_year; 
    251            } 
    252  
    253301           /* HH:MM:SS GMT DD mth YY */ 
    254            else if ( sscanf( cp, "%d:%d:%d GMT %d %400[a-zA-Z] %d", 
    255                                          &tm_hour, &tm_min, &tm_sec, &tm_mday, str_mon, 
    256                                          &tm_year ) == 6 && 
    257                            scan_mon( str_mon, &tm_mon ) ) 
    258            { 
    259                          tm.tm_hour = tm_hour; 
    260                          tm.tm_min = tm_min; 
    261                          tm.tm_sec = tm_sec; 
    262                          tm.tm_mday = tm_mday; 
    263                          tm.tm_mon = tm_mon; 
    264                          tm.tm_year = tm_year; 
    265            } 
    266  
    267            /* wdy, DD-mth-YY HH:MM:SS GMT */ 
    268            else if ( sscanf( cp, "%400[a-zA-Z], %d-%400[a-zA-Z]-%d %d:%d:%d GMT", 
    269                                          str_wday, &tm_mday, str_mon, &tm_year, &tm_hour, &tm_min, 
    270                                          &tm_sec ) == 7 && 
    271                            scan_wday( str_wday, &tm_wday ) && 
    272                            scan_mon( str_mon, &tm_mon ) ) 
    273            { 
    274                          tm.tm_wday = tm_wday; 
    275                          tm.tm_mday = tm_mday; 
    276                          tm.tm_mon = tm_mon; 
    277                          tm.tm_year = tm_year; 
    278                          tm.tm_hour = tm_hour; 
    279                          tm.tm_min = tm_min; 
    280                          tm.tm_sec = tm_sec; 
    281            } 
    282  
    283            /* wdy, DD mth YY HH:MM:SS GMT */ 
    284            else if ( sscanf( cp, "%400[a-zA-Z], %d %400[a-zA-Z] %d %d:%d:%d GMT", 
    285                                          str_wday, &tm_mday, str_mon, &tm_year, &tm_hour, &tm_min, 
    286                                          &tm_sec ) == 7 && 
    287                            scan_wday( str_wday, &tm_wday ) && 
    288                            scan_mon( str_mon, &tm_mon ) ) 
    289            { 
    290                          tm.tm_wday = tm_wday; 
    291                          tm.tm_mday = tm_mday; 
    292                          tm.tm_mon = tm_mon; 
    293                          tm.tm_year = tm_year; 
    294                          tm.tm_hour = tm_hour; 
    295                          tm.tm_min = tm_min; 
    296                          tm.tm_sec = tm_sec; 
    297            } 
    298  
    299            /* wdy mth DD HH:MM:SS GMT YY */ 
    300            else if ( sscanf( cp, "%400[a-zA-Z] %400[a-zA-Z] %d %d:%d:%d GMT %d", 
    301                                          str_wday, str_mon, &tm_mday, &tm_hour, &tm_min, &tm_sec, 
    302                                          &tm_year ) == 7 && 
    303                            scan_wday( str_wday, &tm_wday ) && 
    304                            scan_mon( str_mon, &tm_mon ) ) 
    305            { 
    306                          tm.tm_wday = tm_wday; 
    307                          tm.tm_mon = tm_mon; 
    308                          tm.tm_mday = tm_mday; 
    309                          tm.tm_hour = tm_hour; 
    310                          tm.tm_min = tm_min; 
    311                          tm.tm_sec = tm_sec; 
    312                          tm.tm_year = tm_year; 
    313            } 
    314            else 
    315                          return (time_t) -1; 
     302           else 
     303           if ( sscanf( cp, "%d:%d:%d GMT %d%2[ -]%60[a-zA-Z]%2[ -]%d", 
     304                        &tm_hour, &tm_min, &tm_sec, 
     305                        &tm_mday, str_sep1, str_mon, str_sep2, &tm_year ) == 8 && 
     306                    scan_mon( str_mon, &tm_mon ) ) 
     307           { 
     308                        tm.tm_hour = tm_hour; 
     309                        tm.tm_min = tm_min; 
     310                        tm.tm_sec = tm_sec; 
     311                        tm.tm_mday = tm_mday; 
     312                        tm.tm_mon = tm_mon; 
     313                        tm.tm_year = tm_year; 
     314           } 
     315           else 
     316                        return (time_t) -1; 
    316317 
    317318           if ( tm.tm_year > 1900 )