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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
split.c
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：7k
源码类别：

MySQL数据库

开发平台：

Visual C++

split.c：源码内容
  1. #include <stdio.h>
  2. #include <string.h>
  4. /*
  5.  - split - divide a string into fields, like awk split()
  6.  = int split(char *string, char *fields[], int nfields, char *sep);
  7.  */
  8. int /* number of fields, including overflow */
  9. split(string, fields, nfields, sep)
  10. char *string;
  11. char *fields[]; /* list is not NULL-terminated */
  12. int nfields; /* number of entries available in fields[] */
  13. char *sep; /* "" white, "c" single char, "ab" [ab]+ */
  14. {
  15. register char *p = string;
  16. register char c; /* latest character */
  17. register char sepc = sep[0];
  18. register char sepc2;
  19. register int fn;
  20. register char **fp = fields;
  21. register char *sepp;
  22. register int trimtrail;
  24. /* white space */
  25. if (sepc == '') {
  26. while ((c = *p++) == ' ' || c == 't')
  27. continue;
  28. p--;
  29. trimtrail = 1;
  30. sep = (char*) " t"; /* note, code below knows this is 2 long */
  31. sepc = ' ';
  32. } else
  33. trimtrail = 0;
  34. sepc2 = sep[1]; /* now we can safely pick this up */
  36. /* catch empties */
  37. if (*p == '')
  38. return(0);
  40. /* single separator */
  41. if (sepc2 == '') {
  42. fn = nfields;
  43. for (;;) {
  44. *fp++ = p;
  45. fn--;
  46. if (fn == 0)
  47. break;
  48. while ((c = *p++) != sepc)
  49. if (c == '')
  50. return(nfields - fn);
  51. *(p-1) = '';
  52. }
  53. /* we have overflowed the fields vector -- just count them */
  54. fn = nfields;
  55. for (;;) {
  56. while ((c = *p++) != sepc)
  57. if (c == '')
  58. return(fn);
  59. fn++;
  60. }
  61. /* not reached */
  62. }
  64. /* two separators */
  65. if (sep[2] == '') {
  66. fn = nfields;
  67. for (;;) {
  68. *fp++ = p;
  69. fn--;
  70. while ((c = *p++) != sepc && c != sepc2)
  71. if (c == '') {
  72. if (trimtrail && **(fp-1) == '')
  73. fn++;
  74. return(nfields - fn);
  75. }
  76. if (fn == 0)
  77. break;
  78. *(p-1) = '';
  79. while ((c = *p++) == sepc || c == sepc2)
  80. continue;
  81. p--;
  82. }
  83. /* we have overflowed the fields vector -- just count them */
  84. fn = nfields;
  85. while (c != '') {
  86. while ((c = *p++) == sepc || c == sepc2)
  87. continue;
  88. p--;
  89. fn++;
  90. while ((c = *p++) != '' && c != sepc && c != sepc2)
  91. continue;
  92. }
  93. /* might have to trim trailing white space */
  94. if (trimtrail) {
  95. p--;
  96. while ((c = *--p) == sepc || c == sepc2)
  97. continue;
  98. p++;
  99. if (*p != '') {
  100. if (fn == nfields+1)
  101. *p = '';
  102. fn--;
  103. }
  104. }
  105. return(fn);
  106. }
  108. /* n separators */
  109. fn = 0;
  110. for (;;) {
  111. if (fn < nfields)
  112. *fp++ = p;
  113. fn++;
  114. for (;;) {
  115. c = *p++;
  116. if (c == '')
  117. return(fn);
  118. sepp = sep;
  119. while ((sepc = *sepp++) != '' && sepc != c)
  120. continue;
  121. if (sepc != '') /* it was a separator */
  122. break;
  123. }
  124. if (fn < nfields)
  125. *(p-1) = '';
  126. for (;;) {
  127. c = *p++;
  128. sepp = sep;
  129. while ((sepc = *sepp++) != '' && sepc != c)
  130. continue;
  131. if (sepc == '') /* it wasn't a separator */
  132. break;
  133. }
  134. p--;
  135. }
  137. /* not reached */
  138. }
  140. #ifdef TEST_SPLIT
  143. /*
  144.  * test program
  145.  * pgm runs regression
  146.  * pgm sep splits stdin lines by sep
  147.  * pgm str sep splits str by sep
  148.  * pgm str sep n splits str by sep n times
  149.  */
  150. int
  151. main(argc, argv)
  152. int argc;
  153. char *argv[];
  154. {
  155. char buf[512];
  156. register int n;
  157. # define MNF 10
  158. char *fields[MNF];
  160. if (argc > 4)
  161. for (n = atoi(argv[3]); n > 0; n--) {
  162. (void) strcpy(buf, argv[1]);
  163. }
  164. else if (argc > 3)
  165. for (n = atoi(argv[3]); n > 0; n--) {
  166. (void) strcpy(buf, argv[1]);
  167. (void) split(buf, fields, MNF, argv[2]);
  168. }
  169. else if (argc > 2)
  170. dosplit(argv[1], argv[2]);
  171. else if (argc > 1)
  172. while (fgets(buf, sizeof(buf), stdin) != NULL) {
  173. buf[strlen(buf)-1] = ''; /* stomp newline */
  174. dosplit(buf, argv[1]);
  175. }
  176. else
  177. regress();
  179. exit(0);
  180. }
  182. dosplit(string, seps)
  183. char *string;
  184. char *seps;
  185. {
  186. # define NF 5
  187. char *fields[NF];
  188. register int nf;
  190. nf = split(string, fields, NF, seps);
  191. print(nf, NF, fields);
  192. }
  194. print(nf, nfp, fields)
  195. int nf;
  196. int nfp;
  197. char *fields[];
  198. {
  199. register int fn;
  200. register int bound;
  202. bound = (nf > nfp) ? nfp : nf;
  203. printf("%d:t", nf);
  204. for (fn = 0; fn < bound; fn++)
  205. printf(""%s"%s", fields[fn], (fn+1 < nf) ? ", " : "n");
  206. }
  208. #define RNF 5 /* some table entries know this */
  209. struct {
  210. char *str;
  211. char *seps;
  212. int nf;
  213. char *fi[RNF];
  214. } tests[] = {
  215. "", " ", 0, { "" },
  216. " ", " ", 2, { "", "" },
  217. "x", " ", 1, { "x" },
  218. "xy", " ", 1, { "xy" },
  219. "x y", " ", 2, { "x", "y" },
  220. "abc def  g ", " ", 5, { "abc", "def", "", "g", "" },
  221. "  a bcd", " ", 4, { "", "", "a", "bcd" },
  222. "a b c d e f", " ", 6, { "a", "b", "c", "d", "e f" },
  223. " a b c d ", " ", 6, { "", "a", "b", "c", "d " },
  225. "", " _", 0, { "" },
  226. " ", " _", 2, { "", "" },
  227. "x", " _", 1, { "x" },
  228. "x y", " _", 2, { "x", "y" },
  229. "ab _ cd", " _", 2, { "ab", "cd" },
  230. " a_b  c ", " _", 5, { "", "a", "b", "c", "" },
  231. "a b c_d e f", " _", 6, { "a", "b", "c", "d", "e f" },
  232. " a b c d ", " _", 6, { "", "a", "b", "c", "d " },
  234. "", " _~", 0, { "" },
  235. " ", " _~", 2, { "", "" },
  236. "x", " _~", 1, { "x" },
  237. "x y", " _~", 2, { "x", "y" },
  238. "ab _~ cd", " _~", 2, { "ab", "cd" },
  239. " a_b  c~", " _~", 5, { "", "a", "b", "c", "" },
  240. "a b_c d~e f", " _~", 6, { "a", "b", "c", "d", "e f" },
  241. "~a b c d ", " _~", 6, { "", "a", "b", "c", "d " },
  243. "", " _~-", 0, { "" },
  244. " ", " _~-", 2, { "", "" },
  245. "x", " _~-", 1, { "x" },
  246. "x y", " _~-", 2, { "x", "y" },
  247. "ab _~- cd", " _~-", 2, { "ab", "cd" },
  248. " a_b  c~", " _~-", 5, { "", "a", "b", "c", "" },
  249. "a b_c-d~e f", " _~-", 6, { "a", "b", "c", "d", "e f" },
  250. "~a-b c d ", " _~-", 6, { "", "a", "b", "c", "d " },
  252. "", "  ", 0, { "" },
  253. " ", "  ", 2, { "", "" },
  254. "x", "  ", 1, { "x" },
  255. "xy", "  ", 1, { "xy" },
  256. "x y", "  ", 2, { "x", "y" },
  257. "abc def  g ", "  ", 4, { "abc", "def", "g", "" },
  258. "  a bcd", "  ", 3, { "", "a", "bcd" },
  259. "a b c d e f", "  ", 6, { "a", "b", "c", "d", "e f" },
  260. " a b c d ", "  ", 6, { "", "a", "b", "c", "d " },
  262. "", "", 0, { "" },
  263. " ", "", 0, { "" },
  264. "x", "", 1, { "x" },
  265. "xy", "", 1, { "xy" },
  266. "x y", "", 2, { "x", "y" },
  267. "abc def  g ", "", 3, { "abc", "def", "g" },
  268. "t a bcd", "", 2, { "a", "bcd" },
  269. "  a tbt c ", "", 3, { "a", "b", "c" },
  270. "a b c d e ", "", 5, { "a", "b", "c", "d", "e" },
  271. "a btc d e f", "", 6, { "a", "b", "c", "d", "e f" },
  272. " a b c d e f ", "", 6, { "a", "b", "c", "d", "e f " },
  274. NULL, NULL, 0, { NULL },
  275. };
  277. regress()
  278. {
  279. char buf[512];
  280. register int n;
  281. char *fields[RNF+1];
  282. register int nf;
  283. register int i;
  284. register int printit;
  285. register char *f;
  287. for (n = 0; tests[n].str != NULL; n++) {
  288. (void) strcpy(buf, tests[n].str);
  289. fields[RNF] = NULL;
  290. nf = split(buf, fields, RNF, tests[n].seps);
  291. printit = 0;
  292. if (nf != tests[n].nf) {
  293. printf("split `%s' by `%s' gave %d fields, not %dn",
  294. tests[n].str, tests[n].seps, nf, tests[n].nf);
  295. printit = 1;
  296. } else if (fields[RNF] != NULL) {
  297. printf("split() went beyond array endn");
  298. printit = 1;
  299. } else {
  300. for (i = 0; i < nf && i < RNF; i++) {
  301. f = fields[i];
  302. if (f == NULL)
  303. f = "(NULL)";
  304. if (strcmp(f, tests[n].fi[i]) != 0) {
  305. printf("split `%s' by `%s', field %d is `%s', not `%s'n",
  306. tests[n].str, tests[n].seps,
  307. i, fields[i], tests[n].fi[i]);
  308. printit = 1;
  309. }
  310. }
  311. }
  312. if (printit)
  313. print(nf, RNF, fields);
  314. }
  315. }
  316. #endif