String tokenizer


Data Structures

struct  strtok_t

Defines

#define strtok_for_each(st, p)   list_for_each_entry(p, &(st->list), list)
 interate through tokens

Functions

strtok_tstrtok_init_argv (strtok_t *st, char *argv[], int argc, int empty)
 initialize string tokenizer from argument vector
strtok_tstrtok_init_str (strtok_t *st, const char *str, char *delim, int empty)
 initialize string tokenizer from character array
void strtok_free (strtok_t *st)
 deallocate string tokenizer
int strtok_count (strtok_t *st)
 count number of tokens
int strtok_append (strtok_t *st, const char *token)
 append a token
void strtok_delete (strtok_t *st, const char *token)
 delete one or more tokens
char * strtok_prev (strtok_t **st)
 Go to the previous token.
char * strtok_next (strtok_t **st)
 Go to the previous token.
int strtok_toargv (strtok_t *st, char **argv)
 convert string tokenizer to argument vector
int strtok_tostr (strtok_t *st, char **str, char *delim)
 convert string tokenizer to character array


Define Documentation

#define strtok_for_each ( st,
 )     list_for_each_entry(p, &(st->list), list)

interate through tokens

Definition at line 112 of file strtok.h.

Referenced by flist32_from_str(), flist64_from_str(), mkdirp(), str_path_isabs(), str_path_isdot(), strtok_toargv(), and strtok_tostr().


Function Documentation

strtok_t* strtok_init_argv ( strtok_t st,
char *  argv[],
int  argc,
int  empty 
)

initialize string tokenizer from argument vector

Parameters:
[out] st tokenizer to initialize
[in] argv argument vector
[in] argc argument vector size
Returns:
A pointer to st.

Definition at line 21 of file strtok_init_argv.c.

References strtok_t::list, mem_alloc(), str_dup(), str_isempty, and strtok_free().

00022 {
00023         int i;
00024         strtok_t *new;
00025 
00026         INIT_LIST_HEAD(&(st->list));
00027 
00028         for (i = 0; i < argc; i++) {
00029                 if (!empty && str_isempty(argv[i]))
00030                         continue;
00031 
00032                 if (!(new = mem_alloc(sizeof(strtok_t)))) {
00033                         strtok_free(st);
00034                         return 0;
00035                 }
00036 
00037                 if (!(new->token = str_dup(argv[i]))) {
00038                         strtok_free(st);
00039                         return 0;
00040                 }
00041 
00042                 list_add_tail(&(new->list), &(st->list));
00043         }
00044 
00045         return st;
00046 }

strtok_t* strtok_init_str ( strtok_t st,
const char *  str,
char *  delim,
int  empty 
)

initialize string tokenizer from character array

Parameters:
[out] st tokenizer to initialize
[in] str pointer to a string
[in] delim token delimiter
[in] empty convert empty tokens
Returns:
A pointer to st.

Definition at line 21 of file strtok_init_str.c.

References strtok_t::list, mem_alloc(), mem_free(), mem_set(), str_dup(), str_isempty, str_len(), str_str(), and strtok_free().

Referenced by exec_fork(), exec_fork_background(), exec_fork_pipe(), exec_replace(), flist32_from_str(), flist64_from_str(), mkdirp(), str_path_isabs(), and str_path_isdot().

00022 {
00023         strtok_t *new;
00024         char *scpy, *cur, *token;
00025 
00026         INIT_LIST_HEAD(&(st->list));
00027 
00028         if (!str)
00029                 return st;
00030 
00031         scpy = cur = token = str_dup(str);
00032 
00033         if (!scpy)
00034                 return 0;
00035 
00036         while (token) {
00037                 cur = str_str(cur, delim);
00038 
00039                 if (cur) {
00040                         mem_set(cur, 0, str_len(delim));
00041                         cur += str_len(delim);
00042                 }
00043 
00044                 if (empty || !str_isempty(token)) {
00045                         if (!(new = mem_alloc(sizeof(strtok_t))))
00046                                 goto free;
00047 
00048                         if (!(new->token = str_dup(token)))
00049                                 goto free;
00050 
00051                         list_add_tail(&(new->list), &(st->list));
00052                 }
00053 
00054                 token = cur;
00055         }
00056 
00057         goto out;
00058 
00059 free:
00060         strtok_free(st);
00061         st = 0;
00062 
00063 out:
00064         mem_free(scpy);
00065         return st;
00066 }

void strtok_free ( strtok_t st  ) 

deallocate string tokenizer

Parameters:
[out] st tokenizer to free

Definition at line 22 of file strtok_free.c.

References strtok_t::list, list_entry, list_for_each_safe, mem_free(), and strtok_t::token.

Referenced by exec_fork(), exec_fork_background(), exec_fork_pipe(), exec_replace(), flist32_from_str(), flist64_from_str(), mkdirp(), str_path_isabs(), str_path_isdot(), strtok_init_argv(), and strtok_init_str().

00023 {
00024         int errno_orig = errno;
00025         strtok_t *p;
00026         list_t *pos, *tmp;
00027 
00028         list_for_each_safe(pos, tmp, &(st->list)) {
00029                 p = list_entry(pos, strtok_t, list);
00030                 list_del(pos);
00031 
00032                 if (p->token)
00033                         mem_free(p->token);
00034 
00035                 mem_free(p);
00036         }
00037 
00038         errno = errno_orig;
00039 }

int strtok_count ( strtok_t st  ) 

count number of tokens

Parameters:
[out] st tokenizer to initialize
Returns:
Number of tokens in st.

Definition at line 19 of file strtok_count.c.

References strtok_t::list, and list_for_each.

Referenced by exec_fork(), exec_fork_background(), exec_fork_pipe(), exec_replace(), strtok_toargv(), and strtok_tostr().

00020 {
00021         list_t *pos;
00022         int count = 0;
00023 
00024         list_for_each(pos, &(st->list))
00025                 count++;
00026 
00027         return count;
00028 }

int strtok_append ( strtok_t st,
const char *  token 
)

append a token

Parameters:
[out] st tokenizer to append to
[in] token token to append
Returns:
0 on success, -1 on error with errno set.

Definition at line 21 of file strtok_append.c.

References strtok_t::list, mem_alloc(), mem_free(), and str_dup().

00022 {
00023         strtok_t *new;
00024 
00025         if (!(new = mem_alloc(sizeof(strtok_t))))
00026                 return -1;
00027 
00028         if (!(new->token = str_dup(token))) {
00029                 mem_free(new);
00030                 return -1;
00031         }
00032 
00033         list_add_tail(&(new->list), &(st->list));
00034 
00035         return 0;
00036 }

void strtok_delete ( strtok_t st,
const char *  token 
)

delete one or more tokens

Parameters:
[out] st tokenizer to delete from
[in] token token to delete

Definition at line 21 of file strtok_delete.c.

References strtok_t::list, list_entry, list_for_each_safe, mem_free(), str_equal(), and strtok_t::token.

00022 {
00023         strtok_t *p;
00024         list_t *pos, *tmp;
00025 
00026         list_for_each_safe(pos, tmp, &(st->list)) {
00027                 p = list_entry(pos, strtok_t, list);
00028 
00029                 if (str_equal(p->token, token)) {
00030                         list_del(pos);
00031                         mem_free(p->token);
00032                         mem_free(p);
00033                 }
00034         }
00035 }

char* strtok_prev ( strtok_t **  st  ) 

Go to the previous token.

Parameters:
[in] st tokenizer to iterate

Definition at line 19 of file strtok_prev.c.

References strtok_t::list, list_entry, and strtok_t::token.

00020 {
00021         strtok_t *oldhead = *st;
00022         list_t   *prev    = (&(oldhead->list))->prev;
00023         strtok_t *newhead = list_entry(prev, strtok_t, list);
00024 
00025         *st = newhead;
00026 
00027         return oldhead->token;
00028 }

char* strtok_next ( strtok_t **  st  ) 

Go to the previous token.

Parameters:
[in] st tokenizer to iterate

Definition at line 19 of file strtok_next.c.

References strtok_t::list, list_entry, and strtok_t::token.

00020         {
00021         strtok_t *oldhead = *st;
00022         list_t   *next    = (&(oldhead->list))->next;
00023         strtok_t *newhead = list_entry(next, strtok_t, list);
00024 
00025         *st = newhead;
00026 
00027         return oldhead->token;
00028 }

int strtok_toargv ( strtok_t st,
char **  argv 
)

convert string tokenizer to argument vector

Parameters:
[out] st tokenizer to convert
[in] argv pointer to an argument vector
[in] argc pointer to number of elements stored in argv
0 on success, -1 on error with errno set.

Definition at line 19 of file strtok_toargv.c.

References strtok_count(), strtok_for_each, and strtok_t::token.

Referenced by exec_fork(), exec_fork_background(), exec_fork_pipe(), and exec_replace().

00020 {
00021         int i = 0;
00022         strtok_t *p;
00023 
00024         if (strtok_count(st) < 1)
00025                 return 0;
00026 
00027         strtok_for_each(st, p)
00028                 argv[i++] = p->token;
00029 
00030         argv[i] = NULL;
00031 
00032         return i;
00033 }

int strtok_tostr ( strtok_t st,
char **  str,
char *  delim 
)

convert string tokenizer to character array

Parameters:
[out] st tokenizer to convert
[in] str pointer to a string
0 on success, -1 on error with errno set.

Definition at line 21 of file strtok_tostr.c.

References stralloc_t::len, str_len(), stralloc_catf(), stralloc_finalize(), stralloc_free(), stralloc_init(), strtok_count(), strtok_for_each, and strtok_t::token.

00022 {
00023         int i = 0;
00024         stralloc_t _sa, *sa = &_sa;
00025         strtok_t *p;
00026 
00027         if (strtok_count(st) < 1)
00028                 return 0;
00029 
00030         stralloc_init(sa);
00031 
00032         strtok_for_each(st, p) {
00033                 if (stralloc_catf(sa, "%s%s", p->token, delim) == -1)
00034                         return -1;
00035 
00036                 i++;
00037         }
00038 
00039         if (sa->len > 0)
00040                 sa->len -= str_len(delim);
00041 
00042         *str = stralloc_finalize(sa);
00043 
00044         stralloc_free(sa);
00045         return i;
00046 }


Generated on Tue Jun 19 20:38:45 2007 for lucid by  doxygen 1.5.2