1 /*

     2 * FUNCTION

     3 * <<strtok>>---get next token from a string

     4 * INDEX

     5 * strtok

     6 * INDEX

     7 * strtok_r

     8 * ANSI_SYNOPSIS

     9 * #include <string.h>

    10 * char *strtok(char *<[source]>, const char *<[delimiters]>)

    11 * char *strtok_r(char *<[source]>, const char *<[delimiters]>,

    12 * char **<[lasts]>)

    13 * TRAD_SYNOPSIS

    14 * #include <string.h>

    15 * char *strtok(<[source]>, <[delimiters]>)

    16 * char *<[source]>;

    17 * char *<[delimiters]>;

    18 * char *strtok_r(<[source]>, <[delimiters]>, <[lasts]>)

    19 * char *<[source]>;

    20 * char *<[delimiters]>;

    21 * char **<[lasts]>;

    22 * A series of calls to <<strtok>> break the string starting at

    23 * <<*<[source]>>> into a sequence of tokens.  The tokens are

    24 * delimited from one another by characters from the string at

    25 * <<*<[delimiters]>>>, at the outset.

    26 * The first call to <<strtok>> normally has a string address as

    27 * the first argument; subsequent calls can use <<NULL>> as the

    28 * first argument, to continue searching the same string.  You

    29 * can continue searching a single string with different

    30 * delimiters by using a different delimiter string on each call.

    31 * <<strtok>> begins by searching for any character not in the

    32 * <[delimiters]> string: the first such character is the

    33 * beginning of a token (and its address will be the result of

    34 * the <<strtok>> call). <<strtok>> then continues searching

    35 * until it finds another delimiter character; it replaces that

    36 * character by <<NULL>> and returns.  (If <<strtok>> comes to

    37 * the end of the <<*<[source]>>> string without finding any more

    38 * delimiters, the entire remainder of the string is treated as

    39 * the next token).

    40 * <<strtok>> starts its search at <<*<[source]>>>, unless you

    41 * pass <<NULL>> as the first argument;  if <[source]> is

    42 * <<NULL>>, <<strtok>> continues searching from the end of the

    43 * last search. Exploiting the <<NULL>> first argument leads to

    44 * non-reentrant code. You can easily circumvent this problem by

    45 * saving the last delimiter address in your application, and

    46 * always using it to pass a non-null <[source]> argument.

    47 * RETURNS

    48 * <<strtok>> returns a pointer to the next token, or <<NULL>> if

    49 * no more tokens can be found.

    50 * PORTABILITY

    51 * <<strtok>> is ANSI C.

    52 * <<strtok>> requires no supporting OS subroutines.

    53 * QUICKREF

    54 * strtok ansi impure

    55 * 

    56 *

    57 */

    58 

    59 

    60 

    61 #include <sys/reent.h>

    62 #include <string.h>

    63 

    64 /**

    65 Sequentially truncate string if delimiter is found.

    66 If string is not NULL, the function scans string for the first occurrence of 

    67 any character included in delimiters. If it is found, the function overwrites 

    68 the delimiter in string by a null-character and returns a pointer to the token,

    69 i.e. the part of the scanned string previous to the delimiter.

    70 After a first call to strtok, the function may be called with NULL as string parameter,

    71 and it will follow by where the last call to strtok found a delimiter.

    72 @return A pointer to the last token found in string.

    73 NULL is returned when there are no more tokens to be found.

    74 @param s Null-terminated string to scan. 

    75 @param delim Null-terminated string containing the separators.

    76 */

    77 EXPORT_C char *

    78 strtok (register char *s, register const char *delim)

    79 {

    80     return strtok_r (s, delim, &(_REENT->_scanpoint));

    81 }

    82 

    83 /*

    84  * Copyright (c) 1988 Regents of the University of California.

    85  * All rights reserved.

    86  *

    87  * Redistribution and use in source and binary forms, with or without

    88  * modification, are permitted provided that the following conditions

    89  * are met:

    90  * 1. Redistributions of source code must retain the above copyright

    91  *    notice, this list of conditions and the following disclaimer.

    92  * 2. Redistributions in binary form must reproduce the above copyright

    93  *    notice, this list of conditions and the following disclaimer in the

    94  *    documentation and/or other materials provided with the distribution.

    95  * 3. All advertising materials mentioning features or use of this software

    96  *    must display the following acknowledgement:

    97  *	This product includes software developed by the University of

    98  *	California, Berkeley and its contributors.

    99  * 4. Neither the name of the University nor the names of its contributors

   100  *    may be used to endorse or promote products derived from this software

   101  *    without specific prior written permission.

   102  *

   103  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

   104  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

   105  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

   106  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

   107  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

   108  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

   109  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

   110  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

   111  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

   112  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

   113  * SUCH DAMAGE.

   114  */

   115 

   116 EXPORT_C char *

   117 strtok_r (register char *s, register const char *delim, char **lasts)

   118 {

   119 	register char *spanp;

   120 	register int c, sc;

   121 	char *tok;

   122 

   123 

   124 	if (s == NULL && (s = *lasts) == NULL)

   125 		return (NULL);

   126 

   127 	/*

   128 	 * Skip (span) leading delimiters (s += strspn(s, delim), sort of).

   129 	 */

   130 cont:

   131 	c = *s++;

   132 	for (spanp = (char *)delim; (sc = *spanp++) != 0;) {

   133 		if (c == sc)

   134 			goto cont;

   135 	}

   136 

   137 	if (c == 0) {		/* no non-delimiter characters */

   138 		*lasts = NULL;

   139 		return (NULL);

   140 	}

   141 	tok = s - 1;

   142 

   143 	/*

   144 	 * Scan token (scan for delimiters: s += strcspn(s, delim), sort of).

   145 	 * Note that delim must have one NUL; we stop if we see that, too.

   146 	 */

   147 	for (;;) {

   148 		c = *s++;

   149 		spanp = (char *)delim;

   150 		do {

   151 			if ((sc = *spanp++) == c) {

   152 				if (c == 0)

   153 					s = NULL;

   154 				else

   155 					s[-1] = 0;

   156 				*lasts = s;

   157 				return (tok);

   158 			}

   159 		} while (sc != 0);

   160 	}

   161 	/* NOTREACHED */

   162 }