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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 手机短信编程 > 查看源码
token.c
资源名称：sms_client-2.0.7k.tgz　[点击查看]
上传用户：mei_mei897
上传日期：2007-01-05
资源大小：82k
文件大小：7k
源码类别：

手机短信编程

开发平台：

Unix_Linux

token.c：源码内容
  1. /* -------------------------------------------------------------------- */
  2. /* SMS Client, send messages to mobile phones and pagers */
  3. /* */
  4. /* token.c */
  5. /* */
  6. /*  Copyright (C) 1997,1998 Angelo Masci */
  7. /* */
  8. /*  This library is free software; you can redistribute it and/or */
  9. /*  modify it under the terms of the GNU Library General Public */
  10. /*  License as published by the Free Software Foundation; either */
  11. /*  version 2 of the License, or (at your option) any later version. */
  12. /* */
  13. /*  This library is distributed in the hope that it will be useful, */
  14. /*  but WITHOUT ANY WARRANTY; without even the implied warranty of */
  15. /*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU */
  16. /*  Library General Public License for more details. */
  17. /* */
  18. /*  You should have received a copy of the GNU Library General Public */
  19. /*  License along with this library; if not, write to the Free */
  20. /*  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
  21. /* */
  22. /*  You can contact the author at this e-mail address: */
  23. /* */
  24. /*  angelo@styx.demon.co.uk */
  25. /* */
  26. /* -------------------------------------------------------------------- */
  27. /* $Id$
  28.    -------------------------------------------------------------------- */
  30. #include <stdio.h>
  31. #include <ctype.h>
  32. #include <string.h>
  34. #include "token.h"
  35. #include "common.h"
  37. /* -------------------------------------------------------------------- */
  38. /* -------------------------------------------------------------------- */
  39. char *get_line(char *str, int n, int *line_count, FILE *fp)
  40. {
  41. char *ptr;
  43. (*line_count)++;
  44. while(fgets(str, n, fp) != NULL)
  45. {
  46. ptr = str;
  47. while(isspace(*ptr))
  48. { ptr++;
  49. }
  51. if (*ptr != '')
  52. { return str;
  53. }
  55. (*line_count)++; /* A blank line was skipped  */
  56. /* so increment the line count */
  57. }
  59. return NULL;
  60. }
  62. /* -------------------------------------------------------------------- */
  63. /* -------------------------------------------------------------------- */
  64. int escape_char_token(char *token, int maxlen, char *ptr, char **eptr)
  65. {
  66. int  type;
  69. ptr++;
  70. if (*ptr == 'a')
  71. { /* a  */
  73. type     = ALERT_TOKEN;
  74. token[0] = 'f';
  75. token[1] = '';
  76. *eptr    = ++ptr;
  77. }
  78. else
  79. if (*ptr == 'b')
  80. { /* b */
  82. type     = BACKSPACE_TOKEN;
  83. token[0] = 'b';
  84. token[1] = '';
  85. *eptr    = ++ptr;
  86. }
  87. else
  88. if (*ptr == 'f')
  89. { /* f  */
  91. type     = FORMFEED_TOKEN;
  92. token[0] = 'f';
  93. token[1] = '';
  94. *eptr    = ++ptr;
  95. }
  96. else
  97. if (*ptr == 'n')
  98. { /* n  */
  100. type     = NEWLINE_TOKEN;
  101. token[0] = 'n';
  102. token[1] = '';
  103. *eptr    = ++ptr;
  104. }
  105. else
  106. if (*ptr == 'r')
  107. { /* r  */
  109. type     = CARRIAGE_RETURN_TOKEN;
  110. token[0] = 'r';
  111. token[1] = '';
  112. *eptr    = ++ptr;
  113. }
  114. else
  115. if (*ptr == 't')
  116. { /* t  */
  118. type     = HORIZONTAL_TAB_TOKEN;
  119. token[0] = 't';
  120. token[1] = '';
  121. *eptr    = ++ptr;
  122. }
  123. else
  124. if (*ptr == 'v')
  125. { /* v  */
  127. type     = VERTICLE_TAB_TOKEN;
  128. token[0] = 'v';
  129. token[1] = '';
  130. *eptr    = ++ptr;
  131. }
  132. else
  133. if (*ptr == 'x')
  134. { /* x  */
  136. int low_nibble,
  137. high_nibble;
  139. ptr++;
  140. if (isxdigit(*ptr))
  141. {
  142. if ((*ptr >= '0') && (*ptr <= '9'))
  143. {
  144. high_nibble = (*ptr - '0') << 4;
  145. }
  146. else
  147. if ((*ptr >= 'a') && (*ptr <= 'f'))
  148. {
  149. high_nibble = (10 + (*ptr - 'a')) << 4;
  150. }
  151. else
  152. { high_nibble = (10 + (*ptr - 'A')) << 4;
  153. }
  155. ptr++;
  156. if (isxdigit(*ptr))
  157. {
  158. if ((*ptr >= '0') && (*ptr <= '9'))
  159. {
  160. low_nibble = (*ptr - '0');
  161. }
  162. else
  163. if ((*ptr >= 'a') && (*ptr <= 'f'))
  164. {
  165. low_nibble = (10 + (*ptr - 'a'));
  166. }
  167. else
  168. { low_nibble = (10 + (*ptr - 'A'));
  169. }
  171. type     = HEX_TOKEN;
  172. token[0] = high_nibble + low_nibble;
  173. token[1] = '';
  174. *eptr    = ++ptr;
  175. }
  176. else
  177. { type     = ERROR_HEX_TOKEN;
  179. ptr -= 3;
  180. token[0] = *ptr++;
  181. token[1] = *ptr++;
  182. token[2] = *ptr++;
  183. token[3] = '';
  185. *eptr    = ptr;
  186. }
  187. }
  188. else
  189. { type     = ERROR_HEX_TOKEN;
  191. ptr -= 2;
  192. token[0] = *ptr++;
  193. token[1] = *ptr++;
  194. token[2] = '';
  196. *eptr    = ptr;
  197. }
  198. }
  199. else
  200. if (*ptr == '\')
  201. { /*   */
  203. type     = BACKSLASH_TOKEN;
  204. token[0] = '\';
  205. token[1] = '';
  206. *eptr    = ++ptr;
  207. }
  208. else
  209. if (*ptr == '"')
  210. { /* Quote */
  212. type     = QUOTE_TOKEN;
  213. token[0] = '"';
  214. token[1] = '';
  215. *eptr    = ++ptr;
  216. }
  217. else
  218. if (*ptr == ''')
  219. { /* Single Quote */
  221. type     = SINGLE_QUOTE_TOKEN;
  222. token[0] = ''';
  223. token[1] = '';
  224. *eptr    = ++ptr;
  225. }
  226. else
  227. { type     = BACKSLASH_TOKEN;
  228. token[0] = '\';
  229. token[1] = '';
  231. *eptr    = ptr;
  232. }
  234. return type;
  235. }
  237. /* -------------------------------------------------------------------- */
  238. /* -------------------------------------------------------------------- */
  239. int isstring(char c)
  240. {
  241. if (isspace(c))
  242. { return FALSE;
  243. }
  245. if ((c != '"') &&
  246.     (c != ''') &&
  247.     (c != '#') &&
  248.     (c != '=') &&
  249.     (c != '') &&
  250.     (c != 'n'))
  251. { return TRUE;
  252. }
  254. return FALSE;
  255. }
  257. /* -------------------------------------------------------------------- */
  258. /* -------------------------------------------------------------------- */
  259. int get_token(char *token, int maxlen, char *ptr, char **eptr)
  260. {
  261. int type,
  262. i;
  265. while (isspace(*ptr)) /* Skip white space  */
  266. { ptr++;
  267. }
  269. if (isstring(*ptr))
  270. {
  271. type = STRING_TOKEN;
  273. for (i=0; i<(maxlen -1); i++)
  274. {
  275. if (*ptr == '')
  276. { break;
  277. }
  279. if (!isstring(*ptr))
  280. { break;
  281. }
  283. if (*ptr == '\')
  284. {
  285. char etoken[128];
  287. escape_char_token(etoken, maxlen, ptr, &ptr);
  289. token[i] = '';
  290. sms_strcat(token, etoken);
  291. continue;
  292. }
  294. token[i] = *ptr;
  295. ptr++;
  296. }
  298. token[i] = '';
  299. *eptr    = ptr;
  300. } 
  301. else
  302. if (*ptr == '"') /* Quoted String  */
  303. { /* All characters within */
  304. /* doublequotes  */
  305. /* If missing closing quote */
  306. /* Quoted String Error token */
  307. /* returned */
  309. char etoken[128];
  312. type = QUOTED_STRING_TOKEN;
  314. ptr++;
  315. for (i=0; i<(maxlen -1); i++)
  316. {
  317. if (*ptr == '')
  318. { break;
  319. }
  321. if (*ptr == '\')
  322. {
  323. escape_char_token(etoken, maxlen, ptr, &ptr);
  325. token[i] = '';
  326. sms_strcat(token, etoken);
  327. continue;
  328. }
  329. else
  330. if (*ptr == '"')
  331. { break;
  332. }
  334. token[i] = *ptr;
  335. ptr++;
  336. }
  338. if (*ptr != '"')
  339. { type = QUOTED_STRING_ERROR_TOKEN;
  340. }
  341. else
  342. { ptr++;
  343. }
  345. token[i] = '';
  346. *eptr    = ptr;
  347. }
  348. else
  349. if (*ptr == ''') /* Single Quoted String  */
  350. { /* All characters within */
  351. /* singlequotes  */
  352. /* If missing closing quote */
  353. /* Single Quoted String Error  */
  354. /* token returned */
  357. type = SINGLE_QUOTED_STRING_TOKEN;
  359. ptr++;
  361. for (i=0; i<(maxlen -1); i++)
  362. {
  363. if (*ptr == '')
  364. { break;
  365. }
  367. if (*ptr == ''')
  368. { break;
  369. }
  371. token[i] = *ptr;
  372. ptr++;
  373. }
  375. if (*ptr != ''')
  376. { type = SINGLE_QUOTED_STRING_ERROR_TOKEN;
  377. }
  378. else
  379. { ptr++;
  380. }
  382. token[i] = '';
  383. *eptr    = ptr;
  384. }
  385. else
  386. if (*ptr == '#') /* Comment */
  387. {
  388. type     = COMMENT_TOKEN;
  390. ptr++;
  392. i = 0;
  393. while (*ptr != '')
  394. { token[i] = *ptr++;
  395. }
  397. token[i] = *ptr;
  398. *eptr    = ptr;
  399. }
  400. else
  401. if (*ptr == '=') /* Assignment */
  402. {
  403. type     = ASSIGNMENT_TOKEN;
  404. token[0] = '=';
  405. token[1] = '';
  406. *eptr    = ++ptr;
  407. }
  408. else
  409. if ((*ptr == '') || (*ptr == 'n')) /* EOL */
  410. {
  411. type     = NULL_TOKEN;
  412. token[0] = '';
  413. *eptr    = ptr;
  414. }
  415. else
  416. { type = UNKNOWN_TOKEN;
  418. for (i=0; i<(maxlen -1); i++)
  419. {
  420. if (*ptr == '')
  421. { break;
  422. }
  424. token[i] = *ptr;
  425. ptr++;
  426. }
  428. token[i] = '';
  429. *eptr    = ptr;
  430. }
  432. return type;
  433. }