1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
/** @addtogroup library
* The library tapset is a collection of standard functions.
* @{
*/
/** @addtogroup library
* @code function strlen:long(s:string) @endcode
* @param s string
* @return Returns the length of the string.
*/
function strlen:long(s:string) %{ /* pure */ /* unprivileged */
THIS->__retvalue = strlen(THIS->s);
%}
/** @addtogroup library
* @code function substr:string(str:string,start:long,length:long) @endcode
* @param str string
* @param start Starting position. 0 = start of the string
* @param length Length of string to return.
* @return Returns the substring.
*/
function substr:string(str:string,start:long, length:long) %{ /* pure */ /* unprivileged */
int length = THIS->length >= MAXSTRINGLEN ? MAXSTRINGLEN : THIS->length + 1;
if (THIS->start >= 0 && length > 0 && THIS->start < strlen(THIS->str))
strlcpy(THIS->__retvalue, THIS->str + THIS->start, length);
%}
/** @addtogroup library
* @code function stringat:string(str:string, pos:long) @endcode
* @param str string
* @param pos the given position. 0 = start of the string
* @return Returns the char in given position of string.
*/
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;
%}
/** @addtogroup library
* @code isinstr:long(s1:string,s2:string) @endcode
* @param s1 string
* @param s2 string
* @return 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;
%}
/*
* text_str()
*
* 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);
%}
function text_strn:string(input:string, len:long, quoted:long)
%{ /* pure */ /* unprivileged */
_stp_text_str(THIS->__retvalue, THIS->input, THIS->len, THIS->quoted, 0);
%}
/*
* tokenize - 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
* 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.
*/
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);
}
%}
/** @addtogroup library
* @code str_replace:string (prnt_str:string, srch_str:string, rplc_str:string) @endcode
* @param prnt_str The parent string.
* @param srch_str The substring which is used to search in the parent string prnt_str.
* @param rplc_str The substring which is used to replace the searched string srch_str.
* @return Returns the parent string with substrings replaced. Else returns parent string.
*/
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;
%}
/*
* 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);
%}
/** @} */
|
