// Standard string functions tapset.
// Copyright (C) 2009 Red Hat, Inc.
//
// This file is part of systemtap, and is free software.  You can
// redistribute it and/or modify it under the terms of the GNU General
// Public License (GPL); either version 2, or (at your option) any
// later version.

/**
 * sfunction strlen - Returns the length of a string.
 * @s: the string
 *
 * Description: Returns the lenght of the string, which can be zero up
 * to MAXSTRINGLEN.
 */
function strlen:long(s:string) %{ /* pure */ /* unprivileged */
        THIS->__retvalue = strlen(THIS->s);
%}

/**
 * sfunction substr - Returns a substring.
 * @str: The string to take a substring from
 * @start: Starting position.  0 = start of the string.
 * @length: Length of string to return.
 *
 * Description: Returns the substring of the up to the given length
 * starting at the given start position.
 */
function substr:string(str:string,start:long, length:long) %{ /* pure */ /* unprivileged */
	int64_t length = clamp_t(int64_t, THIS->length + 1, 0, MAXSTRINGLEN);
	if (THIS->start >= 0 && THIS->start < strlen(THIS->str))
		strlcpy(THIS->__retvalue, THIS->str + THIS->start, length);
%}

/**
 * sfunction stringat - Returns the char at a given position in the string.
 * @str: The string to fetch the character from.
 * @pos: The position to get the character from.  0 = start of the string.
 *
 * Returns the character at a given position in the string or zero if the
 * string doesn't have as many characters.
 */
function stringat:long(str:string, pos:long) %{ /* pure */ /* unprivileged */
	if (THIS->pos >= 0 && THIS->pos < strlen(THIS->str))
		THIS->__retvalue = THIS->str[THIS->pos];
	else
		THIS->__retvalue = 0;
%}

/**
 * sfunction isinstr - Returns whether a string is a substring of another string.
 * @s1: String to search in.
 * @s2: Substring to find.
 *
 * Description: Returns 1 if s2 is in s1, otherwise 0.
 */
function isinstr:long(s1:string,s2:string) %{ /* pure */ /* unprivileged */
	if (strstr(THIS->s1,THIS->s2) != NULL)
		THIS->__retvalue = 1;
	else
		THIS->__retvalue = 0;
%}

/**
 * sfunction text_str - Escape any non-printable chars in a string.
 * @input: The string to escape.
 *
 * Description Takes a string, and any ASCII characters that are not
 * printable are replaced by the corresponding escape sequence in the
 * returned string.
 */
function text_str:string(input:string) 
%{ /* pure */ /* unprivileged */
	_stp_text_str(THIS->__retvalue, THIS->input, 0, 0, 0);
%}

/**
 * sfunction text_strn - Escape any non-printable chars in a string.
 * @input: The string to escape.
 * @len: Maximum length of string to return. 0 means MAXSTRINGLEN.
 * @quoted: Put double quotes around the string. If input string is
 * truncated it will have "..." after the second quote.
 *
 * Description Takes a string, and any ASCII characters that are not
 * printable are replaced by the corresponding escape sequence in the
 * returned string.
 */
function text_strn:string(input:string, len:long, quoted:long)
%{ /* pure */ /* unprivileged */
	int64_t len = clamp_t(int64_t, THIS->len, 0, MAXSTRINGLEN);
	_stp_text_str(THIS->__retvalue, THIS->input, len, THIS->quoted, 0);
%}

/**
 * sfunction tokenize - Return the next non-empty token in a string.
 * @input: String to tokenize. If NULL, returns the next non-empty token
 * in the string passed in the previous call to tokenize().
 * @delim: Token delimiter. Set of characters that delimit the tokens.
 * 
 * Description: Given a string and a token delimiter, return the next
 * non-empty token in the string or blank when no more non-empty tokens
 * are left.
 */
function tokenize:string(input:string, delim:string)
%{ /* unprivileged */
	static char str[MAXSTRINGLEN];
	static char *str_start;
	static char *str_end;
	char *token = NULL;
	char *token_end = NULL;

	if (THIS->input[0]) {
		strncpy(str, THIS->input, MAXSTRINGLEN);
		str_start = &str[0];
		str_end = &str[0] + strlen(str);
	}
	do {
		token = strsep(&str_start, THIS->delim);
	} while (token && !token[0]);
	if (token) {
		token_end = (str_start ? str_start - 1 : str_end);
		memcpy(THIS->__retvalue, token, token_end - token + 1);
	}
%}

/**
 * sfunction - str_replace Replaces all instances of a substring with another.
 * @prnt_str: The string to search and replace in.
 * @srch_str: The substring which is used to search in prnt_str string.
 * @rplc_str: The substring which is used to replace srch_str.
 *
 * Description: Returns the given string with substrings replaced.
 */
function str_replace:string (prnt_str:string, srch_str:string, rplc_str:string)
%{ /* pure */ /* unprivileged */
	char *ptr = THIS->prnt_str;
	char *ptr_base = THIS->prnt_str;
	int strlen_srch_str = strlen(THIS->srch_str);

	if(strlen_srch_str == 0) {
		strlcat(THIS->__retvalue, ptr_base, MAXSTRINGLEN);
		return;
	}

	while((ptr = strstr(ptr, THIS->srch_str)) != NULL) {

		*ptr = '\0';
		strlcat(THIS->__retvalue, ptr_base, MAXSTRINGLEN);
		strlcat(THIS->__retvalue, THIS->rplc_str, MAXSTRINGLEN);
		ptr = ptr + strlen_srch_str;
		ptr_base = ptr;
	}

	strlcat(THIS->__retvalue, ptr_base, MAXSTRINGLEN);
	return;
%}

/**
 * sfunction - strtol - Convert a string to a long.
 * @str: String to convert.
 * @base: The base to use
 */
function strtol:long(str:string, base:long)
%{ /* pure */ /* unprivileged */
	THIS->__retvalue = simple_strtol(THIS->str, NULL, THIS->base);
%}

/**
 * sfunction isdigit - Checks for a digit.
 * @str: String to check.
 *
 * Description: Checks for a digit (0 through 9) as the first
 * character of a string.  Returns non-zero if true, and a zero if
 * false.
 */
function isdigit:long(str:string)
%{ /* pure */ /* unprivileged */
	THIS->__retvalue = isdigit(THIS->str[0]);
%}