Changes in uspace/app/bdsh/tok.c [f41682c:36ab7c7] in mainline


Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/bdsh/tok.c

    rf41682c r36ab7c7  
    4242static bool tok_pending_chars(tokenizer_t *);
    4343static int tok_finish_string(tokenizer_t *);
    44 static void tok_start_token(tokenizer_t *, token_type_t);
    4544
    4645/** Initialize the token parser
    … …  
    5150 * @param max_tokens number of elements of the out_tokens array
    5251 */
    53 int tok_init(tokenizer_t *tok, char *input, token_t *out_tokens,
     52int tok_init(tokenizer_t *tok, char *input, char **out_tokens,
    5453    size_t max_tokens)
    5554{       
    5655        tok->in = input;
    5756        tok->in_offset = 0;
    58         tok->last_in_offset = 0;
    59         tok->in_char_offset = 0;
    60         tok->last_in_char_offset = 0;
    6157       
    6258        tok->outtok = out_tokens;
    6359        tok->outtok_offset = 0;
    64         tok->outtok_size = max_tokens;
     60        /* Leave one slot for a null terminator */
     61        assert(max_tokens > 0);
     62        tok->outtok_size = max_tokens - 1;
    6563       
    6664        /* Prepare a buffer where all the token strings will be stored */
    … …  
    8987
    9088/** Tokenize the input string into the tokens */
    91 int tok_tokenize(tokenizer_t *tok, size_t *tokens_length)
     89int tok_tokenize(tokenizer_t *tok)
    9290{
    9391        int rc;
    94         wchar_t next_char;
     92        wchar_t cur_char;
    9593       
    9694        /* Read the input line char by char and append tokens */
    97         while ((next_char = tok_look_char(tok)) != 0) {
    98                 if (next_char == ' ') {
    99                         /* Push the token if there is any.
     95        while ((cur_char = tok_get_char(tok)) != 0) {
     96                if (cur_char == ' ') {
     97                        /* Spaces delimit tokens, but are not processed in any way
     98                         * Push the token if there is any.
    10099                         * There may not be any pending char for a token in case
    101100                         * there are several spaces in the input.
    … …  
    107106                                }
    108107                        }
    109                         tok_start_token(tok, TOKTYPE_SPACE);
    110                         /* Eat all the spaces */
    111                         while (tok_look_char(tok) == ' ') {
    112                                 tok_push_char(tok, tok_get_char(tok));
    113                         }
    114                         tok_push_token(tok);
    115                        
    116                 }
    117                 else if (next_char == '|') {
    118                         /* Pipes are tokens that are delimiters and should be
    119                          * output as a separate token
     108                }
     109                else if (cur_char == '|') {
     110                        /* Pipes are tokens that are delimiters and should be output
     111                         * as a separate token
    120112                         */
    121113                        if (tok_pending_chars(tok)) {
    … …  
    126118                        }
    127119                       
    128                         tok_start_token(tok, TOKTYPE_PIPE);
    129                        
    130                         rc = tok_push_char(tok, tok_get_char(tok));
     120                        rc = tok_push_char(tok, '|');
    131121                        if (rc != EOK) {
    132122                                return rc;
    … …  
    138128                        }
    139129                }
    140                 else if (next_char == '\'') {
     130                else if (cur_char == '\'') {
    141131                        /* A string starts with a quote (') and ends again with a quote.
    142132                         * A literal quote is written as ''
    143133                         */
    144                         tok_start_token(tok, TOKTYPE_TEXT);
    145                         /* Eat the quote */
    146                         tok_get_char(tok);
    147134                        rc = tok_finish_string(tok);
    148135                        if (rc != EOK) {
    … …  
    151138                }
    152139                else {
    153                         if (!tok_pending_chars(tok)) {
    154                                 tok_start_token(tok, TOKTYPE_TEXT);
    155                         }
    156140                        /* If we are handling any other character, just append it to
    157141                         * the current token.
    158142                         */
    159                         rc = tok_push_char(tok, tok_get_char(tok));
     143                        rc = tok_push_char(tok, cur_char);
    160144                        if (rc != EOK) {
    161145                                return rc;
    … …  
    172156        }
    173157       
    174         *tokens_length = tok->outtok_offset;
     158        /* We always have a space for the terminator, as we
     159         * reserved it in tok_init */
     160        tok->outtok[tok->outtok_offset] = 0;
    175161       
    176162        return EOK;
    … …  
    181167{
    182168        int rc;
    183         wchar_t next_char;
    184        
    185         while ((next_char = tok_look_char(tok)) != 0) {
    186                 if (next_char == '\'') {
    187                         /* Eat the quote */
    188                         tok_get_char(tok);
     169        wchar_t cur_char;
     170       
     171        while ((cur_char = tok_get_char(tok)) != 0) {
     172                if (cur_char == '\'') {
    189173                        if (tok_look_char(tok) == '\'') {
    190174                                /* Encode a single literal quote */
    … …  
    203187                }
    204188                else {
    205                         rc = tok_push_char(tok, tok_get_char(tok));
     189                        rc = tok_push_char(tok, cur_char);
    206190                        if (rc != EOK) {
    207191                                return rc;
    … …  
    217201wchar_t tok_get_char(tokenizer_t *tok)
    218202{
    219         tok->in_char_offset++;
    220203        return str_decode(tok->in, &tok->in_offset, STR_NO_LIMIT);
    221204}
    … …  
    225208{
    226209        size_t old_offset = tok->in_offset;
    227         size_t old_char_offset = tok->in_char_offset;
    228210        wchar_t ret = tok_get_char(tok);
    229211        tok->in_offset = old_offset;
    230         tok->in_char_offset = old_char_offset;
    231212        return ret;
    232213}
    … …  
    238219}
    239220
    240 void tok_start_token(tokenizer_t *tok, token_type_t type)
    241 {
    242         tok->current_type = type;
    243 }
    244 
    245221/** Push the current token to the output array */
    246222int tok_push_token(tokenizer_t *tok)
    … …  
    255231       
    256232        tok->outbuf[tok->outbuf_offset++] = 0;
    257         token_t *tokinfo = &tok->outtok[tok->outtok_offset++];
    258         tokinfo->type = tok->current_type;
    259         tokinfo->text = tok->outbuf + tok->outbuf_last_start;
    260         tokinfo->byte_start = tok->last_in_offset;
    261         tokinfo->byte_length = tok->in_offset - tok->last_in_offset;
    262         tokinfo->char_start = tok->last_in_char_offset;
    263         tokinfo->char_length = tok->in_char_offset - tok->last_in_char_offset;
     233        tok->outtok[tok->outtok_offset++] = tok->outbuf + tok->outbuf_last_start;
    264234        tok->outbuf_last_start = tok->outbuf_offset;
    265        
    266         /* We have consumed the first char of the next token already */
    267         tok->last_in_offset = tok->in_offset;
    268         tok->last_in_char_offset = tok->in_char_offset;
    269235       
    270236        return EOK;
Note: See TracChangeset for help on using the changeset viewer.