Subversion Repositories Kolibri OS

; some strtok-like function

;

; Copyright (c) 2003 Thomas Mathys

; killer@vantage.ch

;

; This program is free software; you can redistribute it and/or modify

; it under the terms of the GNU General Public License as published by

; the Free Software Foundation; either version 2 of the License, or

; (at your option) any later version.

;

; This program is distributed in the hope that it will be useful,

; but WITHOUT ANY WARRANTY; without even the implied warranty of

; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

; GNU General Public License for more details.

;

; You should have received a copy of the GNU General Public License

; along with this program; if not, write to the Free Software

; Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

;

%ifndef _STRTOK_INC

%define _STRTOK_INC

;********************************************************************

;	strtok

;	this function works like strtok from a c runtime library.

;	note that it is not threadsafe. it would be an easy task

;	to make it threadsafe, though:

;	.adx must be removed, instead the last search address is

;	stored at some location provided by the user (passed as

;	a third parameter in ecx or so)

;

;	input:

;

;	eax	:	address of string to be searched (asciiz), or

;			0 to get the next token of the current string

;	ebx	:	address of delimiter list (asciiz)

;

;	output:

;

;	eax	:	pointer to the next token, or 0 if there

;			aren't any tokens anymore.

;

;	destroys:	nothing

;

;********************************************************************

strtok:

	pushad

	pushfd

	; get start address

	; if the new start address is 0, and the old address (.adx)

	; is also 0, then there's nothing to do and we return 0.

	or	eax,eax			; new address =  0 ?

	jz	.nonewstring		; nope -> use old string

	mov	[.adx],eax		; yeah -> store new string adx

.nonewstring:

	mov	esi,[.adx]		; load string address

	or	esi,esi			; 0 ?

	jnz	.startadxok		; nope -> ok

	xor	eax,eax			; yeah -> return 0

	je	.bye

.startadxok:

	; skip leading delimiters

.skipdelimiters:

	lodsb				; read character

	mov	edi,ebx			; edi -> delimiter list

.foo:

	mov	cl,[edi]		; get delimiter

	inc	edi

	or	cl,cl			; end of delimiter list

	jz	.endofdelimiterlist

	cmp	al,cl			; if AL is a delimiter, then

	je	.skipdelimiters		; we need to skip it too...

	jmp	.foo			; otherwise try next delimiter

.endofdelimiterlist:

	; end of string reached without finding any non-delimiters ?

	or	al,al			; character = 0 ?

	jnz	.bar			; nope -> continue

	mov	dword [.adx],0		; yeah -> remember this

	xor	eax,eax			; and return 0

	jmp	.bye

.bar:

	; found the start of a token, let's store its address

	mov	edx,esi

	dec	edx			; edx = start address of token

	; find the end of the token

.abraham:

	lodsb				; get character

	mov	edi,ebx			; edi -> delimiter list

.bebraham:

	mov	cl,[edi]		; get delimiter

	inc	edi

	cmp	al,cl			; is AL a delimiter ?

	jne	.cebraham		; nope -> continue

	or	al,al			; terminating zero found ?

	jnz	.argle

	xor	esi,esi			; yeah -> remember this

	jmp	.bargle

.argle:

	mov	byte [esi-1],0		; nope -> mark end of token

.bargle:

	mov	[.adx],esi		; remember search address

	mov	eax,edx			; return token address

	jmp	.bye

.cebraham:

	or	cl,cl			; end of delimiter list ?

	jnz	.bebraham		; nope -> try next delimiter

	jmp	.abraham

	; write return value into stack, so that when popad

	; gets executed, eax will receive the return value.

.bye:

	mov	[esp+4*8],eax

	popfd

	popad

	ret

.adx	dd	0

%endif