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

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

手机短信编程

开发平台：

Unix_Linux

gs_token.c：源码内容
  1. /* -------------------------------------------------------------------- */
  2. /* SMS Client, send messages to mobile phones and pagers */
  3. /* */
  4. /* gs_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 <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_list.h"
  40. /* -------------------------------------------------------------------- */
  42. TOKEN_ID
  43. null_tok,
  44. eof_tok,
  45. assignment_tok,
  46. lparen_tok,
  47. rparen_tok,
  48. lcurly_tok,
  49. rcurly_tok,
  50. comma_tok,
  51. dot_tok,
  52. semicolon_tok;
  54. struct init_token_struct
  55. {
  56. TOKEN_ID 
  57. *var;
  59. char *str;
  60. int type;
  61. int type_ptr;
  62. void *ptr;
  64. } init_token_table[] =
  66. {
  67. { &null_tok,  "<NULL>",  T_SPECIAL, 0, NULL },
  68. { &eof_tok,  "<EOF>",  T_SPECIAL, 0, NULL },
  69. { &assignment_tok,  "=",  T_SPECIAL, 0, NULL },
  70. { &lparen_tok,  "(",  T_SPECIAL, 0, NULL },
  71. { &rparen_tok,  ")",  T_SPECIAL, 0, NULL },
  72. { &lcurly_tok,  "{",  T_SPECIAL, 0, NULL },
  73. { &rcurly_tok,  "}",  T_SPECIAL, 0, NULL },
  74. { &comma_tok,  ",",  T_SPECIAL, 0, NULL },
  75. { &dot_tok,  ".",  T_SPECIAL, 0, NULL },
  76. { &semicolon_tok,  ";",  T_SPECIAL, 0, NULL },
  77. { NULL,  NULL,  T_SPECIAL, 0, NULL }
  78. };
  81. static TOKEN_ID
  82. token_pushed = NULL;
  84. static TOKEN_HEAP
  85. builtin = { NULL };
  87. static FILE *parser_fp = stdin;
  90. /* -------------------------------------------------------------------- */
  92. #define MAX_CHARACTER_STACK 512
  94. static char character_stack[MAX_CHARACTER_STACK];
  95. static int  character_stack_top = -1;
  97. /* -------------------------------------------------------------------- */
  99. static int get_next_character(void);
  100. static int is_valid_identifier_character(int character);
  101. static int push_character(int character);
  102. static int pop_character(void);
  103. static int escape_char(void);
  105. /* -------------------------------------------------------------------- */
  106. /* -------------------------------------------------------------------- */
  107. int gs_open(char *file)
  108. {
  109. parser_fp = fopen(file, "r");
  110. if (parser_fp == NULL)
  111. { return -1;
  112. }
  114. return 0;
  115. }
  118. /* -------------------------------------------------------------------- */
  119. /* -------------------------------------------------------------------- */
  120. int gs_close(void)
  121. {
  122. if (fileno(stdin) == fileno(parser_fp))
  123. { return 0;
  124. }
  126. return fclose(parser_fp);
  127. }
  130. /* -------------------------------------------------------------------- */
  131. /* If we have pushed back a character then return it, else */
  132. /* return the next character. */
  133. /* -------------------------------------------------------------------- */
  134. static int get_next_character(void)
  135. {
  136. int  character;
  139. character = pop_character();
  140. if (character != -1)
  141. { return character;
  142. }
  144. return fgetc(parser_fp);
  145. }
  148. /* -------------------------------------------------------------------- */
  149. /* -------------------------------------------------------------------- */
  150. static int push_character(int character)
  151. {
  152. if (character_stack_top +1 >= MAX_CHARACTER_STACK)
  153. {
  154. return -1;
  155. }
  157. character_stack_top++;
  158. character_stack[character_stack_top] = character;
  159. return 0;
  160. }
  163. /* -------------------------------------------------------------------- */
  164. /* -------------------------------------------------------------------- */
  165. static int pop_character(void)
  166. {
  167. int character;
  170. if (character_stack_top == -1)
  171. { return -1;
  172. }
  174. character = character_stack[character_stack_top];
  175. character_stack_top--;
  176. return character;
  177. }
  180. /* -------------------------------------------------------------------- */
  181. /* -------------------------------------------------------------------- */
  182. void push_back_token(TOKEN_ID token)
  183. { token_pushed = token;
  184. }
  187. /* -------------------------------------------------------------------- */
  188. /* -------------------------------------------------------------------- */
  189. static int is_valid_identifier_character(int character)
  190. {
  191. if ((isalpha(character)) || (character == '_'))
  192. { return TRUE;
  193. }
  195. return FALSE;
  196. }
  199. /* -------------------------------------------------------------------- */
  200. /* -------------------------------------------------------------------- */
  201. static int escape_char(void)
  202. {
  203. int  character, 
  204. escaped_character;
  206. character = get_next_character();
  208. if (character == 'a')
  209. { escaped_character = 'f';
  210. }
  211. else
  212. if (character == 'b')
  213. { escaped_character = 'b';
  214. }
  215. else
  216. if (character == 'f')
  217. { escaped_character = 'f';
  218. }
  219. else
  220. if (character == 'n')
  221. { escaped_character = 'n';
  222. }
  223. else
  224. if (character == 'r')
  225. { escaped_character = 'r';
  226. }
  227. else
  228. if (character == 't')
  229. { escaped_character = 't';
  230. }
  231. else
  232. if (character == 'v')
  233. { escaped_character = 'v';
  234. }
  235. else
  236. if (character == 'x')
  237. {
  238. int low_nibble,
  239. high_nibble,
  240. high_character,
  241. low_character;
  243. character = get_next_character();
  244. high_character = character;
  246. if (isxdigit(character))
  247. {
  248. if ((character >= '0') && (character <= '9'))
  249. {
  250. high_nibble = (character - '0') << 4;
  251. }
  252. else
  253. if ((character >= 'a') && (character <= 'f'))
  254. {
  255. high_nibble = (10 + (character - 'a')) << 4;
  256. }
  257. else
  258. { high_nibble = (10 + (character - 'A')) << 4;
  259. }
  261. character = get_next_character();
  262. low_character = character;
  265. if (isxdigit(character))
  266. {
  267. if ((character >= '0') && (character <= '9'))
  268. {
  269. low_nibble = (character - '0');
  270. }
  271. else
  272. if ((character >= 'a') && (character <= 'f'))
  273. {
  274. low_nibble = (10 + (character - 'a'));
  275. }
  276. else
  277. { low_nibble = (10 + (character - 'A'));
  278. }
  280. escaped_character = high_nibble + low_nibble;
  281. }
  282. else
  283. {
  284. /* Error */
  286. push_character('x');
  287. push_character(high_character);
  288. push_character(low_character);
  290. escaped_character = '\';
  291. }
  292. }
  293. else
  294. {
  295. /* Error */
  297. push_character('x');
  298. push_character(high_character);
  300. escaped_character = '\';
  301. }
  302. }
  303. else
  304. if (character == '\')
  305. { escaped_character = '\';
  306. }
  307. else
  308. if (character == '"')
  309. { escaped_character = '"';
  310. }
  311. else
  312. if (character == ''')
  313. { escaped_character = ''';
  314. }
  315. else
  316. {
  317. /* Error */
  319. push_character(character);
  320. escaped_character = '\';
  321. }
  323. return escaped_character;
  324. }
  326. /* -------------------------------------------------------------------- */
  327. /* -------------------------------------------------------------------- */
  328. TOKEN_ID get_next_token(TOKEN_HEAP *heap)
  329. {
  330. char   str[1024],
  331. *str_ptr;
  333. int  character;
  335. TOKEN_ID
  336. token_id;
  339. if (token_pushed != NULL)
  340. {
  341. token_id = token_pushed;
  342. token_pushed = NULL;
  343. return token_id;
  344. }
  347. character = get_next_character();
  349. /* ---------------------------- */
  350. /* Throw away any whitespace  */
  351. /* ---------------------------- */
  354. while (isspace(character))
  355. { character = get_next_character();
  356. }
  358. /* ---------------------------- */
  359. /* Identifier */
  360. /* ---------------------------- */
  362. if (is_valid_identifier_character(character))
  363. {
  364. str_ptr = str;
  365. while (is_valid_identifier_character(character))
  366. {
  367. *str_ptr++ = character;
  368.  character = get_next_character();
  369. }
  371. *str_ptr = '';
  373. push_character(character);
  375. lprintf(LOG_VERYVERBOSE, "Found Identifier '%s'n", str);
  376. token_id = add_token(heap, str, T_IDENTIFIER, NULL);
  377. }
  378. else
  379. if (character == '"') 
  380. {
  381. character = get_next_character();
  383. str_ptr = str;
  384. while ((character != '"') && (character != EOF))
  385. {
  386. if (character == '\')
  387. {
  388. *str_ptr++ = escape_char();
  389. }
  390. else
  391. { *str_ptr++ = character;
  392. }
  394. character = get_next_character();
  395. }
  397. *str_ptr = '';
  399. if (character == '"')
  400. {
  401. lprintf(LOG_VERYVERBOSE, "Found Identifier '%s'n", str);
  402. token_id = add_token(heap, str, T_STRING, NULL);
  403. }
  404. else
  405. { token_id = null_tok;
  406. }
  407. }
  408. else
  409. if (character == ''') 
  410. {
  411. character = get_next_character();
  413. str_ptr = str;
  414. while ((character != ''') && (character != EOF))
  415. {
  416. *str_ptr++ = character;
  417.  character = get_next_character();
  418. }
  420. *str_ptr = '';
  422. if (character == ''')
  423. {
  424. lprintf(LOG_VERYVERBOSE, "Found Identifier '%s'n", str);
  425. token_id = add_token(heap, str, T_STRING, NULL);
  426. }
  427. else
  428. { token_id = null_tok;
  429. }
  430. }
  431. else
  432. if (character == '=')
  433. { token_id = assignment_tok;
  434. }
  435. else
  436. if (character == '(')
  437. { token_id = lparen_tok;
  438. }
  439. else
  440. if (character == ')')
  441. { token_id = rparen_tok;
  442. }
  443. else
  444. if (character == '{')
  445. { token_id = lcurly_tok;
  446. }
  447. else
  448. if (character == '}')
  449. { token_id = rcurly_tok;
  450. }
  451. else
  452. if (character == ',')
  453. { token_id = comma_tok;
  454. }
  455. else
  456. if (character == '.')
  457. { token_id = dot_tok;
  458. }
  459. else
  460. if (character == ';')
  461. { token_id = semicolon_tok;
  462. }
  463. else
  464. if (character == EOF)
  465. { token_id = eof_tok;
  466. }
  467. else
  468. { token_id = null_tok;
  469. }
  472. lprintf(LOG_VERYVERBOSE, "Token id = %pn", token_id);
  473. return token_id;
  474. }
  477. /* -------------------------------------------------------------------- */
  478. /* Add token searches the token heap for 'str' */
  479. /* -------------------------------------------------------------------- */
  480. TOKEN_ID add_token(TOKEN_HEAP *heap, char *str, int type, void *ptr)
  481. {
  482. TOKEN_ID
  483. token;
  485. lprintf(LOG_VERYVERBOSE, "Entering add_token()n");
  487. heap->list = add_token_list_item(heap->list, &token, str, type, 0, ptr);
  489. lprintf(LOG_VERYVERBOSE, "returning %pn", token);
  491. return token;
  492. }
  494. /* -------------------------------------------------------------------- */
  495. /* -------------------------------------------------------------------- */
  496. char *get_token_strvalue(TOKEN_HEAP *heap, TOKEN_ID token_id)
  497. { return token_id->str;
  498. }
  501. /* -------------------------------------------------------------------- */
  502. /* -------------------------------------------------------------------- */
  503. char *get_token_strtype(TOKEN_HEAP *heap, TOKEN_ID token_id)
  504. { return "UNKNOWN";
  505. }
  508. /* -------------------------------------------------------------------- */
  509. /* -------------------------------------------------------------------- */
  510. int get_token_type(TOKEN_HEAP *heap, TOKEN_ID token_id)
  511. { return token_id->type;
  512. }
  515. /* -------------------------------------------------------------------- */
  516. /* -------------------------------------------------------------------- */
  517. int get_token_indirect_type(TOKEN_HEAP *heap, TOKEN_ID token_id)
  518. { return token_id->ptr_type;
  519. }
  522. /* -------------------------------------------------------------------- */
  523. /* -------------------------------------------------------------------- */
  524. char *get_token_indirect_string(TOKEN_HEAP *heap, TOKEN_ID token_id)
  525. { return token_id->ptr;
  526. }
  529. /* -------------------------------------------------------------------- */
  530. /* -------------------------------------------------------------------- */
  531. TOKEN_HEAP *get_token_indirect_dictionary(TOKEN_HEAP *heap, TOKEN_ID token_id)
  532. { return (TOKEN_HEAP *)token_id->ptr;
  533. }
  536. /* -------------------------------------------------------------------- */
  537. /* -------------------------------------------------------------------- */
  538. TOKEN_HEAP *get_token_indirect_list(TOKEN_HEAP *heap, TOKEN_ID token_id)
  539. { return (TOKEN_HEAP *)token_id->ptr;
  540. }
  543. /* -------------------------------------------------------------------- */
  544. /* -------------------------------------------------------------------- */
  545. void token_assign_value(TOKEN_HEAP *heap, TOKEN_ID token_id, char *string)
  546. {
  547. token_id->ptr_type = TP_STRING;
  548. token_id->ptr      = string;
  549. }
  552. /* -------------------------------------------------------------------- */
  553. /* -------------------------------------------------------------------- */
  554. void token_assign_dictionary(TOKEN_HEAP *heap, TOKEN_ID token_id, TOKEN_HEAP *dictionary)
  555. {
  556. token_id->ptr_type = TP_DICTIONARY;
  557. token_id->ptr      = dictionary;
  558. }
  561. /* -------------------------------------------------------------------- */
  562. /* -------------------------------------------------------------------- */
  563. void token_assign_list(TOKEN_HEAP *heap, TOKEN_ID token_id, TOKEN_HEAP *list)
  564. {
  565. token_id->ptr_type = TP_LIST;
  566. token_id->ptr      = list;
  567. }
  570. /* -------------------------------------------------------------------- */
  571. /* Add our reserved tokens to the reserved builtin heap. */
  572. /* if builtin heap has been filled by an earlier call just */
  573. /* return from this function. */
  574. /* -------------------------------------------------------------------- */
  575. void init_builtin_heap(void)
  576. {
  577. int  i;
  579. if (builtin.list == NULL)
  580. {
  581. for (i=0; init_token_table[i].var != NULL; i++)
  582. {
  583. *(init_token_table[i].var) = add_token(&builtin, 
  584.                                        init_token_table[i].str,
  585.                                        init_token_table[i].type,
  586.                                        init_token_table[i].ptr);
  587. }
  588. }
  589. }
  592. /* -------------------------------------------------------------------- */
  593. /* -------------------------------------------------------------------- */
  594. void init_heap(TOKEN_HEAP *heap)
  595. {
  596. heap->list = NULL;
  597. }
  600. /* -------------------------------------------------------------------- */
  601. /* -------------------------------------------------------------------- */
  602. TOKEN_HEAP *generate_new_heap(void)
  603. {
  604. TOKEN_HEAP
  605. *heap;
  607. heap = (TOKEN_HEAP *)malloc(sizeof(TOKEN_HEAP));
  608. if (heap == NULL)
  609. { return heap;
  610. }
  612. init_heap(heap);
  613. return heap;
  614. }
  617. /* -------------------------------------------------------------------- */
  618. /* -------------------------------------------------------------------- */
  619. void dump_heap(TOKEN_HEAP *heap, char *name)
  620. {
  621. TOKEN_LIST
  622. *item;
  624. TOKEN_ID
  625. token;
  628. fprintf(stdout, " %s = { n", name);
  630. item = heap->list;
  631. while(item != NULL)
  632. {
  633. token = item->token;
  635. if (get_token_type(heap, token) == T_IDENTIFIER)
  636. {
  637. if (get_token_indirect_type(heap, token) == TP_STRING)
  638. {
  639. fprintf(stdout, "%s = %sn", 
  640.         get_token_strvalue(heap, token),
  641.         get_token_indirect_string(heap, token));
  642. }
  643. else
  644. if (get_token_indirect_type(heap, token) == TP_DICTIONARY)
  645. {
  646. dump_heap(get_token_indirect_dictionary(heap, token), 
  647.             get_token_strvalue(heap, token));
  648. }
  649. else
  650. if (get_token_indirect_type(heap, token) == TP_LIST)
  651. {
  652. dump_heap(get_token_indirect_list(heap, token), 
  653.             get_token_strvalue(heap, token));
  654. }
  655. }
  658. item = item->next;
  659. }
  661. fprintf(stdout, " }n");
  662. }
  665. /* -------------------------------------------------------------------- */
  666. /* -------------------------------------------------------------------- */
  667. void free_heap(TOKEN_HEAP *heap)
  668. {
  669. TOKEN_LIST
  670. *item,
  671. *prev_item;
  674. TOKEN_ID
  675. token;
  678. item = heap->list;
  679. while(item != NULL)
  680. {
  681. token = item->token;
  682. if (get_token_type(heap, token) == T_IDENTIFIER)
  683. {
  684. if (get_token_indirect_type(heap, token) == TP_DICTIONARY)
  685. {
  686. free_heap(get_token_indirect_dictionary(heap, token));
  687. }
  688. else
  689. if (get_token_indirect_type(heap, token) == TP_LIST)
  690. {
  691. free_heap(get_token_indirect_list(heap, token));
  692. }
  693. }
  695. prev_item = item;
  696. item = item->next;
  698. free(prev_item->token->str);
  699. free(prev_item->token);
  700. free(prev_item);
  701. }
  702. }