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

源码开发语言/平台
当前位置：首页 > 电子书籍 > VC书籍 > 查看源码
text.c
资源名称：c.rar　[点击查看]
上传用户：shmaik
上传日期：2014-06-01
资源大小：45093k
文件大小：10k
源码类别：

VC书籍

开发平台：

C/C++

text.c：源码内容
  1. static char rcsid[] = "$Id: H:/drh/idioms/book/RCS/text.doc,v 1.10 1996/06/26 23:02:01 drh Exp $";
  2. #include <string.h>
  3. #include <limits.h>
  4. #include "assert.h"
  5. #include "fmt.h"
  6. #include "text.h"
  7. #include "mem.h"
  8. #define T Text_T
  9. #define idx(i, len) ((i) <= 0 ? (i) + (len) : (i) - 1)
  10. #define isatend(s, n) ((s).str+(s).len == current->avail
  11. && current->avail + (n) <= current->limit)
  12. #define equal(s, i, t) 
  13. (memcmp(&(s).str[i], (t).str, (t).len) == 0)
  14. struct Text_save_T {
  15. struct chunk *current;
  16. char *avail;
  17. };
  18. static char cset[] =
  19. "00010203040506071011121314151617"
  20. "20212223242526273031323334353637"
  21. "40414243444546475051525354555657"
  22. "60616263646566677071727374757677"
  23. "100101102103104105106107110111112113114115116117"
  24. "120121122123124125126127130131132133134135136137"
  25. "140141142143144145146147150151152153154155156157"
  26. "160161162163164165166167170171172173174175176177"
  27. "200201202203204205206207210211212213214215216217"
  28. "220221222223224225226227230231232233234235236237"
  29. "240241242243244245246247250251252253254255256257"
  30. "260261262263264265266267270271272273274275276277"
  31. "300301302303304305306307310311312313314315316317"
  32. "320321322323324325326327330331332333334335336337"
  33. "340341342343344345346347350351352353354355356357"
  34. "360361362363364365366367370371372373374375376377"
  35. ;
  36. const T Text_cset   = { 256, cset };
  37. const T Text_ascii  = { 127, cset };
  38. const T Text_ucase  = {  26, cset + 'A' };
  39. const T Text_lcase  = {  26, cset + 'a' };
  40. const T Text_digits = {  10, cset + '0' };
  41. const T Text_null   = {   0, cset };
  42. static struct chunk {
  43. struct chunk *link;
  44. char *avail;
  45. char *limit;
  46. } head = { NULL, NULL, NULL }, *current = &head;
  47. static char *alloc(int len) {
  48. assert(len >= 0);
  49. if (current->avail + len > current->limit) {
  50. current = current->link = 
  51. ALLOC(sizeof (*current) + 10*1024 + len);
  52. current->avail = (char *)(current + 1);
  53. current->limit = current->avail + 10*1024 + len;
  54. current->link = NULL;
  55. }
  56. current->avail += len;
  57. return current->avail - len;
  58. }
  59. int Text_pos(T s, int i) {
  60. assert(s.len >= 0 && s.str);
  61. i = idx(i, s.len);
  62. assert(i >= 0 && i <= s.len);
  63. return i + 1;
  64. }
  65. T Text_box(const char *str, int len) {
  66. T text;
  67. assert(str);
  68. assert(len >= 0);
  69. text.str = str;
  70. text.len = len;
  71. return text;
  72. }
  73. T Text_sub(T s, int i, int j) {
  74. T text;
  75. assert(s.len >= 0 && s.str);
  76. i = idx(i, s.len);
  77. j = idx(j, s.len);
  78. if (i > j) { int t = i; i = j; j = t; }
  79. assert(i >= 0 && j <= s.len);
  80. text.len = j - i;
  81. text.str = s.str + i;
  82. return text;
  83. }
  84. T Text_put(const char *str) {
  85. T text;
  86. assert(str);
  87. text.len = strlen(str);
  88. text.str = memcpy(alloc(text.len), str, text.len);
  89. return text;
  90. }
  91. char *Text_get(char *str, int size, T s) {
  92. assert(s.len >= 0 && s.str);
  93. if (str == NULL)
  94. str = ALLOC(s.len + 1);
  95. else
  96. assert(size >= s.len + 1);
  97. memcpy(str, s.str, s.len);
  98. str[s.len] = '';
  99. return str;
  100. }
  101. T Text_dup(T s, int n) {
  102. assert(s.len >= 0 && s.str);
  103. assert(n >= 0);
  104. if (n == 0 || s.len == 0)
  105. return Text_null;
  106. if (n == 1)
  107. return s;
  108. {
  109. T text;
  110. char *p;
  111. text.len = n*s.len;
  112. if (isatend(s, text.len - s.len)) {
  113. text.str = s.str;
  114. p = alloc(text.len - s.len);
  115. n--;
  116. } else
  117. text.str = p = alloc(text.len);
  118. for ( ; n-- > 0; p += s.len)
  119. memcpy(p, s.str, s.len);
  120. return text;
  121. }
  122. }
  123. T Text_cat(T s1, T s2) {
  124. assert(s1.len >= 0 && s1.str);
  125. assert(s2.len >= 0 && s2.str);
  126. if (s1.len == 0)
  127. return s2;
  128. if (s2.len == 0)
  129. return s1;
  130. if (s1.str + s1.len == s2.str) {
  131. s1.len += s2.len;
  132. return s1;
  133. }
  134. {
  135. T text;
  136. text.len = s1.len + s2.len;
  137. if (isatend(s1, s2.len)) {
  138. text.str = s1.str;
  139. memcpy(alloc(s2.len), s2.str, s2.len);
  140. } else {
  141. char *p;
  142. text.str = p = alloc(s1.len + s2.len);
  143. memcpy(p,          s1.str, s1.len);
  144. memcpy(p + s1.len, s2.str, s2.len);
  145. }
  146. return text;
  147. } 
  148. }
  149. T Text_reverse(T s) {
  150. assert(s.len >= 0 && s.str);
  151. if (s.len == 0)
  152. return Text_null;
  153. else if (s.len == 1)
  154. return s;
  155. else {
  156. T text;
  157. char *p;
  158. int i = s.len;
  159. text.len = s.len;
  160. text.str = p = alloc(s.len);
  161. while (--i >= 0)
  162. *p++ = s.str[i];
  163. return text;
  164. }
  165. }
  166. T Text_map(T s, const T *from, const T *to) {
  167. static char map[256];
  168. static int inited = 0;
  169. assert(s.len >= 0 && s.str);
  170. if (from && to) {
  171. int k;
  172. for (k = 0; k < (int)sizeof map; k++)
  173. map[k] = k;
  174. assert(from->len == to->len);
  175. for (k = 0; k < from->len; k++)
  176. map[from->str[k]] = to->str[k];
  177. inited = 1;
  178. } else {
  179. assert(from == NULL && to == NULL);
  180. assert(inited);
  181. }
  182. if (s.len == 0)
  183. return Text_null;
  184. else {
  185. T text;
  186. int i;
  187. char *p;
  188. text.len = s.len;
  189. text.str = p = alloc(s.len);
  190. for (i = 0; i < s.len; i++)
  191. *p++ = map[s.str[i]];
  192. return text;
  193. }
  194. }
  195. int Text_cmp(T s1, T s2) {
  196. assert(s1.len >= 0 && s1.str);
  197. assert(s2.len >= 0 && s2.str);
  198. if (s1.str == s2.str)
  199. return s1.len - s2.len;
  200. else if (s1.len < s2.len) {
  201. int cond = memcmp(s1.str, s2.str, s1.len);
  202. return cond == 0 ? -1 : cond;
  203. } else if (s1.len > s2.len) {
  204. int cond = memcmp(s1.str, s2.str, s2.len);
  205. return cond == 0 ? +1 : cond;
  206. } else
  207. return memcmp(s1.str, s2.str, s1.len);
  208. }
  209. Text_save_T Text_save(void) {
  210. Text_save_T save;
  211. NEW(save);
  212. save->current = current;
  213. save->avail = current->avail;
  214. alloc(1);
  215. return save;
  216. }
  217. void Text_restore(Text_save_T *save) {
  218. struct chunk *p, *q;
  219. assert(save && *save);
  220. current = (*save)->current;
  221. current->avail = (*save)->avail;
  222. FREE(*save);
  223. for (p = current->link; p; p = q) {
  224. q = p->link;
  225. FREE(p);
  226. }
  227. current->link = NULL;
  228. }
  229. int Text_chr(T s, int i, int j, int c) {
  230. assert(s.len >= 0 && s.str);
  231. i = idx(i, s.len);
  232. j = idx(j, s.len);
  233. if (i > j) { int t = i; i = j; j = t; }
  234. assert(i >= 0 && j <= s.len);
  235. for ( ; i < j; i++)
  236. if (s.str[i] == c)
  237. return i + 1;
  238. return 0;
  239. }
  240. int Text_rchr(T s, int i, int j, int c) {
  241. assert(s.len >= 0 && s.str);
  242. i = idx(i, s.len);
  243. j = idx(j, s.len);
  244. if (i > j) { int t = i; i = j; j = t; }
  245. assert(i >= 0 && j <= s.len);
  246. while (j > i)
  247. if (s.str[--j] == c)
  248. return j + 1;
  249. return 0;
  250. }
  251. int Text_upto(T s, int i, int j, T set) {
  252. assert(set.len >= 0 && set.str);
  253. assert(s.len >= 0 && s.str);
  254. i = idx(i, s.len);
  255. j = idx(j, s.len);
  256. if (i > j) { int t = i; i = j; j = t; }
  257. assert(i >= 0 && j <= s.len);
  258. for ( ; i < j; i++)
  259. if (memchr(set.str, s.str[i], set.len))
  260. return i + 1;
  261. return 0;
  262. }
  263. int Text_rupto(T s, int i, int j, T set) {
  264. assert(set.len >= 0 && set.str);
  265. assert(s.len >= 0 && s.str);
  266. i = idx(i, s.len);
  267. j = idx(j, s.len);
  268. if (i > j) { int t = i; i = j; j = t; }
  269. assert(i >= 0 && j <= s.len);
  270. while (j > i)
  271. if (memchr(set.str, s.str[--j], set.len))
  272. return j + 1;
  273. return 0;
  274. }
  275. int Text_find(T s, int i, int j, T str) {
  276. assert(str.len >= 0 && str.str);
  277. assert(s.len >= 0 && s.str);
  278. i = idx(i, s.len);
  279. j = idx(j, s.len);
  280. if (i > j) { int t = i; i = j; j = t; }
  281. assert(i >= 0 && j <= s.len);
  282. if (str.len == 0)
  283. return i + 1;
  284. else if (str.len == 1) {
  285. for ( ; i < j; i++)
  286. if (s.str[i] == *str.str)
  287. return i + 1;
  288. } else
  289. for ( ; i + str.len <= j; i++)
  290. if (equal(s, i, str))
  291. return i + 1;
  292. return 0;
  293. }
  294. int Text_rfind(T s, int i, int j, T str) {
  295. assert(str.len >= 0 && str.str);
  296. assert(s.len >= 0 && s.str);
  297. i = idx(i, s.len);
  298. j = idx(j, s.len);
  299. if (i > j) { int t = i; i = j; j = t; }
  300. assert(i >= 0 && j <= s.len);
  301. if (str.len == 0)
  302. return j + 1;
  303. else if (str.len == 1) {
  304. while (j > i)
  305. if (s.str[--j] == *str.str)
  306. return j + 1;
  307. } else
  308. for ( ; j - str.len >= i; j--)
  309. if (equal(s, j - str.len, str))
  310. return j - str.len + 1;
  311. return 0;
  312. }
  313. int Text_any(T s, int i, T set) {
  314. assert(s.len >= 0 && s.str);
  315. assert(set.len >= 0 && set.str);
  316. i = idx(i, s.len);
  317. assert(i >= 0 && i <= s.len);
  318. if (i < s.len && memchr(set.str, s.str[i], set.len))
  319. return i + 2;
  320. return 0;
  321. }
  322. int Text_many(T s, int i, int j, T set) {
  323. assert(set.len >= 0 && set.str);
  324. assert(s.len >= 0 && s.str);
  325. i = idx(i, s.len);
  326. j = idx(j, s.len);
  327. if (i > j) { int t = i; i = j; j = t; }
  328. assert(i >= 0 && j <= s.len);
  329. if (i < j && memchr(set.str, s.str[i], set.len)) {
  330. do
  331. i++;
  332. while (i < j
  333. && memchr(set.str, s.str[i], set.len));
  334. return i + 1;
  335. }
  336. return 0;
  337. }
  338. int Text_rmany(T s, int i, int j, T set) {
  339. assert(set.len >= 0 && set.str);
  340. assert(s.len >= 0 && s.str);
  341. i = idx(i, s.len);
  342. j = idx(j, s.len);
  343. if (i > j) { int t = i; i = j; j = t; }
  344. assert(i >= 0 && j <= s.len);
  345. if (j > i && memchr(set.str, s.str[j-1], set.len)) {
  346. do
  347. --j;
  348. while (j >= i
  349. && memchr(set.str, s.str[j], set.len));
  350. return j + 2;
  351. }
  352. return 0;
  353. }
  354. int Text_match(T s, int i, int j, T str) {
  355. assert(str.len >= 0 && str.str);
  356. assert(s.len >= 0 && s.str);
  357. i = idx(i, s.len);
  358. j = idx(j, s.len);
  359. if (i > j) { int t = i; i = j; j = t; }
  360. assert(i >= 0 && j <= s.len);
  361. if (str.len == 0)
  362. return i + 1;
  363. else if (str.len == 1) {
  364. if (i < j && s.str[i] == *str.str)
  365. return i + 2;
  366. } else if (i + str.len <= j && equal(s, i, str))
  367. return i + str.len + 1;
  368. return 0;
  369. }
  370. int Text_rmatch(T s, int i, int j, T str) {
  371. assert(str.len >= 0 && str.str);
  372. assert(s.len >= 0 && s.str);
  373. i = idx(i, s.len);
  374. j = idx(j, s.len);
  375. if (i > j) { int t = i; i = j; j = t; }
  376. assert(i >= 0 && j <= s.len);
  377. if (str.len == 0)
  378. return j + 1;
  379. else if (str.len == 1) {
  380. if (j > i && s.str[j-1] == *str.str)
  381. return j;
  382. } else if (j - str.len >= i
  383. && equal(s, j - str.len, str))
  384. return j - str.len + 1;
  385. return 0;
  386. }
  387. void Text_fmt(int code, va_list *app,
  388. int put(int c, void *cl), void *cl,
  389. unsigned char flags[], int width, int precision) {
  390. T *s;
  391. assert(app && flags);
  392. s = va_arg(*app, T*);
  393. assert(s && s->len >= 0 && s->str);
  394. Fmt_puts(s->str, s->len, put, cl, flags,
  395. width, precision);
  396. }