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

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

手机短信编程

开发平台：

Unix_Linux

gs_parser.c：源码内容
  1. /* -------------------------------------------------------------------- */
  2. /* SMS Client, send messages to mobile phones and pagers */
  3. /* */
  4. /* gs_parser.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 <string.h>
  32. #include <ctype.h>
  33. #include <stdlib.h>
  35. #include "common.h"
  36. #include "logfile.h"
  37. #include "gs_token.h"
  38. #include "gs_parser.h"
  40. /* -------------------------------------------------------------------- */
  41. /* -------------------------------------------------------------------- */
  42. int parse_dictionary(TOKEN_HEAP *heap)
  43. {
  44. TOKEN_ID
  45. token_id;
  48. lprintf(LOG_VERYVERBOSE, "Entering parse_dictionary()n");
  50. token_id = get_next_token(heap);
  51. if (token_id == lcurly_tok)
  52. {
  53. if (parse_dictionary_items(heap))
  54. {
  55. token_id = get_next_token(heap);
  56. if (token_id == rcurly_tok)
  57. { return TRUE;
  58. }
  59. else
  60. { lprintf(LOG_ERROR, "Expecting '}'n");
  61. return FALSE;
  62. }
  63. }
  64. else
  65. { lprintf(LOG_ERROR, "Expecting Dictionary itemsn");
  66. return FALSE;
  67. }
  68. }
  69. else
  70. {
  71. lprintf(LOG_ERROR, "Expecting '{'n");
  72. return FALSE;
  73. }
  75. return TRUE;
  76. }
  79. /* -------------------------------------------------------------------- */
  80. /* -------------------------------------------------------------------- */
  81. int parse_list(TOKEN_HEAP *heap)
  82. {
  83. TOKEN_ID
  84. token_id;
  87. lprintf(LOG_VERYVERBOSE, "Entering parse_list()n");
  90. token_id = get_next_token(heap);
  91. if (token_id == lparen_tok)
  92. {
  93. if (parse_list_items(heap, 0))
  94. {
  95. token_id = get_next_token(heap);
  96. if (token_id == rparen_tok)
  97. { return TRUE;
  98. }
  99. else
  100. { lprintf(LOG_ERROR, "Expecting ')'n");
  101. return FALSE;
  102. }
  103. }
  104. else
  105. { lprintf(LOG_ERROR, "Expecting List itemsn");
  106. return FALSE;
  107. }
  108. }
  109. else
  110. {
  111. lprintf(LOG_ERROR, "Expecting '('n");
  112. return FALSE;
  113. }
  115. return TRUE;
  116. }
  119. /* -------------------------------------------------------------------- */
  120. /* -------------------------------------------------------------------- */
  121. int parse_list_items(TOKEN_HEAP *heap, int depth)
  122. {
  123. TOKEN_ID
  124. token_id,
  125. identifier;
  128. TOKEN_HEAP
  129. *dictionary,
  130. *list;
  132. char buf[16],
  133. *string;
  137. lprintf(LOG_VERYVERBOSE, "Entering parse_list_items()n");
  139. sprintf(buf, "[%d]", depth);
  140. identifier = add_token(heap, buf, T_IDENTIFIER, NULL);
  142. depth++;
  144. token_id = get_next_token(heap);
  145. if (token_id == lcurly_tok)
  146. {
  147. dictionary = generate_new_heap();
  148. if (dictionary == NULL)
  149. { lprintf(LOG_ERROR, "Allocating memoryn");
  150. return FALSE;
  151. }
  153. token_assign_dictionary(heap, identifier, dictionary);
  155. push_back_token(token_id);
  156. if (parse_dictionary(dictionary))
  157. {
  158. token_id = get_next_token(heap);
  159. if (token_id == comma_tok)
  160. {
  161. return parse_list_items(heap, depth);
  162. }
  163. else
  164. { push_back_token(token_id);
  165. return TRUE;
  166. }
  167. }
  168. else
  169. { lprintf(LOG_ERROR, "Failed parsing Dictionaryn");
  170. return FALSE;
  171. }
  172. }
  173. else
  174. if (token_id == lparen_tok)
  175. {
  176. list = generate_new_heap();
  177. if (list == NULL)
  178. { lprintf(LOG_ERROR, "Allocating memoryn");
  179. return FALSE;
  180. }
  182. token_assign_list(heap, identifier, list);
  184. push_back_token(token_id);
  185. if(parse_list(list))
  186. {
  187. token_id = get_next_token(heap);
  188. if (token_id == comma_tok)
  189. {
  190. return parse_list_items(heap, depth);
  191. }
  192. else
  193. { push_back_token(token_id);
  194. return TRUE;
  195. }
  196. }
  197. else
  198. { lprintf(LOG_ERROR, "Failed parsing Listn");
  199. return FALSE;
  200. }
  201. }
  202. else
  203. if (get_token_type(heap, token_id) == T_STRING)
  204. {
  205. string = get_token_strvalue(heap, token_id);
  206. token_assign_value(heap, identifier, string);
  208. token_id = get_next_token(heap);
  209. if (token_id == comma_tok)
  210. {
  211. return parse_list_items(heap, depth);
  212. }
  213. else
  214. { push_back_token(token_id);
  215. return TRUE;
  216. }
  217. }
  218. else
  219. {
  220. lprintf(LOG_ERROR, "Expecting Identifier, Dictionary or Listn");
  221. return FALSE;
  222. }
  224. return TRUE; 
  225. }
  228. /* -------------------------------------------------------------------- */
  229. /* -------------------------------------------------------------------- */
  230. int parse_dictionary_items(TOKEN_HEAP *heap)
  231. {
  232. TOKEN_ID
  233. token_id,
  234. identifier;
  236. TOKEN_HEAP
  237. *dictionary,
  238. *list;
  240. char *string;
  243. lprintf(LOG_VERYVERBOSE, "Entering parse_dictionary_items()n");
  245. token_id = get_next_token(heap);
  246. if (get_token_type(heap, token_id) == T_IDENTIFIER)
  247. {
  248. identifier = token_id;
  250. token_id = get_next_token(heap);
  251. if (token_id == assignment_tok)
  252. {
  253. token_id = get_next_token(heap);
  254. if (token_id == lcurly_tok)
  255. {
  256. dictionary = generate_new_heap();
  257. if (dictionary == NULL)
  258. { lprintf(LOG_ERROR, "Allocating memoryn");
  259. return FALSE;
  260. }
  262. token_assign_dictionary(heap, identifier, dictionary);
  264. push_back_token(token_id);
  265. if (parse_dictionary(dictionary))
  266. {
  267. token_id = get_next_token(heap);
  268. if (token_id == semicolon_tok)
  269. {
  270. token_id = get_next_token(heap);
  271. if (token_id != rcurly_tok)
  272. {
  273. push_back_token(token_id);
  274. return parse_dictionary_items(heap);
  275. }
  276. else
  277. { push_back_token(token_id);
  278. return TRUE;
  279. }
  280. }
  281. else
  282. { lprintf(LOG_ERROR, "Failed parsing dictionary items semicolon expectedn");
  283. return FALSE;
  284. }
  285. }
  286. else
  287. { lprintf(LOG_ERROR, "Failed parsing Dictionaryn");
  288. return FALSE;
  289. }
  291. }
  292. else
  293. if (token_id == lparen_tok)
  294. {
  295. list = generate_new_heap();
  296. if (list == NULL)
  297. { lprintf(LOG_ERROR, "Allocating memoryn");
  298. return FALSE;
  299. }
  301. token_assign_list(heap, identifier, list);
  303. push_back_token(token_id);
  304. if(parse_list(list))
  305. {
  306. token_id = get_next_token(heap);
  307. if (token_id == semicolon_tok)
  308. {
  309. token_id = get_next_token(heap);
  310. if (token_id != rcurly_tok)
  311. {
  312. push_back_token(token_id);
  313. return parse_dictionary_items(heap);
  314. }
  315. else
  316. { push_back_token(token_id);
  317. return TRUE;
  318. }
  319. }
  320. else
  321. { lprintf(LOG_ERROR, "Failed parsing dictionary items semicolon expectedn");
  322. return FALSE;
  323. }
  324. }
  325. else
  326. { lprintf(LOG_ERROR, "Failed parsing Listn");
  327. return FALSE;
  328. }
  329. }
  330. else
  331. if (get_token_type(heap, token_id) == T_STRING)
  332. {
  333. string = get_token_strvalue(heap, token_id);
  334. token_assign_value(heap, identifier, string);
  336. token_id = get_next_token(heap);
  337. if (token_id == semicolon_tok)
  338. {
  339. token_id = get_next_token(heap);
  340. if (token_id != rcurly_tok)
  341. {
  342. push_back_token(token_id);
  343. return parse_dictionary_items(heap);
  344. }
  345. else
  346. { push_back_token(token_id);
  347. return TRUE;
  348. }
  349. }
  350. else
  351. { lprintf(LOG_ERROR, "Failed parsing dictionary items semicolon expectedn");
  352. return FALSE;
  353. }
  354. }
  355. else
  356. {
  357. lprintf(LOG_ERROR, "Expecting Identifier, Dictionary or Listn");
  358. return FALSE;
  359. }
  360. }
  361. else
  362. {
  363. lprintf(LOG_ERROR, "Expecting '='n");
  364. return FALSE;
  365. }
  366. }
  367. else
  368. {
  369. lprintf(LOG_ERROR, "Expecting Identifiern");
  370. return FALSE;
  371. }
  373. return TRUE;
  374. }