Ignore:
Timestamp:
Nov 22, 2005 11:51:50 PM (17 years ago)
Author:
bennylp
Message:

More optimizations for msg parser etc.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • pjproject/trunk/pjlib-util/src/pjlib-util/scanner.c

    r73 r77  
    2424#include <pj/assert.h> 
    2525 
    26 #define PJ_SCAN_IS_SPACE(c)     ((c)==' ' || (c)=='\t') 
    27 #define PJ_SCAN_IS_NEWLINE(c)   ((c)=='\r' || (c)=='\n') 
    28 #define PJ_SCAN_CHECK_EOF(s)    (s != end) 
     26#define PJ_SCAN_IS_SPACE(c)             ((c)==' ' || (c)=='\t') 
     27#define PJ_SCAN_IS_NEWLINE(c)           ((c)=='\r' || (c)=='\n') 
     28#define PJ_SCAN_IS_PROBABLY_SPACE(c)    ((c) <= 32) 
     29#define PJ_SCAN_CHECK_EOF(s)            (*s) 
    2930 
    3031 
    … …  
    108109    scanner->end = bufstart + buflen; 
    109110    scanner->line = 1; 
    110     scanner->col = 1; 
     111    scanner->start_line = scanner->begin; 
    111112    scanner->callback = callback; 
    112113    scanner->skip_ws = options; 
    … …  
    114115    if (scanner->skip_ws)  
    115116        pj_scan_skip_whitespace(scanner); 
    116  
    117     scanner->col = scanner->curptr - scanner->begin + 1; 
    118117} 
    119118 
    … …  
    129128    register char *s = scanner->curptr; 
    130129 
    131     PJ_CHECK_STACK(); 
    132  
    133130    while (PJ_SCAN_IS_SPACE(*s)) { 
    134131        ++s; 
    135132    } 
    136133 
    137     if ((scanner->skip_ws & PJ_SCAN_AUTOSKIP_NEWLINE) && PJ_SCAN_IS_NEWLINE(*s)) { 
     134    if (PJ_SCAN_IS_NEWLINE(*s) && (scanner->skip_ws & PJ_SCAN_AUTOSKIP_NEWLINE)) { 
    138135        for (;;) { 
    139136            if (*s == '\r') { 
    … …  
    141138                if (*s == '\n') ++s; 
    142139                ++scanner->line; 
    143                 scanner->col = 1; 
    144                 scanner->curptr = s; 
     140                scanner->curptr = scanner->start_line = s; 
    145141            } else if (*s == '\n') { 
    146142                ++s; 
    147143                ++scanner->line; 
    148                 scanner->col = 1; 
    149                 scanner->curptr = s; 
     144                scanner->curptr = scanner->start_line = s; 
    150145            } else if (PJ_SCAN_IS_SPACE(*s)) { 
    151146                do { 
    … …  
    160155    if (PJ_SCAN_IS_NEWLINE(*s) && (scanner->skip_ws & PJ_SCAN_AUTOSKIP_WS_HEADER)==PJ_SCAN_AUTOSKIP_WS_HEADER) { 
    161156        /* Check for header continuation. */ 
    162         scanner->col += s - scanner->curptr; 
    163157        scanner->curptr = s; 
    164158 
    … …  
    169163            ++s; 
    170164        } 
     165        scanner->start_line = s; 
     166 
    171167        if (PJ_SCAN_IS_SPACE(*s)) { 
    172168            register char *t = s; 
    … …  
    176172 
    177173            ++scanner->line; 
    178             scanner->col = t-s; 
    179174            scanner->curptr = t; 
    180175        } 
    181176    } else { 
    182         scanner->col += s - scanner->curptr; 
    183177        scanner->curptr = s; 
     178    } 
     179} 
     180 
     181PJ_DEF(void) pj_scan_skip_line( pj_scanner *scanner ) 
     182{ 
     183    char *s = pj_native_strchr(scanner->curptr, '\n'); 
     184    if (!s) { 
     185        scanner->curptr = scanner->end; 
     186    } else { 
     187        scanner->curptr = scanner->start_line = s+1; 
     188        scanner->line++; 
     189        if (PJ_SCAN_IS_PROBABLY_SPACE(*s) && scanner->skip_ws) { 
     190            pj_scan_skip_whitespace(scanner);     
     191        } 
    184192    } 
    185193} 
    … …  
    189197{ 
    190198    register char *s = scanner->curptr; 
    191     register char *end = scanner->end; 
    192  
    193     PJ_CHECK_STACK(); 
    194  
    195     if (pj_scan_is_eof(scanner)) { 
     199 
     200    if (s >= scanner->end) { 
    196201        pj_scan_syntax_err(scanner); 
    197202        return -1; 
    198203    } 
    199204 
    200     while (PJ_SCAN_CHECK_EOF(s) && pj_cis_match(spec, *s)) 
    201         ++s; 
    202  
    203     pj_strset3(out, scanner->curptr, s); 
    204     return s < scanner->end ? *s : 0; 
     205    /* Don't need to check EOF with PJ_SCAN_CHECK_EOF(s) */ 
     206    while (pj_cis_match(spec, *s)) 
     207        ++s; 
     208 
     209    pj_strset3(out, scanner->curptr, s); 
     210    return *s; 
    205211} 
    206212 
    … …  
    210216{ 
    211217    char *endpos = scanner->curptr + len; 
    212  
    213     PJ_CHECK_STACK(); 
    214218 
    215219    if (endpos > scanner->end) { 
    … …  
    228232{ 
    229233    register char *s = scanner->curptr; 
    230     register char *end = scanner->end; 
    231  
    232     PJ_CHECK_STACK(); 
    233  
    234     if (pj_scan_is_eof(scanner)) { 
     234 
     235    if (s >= scanner->end) { 
    235236        pj_scan_syntax_err(scanner); 
    236237        return -1; 
    … …  
    241242 
    242243    pj_strset3(out, scanner->curptr, s); 
    243     return s!=scanner->end ? *s : 0; 
     244    return *s; 
    244245} 
    245246 
    … …  
    249250{ 
    250251    register char *s = scanner->curptr; 
    251     register char *end = scanner->end; 
    252     char *start = s; 
    253  
    254     PJ_CHECK_STACK(); 
    255252 
    256253    pj_assert(pj_cis_match(spec,0)==0); 
    257254 
    258     if (pj_scan_is_eof(scanner) || !pj_cis_match(spec, *s)) { 
     255    /* EOF is detected implicitly */ 
     256    if (!pj_cis_match(spec, *s)) { 
    259257        pj_scan_syntax_err(scanner); 
    260258        return; 
    … …  
    271269    pj_strset3(out, scanner->curptr, s); 
    272270 
    273     scanner->col += (s - start); 
    274271    scanner->curptr = s; 
    275272 
    276     if (scanner->skip_ws) { 
     273    if (PJ_SCAN_IS_PROBABLY_SPACE(*s) && scanner->skip_ws) { 
    277274        pj_scan_skip_whitespace(scanner);     
    278275    } 
    … …  
    285282{ 
    286283    register char *s = scanner->curptr; 
    287     register char *end = scanner->end; 
    288     char *start = s; 
    289284     
    290     PJ_CHECK_STACK(); 
    291  
    292285    /* Check and eat the begin_quote. */ 
    293286    if (*s != begin_quote) { 
    … …  
    301294    do { 
    302295        /* loop until end_quote is found. */ 
    303         do { 
     296        while (*s && *s != '\n' && *s != end_quote) { 
    304297            ++s; 
    305         } while (s != end && *s != '\n' && *s != end_quote); 
     298        } 
    306299 
    307300        /* check that no backslash character precedes the end_quote. */ 
    … …  
    319312                    /* break from main loop if we have odd number of backslashes */ 
    320313                    if (((unsigned)(q-r) & 0x01) == 1) { 
     314                        ++s; 
    321315                        break; 
    322316                    } 
     317                    ++s; 
    323318                } 
    324319            } else { 
    … …  
    341336    pj_strset3(out, scanner->curptr, s); 
    342337 
    343     scanner->col += (s - start); 
    344338    scanner->curptr = s; 
    345339 
    346     if (scanner->skip_ws) { 
     340    if (PJ_SCAN_IS_PROBABLY_SPACE(*s) && scanner->skip_ws) { 
    347341        pj_scan_skip_whitespace(scanner); 
    348342    } 
    … …  
    350344 
    351345PJ_DEF(void) pj_scan_get_n( pj_scanner *scanner, 
    352                              unsigned N, pj_str_t *out) 
    353 { 
    354     register char *s = scanner->curptr; 
    355     char *start = scanner->curptr; 
    356  
    357     PJ_CHECK_STACK(); 
    358  
     346                            unsigned N, pj_str_t *out) 
     347{ 
    359348    if (scanner->curptr + N > scanner->end) { 
    360349        pj_scan_syntax_err(scanner); 
    … …  
    362351    } 
    363352 
    364     pj_strset(out, s, N); 
     353    pj_strset(out, scanner->curptr, N); 
    365354     
    366     s += N; 
    367     scanner->col += (s - start); 
    368     scanner->curptr = s; 
    369  
    370     if (scanner->skip_ws) { 
     355    scanner->curptr += N; 
     356 
     357    if (PJ_SCAN_IS_PROBABLY_SPACE(*scanner->curptr) && scanner->skip_ws) { 
    371358        pj_scan_skip_whitespace(scanner); 
    372359    } 
    … …  
    376363PJ_DEF(int) pj_scan_get_char( pj_scanner *scanner ) 
    377364{ 
    378     char *start = scanner->curptr; 
    379     int chr = *start; 
    380  
    381     PJ_CHECK_STACK(); 
    382  
    383     if (pj_scan_is_eof(scanner)) { 
     365    int chr = *scanner->curptr; 
     366 
     367    if (!chr) { 
    384368        pj_scan_syntax_err(scanner); 
    385369        return 0; 
    … …  
    387371 
    388372    ++scanner->curptr; 
    389     scanner->col += (scanner->curptr - start); 
    390  
    391     if (scanner->skip_ws) { 
     373 
     374    if (PJ_SCAN_IS_PROBABLY_SPACE(*scanner->curptr) && scanner->skip_ws) { 
    392375        pj_scan_skip_whitespace(scanner); 
    393376    } 
    … …  
    398381PJ_DEF(void) pj_scan_get_newline( pj_scanner *scanner ) 
    399382{ 
    400     PJ_CHECK_STACK(); 
    401  
    402383    if (!PJ_SCAN_IS_NEWLINE(*scanner->curptr)) { 
    403384        pj_scan_syntax_err(scanner); 
    … …  
    413394 
    414395    ++scanner->line; 
    415     scanner->col = 1; 
    416  
    417     if (scanner->skip_ws) { 
     396    scanner->start_line = scanner->curptr; 
     397 
     398    if (PJ_SCAN_IS_PROBABLY_SPACE(*scanner->curptr) && scanner->skip_ws) { 
    418399        pj_scan_skip_whitespace(scanner); 
    419400    } 
    … …  
    425406{ 
    426407    register char *s = scanner->curptr; 
    427     register char *end = scanner->end; 
    428     char *start = s; 
    429  
    430     PJ_CHECK_STACK(); 
    431  
    432     if (pj_scan_is_eof(scanner)) { 
     408 
     409    if (s >= scanner->end) { 
    433410        pj_scan_syntax_err(scanner); 
    434411        return; 
    … …  
    441418    pj_strset3(out, scanner->curptr, s); 
    442419 
    443     scanner->col += (s - start); 
    444420    scanner->curptr = s; 
    445421 
    446     if (scanner->skip_ws) { 
     422    if (PJ_SCAN_IS_PROBABLY_SPACE(*s) && scanner->skip_ws) { 
    447423        pj_scan_skip_whitespace(scanner); 
    448424    } 
    … …  
    454430{ 
    455431    register char *s = scanner->curptr; 
    456     register char *end = scanner->end; 
    457     char *start = s; 
    458  
    459     PJ_CHECK_STACK(); 
    460  
    461     if (pj_scan_is_eof(scanner)) { 
     432 
     433    if (s >= scanner->end) { 
    462434        pj_scan_syntax_err(scanner); 
    463435        return; 
    … …  
    470442    pj_strset3(out, scanner->curptr, s); 
    471443 
    472     scanner->col += (s - start); 
    473444    scanner->curptr = s; 
    474445 
    475     if (scanner->skip_ws) { 
     446    if (PJ_SCAN_IS_PROBABLY_SPACE(*s) && scanner->skip_ws) { 
    476447        pj_scan_skip_whitespace(scanner); 
    477448    } 
    … …  
    483454{ 
    484455    register char *s = scanner->curptr; 
    485     register char *end = scanner->end; 
    486     char *start = scanner->curptr; 
    487  
    488     PJ_CHECK_STACK(); 
    489  
    490     if (pj_scan_is_eof(scanner)) { 
    491         pj_scan_syntax_err(scanner); 
    492         return; 
    493     } 
    494  
    495     while (PJ_SCAN_CHECK_EOF(s) && !strchr(until_spec, *s)) { 
    496         ++s; 
    497     } 
    498  
    499     pj_strset3(out, scanner->curptr, s); 
    500  
    501     scanner->col += (s - start); 
     456    int speclen; 
     457 
     458    if (s >= scanner->end) { 
     459        pj_scan_syntax_err(scanner); 
     460        return; 
     461    } 
     462 
     463    speclen = strlen(until_spec); 
     464    while (PJ_SCAN_CHECK_EOF(s) && !memchr(until_spec, *s, speclen)) { 
     465        ++s; 
     466    } 
     467 
     468    pj_strset3(out, scanner->curptr, s); 
     469 
    502470    scanner->curptr = s; 
    503471 
    504     if (scanner->skip_ws) { 
     472    if (PJ_SCAN_IS_PROBABLY_SPACE(*s) && scanner->skip_ws) { 
    505473        pj_scan_skip_whitespace(scanner); 
    506474    } 
    … …  
    512480    char *start = scanner->curptr; 
    513481 
    514     PJ_CHECK_STACK(); 
    515  
    516482    if (scanner->curptr + N > scanner->end) { 
    517483        pj_scan_syntax_err(scanner); 
    … …  
    520486 
    521487    scanner->curptr += N; 
    522     scanner->col += (scanner->curptr - start); 
    523  
    524     if (skip_ws) { 
     488 
     489    if (PJ_SCAN_IS_PROBABLY_SPACE(*scanner->curptr) && skip_ws) { 
    525490        pj_scan_skip_whitespace(scanner); 
    526491    } 
    … …  
    547512} 
    548513 
     514PJ_DEF(int) pj_scan_stricmp_alnum( pj_scanner *scanner, const char *s,  
     515                                   int len) 
     516{ 
     517    if (scanner->curptr + len > scanner->end) { 
     518        pj_scan_syntax_err(scanner); 
     519        return -1; 
     520    } 
     521    return strnicmp_alnum(scanner->curptr, s, len); 
     522} 
    549523 
    550524PJ_DEF(void) pj_scan_save_state( pj_scanner *scanner, pj_scan_state *state) 
    551525{ 
    552     PJ_CHECK_STACK(); 
    553  
    554526    state->curptr = scanner->curptr; 
    555527    state->line = scanner->line; 
    556     state->col = scanner->col; 
     528    state->start_line = scanner->start_line; 
    557529} 
    558530 
    … …  
    561533                                     pj_scan_state *state) 
    562534{ 
    563     PJ_CHECK_STACK(); 
    564  
    565535    scanner->curptr = state->curptr; 
    566536    scanner->line = state->line; 
    567     scanner->col = state->col; 
    568 } 
    569  
    570  
     537    scanner->start_line = state->start_line; 
     538} 
     539 
     540 
Note: See TracChangeset for help on using the changeset viewer.