/* *	HT Editor *	strtools.cc * *	Copyright (C) 1999-2002 Stefan Weyergraf (stefan@weyergraf.de) *	Copyright (C) 1999-2003 Sebastian Biallas (sb@biallas.net) * *	This program is free software; you can redistribute it and/or modify *	it under the terms of the GNU General Public License version 2 as *	published by the Free Software Foundation. * *	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., 675 Mass Ave, Cambridge, MA 02139, USA. */#include "atom.h"#include "htdebug.h"#include "except.h"#include "snprintf.h"#include "stream.h"#include "strtools.h"#include "tools.h"#include "io/types.h"#include <cctype>#include <cstdarg>#include <cstdlib>#include <cstring>char hexchars[17]="0123456789abcdef";char *ht_strdup(const char *str){	if (str) {		int len = strlen(str)+1;		char *s = ht_malloc(len);		memcpy(s, str, len);		return s;	} else {		return NULL;	}}/** *	Like ht_strdup but dups a maximum of |maxlen| characters of |str|. *	@returns new string */char *ht_strndup(const char *str, size_t maxlen){	maxlen ++;	if (str) {		uint len = strlen(str)+1;		len = MIN(len, maxlen);		char *s = ht_malloc(len);		memcpy(s, str, len);		s[len-1] = 0;		return s;	} else {		return NULL;	}}/** *	Like strcpy but copies a maximum of |maxlen| characters *	(including trailing zero). *	The operation is performed in a way that the trailing zero *	is always written if maxlen is > 0. *	@returns number of characters copied (without trailing zero) */size_t ht_strlcpy(char *s1, const char *s2, size_t maxlen){	if (!maxlen) return 0;	char *os1 = s1;	while (true) {		if (!--maxlen) {			*s1 = 0;			return s1 - os1;		}		*s1 = *s2;		if (!*s2) return s1 - os1;		s1++; s2++;	}}size_t ht_strlcat(char *s1, const char *s2, size_t maxlen){	char *os1 = s1;	while (maxlen && *s1) {		maxlen--;		s1++;	}	if (!maxlen) return os1-s1;	while (true) {		if (!--maxlen) {			*s1 = 0;			return s1 - os1;		}		*s1 = *s2;		if (!*s2) return s1 - os1;		s1++; s2++;	}}int ht_strncmp(const char *s1, const char *s2, size_t max){	if (!s1) return s2 ? -1 : 0;	if (!s2) return s1 ? 1 : 0;	while (max--) {		if (!*s1) return *s2 ? -1 : 0;		if (!*s2) return *s1 ? 1 : 0;		if (*s1>*s2) {			return 1;		} else if (*s1<*s2) {			return -1;		}		s1++;s2++;	}	return 0;}int ht_strnicmp(const char *s1, const char *s2, size_t max){	if (!s1) return s2 ? -1 : 0;	if (!s2) return s1 ? 1 : 0;	while (max--) {		if (!*s1) return *s2 ? -1 : 0;		if (!*s2) return *s1 ? 1 : 0;		char c1=tolower(*s1), c2=tolower(*s2);		if (c1>c2) {			return 1;		} else if (c1<c2) {			return -1;		}		s1++;s2++;	}	return 0;}int ht_stricmp(const char *s1, const char *s2){	if (!s1) return s2 ? -1 : 0;	if (!s2) return s1 ? 1 : 0;	while (1) {		if (!*s1) return *s2 ? -1 : 0;		if (!*s2) return *s1 ? 1 : 0;		char c1 = tolower(*s1), c2 = tolower(*s2);		if (c1 > c2) {			return 1;		} else if (c1 < c2) {			return -1;		}		s1++; s2++;	}}size_t ht_strccomm(const char *s1, const char *s2){	if (!s1 || !s2) return 0;	int r=0;	while (*s1 && *s2 && *s1 == *s2) { s1++; s2++; r++; }	return r;}size_t ht_strcicomm(const char *s1, const char *s2){	if (!s1 || !s2) return 0;	int r=0;	while (*s1 && *s2 && tolower(*s1) == tolower(*s2)) { s1++; s2++; r++; }	return r;}int escape_special_str(char *result, int resultmaxlen, const char *s, const char *specialchars, bool bit7){	return escape_special(result, resultmaxlen, s, strlen(s), specialchars, bit7);}int escape_special(char *result, int resultmaxlen, const void *S, int len, const char *specialchars, bool bit7){	byte *s = (byte*)S;	if (!s) return 0;	if (resultmaxlen <= 0) return 0;	char *old = result;	if (!specialchars) specialchars="";	while (len--) {		if (*s && strchr(specialchars, *s)) {			*result++ = '\\';			if (--resultmaxlen<2) break;			*result++ = *s;			if (--resultmaxlen<2) break;		} else if (*s < 32 || (bit7 && (*s > 0x7f)) || *s=='\\') {			*result++ = '\\';			if (--resultmaxlen<2) break;			switch (*s) {				case '\0':					*result++='0';					break;				case '\a':					*result++='a';					break;				case '\b':					*result++='b';					break;				case '\e':					*result++='e';					break;				case '\f':					*result++='f';					break;				case '\n':					*result++='n';					break;				case '\r':					*result++='r';					break;				case '\t':					*result++='t';					break;				case '\v':					*result++='v';					break;				case '\\':					*result++='\\';					break;				case '\"':					*result++='"';					break;				default:					*result++='x';					if (--resultmaxlen<2) break;					*result++=hexchars[((*s & 0xf0) >> 4)];					if (--resultmaxlen<2) break;					*result++=hexchars[(*s & 0x0f)];			}			if (--resultmaxlen < 2) break;		} else {			*result++ = *s;			if (--resultmaxlen < 2) break;		}		s++;	}	*result = 0;	return result-old;}int unescape_special_str(char *result, int resultmaxlen, const char *s){	int l=unescape_special(result, resultmaxlen-1, s);	result[l]=0;	return l;}int unescape_special(void *Result, int resultmaxlen, const char *s){	char *result = (char*)Result;	char *old = result;	while (s && *s) {		if (*s == '\\') {			s++;			switch (*s) {			case '0':				*result++='\0';				break;			case 'a':				*result++='\a';				break;			case 'b':				*result++='\b';				break;			case 'e':				*result++='\e';				break;			case 'f':				*result++='\f';				break;			case 'n':				*result++='\n';				break;			case 'r':				*result++='\r';				break;			case 't':				*result++='\t';				break;			case 'v':				*result++='\v';				break;			case '\\':				*result++='\\';				break;			case '\"':				*result++='"';				break;			case 'x':				s++;				byte v = hexdigit(*s) * 16;				s++;				v += hexdigit(*s);				*result++ = (char)v;			}			if (!--resultmaxlen) break;		} else {			*result++ = *s;			if (!--resultmaxlen) break;		}		s++;	}	return result-old;}int bin2str(char *result, const void *S, int len){	byte *s = (byte*)S;	while (len--) {//		if (*s<32) *result=' '; else *result=*s;		if (*s==0) *result=' '; else *result=*s;		result++;		s++;	}	*result=0;	return len;}void wide_char_to_multi_byte(char *result, const byte *Unicode, int maxlen){	if (!maxlen) return;	struct doof {		char c1;		char c2;	};	doof *unicode = (doof*)Unicode;	for (int i=0; i < maxlen - 1; i++) {		if (unicode->c2) {			*result++ = 0xff;		} else {			if (!unicode->c1) break;			*result++ = unicode->c1;		}		unicode++;	}	*result=0;}void memdowncase(byte *buf, int len){	for (int i=0; i < len; i++) {		if (buf[i] >= 'A' && buf[i] <= 'Z') buf[i] += 32;	}}byte *ht_memmem(const byte *haystack, int haystack_len, const byte *needle, int needle_len){	while (haystack_len && haystack_len >= needle_len) {		if (memcmp(haystack, needle, needle_len) == 0) return (byte*)haystack;		haystack++;		haystack_len--;	}	return NULL;}/* common string parsing functions */bool is_whitespace(char c){	return c && (unsigned char)c <= 32;}void whitespaces(const char *&str){	while ((unsigned char)*str <= 32) {		if (!*str) return;		str++;	}}void non_whitespaces(const char *&str){	while ((unsigned char)*str > 32) {		str++;	}}bool waitforchar(const char *&str, char b){	while (*str != b) {		if (!*str) return false;		str++;	}	return true;}static bool bnstr2bin(uint64 &u64, const char *&str, int base){	u64 = 0;	uint64 ubase = base;	int i = 0;	do {		int c = hexdigit(*str);		if (c == -1 || c >= base) return (i == 0) ? false : true;		u64 *= ubase;		u64 += c;		str++;		i++;	} while (*str);	return true;}bool parseIntStr(const char *&str, uint64 &u64, int defaultbase){	int base = defaultbase;	if (base == 10 && ht_strnicmp("0x", str, 2) == 0) {		str += 2;		base = 16;	}	return bnstr2bin(u64, str, base);}bool parseIntStr(char *&str, uint64 &u64, int defaultbase){	int base = defaultbase;	if (base == 10 && ht_strnicmp("0x", str, 2) == 0) {		str += 2;		base = 16;	}	return bnstr2bin(u64, (const char *&)str, base);}bool str2int(const char *str, uint64 &u64, int defaultbase){	uint base = defaultbase;	size_t len = strlen(str);	if (!len) return false;	bool n = false;	if (defaultbase == 10) {		if (ht_strnicmp("0x", str, 2) == 0) {			str += 2;			base = 16;			len -= 2;			if (!len) return false;		} else {			switch (tolower(str[len-1])) {			case 'b': base = 2; break;			case 'o': base = 8; break;			case 'h': base = 16; break;			default: goto skip;			}				len--;				if (!len) return false;			skip:			if (str[0] == '-') {				str++; len--;				if (!len) return false;				n = true;			}		}	}	u64 = 0;	do {		int c = hexdigit(str[0]);		if (c == -1 || c >= int(base)) return false;		u64 *= base;		u64 += c;		str++;	} while (--len);	if (n) u64 = -u64;	return true;}/* hex/string functions */int hexdigit(char a){	if (a >= '0' && a <= '9') {		return a-'0';	} else if (a >= 'a' && a <= 'f') {		return a-'a'+10;	} else if (a >= 'A' && a <= 'F') {		return a-'A'+10;	}	return -1;}bool hexb_ex(uint8 &result, const char *s){	int v, w;	v = hexdigit(s[0]);	w = hexdigit(s[1]);	if ((v < 0) || (w < 0)) return false;	result = (v<<4) | w;	return true;}bool hexw_ex(uint16 &result, const char *s){	uint8 v, w;	if (!hexb_ex(v, s) || !hexb_ex(w, s+2)) return false;	result = (v<<8) | w;	return true;}bool hexd_ex(uint32 &result, const char *s){	uint16 v, w;	if (!hexw_ex(v, s) || !hexw_ex(w, s+4)) return false;	result = (v<<16) | w;	return true;}