Subversion Repositories spk

Rev

Rev 114 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1 cycrow 1 
#include <stdarg.h>
2 
#include <math.h>
3 
#include "strutils.h"
4 
//---------------------------------------------------------------------------------
5 
char ** strexplode(char separator, char *string, size_t *size, size_t limit)
6 
{
7 
	size_t len=strlen(string);
8 
	char *pos=string, *old=string, *end = string + len;
9 
	char **array;
10 
	*size=memrep(string, separator, 0, len, limit);
11 
	if(limit==0) (*size)++;
12 
	array=new char*[*size];
13 
	int i=0;
14 
	size_t done=0;
15 
	do{
16 
		pos=(char*)memchr(pos, 0, end - pos);
17 
		array[i++]=old;
18 
		if(pos) old=++pos;
19 
		if(limit && (++done >=limit)) break;
20 
	}
21 
	while(pos && pos <= end);
22 
 
23 
	return array;
24 
}
25 
//---------------------------------------------------------------------------------
26 
char * ExtractFileName(const char *pszPath, bool bNoExtension)
27 
{
28 
	const char *end=pszPath + strlen(pszPath);
114 cycrow 29 
	char *pos = const_cast<char*>(strrchr(pszPath, '\\'));
1 cycrow 30 
	if(pos==NULL) pos=(char*)pszPath - 1;
114 cycrow 31 
	char *str=new char[end - pos + 1];
32 
	memcpy(str, ++pos, end - pos + 1);
1 cycrow 33 
	if(bNoExtension){
34 
		pos=strrchr(str, '.');
35 
		if(pos) *pos=0;
36 
	}
37 
	return str;
38 
}
39 
//---------------------------------------------------------------------------------
114 cycrow 40 
#ifdef STRUTILS_WIN_WCHAR
41 
wchar_t * ExtractFileNameW(const wchar_t *pszPath, bool bNoExtension)
42 
{
43 
	const wchar_t *end=pszPath + wcslen(pszPath);
44 
	wchar_t *pos=wcsrchr(pszPath, '\\');
45 
	if(pos==NULL) pos=(wchar_t*)pszPath - 1;
46 
	wchar_t *str=new wchar_t[end - pos + 1];
47 
	memcpy(str, ++pos, (end - pos + 1) * sizeof(wchar_t));
48 
	if(bNoExtension){
49 
		pos=wcsrchr(str, '.');
50 
		if(pos) *pos=0;
51 
	}
52 
	return str;
53 
}
54 
//---------------------------------------------------------------------------------
55 
#endif
56 
 
1 cycrow 57 
char * ExtractFilePath(const char *pszPath)
58 
{
114 cycrow 59 
	const char *pos=strrchr(pszPath, '\\');
60 
	char *path = NULL;
1 cycrow 61 
	if(pos){
114 cycrow 62 
		path = new char[pos - pszPath + 1];
1 cycrow 63 
		memcpy(path, pszPath, pos - pszPath);
114 cycrow 64 
		path[pos - pszPath] = 0;
1 cycrow 65 
	}
66 
	return path;
67 
}
68 
//---------------------------------------------------------------------------------
121 cycrow 69 
 
1 cycrow 70 
char * strcat2(int num, ...)
71 
{
121 cycrow 72 
	/*
1 cycrow 73 
	va_list ap=va_start(ap, num);
74 
	const char *s;
75 
	char *str;
76 
	size_t l=0;
77 
	for(int i=0; i < num; i++){
78 
		s=va_arg(ap, char*);
79 
		l+=strlen(s);
80 
	}
81 
	va_end(ap);
82 
	str=new char[l + 1];
83 
	str[0]=0;
84 
	ap=va_start(ap, num);
85 
	for(int i=0; i < num; i++){
86 
		s=va_arg(ap, const char*);
87 
		strcat(str, s);
88 
	}
89 
	va_end(ap);
90 
	return str;
121 cycrow 91 
	*/
92 
	return NULL;
1 cycrow 93 
}
94 
//---------------------------------------------------------------------------------
95 
char ** lineexplode(char *pszBuffer, size_t size, size_t *count)
96 
{
97 
	char **ar;
98 
	size_t cnt=0;
99 
	// change LF to 0
100 
	memrep(pszBuffer, 10, 0, size);
101 
	// chanfe CR to 0
102 
	memrep(pszBuffer, 13, 0, size);
103 
 
104 
	char *pos=pszBuffer, *old=pszBuffer, *end=pszBuffer + size;
105 
	do{
106 
		pos=(char*)memchr(old, 0, end - pos);
107 
		cnt++;
108 
		if(pos)
109 
			while(*(++pos)==0) ;
110 
		old=pos;
111 
	}
112 
	while(pos && ((end - pos) > 0));
113 
 
114 
	if(cnt==0) {
115 
		*count=0;
116 
		return NULL;
117 
	}
118 
	ar=new char*[cnt];
119 
	size_t i=0;
120 
	old=pos=pszBuffer;
121 
	do{
122 
		pos=(char*)memchr(old, 0, end - pos);
123 
		ar[i++]=old;
124 
		if(pos)
125 
			while(*(++pos)==0) ;
126 
		old=pos;
127 
	}
128 
	while(pos && ((end - pos) > 0));
129 
	*count=cnt;
130 
	return ar;
131 
}
132 
//---------------------------------------------------------------------------------
133 
char * ChangeFileExtension(const char *pszFileName, const char *pszExt)
134 
{
135 
	const char *ch, *end=pszFileName + strlen(pszFileName);
136 
	char *newfile;
137 
 
138 
	for(ch=end; ch >= pszFileName && *ch!='.' && *ch!='\\'; ch--)
139 
	 ;;
140 
 
141 
	size_t len;
142 
	if(*ch=='\\')
143 
		len=end - pszFileName;
144 
	else if(ch < pszFileName)
145 
		len=end - ch - 1;
146 
	else
147 
		len=ch - pszFileName;
148 
	size_t extlen=strlen(pszExt);
149 
	newfile=new char[len + extlen + 2];
150 
	newfile[len + extlen + 1]=0;
151 
	memcpy(newfile, pszFileName, len);
152 
	newfile[len]='.';
153 
	memcpy(newfile + len + 1, pszExt, extlen);
154 
	return newfile;
155 
}
156 
//---------------------------------------------------------------------------------
157 
const char * GetFileExtension(const char *pszFileName)
158 
{
159 
	const char *ch, *end=pszFileName + strlen(pszFileName);
160 
 
161 
	for(ch=end; ch >= pszFileName && *ch!='.' && *ch!='\\'; ch--)
162 
	 ;;
163 
 
164 
	if(ch < pszFileName || *ch=='\\')
165 
		return end;
166 
	else
167 
		return ch + 1;
168 
}
169 
//---------------------------------------------------------------------------------
170 
int hextoi(const char *str)
171 
{
172 
	size_t len, last;
173 
	bool neg=false;
174 
	while(*str!=0 && *str==' ')
175 
		str++;
176 
 
177 
	// skip leading 0x....
178 
	if(*str=='+')
179 
		str++;
180 
	else if(*str=='-') {
181 
		str++;
182 
		neg=true;
183 
	}
184 
	if(*str=='0' && ((str[1] | 0x20)=='x'))
185 
		str+=2;
186 
 
187 
	int val=0, v;
188 
 
189 
	len=strlen(str);
190 
	for(last=0; last < len; last++){
191 
		int v=str[last] | 0x20;
192 
		if(!((v >= '0' && v <='9') || (v >= 'a' && v <='f')))
193 
			break;
194 
	}
195 
 
114 cycrow 196 
	for(size_t i = last - 1; (int)i >= 0; i--){
197 
		v = str[i] | 0x20;
1 cycrow 198 
		if(v >= 'a')
199 
			v-=87;
200 
		else
201 
			v-=48;
202 
 
114 cycrow 203 
		val += v * (int)pow(16.0, (int)(last - i - 1));
1 cycrow 204 
	}
205 
	if(neg)	val*=-1;
206 
	return val;
207 
}
208 
//---------------------------------------------------------------------------------
209 
bool ishexa(const char *str)
210 
{
211 
	size_t len, last;
212 
	while(*str!=0 && *str==' ')
213 
		str++;
214 
 
215 
	if(*str=='+' || *str=='-')
216 
		str++;
217 
 
218 
	// skip leading 0x....
219 
	if(*str=='0' && ((str[1] | 0x20)=='x'))
220 
		str+=2;
221 
 
222 
	len=strlen(str);
223 
	if(len==0) return false;
224 
	for(last=0; last < len; last++){
225 
		int v=str[last] | 0x20;
226 
		if(!((v >= '0' && v <='9') || (v >= 'a' && v <='f')))
227 
			return false;
228 
	}
229 
 
230 
	return true;
231 
}
232 
//---------------------------------------------------------------------------------