开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
xstring.c
资源名称：pvpgn-1.6.2.rar　[点击查看]
上传用户：tany51
上传日期：2013-06-12
资源大小：1397k
文件大小：7k
源码类别：

MySQL数据库

开发平台：

Visual C++

xstring.c：源码内容
  1. /*
  2.  * Copyright (C) 2000,2001 Onlyer (onlyer@263.net)
  3.  *
  4.  * This program is free software; you can redistribute it and/or
  5.  * modify it under the terms of the GNU General Public License
  6.  * as published by the Free Software Foundation; either version 2
  7.  * of the License, or (at your option) any later version.
  8.  *
  9.  * This program is distributed in the hope that it will be useful,
  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  * GNU General Public License for more details.
  13.  *
  14.  * You should have received a copy of the GNU General Public License
  15.  * along with this program; if not, write to the Free Software
  16.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  17.  */
  18. #include "common/setup_before.h"
  19. #include "setup.h"
  21. #include <stdio.h>
  22. #include <ctype.h>
  23. #ifdef HAVE_STRING_H
  24. # include <string.h>
  25. #else
  26. # ifdef HAVE_STRINGS_H
  27. #  include <strings.h>
  28. # endif
  29. # ifdef HAVE_MEMORY_H
  30. #  include <memory.h>
  31. # endif
  32. #endif
  33. #ifdef STDC_HEADERS
  34. # include <stdlib.h>
  35. #else
  36. # ifdef HAVE_MALLOC_H
  37. #  include <malloc.h>
  38. # endif
  39. #endif
  40. #include "compat/memcpy.h"
  41. #include "compat/memmove.h"
  42. #include "compat/strdup.h"
  44. #include "xstring.h"
  45. #include "common/setup_after.h"
  47. extern char * strtolower(char * str)
  48. {
  49. unsigned int i;
  50. unsigned char ch;
  52. if (!str) return NULL;
  53. for (i=0; (ch=str[i]); i++) {
  54. if ((isupper(ch))) str[i]=ch+('a'-'A');
  55. }
  56. return str;
  57. }
  59. extern unsigned char xtoi(unsigned char ch)
  60. {
  61. unsigned char retval;
  63. if (isalpha(ch)) retval=tolower(ch);
  64. else retval=ch;
  65. if (retval < 'A') retval -= ('0'-0);
  66. else retval -= ('a' - 0xa);
  67. return retval;
  68. }
  70. extern char * str_strip_affix(char * str, char const * affix)
  71. {
  72. unsigned int i, j, n;
  73. int match;
  75. if (!str) return NULL;
  76. if (!affix) return str;
  77. for (i=0; str[i]; i++) {
  78. match=0;
  79. for (n=0; affix[n]; n++) {
  80. if (str[i]==affix[n]) {
  81. match=1;
  82. break;
  83. }
  84. }
  85. if (!match) break;
  86. }
  87. for (j=strlen(str)-1; j>=i; j--) {
  88. match=0;
  89. for (n=0; affix[n]; n++) {
  90. if (str[j]==affix[n]) {
  91. match=1;
  92. break;
  93. }
  94. }
  95. if (!match) break;
  96. }
  97. if (i>j) {
  98. str[0]='';
  99. } else {
  100. memmove(str,str+i,j-i+1);
  101. str[j-i+1]='';
  102. }
  103. return str;
  104. }
  106. extern char * hexstrdup(unsigned char const * src)
  107. {
  108. char * dest;
  109. int len;
  111. if (!src) return NULL;
  112. if (!(dest=strdup(src))) return NULL;
  113. len=hexstrtoraw(src,dest,strlen(dest)+1);
  114. dest[len]='';
  115. return dest;
  116. }
  118. extern unsigned int hexstrtoraw(unsigned char const * src, char * data, unsigned int datalen)
  119. {
  120. unsigned char ch;
  121. unsigned int i, j;
  123. for (i=0, j=0; j<datalen; i++) {
  124. ch=src[i];
  125. if (!ch) break;
  126. if (ch=='\') {
  127. i++;
  128. ch=src[i];
  129. if (!ch) {
  130. break;
  131. } else if (ch=='\') {
  132. data[j++]=ch;
  133. } else if (ch=='x') {
  134. if (isxdigit(src[i+1])) { 
  135. if (isxdigit(src[i+2])) {
  136. data[j++]=xtoi(src[i+1]) * 0x10 + xtoi(src[i+2]);
  137. i+=2;
  138. } else {
  139. data[j++]=xtoi(src[i+1]);
  140. i++;
  141. }
  142. } else {
  143. data[j++]=ch;
  144. }
  145. } else if (ch=='n') {
  146. data[j++]='n';
  147. } else if (ch=='r') {
  148. data[j++]='r';
  149. } else if (ch=='a') {
  150. data[j++]='a';
  151. } else if (ch=='t') {
  152. data[j++]='t';
  153. } else if (ch=='b') {
  154. data[j++]='b';
  155. } else if (ch=='f') {
  156. data[j++]='f';
  157. } else if (ch=='v') {
  158. data[j++]='v';
  159. } else {
  160. data[j++]=ch;
  161. }
  162. } else {
  163. data[j++]=ch;
  164. continue;
  165. }
  166. }
  167. return j;
  168. }
  170. #define SPLIT_STRING_INIT_COUNT 32
  171. #define SPLIT_STRING_INCREASEMENT 32
  172. extern char * * strtoarray(char const * str, char const * delim, int * count)
  173. {
  174. int i ,n, index_size;
  175. int in_delim, match;
  176. char * temp, * result;
  177. int * pindex;
  178. char * pd;
  179. char const * ps;
  180. char * realloc_tmp;
  182. if (!str || !delim || !count) return NULL;
  184. temp=malloc(strlen(str)+1);
  185. if (!temp) return NULL;
  187. n = SPLIT_STRING_INIT_COUNT;
  188. pindex=malloc(sizeof(char *) * n);
  189. if (!pindex) {
  190. free(temp);
  191. return NULL;
  192. }
  194. *count=0;
  195. in_delim=1;
  196. ps=str;
  197. pd=temp;
  198. pindex[0]=0;
  199. while (*ps!='') {
  200. match=0;
  201. for (i=0; delim[i]!=''; i++) {
  202. if ( *ps == delim[i]) {
  203. match=1;
  204. if (!in_delim) {
  205. *pd = '';
  206. pd++;
  207. (*count)++;
  208. in_delim=1;
  209. }
  210. break;
  211. }
  212. }
  213. if (!match) {
  214. if (in_delim) {
  215. if (*count>=n) {
  216. n += SPLIT_STRING_INCREASEMENT;
  217. if (!(realloc_tmp=realloc(pindex,n * sizeof(char *)))) {
  218. free(pindex);
  219. free(temp);
  220. return NULL;
  221. }
  222. pindex=(int *)realloc_tmp;
  223. }
  224. pindex[*count]= pd-temp;
  225. in_delim = 0;
  226. }
  227. *pd = * ps;
  228. pd++;
  229. }
  230. ps++;
  231. }
  232. if (!in_delim) {
  233. *pd='';
  234. pd++;
  235. (*count)++;
  236. }
  237. index_size=*count * sizeof(char *);
  238. if (!index_size) {
  239. free(temp);
  240. free(pindex);
  241. return NULL;
  242. }
  243. result=malloc(pd-temp+index_size);
  244. if (!result) {
  245. free(temp);
  246. free(pindex);
  247. return NULL;
  248. }
  249. memcpy(result+index_size,temp,pd-temp);
  250. for (i=0; i< *count; i++) {
  251. pindex[i]+=(int)result+index_size;
  252. }
  253. memcpy(result,pindex,index_size);
  254. free(temp);
  255. free(pindex);
  256. return (char **) result;
  257. }
  259. extern char * * strtoargv(char const * str, unsigned int * count)
  260. {
  261. unsigned int n, index_size;
  262. char * temp;
  263. unsigned int i;
  264. int j;
  265. int * pindex;
  266. char * result;
  267. char * realloc_tmp;
  269. if (!str || !count) return NULL;
  270. temp=malloc(strlen(str)+1);
  271. if (!temp) return NULL;
  272. n = SPLIT_STRING_INIT_COUNT;
  273. pindex=malloc(n * sizeof (char *));
  274. if (!pindex) return NULL;
  276. i=j=0;
  277. *count=0;
  278. while (str[i]) {
  279. while (str[i]==' ' || str[i]=='t') i++;
  280. if (!str[i]) break;
  281. if (*count >=n ) {
  282. n += SPLIT_STRING_INCREASEMENT;
  283. if (!(realloc_tmp=realloc(pindex,n * sizeof(char *)))) {
  284. free(pindex);
  285. free(temp);
  286. return NULL;
  287. }
  288. pindex=(int *)realloc_tmp;
  289. }
  290. pindex[*count]=j;
  291. (*count)++;
  292. if (str[i]=='"') {
  293. i++;
  294. while (str[i]) {
  295. if (str[i]=='\') {
  296. i++;
  297. if (!str[i]) break;
  298. } else if (str[i]=='"') {
  299. i++;
  300. break;
  301. }
  302. temp[j++]=str[i++];
  303. }
  304. } else {
  305. while (str[i] && str[i] != ' ' && str[i] != 't') {
  306. temp[j++]=str[i++];
  307. }
  308. }
  309. temp[j++]='';
  310. }
  311. index_size= *count * sizeof(char *);
  312. if (!index_size) {
  313. free(temp);
  314. free(pindex);
  315. return NULL;
  316. }
  317. result=malloc(j+index_size);
  318. if (!result) {
  319. free(temp);
  320. free(pindex);
  321. return NULL;
  322. }
  323. memcpy(result+index_size,temp,j);
  324. for (i=0; i< *count; i++) {
  325. pindex[i] +=(int)result+index_size;
  326. }
  327. memcpy(result,pindex,index_size);
  328. free(temp);
  329. free(pindex);
  330. return (char * *)result;
  331. }
  333. #define COMBINE_STRING_INIT_LEN 1024
  334. #define COMBINE_STRING_INCREASEMENT 1024
  335. extern char * arraytostr(char * * array, char const * delim, int count)
  336. {
  337. int i;
  338. unsigned int n;
  339. char * result;
  340. char * realloc_tmp;
  341. int need_delim;
  343. if (!delim || !array) return NULL;
  345. n=COMBINE_STRING_INIT_LEN;
  346. result=malloc(n);
  347. if (!result) return NULL;
  348. result[0]='';
  350. need_delim=0;
  351. for (i=0; i<count; i++) {
  352. if (!array[i]) continue;
  353. if (strlen(result)+strlen(array[i])+strlen(delim)>=n) {
  354. n+=COMBINE_STRING_INCREASEMENT;
  355. if (!(realloc_tmp=realloc(result,n))) {
  356. free(result);
  357. return NULL;
  358. }
  359. result=realloc_tmp;
  360. }
  361. if (need_delim) {
  362. strcat(result,delim);
  363. }
  364. strcat(result,array[i]);
  365. need_delim=1;
  366. }
  367. if (!(realloc_tmp=realloc(result,strlen(result)+1))) {
  368. return result;
  369. }
  370. result=realloc_tmp;
  371. return result;
  372. }