home *** CD-ROM | disk | FTP | other *** search
/ cs.rhul.ac.uk / www.cs.rhul.ac.uk.zip / www.cs.rhul.ac.uk / pub / rdp / rdp_cs3470.tar / test.c < prev    next >
Encoding:
C/C++ Source or Header  |  2009-02-05  |  87.4 KB  |  2,134 lines
  1. /*******************************************************************************
  2. *
  3. * Parser generated by RDP on Dec 20 1997 19:18:32 from rdp.bnf
  4. *
  5. *******************************************************************************/
  6. #include <time.h>
  7. #include "arg.h"
  8. #include "graph.h"
  9. #include "memalloc.h"
  10. #include "scan.h"
  11. #include "set.h"
  12. #include "symbol.h"
  13. #include "textio.h"
  14. #include "rdp_aux.h"
  15. #include "rdp_gram.h"
  16. #include "rdp_prnt.h"
  17. #include "rdp.h"
  18.  
  19. char
  20. * rdp_sourcefilename = NULL,  /* source file name */
  21. * rdp_outputfilename = "rdparser";  /* output file name */
  22.  
  23. int
  24. rdp_symbol_echo = 0,          /* symbol echo flag */
  25. rdp_verbose = 0,              /* verbosity flag */
  26. rdp_pass;                     /* pass number */
  27.  
  28. int rdp_error_return = 0;     /* return value for main routine */
  29.  
  30. char * rdp_tokens = "IGNORE"
  31. "ID" "INTEGER" "REAL" "CHAR" "CHAR_ESC" "STRING" "STRING_ESC" "COMMENT"
  32. "COMMENT_VISIBLE" "COMMENT_NEST" "COMMENT_NEST_VISIBLE" "COMMENT_LINE" "COMMENT_LINE_VISIBLE" "EOF" "EOLN" "\'\"\'"
  33. "\'#\'" "\'\'\'" "\'(\'" "\'(*\'" "\')\'" "\'*\'" "\'.\'" "\':\'"
  34. "\'::\'" "\'::=\'" "\'<\'" "\'>\'" "\'@\'" "\'ALT_ID\'" "\'ANNOTATED_EPSILON_TREE\'" "\'ARG_BLANK\'"
  35. "\'ARG_BOOLEAN\'" "\'ARG_NUMERIC\'" "\'ARG_STRING\'" "\'CASE_INSENSITIVE\'" "\'CHAR\'" "\'CHAR_ESC\'" "\'COMMENT\'" "\'COMMENT_LINE\'"
  36. "\'COMMENT_LINE_VISIBLE\'" "\'COMMENT_NEST\'" "\'COMMENT_NEST_VISIBLE\'" "\'COMMENT_VISIBLE\'" "\'EPSILON_TREE\'" "\'HASH_PRIME\'" "\'HASH_SIZE\'" "\'INCLUDE\'"
  37. "\'INTERPRETER\'" "\'MAX_ERRORS\'" "\'MAX_WARNINGS\'" "\'NEW_ID\'" "\'NUMBER\'" "\'OPTION\'" "\'OUTPUT_FILE\'" "\'PARSER\'"
  38. "\'PASSES\'" "\'POST_PARSE\'" "\'POST_PROCESS\'" "\'PRE_PARSE\'" "\'PRE_PROCESS\'" "\'SET_SIZE\'" "\'SHOW_SKIPS\'" "\'STRING\'"
  39. "\'STRING_ESC\'" "\'SUFFIX\'" "\'SYMBOL_TABLE\'" "\'TAB_WIDTH\'" "\'TEXT_SIZE\'" "\'TITLE\'" "\'TREE\'" "\'USES\'"
  40. "\'[\'" "\'[*\'" "\']\'" "\'^\'" "\'^^\'" "\'^^^\'" "\'^_\'" "\'{\'"
  41. "\'|\'" "\'}\'"; 
  42.  
  43. locals_data * locals_temp = NULL; 
  44. void * locals = NULL; 
  45. codes_data * codes_temp = NULL; 
  46. void * codes = NULL; 
  47. tokens_data * tokens_temp = NULL; 
  48. void * tokens = NULL; 
  49. rdp_data * rdp_temp = NULL; 
  50. void * rdp = NULL; 
  51.  
  52. /* Load keywords */
  53. static void rdp_load_keywords(void)
  54. {
  55.   scan_load_keyword("\"", "\\", RDP_T_16 /* " */ , SCAN_P_STRING_ESC); 
  56.   scan_load_keyword("#", NULL, RDP_T_17 /* # */ , SCAN_P_IGNORE); 
  57.   scan_load_keyword("\'", "\\", RDP_T_18 /* ' */ , SCAN_P_STRING_ESC); 
  58.   scan_load_keyword("(", NULL, RDP_T_19 /* ( */ , SCAN_P_IGNORE); 
  59.   scan_load_keyword("(*", "*)", RDP_T_20 /* (* */ , SCAN_P_COMMENT); 
  60.   scan_load_keyword(")", NULL, RDP_T_21 /* ) */ , SCAN_P_IGNORE); 
  61.   scan_load_keyword("*", NULL, RDP_T_22 /* * */ , SCAN_P_IGNORE); 
  62.   scan_load_keyword(".", NULL, RDP_T_23 /* . */ , SCAN_P_IGNORE); 
  63.   scan_load_keyword(":", NULL, RDP_T_24 /* : */ , SCAN_P_IGNORE); 
  64.   scan_load_keyword("::", NULL, RDP_T_25 /* :: */ , SCAN_P_IGNORE); 
  65.   scan_load_keyword("::=", NULL, RDP_T_26 /* ::= */ , SCAN_P_IGNORE); 
  66.   scan_load_keyword("<", NULL, RDP_T_27 /* < */ , SCAN_P_IGNORE); 
  67.   scan_load_keyword(">", NULL, RDP_T_28 /* > */ , SCAN_P_IGNORE); 
  68.   scan_load_keyword("@", NULL, RDP_T_29 /* @ */ , SCAN_P_IGNORE); 
  69.   scan_load_keyword("ALT_ID", NULL, RDP_T_ALT_ID, SCAN_P_IGNORE); 
  70.   scan_load_keyword("ANNOTATED_EPSILON_TREE", NULL, RDP_T_ANNOTATED_EPSILON_TREE, SCAN_P_IGNORE); 
  71.   scan_load_keyword("ARG_BLANK", NULL, RDP_T_ARG_BLANK, SCAN_P_IGNORE); 
  72.   scan_load_keyword("ARG_BOOLEAN", NULL, RDP_T_ARG_BOOLEAN, SCAN_P_IGNORE); 
  73.   scan_load_keyword("ARG_NUMERIC", NULL, RDP_T_ARG_NUMERIC, SCAN_P_IGNORE); 
  74.   scan_load_keyword("ARG_STRING", NULL, RDP_T_ARG_STRING, SCAN_P_IGNORE); 
  75.   scan_load_keyword("CASE_INSENSITIVE", NULL, RDP_T_CASE_INSENSITIVE, SCAN_P_IGNORE); 
  76.   scan_load_keyword("CHAR", NULL, RDP_T_CHAR, SCAN_P_IGNORE); 
  77.   scan_load_keyword("CHAR_ESC", NULL, RDP_T_CHAR_ESC, SCAN_P_IGNORE); 
  78.   scan_load_keyword("COMMENT", NULL, RDP_T_COMMENT, SCAN_P_IGNORE); 
  79.   scan_load_keyword("COMMENT_LINE", NULL, RDP_T_COMMENT_LINE, SCAN_P_IGNORE); 
  80.   scan_load_keyword("COMMENT_LINE_VISIBLE", NULL, RDP_T_COMMENT_LINE_VISIBLE, SCAN_P_IGNORE); 
  81.   scan_load_keyword("COMMENT_NEST", NULL, RDP_T_COMMENT_NEST, SCAN_P_IGNORE); 
  82.   scan_load_keyword("COMMENT_NEST_VISIBLE", NULL, RDP_T_COMMENT_NEST_VISIBLE, SCAN_P_IGNORE); 
  83.   scan_load_keyword("COMMENT_VISIBLE", NULL, RDP_T_COMMENT_VISIBLE, SCAN_P_IGNORE); 
  84.   scan_load_keyword("EPSILON_TREE", NULL, RDP_T_EPSILON_TREE, SCAN_P_IGNORE); 
  85.   scan_load_keyword("HASH_PRIME", NULL, RDP_T_HASH_PRIME, SCAN_P_IGNORE); 
  86.   scan_load_keyword("HASH_SIZE", NULL, RDP_T_HASH_SIZE, SCAN_P_IGNORE); 
  87.   scan_load_keyword("INCLUDE", NULL, RDP_T_INCLUDE, SCAN_P_IGNORE); 
  88.   scan_load_keyword("INTERPRETER", NULL, RDP_T_INTERPRETER, SCAN_P_IGNORE); 
  89.   scan_load_keyword("MAX_ERRORS", NULL, RDP_T_MAX_ERRORS, SCAN_P_IGNORE); 
  90.   scan_load_keyword("MAX_WARNINGS", NULL, RDP_T_MAX_WARNINGS, SCAN_P_IGNORE); 
  91.   scan_load_keyword("NEW_ID", NULL, RDP_T_NEW_ID, SCAN_P_IGNORE); 
  92.   scan_load_keyword("NUMBER", NULL, RDP_T_NUMBER, SCAN_P_IGNORE); 
  93.   scan_load_keyword("OPTION", NULL, RDP_T_OPTION, SCAN_P_IGNORE); 
  94.   scan_load_keyword("OUTPUT_FILE", NULL, RDP_T_OUTPUT_FILE, SCAN_P_IGNORE); 
  95.   scan_load_keyword("PARSER", NULL, RDP_T_PARSER, SCAN_P_IGNORE); 
  96.   scan_load_keyword("PASSES", NULL, RDP_T_PASSES, SCAN_P_IGNORE); 
  97.   scan_load_keyword("POST_PARSE", NULL, RDP_T_POST_PARSE, SCAN_P_IGNORE); 
  98.   scan_load_keyword("POST_PROCESS", NULL, RDP_T_POST_PROCESS, SCAN_P_IGNORE); 
  99.   scan_load_keyword("PRE_PARSE", NULL, RDP_T_PRE_PARSE, SCAN_P_IGNORE); 
  100.   scan_load_keyword("PRE_PROCESS", NULL, RDP_T_PRE_PROCESS, SCAN_P_IGNORE); 
  101.   scan_load_keyword("SET_SIZE", NULL, RDP_T_SET_SIZE, SCAN_P_IGNORE); 
  102.   scan_load_keyword("SHOW_SKIPS", NULL, RDP_T_SHOW_SKIPS, SCAN_P_IGNORE); 
  103.   scan_load_keyword("STRING", NULL, RDP_T_STRING, SCAN_P_IGNORE); 
  104.   scan_load_keyword("STRING_ESC", NULL, RDP_T_STRING_ESC, SCAN_P_IGNORE); 
  105.   scan_load_keyword("SUFFIX", NULL, RDP_T_SUFFIX, SCAN_P_IGNORE); 
  106.   scan_load_keyword("SYMBOL_TABLE", NULL, RDP_T_SYMBOL_TABLE, SCAN_P_IGNORE); 
  107.   scan_load_keyword("TAB_WIDTH", NULL, RDP_T_TAB_WIDTH, SCAN_P_IGNORE); 
  108.   scan_load_keyword("TEXT_SIZE", NULL, RDP_T_TEXT_SIZE, SCAN_P_IGNORE); 
  109.   scan_load_keyword("TITLE", NULL, RDP_T_TITLE, SCAN_P_IGNORE); 
  110.   scan_load_keyword("TREE", NULL, RDP_T_TREE, SCAN_P_IGNORE); 
  111.   scan_load_keyword("USES", NULL, RDP_T_USES, SCAN_P_IGNORE); 
  112.   scan_load_keyword("[", NULL, RDP_T_73 /* [ */ , SCAN_P_IGNORE); 
  113.   scan_load_keyword("[*", "*]", RDP_T_74 /* [* */ , SCAN_P_COMMENT_VISIBLE); 
  114.   scan_load_keyword("]", NULL, RDP_T_75 /* ] */ , SCAN_P_IGNORE); 
  115.   scan_load_keyword("^", NULL, RDP_T_76 /* ^ */ , SCAN_P_IGNORE); 
  116.   scan_load_keyword("^^", NULL, RDP_T_77 /* ^^ */ , SCAN_P_IGNORE); 
  117.   scan_load_keyword("^^^", NULL, RDP_T_78 /* ^^^ */ , SCAN_P_IGNORE); 
  118.   scan_load_keyword("^_", NULL, RDP_T_79 /* ^_ */ , SCAN_P_IGNORE); 
  119.   scan_load_keyword("{", NULL, RDP_T_80 /* { */ , SCAN_P_IGNORE); 
  120.   scan_load_keyword("|", NULL, RDP_T_81 /* | */ , SCAN_P_IGNORE); 
  121.   scan_load_keyword("}", NULL, RDP_T_82 /* } */ , SCAN_P_IGNORE); 
  122. }
  123.  
  124. /* Set declarations */
  125.  
  126. set_ String_stop = SET_NULL; 
  127. set_ code_stop = SET_NULL; 
  128. set_ comment_stop = SET_NULL; 
  129. set_ dir_first = SET_NULL; 
  130. set_ dir_stop = SET_NULL; 
  131. set_ item_com_first = SET_NULL; 
  132. set_ item_com_stop = SET_NULL; 
  133. set_ item_inl_first = SET_NULL; 
  134. set_ item_inl_stop = SET_NULL; 
  135. set_ item_ret_first = SET_NULL; 
  136. set_ item_ret_stop = SET_NULL; 
  137. set_ prod_first = SET_NULL; 
  138. set_ prod_stop = SET_NULL; 
  139. set_ rdp_dir_11_first = SET_NULL; 
  140. set_ rdp_dir_3_first = SET_NULL; 
  141. set_ rdp_dir_30_first = SET_NULL; 
  142. set_ rdp_dir_33_first = SET_NULL; 
  143. set_ rdp_dir_7_first = SET_NULL; 
  144. set_ rdp_item_inl_14_first = SET_NULL; 
  145. set_ rdp_item_inl_15_first = SET_NULL; 
  146. set_ rdp_item_inl_16_first = SET_NULL; 
  147. set_ rdp_item_inl_21_first = SET_NULL; 
  148. set_ rdp_item_inl_22_first = SET_NULL; 
  149. set_ rdp_item_inl_9_first = SET_NULL; 
  150. set_ rdp_item_ret_4_first = SET_NULL; 
  151. set_ rdp_item_ret_5_first = SET_NULL; 
  152. set_ rdp_item_ret_6_first = SET_NULL; 
  153. set_ rdp_prod_0_first = SET_NULL; 
  154. set_ rdp_prod_1_first = SET_NULL; 
  155. set_ rdp_prod_2_first = SET_NULL; 
  156. set_ rdp_rule_16_first = SET_NULL; 
  157. set_ rdp_seq_0_first = SET_NULL; 
  158. set_ rdp_seq_1_first = SET_NULL; 
  159. set_ rdp_seq_10_first = SET_NULL; 
  160. set_ rdp_seq_17_first = SET_NULL; 
  161. set_ rdp_seq_2_first = SET_NULL; 
  162. set_ rdp_seq_23_first = SET_NULL; 
  163. set_ rdp_seq_24_first = SET_NULL; 
  164. set_ rdp_seq_25_first = SET_NULL; 
  165. set_ rdp_seq_28_first = SET_NULL; 
  166. set_ rdp_seq_29_first = SET_NULL; 
  167. set_ rdp_seq_30_first = SET_NULL; 
  168. set_ rdp_seq_31_first = SET_NULL; 
  169. set_ rdp_seq_32_first = SET_NULL; 
  170. set_ rdp_seq_9_first = SET_NULL; 
  171. set_ rdp_unit_1_first = SET_NULL; 
  172. set_ rdp_unit_2_first = SET_NULL; 
  173. set_ rdp_unit_3_first = SET_NULL; 
  174. set_ rule_stop = SET_NULL; 
  175. set_ seq_first = SET_NULL; 
  176. set_ seq_stop = SET_NULL; 
  177. set_ token_stop = SET_NULL; 
  178. set_ unit_first = SET_NULL; 
  179. set_ unit_stop = SET_NULL; 
  180.  
  181. /* Initialise sets */
  182.  
  183. static void rdp_set_initialise(void)
  184. {
  185.   set_assign_list(& String_stop, SCAN_P_ID, SCAN_P_INTEGER, SCAN_P_REAL, SCAN_P_EOF, RDP_T_16 /* " */ , RDP_T_18 /* ' */ , 
  186.   RDP_T_19                    /* ( */ , RDP_T_21 /* ) */ , RDP_T_23 /* . */ , RDP_T_24 /* : */ , RDP_T_27 /* < */ , 
  187.   RDP_T_28                    /* > */ , RDP_T_ALT_ID, RDP_T_CHAR, RDP_T_CHAR_ESC, RDP_T_COMMENT, RDP_T_COMMENT_LINE, 
  188.   RDP_T_COMMENT_LINE_VISIBLE, RDP_T_COMMENT_NEST, RDP_T_COMMENT_NEST_VISIBLE, RDP_T_COMMENT_VISIBLE, 
  189.   RDP_T_NEW_ID, RDP_T_NUMBER, RDP_T_STRING, RDP_T_STRING_ESC, RDP_T_73 /* [ */ , 
  190.   RDP_T_74                    /* [* */ , RDP_T_75 /* ] */ , RDP_T_76 /* ^ */ , RDP_T_77 /* ^^ */ , RDP_T_78 /* ^^^ */ , 
  191.   RDP_T_79                    /* ^_ */ , RDP_T_80 /* { */ , RDP_T_81 /* | */ , RDP_T_82 /* } */ , SET_END); 
  192.   set_assign_list(& code_stop, SCAN_P_ID, SCAN_P_INTEGER, SCAN_P_REAL, SCAN_P_EOF, RDP_T_16 /* " */ , RDP_T_18 /* ' */ , 
  193.   RDP_T_19                    /* ( */ , RDP_T_21 /* ) */ , RDP_T_23 /* . */ , RDP_T_24 /* : */ , RDP_T_27 /* < */ , 
  194.   RDP_T_28                    /* > */ , RDP_T_29 /* @ */ , RDP_T_ALT_ID, RDP_T_CHAR, RDP_T_CHAR_ESC, 
  195.   RDP_T_COMMENT, RDP_T_COMMENT_LINE, RDP_T_COMMENT_LINE_VISIBLE, RDP_T_COMMENT_NEST, 
  196.   RDP_T_COMMENT_NEST_VISIBLE, RDP_T_COMMENT_VISIBLE, RDP_T_NEW_ID, RDP_T_NUMBER, 
  197.   RDP_T_STRING, RDP_T_STRING_ESC, RDP_T_73 /* [ */ , RDP_T_74 /* [* */ , RDP_T_75 /* ] */ , 
  198.   RDP_T_76                    /* ^ */ , RDP_T_77 /* ^^ */ , RDP_T_78 /* ^^^ */ , RDP_T_79 /* ^_ */ , RDP_T_80 /* { */ , 
  199.   RDP_T_81                    /* | */ , RDP_T_82 /* } */ , SET_END); 
  200.   set_assign_list(& comment_stop, SCAN_P_EOF, SET_END); 
  201.   set_assign_list(& dir_first, RDP_T_ANNOTATED_EPSILON_TREE, RDP_T_ARG_BLANK, RDP_T_ARG_BOOLEAN, RDP_T_ARG_NUMERIC, 
  202.   RDP_T_ARG_STRING, RDP_T_CASE_INSENSITIVE, RDP_T_EPSILON_TREE, RDP_T_HASH_PRIME, 
  203.   RDP_T_HASH_SIZE, RDP_T_INCLUDE, RDP_T_INTERPRETER, RDP_T_MAX_ERRORS, RDP_T_MAX_WARNINGS, 
  204.   RDP_T_OPTION, RDP_T_OUTPUT_FILE, RDP_T_PARSER, RDP_T_PASSES, RDP_T_POST_PARSE, 
  205.   RDP_T_POST_PROCESS, RDP_T_PRE_PARSE, RDP_T_PRE_PROCESS, RDP_T_SET_SIZE, RDP_T_SHOW_SKIPS, 
  206.   RDP_T_SUFFIX, RDP_T_SYMBOL_TABLE, RDP_T_TAB_WIDTH, RDP_T_TEXT_SIZE, RDP_T_TITLE, 
  207.   RDP_T_TREE, RDP_T_USES, SET_END); 
  208.   set_assign_list(& dir_stop, SCAN_P_ID, SCAN_P_EOF, RDP_T_ANNOTATED_EPSILON_TREE, RDP_T_ARG_BLANK, RDP_T_ARG_BOOLEAN, 
  209.   RDP_T_ARG_NUMERIC, RDP_T_ARG_STRING, RDP_T_CASE_INSENSITIVE, RDP_T_EPSILON_TREE, 
  210.   RDP_T_HASH_PRIME, RDP_T_HASH_SIZE, RDP_T_INCLUDE, RDP_T_INTERPRETER, RDP_T_MAX_ERRORS, 
  211.   RDP_T_MAX_WARNINGS, RDP_T_OPTION, RDP_T_OUTPUT_FILE, RDP_T_PARSER, RDP_T_PASSES, 
  212.   RDP_T_POST_PARSE, RDP_T_POST_PROCESS, RDP_T_PRE_PARSE, RDP_T_PRE_PROCESS, RDP_T_SET_SIZE, 
  213.   RDP_T_SHOW_SKIPS, RDP_T_SUFFIX, RDP_T_SYMBOL_TABLE, RDP_T_TAB_WIDTH, RDP_T_TEXT_SIZE, 
  214.   RDP_T_TITLE, RDP_T_TREE, RDP_T_USES, SET_END); 
  215.   set_assign_list(& item_com_first, RDP_T_COMMENT, RDP_T_COMMENT_LINE, RDP_T_COMMENT_NEST, SET_END); 
  216.   set_assign_list(& item_com_stop, SCAN_P_ID, SCAN_P_INTEGER, SCAN_P_REAL, SCAN_P_EOF, RDP_T_16 /* " */ , RDP_T_18 /* ' */ , 
  217.   RDP_T_19                    /* ( */ , RDP_T_21 /* ) */ , RDP_T_23 /* . */ , RDP_T_24 /* : */ , RDP_T_27 /* < */ , 
  218.   RDP_T_28                    /* > */ , RDP_T_ALT_ID, RDP_T_CHAR, RDP_T_CHAR_ESC, RDP_T_COMMENT, RDP_T_COMMENT_LINE, 
  219.   RDP_T_COMMENT_LINE_VISIBLE, RDP_T_COMMENT_NEST, RDP_T_COMMENT_NEST_VISIBLE, RDP_T_COMMENT_VISIBLE, 
  220.   RDP_T_NEW_ID, RDP_T_NUMBER, RDP_T_STRING, RDP_T_STRING_ESC, RDP_T_73 /* [ */ , 
  221.   RDP_T_74                    /* [* */ , RDP_T_75 /* ] */ , RDP_T_76 /* ^ */ , RDP_T_77 /* ^^ */ , RDP_T_78 /* ^^^ */ , 
  222.   RDP_T_79                    /* ^_ */ , RDP_T_80 /* { */ , RDP_T_81 /* | */ , RDP_T_82 /* } */ , SET_END); 
  223.   set_assign_list(& item_inl_first, RDP_T_19 /* ( */ , RDP_T_27 /* < */ , RDP_T_73 /* [ */ , RDP_T_74 /* [* */ , RDP_T_80 /* { */ , SET_END); 
  224.   set_assign_list(& item_inl_stop, SCAN_P_ID, SCAN_P_INTEGER, SCAN_P_REAL, SCAN_P_EOF, RDP_T_16 /* " */ , RDP_T_18 /* ' */ , 
  225.   RDP_T_19                    /* ( */ , RDP_T_21 /* ) */ , RDP_T_23 /* . */ , RDP_T_24 /* : */ , RDP_T_27 /* < */ , 
  226.   RDP_T_28                    /* > */ , RDP_T_ALT_ID, RDP_T_CHAR, RDP_T_CHAR_ESC, RDP_T_COMMENT, RDP_T_COMMENT_LINE, 
  227.   RDP_T_COMMENT_LINE_VISIBLE, RDP_T_COMMENT_NEST, RDP_T_COMMENT_NEST_VISIBLE, RDP_T_COMMENT_VISIBLE, 
  228.   RDP_T_NEW_ID, RDP_T_NUMBER, RDP_T_STRING, RDP_T_STRING_ESC, RDP_T_73 /* [ */ , 
  229.   RDP_T_74                    /* [* */ , RDP_T_75 /* ] */ , RDP_T_80 /* { */ , RDP_T_81 /* | */ , RDP_T_82 /* } */ , SET_END); 
  230.   set_assign_list(& item_ret_first, SCAN_P_ID, SCAN_P_INTEGER, SCAN_P_REAL, RDP_T_16 /* " */ , RDP_T_18 /* ' */ , RDP_T_ALT_ID, 
  231.   RDP_T_CHAR, RDP_T_CHAR_ESC, RDP_T_COMMENT_LINE_VISIBLE, RDP_T_COMMENT_NEST_VISIBLE, 
  232.   RDP_T_COMMENT_VISIBLE, RDP_T_NEW_ID, RDP_T_NUMBER, RDP_T_STRING, RDP_T_STRING_ESC, SET_END); 
  233.   set_assign_list(& item_ret_stop, SCAN_P_ID, SCAN_P_INTEGER, SCAN_P_REAL, SCAN_P_EOF, RDP_T_16 /* " */ , RDP_T_18 /* ' */ , 
  234.   RDP_T_19                    /* ( */ , RDP_T_21 /* ) */ , RDP_T_23 /* . */ , RDP_T_24 /* : */ , RDP_T_27 /* < */ , 
  235.   RDP_T_28                    /* > */ , RDP_T_ALT_ID, RDP_T_CHAR, RDP_T_CHAR_ESC, RDP_T_COMMENT, RDP_T_COMMENT_LINE, 
  236.   RDP_T_COMMENT_LINE_VISIBLE, RDP_T_COMMENT_NEST, RDP_T_COMMENT_NEST_VISIBLE, RDP_T_COMMENT_VISIBLE, 
  237.   RDP_T_NEW_ID, RDP_T_NUMBER, RDP_T_STRING, RDP_T_STRING_ESC, RDP_T_73 /* [ */ , 
  238.   RDP_T_74                    /* [* */ , RDP_T_75 /* ] */ , RDP_T_76 /* ^ */ , RDP_T_77 /* ^^ */ , RDP_T_78 /* ^^^ */ , 
  239.   RDP_T_79                    /* ^_ */ , RDP_T_80 /* { */ , RDP_T_81 /* | */ , RDP_T_82 /* } */ , SET_END); 
  240.   set_assign_list(& prod_first, SCAN_P_ID, SCAN_P_INTEGER, SCAN_P_REAL, RDP_T_16 /* " */ , RDP_T_18 /* ' */ , RDP_T_19 /* ( */ , 
  241.   RDP_T_27                    /* < */ , RDP_T_ALT_ID, RDP_T_CHAR, RDP_T_CHAR_ESC, RDP_T_COMMENT, RDP_T_COMMENT_LINE, 
  242.   RDP_T_COMMENT_LINE_VISIBLE, RDP_T_COMMENT_NEST, RDP_T_COMMENT_NEST_VISIBLE, RDP_T_COMMENT_VISIBLE, 
  243.   RDP_T_NEW_ID, RDP_T_NUMBER, RDP_T_STRING, RDP_T_STRING_ESC, RDP_T_73 /* [ */ , 
  244.   RDP_T_74                    /* [* */ , RDP_T_80 /* { */ , SET_END); 
  245.   set_assign_list(& prod_stop, SCAN_P_EOF, RDP_T_21 /* ) */ , RDP_T_23 /* . */ , RDP_T_28 /* > */ , RDP_T_75 /* ] */ , 
  246.   RDP_T_82                    /* } */ , SET_END); 
  247.   set_assign_list(& rdp_dir_11_first, SCAN_P_ID, RDP_T_74 /* [* */ , SET_END); 
  248.   set_assign_list(& rdp_dir_3_first, SCAN_P_ID, RDP_T_74 /* [* */ , SET_END); 
  249.   set_assign_list(& rdp_dir_30_first, RDP_T_ANNOTATED_EPSILON_TREE, RDP_T_EPSILON_TREE, RDP_T_TREE, SET_END); 
  250.   set_assign_list(& rdp_dir_33_first, RDP_T_ANNOTATED_EPSILON_TREE, RDP_T_EPSILON_TREE, RDP_T_TREE, SET_END); 
  251.   set_assign_list(& rdp_dir_7_first, SCAN_P_ID, RDP_T_74 /* [* */ , SET_END); 
  252.   set_assign_list(& rdp_item_inl_14_first, RDP_T_76 /* ^ */ , RDP_T_77 /* ^^ */ , RDP_T_78 /* ^^^ */ , RDP_T_79 /* ^_ */ , SET_END); 
  253.   set_assign_list(& rdp_item_inl_15_first, SCAN_P_INTEGER, RDP_T_29 /* @ */ , SET_END); 
  254.   set_assign_list(& rdp_item_inl_16_first, SCAN_P_INTEGER, RDP_T_29 /* @ */ , SET_END); 
  255.   set_assign_list(& rdp_item_inl_21_first, RDP_T_19 /* ( */ , RDP_T_27 /* < */ , RDP_T_73 /* [ */ , RDP_T_74 /* [* */ , RDP_T_80 /* { */ , SET_END); 
  256.   set_assign_list(& rdp_item_inl_22_first, RDP_T_19 /* ( */ , RDP_T_27 /* < */ , RDP_T_73 /* [ */ , RDP_T_74 /* [* */ , RDP_T_80 /* { */ , SET_END); 
  257.   set_assign_list(& rdp_item_inl_9_first, RDP_T_17 /* # */ , RDP_T_18 /* ' */ , SET_END); 
  258.   set_assign_list(& rdp_item_ret_4_first, SCAN_P_ID, SCAN_P_INTEGER, SCAN_P_REAL, RDP_T_16 /* " */ , SET_END); 
  259.   set_assign_list(& rdp_item_ret_5_first, SCAN_P_ID, SCAN_P_INTEGER, SCAN_P_REAL, RDP_T_16 /* " */ , SET_END); 
  260.   set_assign_list(& rdp_item_ret_6_first, SCAN_P_ID, SCAN_P_INTEGER, SCAN_P_REAL, RDP_T_16 /* " */ , SET_END); 
  261.   set_assign_list(& rdp_prod_0_first, SCAN_P_ID, SCAN_P_INTEGER, SCAN_P_REAL, RDP_T_16 /* " */ , RDP_T_18 /* ' */ , RDP_T_19 /* ( */ , 
  262.   RDP_T_27                    /* < */ , RDP_T_ALT_ID, RDP_T_CHAR, RDP_T_CHAR_ESC, RDP_T_COMMENT, RDP_T_COMMENT_LINE, 
  263.   RDP_T_COMMENT_LINE_VISIBLE, RDP_T_COMMENT_NEST, RDP_T_COMMENT_NEST_VISIBLE, RDP_T_COMMENT_VISIBLE, 
  264.   RDP_T_NEW_ID, RDP_T_NUMBER, RDP_T_STRING, RDP_T_STRING_ESC, RDP_T_73 /* [ */ , 
  265.   RDP_T_74                    /* [* */ , RDP_T_80 /* { */ , SET_END); 
  266.   set_assign_list(& rdp_prod_1_first, SCAN_P_ID, SCAN_P_INTEGER, SCAN_P_REAL, RDP_T_16 /* " */ , RDP_T_18 /* ' */ , RDP_T_19 /* ( */ , 
  267.   RDP_T_27                    /* < */ , RDP_T_ALT_ID, RDP_T_CHAR, RDP_T_CHAR_ESC, RDP_T_COMMENT, RDP_T_COMMENT_LINE, 
  268.   RDP_T_COMMENT_LINE_VISIBLE, RDP_T_COMMENT_NEST, RDP_T_COMMENT_NEST_VISIBLE, RDP_T_COMMENT_VISIBLE, 
  269.   RDP_T_NEW_ID, RDP_T_NUMBER, RDP_T_STRING, RDP_T_STRING_ESC, RDP_T_73 /* [ */ , 
  270.   RDP_T_74                    /* [* */ , RDP_T_80 /* { */ , SET_END); 
  271.   set_assign_list(& rdp_prod_2_first, SCAN_P_ID, SCAN_P_INTEGER, SCAN_P_REAL, RDP_T_16 /* " */ , RDP_T_18 /* ' */ , RDP_T_19 /* ( */ , 
  272.   RDP_T_27                    /* < */ , RDP_T_ALT_ID, RDP_T_CHAR, RDP_T_CHAR_ESC, RDP_T_COMMENT, RDP_T_COMMENT_LINE, 
  273.   RDP_T_COMMENT_LINE_VISIBLE, RDP_T_COMMENT_NEST, RDP_T_COMMENT_NEST_VISIBLE, RDP_T_COMMENT_VISIBLE, 
  274.   RDP_T_NEW_ID, RDP_T_NUMBER, RDP_T_STRING, RDP_T_STRING_ESC, RDP_T_73 /* [ */ , 
  275.   RDP_T_74                    /* [* */ , RDP_T_80 /* { */ , SET_END); 
  276.   set_assign_list(& rdp_rule_16_first, RDP_T_76 /* ^ */ , RDP_T_77 /* ^^ */ , RDP_T_78 /* ^^^ */ , RDP_T_79 /* ^_ */ , SET_END); 
  277.   set_assign_list(& rdp_seq_0_first, SCAN_P_ID, SCAN_P_INTEGER, SCAN_P_REAL, RDP_T_16 /* " */ , RDP_T_18 /* ' */ , RDP_T_ALT_ID, 
  278.   RDP_T_CHAR, RDP_T_CHAR_ESC, RDP_T_COMMENT_LINE_VISIBLE, RDP_T_COMMENT_NEST_VISIBLE, 
  279.   RDP_T_COMMENT_VISIBLE, RDP_T_NEW_ID, RDP_T_NUMBER, RDP_T_STRING, RDP_T_STRING_ESC, SET_END); 
  280.   set_assign_list(& rdp_seq_1_first, RDP_T_COMMENT, RDP_T_COMMENT_LINE, RDP_T_COMMENT_NEST, SET_END); 
  281.   set_assign_list(& rdp_seq_10_first, SCAN_P_ID, SCAN_P_INTEGER, SCAN_P_REAL, RDP_T_16 /* " */ , RDP_T_18 /* ' */ , RDP_T_ALT_ID, 
  282.   RDP_T_CHAR, RDP_T_CHAR_ESC, RDP_T_COMMENT, RDP_T_COMMENT_LINE, RDP_T_COMMENT_LINE_VISIBLE, 
  283.   RDP_T_COMMENT_NEST, RDP_T_COMMENT_NEST_VISIBLE, RDP_T_COMMENT_VISIBLE, RDP_T_NEW_ID, 
  284.   RDP_T_NUMBER, RDP_T_STRING, RDP_T_STRING_ESC, SET_END); 
  285.   set_assign_list(& rdp_seq_17_first, RDP_T_76 /* ^ */ , RDP_T_77 /* ^^ */ , RDP_T_78 /* ^^^ */ , RDP_T_79 /* ^_ */ , SET_END); 
  286.   set_assign_list(& rdp_seq_2_first, SCAN_P_ID, SCAN_P_INTEGER, SCAN_P_REAL, RDP_T_16 /* " */ , RDP_T_18 /* ' */ , RDP_T_ALT_ID, 
  287.   RDP_T_CHAR, RDP_T_CHAR_ESC, RDP_T_COMMENT, RDP_T_COMMENT_LINE, RDP_T_COMMENT_LINE_VISIBLE, 
  288.   RDP_T_COMMENT_NEST, RDP_T_COMMENT_NEST_VISIBLE, RDP_T_COMMENT_VISIBLE, RDP_T_NEW_ID, 
  289.   RDP_T_NUMBER, RDP_T_STRING, RDP_T_STRING_ESC, SET_END); 
  290.   set_assign_list(& rdp_seq_23_first, RDP_T_76 /* ^ */ , RDP_T_77 /* ^^ */ , RDP_T_78 /* ^^^ */ , RDP_T_79 /* ^_ */ , SET_END); 
  291.   set_assign_list(& rdp_seq_24_first, RDP_T_76 /* ^ */ , RDP_T_77 /* ^^ */ , RDP_T_78 /* ^^^ */ , RDP_T_79 /* ^_ */ , SET_END); 
  292.   set_assign_list(& rdp_seq_25_first, RDP_T_74 /* [* */ , RDP_T_76 /* ^ */ , RDP_T_77 /* ^^ */ , RDP_T_78 /* ^^^ */ , RDP_T_79 /* ^_ */ , SET_END); 
  293.   set_assign_list(& rdp_seq_28_first, RDP_T_19 /* ( */ , RDP_T_27 /* < */ , RDP_T_73 /* [ */ , RDP_T_74 /* [* */ , RDP_T_80 /* { */ , SET_END); 
  294.   set_assign_list(& rdp_seq_29_first, SCAN_P_ID, SCAN_P_INTEGER, SCAN_P_REAL, RDP_T_16 /* " */ , RDP_T_18 /* ' */ , RDP_T_19 /* ( */ , 
  295.   RDP_T_27                    /* < */ , RDP_T_ALT_ID, RDP_T_CHAR, RDP_T_CHAR_ESC, RDP_T_COMMENT, RDP_T_COMMENT_LINE, 
  296.   RDP_T_COMMENT_LINE_VISIBLE, RDP_T_COMMENT_NEST, RDP_T_COMMENT_NEST_VISIBLE, RDP_T_COMMENT_VISIBLE, 
  297.   RDP_T_NEW_ID, RDP_T_NUMBER, RDP_T_STRING, RDP_T_STRING_ESC, RDP_T_73 /* [ */ , 
  298.   RDP_T_74                    /* [* */ , RDP_T_80 /* { */ , SET_END); 
  299.   set_assign_list(& rdp_seq_30_first, SCAN_P_ID, SCAN_P_INTEGER, SCAN_P_REAL, RDP_T_16 /* " */ , RDP_T_18 /* ' */ , RDP_T_19 /* ( */ , 
  300.   RDP_T_27                    /* < */ , RDP_T_ALT_ID, RDP_T_CHAR, RDP_T_CHAR_ESC, RDP_T_COMMENT, RDP_T_COMMENT_LINE, 
  301.   RDP_T_COMMENT_LINE_VISIBLE, RDP_T_COMMENT_NEST, RDP_T_COMMENT_NEST_VISIBLE, RDP_T_COMMENT_VISIBLE, 
  302.   RDP_T_NEW_ID, RDP_T_NUMBER, RDP_T_STRING, RDP_T_STRING_ESC, RDP_T_73 /* [ */ , 
  303.   RDP_T_74                    /* [* */ , RDP_T_80 /* { */ , SET_END); 
  304.   set_assign_list(& rdp_seq_31_first, SCAN_P_ID, SCAN_P_INTEGER, SCAN_P_REAL, RDP_T_16 /* " */ , RDP_T_18 /* ' */ , RDP_T_19 /* ( */ , 
  305.   RDP_T_27                    /* < */ , RDP_T_ALT_ID, RDP_T_CHAR, RDP_T_CHAR_ESC, RDP_T_COMMENT, RDP_T_COMMENT_LINE, 
  306.   RDP_T_COMMENT_LINE_VISIBLE, RDP_T_COMMENT_NEST, RDP_T_COMMENT_NEST_VISIBLE, RDP_T_COMMENT_VISIBLE, 
  307.   RDP_T_NEW_ID, RDP_T_NUMBER, RDP_T_STRING, RDP_T_STRING_ESC, RDP_T_73 /* [ */ , 
  308.   RDP_T_74                    /* [* */ , RDP_T_80 /* { */ , SET_END); 
  309.   set_assign_list(& rdp_seq_32_first, SCAN_P_ID, SCAN_P_INTEGER, SCAN_P_REAL, RDP_T_16 /* " */ , RDP_T_18 /* ' */ , RDP_T_19 /* ( */ , 
  310.   RDP_T_27                    /* < */ , RDP_T_ALT_ID, RDP_T_CHAR, RDP_T_CHAR_ESC, RDP_T_COMMENT, RDP_T_COMMENT_LINE, 
  311.   RDP_T_COMMENT_LINE_VISIBLE, RDP_T_COMMENT_NEST, RDP_T_COMMENT_NEST_VISIBLE, RDP_T_COMMENT_VISIBLE, 
  312.   RDP_T_NEW_ID, RDP_T_NUMBER, RDP_T_STRING, RDP_T_STRING_ESC, RDP_T_73 /* [ */ , 
  313.   RDP_T_74                    /* [* */ , RDP_T_80 /* { */ , SET_END); 
  314.   set_assign_list(& rdp_seq_9_first, RDP_T_76 /* ^ */ , RDP_T_77 /* ^^ */ , RDP_T_78 /* ^^^ */ , RDP_T_79 /* ^_ */ , SET_END); 
  315.   set_assign_list(& rdp_unit_1_first, RDP_T_ANNOTATED_EPSILON_TREE, RDP_T_ARG_BLANK, RDP_T_ARG_BOOLEAN, RDP_T_ARG_NUMERIC, 
  316.   RDP_T_ARG_STRING, RDP_T_CASE_INSENSITIVE, RDP_T_EPSILON_TREE, RDP_T_HASH_PRIME, 
  317.   RDP_T_HASH_SIZE, RDP_T_INCLUDE, RDP_T_INTERPRETER, RDP_T_MAX_ERRORS, RDP_T_MAX_WARNINGS, 
  318.   RDP_T_OPTION, RDP_T_OUTPUT_FILE, RDP_T_PARSER, RDP_T_PASSES, RDP_T_POST_PARSE, 
  319.   RDP_T_POST_PROCESS, RDP_T_PRE_PARSE, RDP_T_PRE_PROCESS, RDP_T_SET_SIZE, RDP_T_SHOW_SKIPS, 
  320.   RDP_T_SUFFIX, RDP_T_SYMBOL_TABLE, RDP_T_TAB_WIDTH, RDP_T_TEXT_SIZE, RDP_T_TITLE, 
  321.   RDP_T_TREE, RDP_T_USES, SET_END); 
  322.   set_assign_list(& rdp_unit_2_first, SCAN_P_ID, RDP_T_ANNOTATED_EPSILON_TREE, RDP_T_ARG_BLANK, RDP_T_ARG_BOOLEAN, RDP_T_ARG_NUMERIC, 
  323.   RDP_T_ARG_STRING, RDP_T_CASE_INSENSITIVE, RDP_T_EPSILON_TREE, RDP_T_HASH_PRIME, 
  324.   RDP_T_HASH_SIZE, RDP_T_INCLUDE, RDP_T_INTERPRETER, RDP_T_MAX_ERRORS, RDP_T_MAX_WARNINGS, 
  325.   RDP_T_OPTION, RDP_T_OUTPUT_FILE, RDP_T_PARSER, RDP_T_PASSES, RDP_T_POST_PARSE, 
  326.   RDP_T_POST_PROCESS, RDP_T_PRE_PARSE, RDP_T_PRE_PROCESS, RDP_T_SET_SIZE, RDP_T_SHOW_SKIPS, 
  327.   RDP_T_SUFFIX, RDP_T_SYMBOL_TABLE, RDP_T_TAB_WIDTH, RDP_T_TEXT_SIZE, RDP_T_TITLE, 
  328.   RDP_T_TREE, RDP_T_USES, SET_END); 
  329.   set_assign_list(& rdp_unit_3_first, SCAN_P_ID, RDP_T_ANNOTATED_EPSILON_TREE, RDP_T_ARG_BLANK, RDP_T_ARG_BOOLEAN, RDP_T_ARG_NUMERIC, 
  330.   RDP_T_ARG_STRING, RDP_T_CASE_INSENSITIVE, RDP_T_EPSILON_TREE, RDP_T_HASH_PRIME, 
  331.   RDP_T_HASH_SIZE, RDP_T_INCLUDE, RDP_T_INTERPRETER, RDP_T_MAX_ERRORS, RDP_T_MAX_WARNINGS, 
  332.   RDP_T_OPTION, RDP_T_OUTPUT_FILE, RDP_T_PARSER, RDP_T_PASSES, RDP_T_POST_PARSE, 
  333.   RDP_T_POST_PROCESS, RDP_T_PRE_PARSE, RDP_T_PRE_PROCESS, RDP_T_SET_SIZE, RDP_T_SHOW_SKIPS, 
  334.   RDP_T_SUFFIX, RDP_T_SYMBOL_TABLE, RDP_T_TAB_WIDTH, RDP_T_TEXT_SIZE, RDP_T_TITLE, 
  335.   RDP_T_TREE, RDP_T_USES, SET_END); 
  336.   set_assign_list(& rule_stop, SCAN_P_ID, SCAN_P_EOF, RDP_T_ANNOTATED_EPSILON_TREE, RDP_T_ARG_BLANK, RDP_T_ARG_BOOLEAN, 
  337.   RDP_T_ARG_NUMERIC, RDP_T_ARG_STRING, RDP_T_CASE_INSENSITIVE, RDP_T_EPSILON_TREE, 
  338.   RDP_T_HASH_PRIME, RDP_T_HASH_SIZE, RDP_T_INCLUDE, RDP_T_INTERPRETER, RDP_T_MAX_ERRORS, 
  339.   RDP_T_MAX_WARNINGS, RDP_T_OPTION, RDP_T_OUTPUT_FILE, RDP_T_PARSER, RDP_T_PASSES, 
  340.   RDP_T_POST_PARSE, RDP_T_POST_PROCESS, RDP_T_PRE_PARSE, RDP_T_PRE_PROCESS, RDP_T_SET_SIZE, 
  341.   RDP_T_SHOW_SKIPS, RDP_T_SUFFIX, RDP_T_SYMBOL_TABLE, RDP_T_TAB_WIDTH, RDP_T_TEXT_SIZE, 
  342.   RDP_T_TITLE, RDP_T_TREE, RDP_T_USES, SET_END); 
  343.   set_assign_list(& seq_first, SCAN_P_ID, SCAN_P_INTEGER, SCAN_P_REAL, RDP_T_16 /* " */ , RDP_T_18 /* ' */ , RDP_T_19 /* ( */ , 
  344.   RDP_T_27                    /* < */ , RDP_T_ALT_ID, RDP_T_CHAR, RDP_T_CHAR_ESC, RDP_T_COMMENT, RDP_T_COMMENT_LINE, 
  345.   RDP_T_COMMENT_LINE_VISIBLE, RDP_T_COMMENT_NEST, RDP_T_COMMENT_NEST_VISIBLE, RDP_T_COMMENT_VISIBLE, 
  346.   RDP_T_NEW_ID, RDP_T_NUMBER, RDP_T_STRING, RDP_T_STRING_ESC, RDP_T_73 /* [ */ , 
  347.   RDP_T_74                    /* [* */ , RDP_T_80 /* { */ , SET_END); 
  348.   set_assign_list(& seq_stop, SCAN_P_EOF, RDP_T_21 /* ) */ , RDP_T_23 /* . */ , RDP_T_28 /* > */ , RDP_T_75 /* ] */ , 
  349.   RDP_T_81                    /* | */ , RDP_T_82 /* } */ , SET_END); 
  350.   set_assign_list(& token_stop, SCAN_P_ID, SCAN_P_INTEGER, SCAN_P_REAL, SCAN_P_EOF, RDP_T_16 /* " */ , RDP_T_18 /* ' */ , 
  351.   RDP_T_19                    /* ( */ , RDP_T_21 /* ) */ , RDP_T_23 /* . */ , RDP_T_24 /* : */ , RDP_T_27 /* < */ , 
  352.   RDP_T_28                    /* > */ , RDP_T_ALT_ID, RDP_T_CHAR, RDP_T_CHAR_ESC, RDP_T_COMMENT, RDP_T_COMMENT_LINE, 
  353.   RDP_T_COMMENT_LINE_VISIBLE, RDP_T_COMMENT_NEST, RDP_T_COMMENT_NEST_VISIBLE, RDP_T_COMMENT_VISIBLE, 
  354.   RDP_T_NEW_ID, RDP_T_NUMBER, RDP_T_STRING, RDP_T_STRING_ESC, RDP_T_73 /* [ */ , 
  355.   RDP_T_74                    /* [* */ , RDP_T_75 /* ] */ , RDP_T_76 /* ^ */ , RDP_T_77 /* ^^ */ , RDP_T_78 /* ^^^ */ , 
  356.   RDP_T_79                    /* ^_ */ , RDP_T_80 /* { */ , RDP_T_81 /* | */ , RDP_T_82 /* } */ , SET_END); 
  357.   set_assign_list(& unit_first, SCAN_P_ID, RDP_T_ANNOTATED_EPSILON_TREE, RDP_T_ARG_BLANK, RDP_T_ARG_BOOLEAN, RDP_T_ARG_NUMERIC, 
  358.   RDP_T_ARG_STRING, RDP_T_CASE_INSENSITIVE, RDP_T_EPSILON_TREE, RDP_T_HASH_PRIME, 
  359.   RDP_T_HASH_SIZE, RDP_T_INCLUDE, RDP_T_INTERPRETER, RDP_T_MAX_ERRORS, RDP_T_MAX_WARNINGS, 
  360.   RDP_T_OPTION, RDP_T_OUTPUT_FILE, RDP_T_PARSER, RDP_T_PASSES, RDP_T_POST_PARSE, 
  361.   RDP_T_POST_PROCESS, RDP_T_PRE_PARSE, RDP_T_PRE_PROCESS, RDP_T_SET_SIZE, RDP_T_SHOW_SKIPS, 
  362.   RDP_T_SUFFIX, RDP_T_SYMBOL_TABLE, RDP_T_TAB_WIDTH, RDP_T_TEXT_SIZE, RDP_T_TITLE, 
  363.   RDP_T_TREE, RDP_T_USES, SET_END); 
  364.   set_assign_list(& unit_stop, SCAN_P_EOF, SET_END); 
  365. }
  366.  
  367. /* Parser forward declarations and macros */
  368. static char * String(void); 
  369. static char * code(void); 
  370. static void dir(void); 
  371. static rdp_data * item_com(void); 
  372. static rdp_data * item_inl(void); 
  373. static rdp_data * item_ret(void); 
  374. static rdp_list * prod(void); 
  375. static rdp_data * rule(void); 
  376. static rdp_list * seq(void); 
  377. static char * token(void); 
  378. void unit(void); 
  379.  
  380. /* Parser functions */
  381. static char * String(void)
  382. {
  383.   char * result; 
  384.   {
  385.     scan_test(NULL, RDP_T_16  /* " */ , & String_stop); 
  386.     result = SCAN_CAST->id; 
  387.     scan_(); 
  388.     scan_test_set(NULL, & String_stop, & String_stop); 
  389.   }
  390.   return result; 
  391. }
  392.  
  393. static char * code(void)
  394. {
  395.   char * result; 
  396.   {
  397.     scan_test(NULL, RDP_T_74  /* [* */ , & code_stop); 
  398.     result = SCAN_CAST->id; 
  399.     scan_(); 
  400.     scan_test_set(NULL, & code_stop, & code_stop); 
  401.   }
  402.   return result; 
  403. }
  404.  
  405. static void dir(void)
  406. {
  407.   char * filename; 
  408.   char * key; 
  409.   char * var; 
  410.   char * desc; 
  411.   char * name; 
  412.   long int size; 
  413.   long int prime; 
  414.   char * compare; 
  415.   char * hash; 
  416.   char * print; 
  417.   char * data_fields; 
  418.   char * s; 
  419.   long int n; 
  420.   char * str; 
  421.   {
  422.     if (scan_test(NULL, RDP_T_INCLUDE, NULL))
  423.     {
  424.       scan_test(NULL, RDP_T_INCLUDE, & dir_stop); 
  425.       scan_(); 
  426.       scan_test(NULL, RDP_T_19 /* ( */ , & dir_stop); 
  427.       scan_(); 
  428.       filename = code(); 
  429.       if (rdp_pass == 2){ \
  430.           if (text_open(filename)== NULL)\
  431.           text_message(TEXT_ERROR_ECHO, "include file \'%s\' not found\n", filename); \
  432.         text_get_char(); \
  433.         scan_(); \
  434.         \
  435.       }
  436.       scan_test(NULL, RDP_T_21 /* ) */ , & dir_stop); 
  437.       scan_(); 
  438.     }
  439.     else
  440.       if (scan_test(NULL, RDP_T_ARG_BOOLEAN, NULL))
  441.     {
  442.       scan_test(NULL, RDP_T_ARG_BOOLEAN, & dir_stop); 
  443.       scan_(); 
  444.       scan_test(NULL, RDP_T_19 /* ( */ , & dir_stop); 
  445.       scan_(); 
  446.       scan_test(NULL, SCAN_P_ID, & dir_stop); 
  447.       key = SCAN_CAST->id; 
  448.       scan_(); 
  449.       {                       /* Start of rdp_dir_3 */
  450.         while (1)
  451.         {
  452.           scan_test_set(NULL, & rdp_dir_3_first, & dir_stop); 
  453.           {
  454.             if (scan_test(NULL, SCAN_P_ID, NULL))
  455.             {
  456.               scan_test(NULL, SCAN_P_ID, & dir_stop); 
  457.               var = SCAN_CAST->id; 
  458.               scan_(); 
  459.             }
  460.             else
  461.               if (scan_test(NULL, RDP_T_74 /* [* */ , NULL))
  462.             {
  463.               var = code(); 
  464.             }
  465.             else
  466.               scan_test_set(NULL, & rdp_dir_3_first, & dir_stop); 
  467.           }
  468.           break;              /* hi limit is 1! */
  469.         }
  470.       }                       /* end of rdp_dir_3 */
  471.       desc = String(); 
  472.       scan_test(NULL, RDP_T_21 /* ) */ , & dir_stop); 
  473.       scan_(); 
  474.       if (rdp_pass == 2){ \
  475.           rdp_add_arg(ARG_BOOLEAN, key, var, desc); \
  476.       }
  477.     }
  478.     else
  479.       if (scan_test(NULL, RDP_T_ARG_NUMERIC, NULL))
  480.     {
  481.       scan_test(NULL, RDP_T_ARG_NUMERIC, & dir_stop); 
  482.       scan_(); 
  483.       scan_test(NULL, RDP_T_19 /* ( */ , & dir_stop); 
  484.       scan_(); 
  485.       scan_test(NULL, SCAN_P_ID, & dir_stop); 
  486.       key = SCAN_CAST->id; 
  487.       scan_(); 
  488.       {                       /* Start of rdp_dir_7 */
  489.         while (1)
  490.         {
  491.           scan_test_set(NULL, & rdp_dir_7_first, & dir_stop); 
  492.           {
  493.             if (scan_test(NULL, SCAN_P_ID, NULL))
  494.             {
  495.               scan_test(NULL, SCAN_P_ID, & dir_stop); 
  496.               var = SCAN_CAST->id; 
  497.               scan_(); 
  498.             }
  499.             else
  500.               if (scan_test(NULL, RDP_T_74 /* [* */ , NULL))
  501.             {
  502.               var = code(); 
  503.             }
  504.             else
  505.               scan_test_set(NULL, & rdp_dir_7_first, & dir_stop); 
  506.           }
  507.           break;              /* hi limit is 1! */
  508.         }
  509.       }                       /* end of rdp_dir_7 */
  510.       desc = String(); 
  511.       scan_test(NULL, RDP_T_21 /* ) */ , & dir_stop); 
  512.       scan_(); 
  513.       if (rdp_pass == 2){ \
  514.           rdp_add_arg(ARG_NUMERIC, key, var, desc); \
  515.       }
  516.     }
  517.     else
  518.       if (scan_test(NULL, RDP_T_ARG_STRING, NULL))
  519.     {
  520.       scan_test(NULL, RDP_T_ARG_STRING, & dir_stop); 
  521.       scan_(); 
  522.       scan_test(NULL, RDP_T_19 /* ( */ , & dir_stop); 
  523.       scan_(); 
  524.       scan_test(NULL, SCAN_P_ID, & dir_stop); 
  525.       key = SCAN_CAST->id; 
  526.       scan_(); 
  527.       {                       /* Start of rdp_dir_11 */
  528.         while (1)
  529.         {
  530.           scan_test_set(NULL, & rdp_dir_11_first, & dir_stop); 
  531.           {
  532.             if (scan_test(NULL, SCAN_P_ID, NULL))
  533.             {
  534.               scan_test(NULL, SCAN_P_ID, & dir_stop); 
  535.               var = SCAN_CAST->id; 
  536.               scan_(); 
  537.             }
  538.             else
  539.               if (scan_test(NULL, RDP_T_74 /* [* */ , NULL))
  540.             {
  541.               var = code(); 
  542.             }
  543.             else
  544.               scan_test_set(NULL, & rdp_dir_11_first, & dir_stop); 
  545.           }
  546.           break;              /* hi limit is 1! */
  547.         }
  548.       }                       /* end of rdp_dir_11 */
  549.       desc = String(); 
  550.       scan_test(NULL, RDP_T_21 /* ) */ , & dir_stop); 
  551.       scan_(); 
  552.       if (rdp_pass == 2){ \
  553.           rdp_add_arg(ARG_STRING, key, var, desc); \
  554.       }
  555.     }
  556.     else
  557.       if (scan_test(NULL, RDP_T_ARG_BLANK, NULL))
  558.     {
  559.       scan_test(NULL, RDP_T_ARG_BLANK, & dir_stop); 
  560.       scan_(); 
  561.       scan_test(NULL, RDP_T_19 /* ( */ , & dir_stop); 
  562.       scan_(); 
  563.       desc = String(); 
  564.       scan_test(NULL, RDP_T_21 /* ) */ , & dir_stop); 
  565.       scan_(); 
  566.       if (rdp_pass == 2){ \
  567.           rdp_add_arg(ARG_BLANK, NULL, NULL, desc); \
  568.       }
  569.     }
  570.     else
  571.       if (scan_test(NULL, RDP_T_SYMBOL_TABLE, NULL))
  572.     {
  573.       rdp_table_list * temp; 
  574.       scan_test(NULL, RDP_T_SYMBOL_TABLE, & dir_stop); 
  575.       scan_(); 
  576.       scan_test(NULL, RDP_T_19 /* ( */ , & dir_stop); 
  577.       scan_(); 
  578.       scan_test(NULL, SCAN_P_ID, & dir_stop); 
  579.       name = SCAN_CAST->id; 
  580.       scan_(); 
  581.       scan_test(NULL, SCAN_P_INTEGER, & dir_stop); 
  582.       size = SCAN_CAST->data.i; 
  583.       scan_(); 
  584.       scan_test(NULL, SCAN_P_INTEGER, & dir_stop); 
  585.       prime = SCAN_CAST->data.i; 
  586.       scan_(); 
  587.       scan_test(NULL, SCAN_P_ID, & dir_stop); 
  588.       compare = SCAN_CAST->id; 
  589.       scan_(); 
  590.       scan_test(NULL, SCAN_P_ID, & dir_stop); 
  591.       hash = SCAN_CAST->id; 
  592.       scan_(); 
  593.       scan_test(NULL, SCAN_P_ID, & dir_stop); 
  594.       print = SCAN_CAST->id; 
  595.       scan_(); 
  596.       data_fields = code(); 
  597.       if (rdp_pass == 2){ \
  598.           temp =(rdp_table_list *) mem_malloc(sizeof(rdp_table_list)); \
  599.         temp->name = name; \
  600.         temp->size =(unsigned) size; \
  601.         temp->prime =(unsigned) prime; \
  602.         temp->compare = compare; \
  603.         temp->hash = hash; \
  604.         temp->print = print; \
  605.         temp->data_fields = data_fields; \
  606.         temp->next = rdp_dir_symbol_table; \
  607.         rdp_dir_symbol_table = temp; \
  608.         \
  609.       }
  610.       scan_test(NULL, RDP_T_21 /* ) */ , & dir_stop); 
  611.       scan_(); 
  612.     }
  613.     else
  614.       if (scan_test(NULL, RDP_T_USES, NULL))
  615.     {
  616.       rdp_string_list * temp; 
  617.       scan_test(NULL, RDP_T_USES, & dir_stop); 
  618.       scan_(); 
  619.       scan_test(NULL, RDP_T_19 /* ( */ , & dir_stop); 
  620.       scan_(); 
  621.       s = String(); 
  622.       if (rdp_pass == 2){ \
  623.           temp =(rdp_string_list *) mem_malloc(sizeof(rdp_string_list)); \
  624.         temp->str1 = s; \
  625.         temp->next = rdp_dir_include; \
  626.         rdp_dir_include = temp; \
  627.         \
  628.       }
  629.       scan_test(NULL, RDP_T_21 /* ) */ , & dir_stop); 
  630.       scan_(); 
  631.     }
  632.     else
  633.       if (scan_test(NULL, RDP_T_OUTPUT_FILE, NULL))
  634.     {
  635.       scan_test(NULL, RDP_T_OUTPUT_FILE, & dir_stop); 
  636.       scan_(); 
  637.       scan_test(NULL, RDP_T_19 /* ( */ , & dir_stop); 
  638.       scan_(); 
  639.       s = String(); 
  640.       rdp_dir_output_file = s; 
  641.       scan_test(NULL, RDP_T_21 /* ) */ , & dir_stop); 
  642.       scan_(); 
  643.     }
  644.     else
  645.       if (scan_test(NULL, RDP_T_PARSER, NULL))
  646.     {
  647.       scan_test(NULL, RDP_T_PARSER, & dir_stop); 
  648.       scan_(); 
  649.       scan_test(NULL, RDP_T_19 /* ( */ , & dir_stop); 
  650.       scan_(); 
  651.       scan_test(NULL, SCAN_P_ID, & dir_stop); 
  652.       name = SCAN_CAST->id; 
  653.       scan_(); 
  654.       if (rdp_pass == 2){ \
  655.           rdp_start_prod = rdp_find(name, K_PRIMARY, RDP_OLD); rdp_start_prod->call_count++; \
  656.       }
  657.       scan_test(NULL, RDP_T_21 /* ) */ , & dir_stop); 
  658.       scan_(); 
  659.     }
  660.     else
  661.       if (scan_test(NULL, RDP_T_POST_PARSE, NULL))
  662.     {
  663.       scan_test(NULL, RDP_T_POST_PARSE, & dir_stop); 
  664.       scan_(); 
  665.       scan_test(NULL, RDP_T_19 /* ( */ , & dir_stop); 
  666.       scan_(); 
  667.       s = code(); 
  668.       rdp_dir_post_parse = s; 
  669.       scan_test(NULL, RDP_T_21 /* ) */ , & dir_stop); 
  670.       scan_(); 
  671.     }
  672.     else
  673.       if (scan_test(NULL, RDP_T_PRE_PARSE, NULL))
  674.     {
  675.       scan_test(NULL, RDP_T_PRE_PARSE, & dir_stop); 
  676.       scan_(); 
  677.       scan_test(NULL, RDP_T_19 /* ( */ , & dir_stop); 
  678.       scan_(); 
  679.       s = code(); 
  680.       rdp_dir_pre_parse = s; 
  681.       scan_test(NULL, RDP_T_21 /* ) */ , & dir_stop); 
  682.       scan_(); 
  683.     }
  684.     else
  685.       if (scan_test(NULL, RDP_T_SUFFIX, NULL))
  686.     {
  687.       scan_test(NULL, RDP_T_SUFFIX, & dir_stop); 
  688.       scan_(); 
  689.       scan_test(NULL, RDP_T_19 /* ( */ , & dir_stop); 
  690.       scan_(); 
  691.       s = String(); 
  692.       rdp_dir_suffix = s; 
  693.       scan_test(NULL, RDP_T_21 /* ) */ , & dir_stop); 
  694.       scan_(); 
  695.     }
  696.     else
  697.       if (scan_test(NULL, RDP_T_TITLE, NULL))
  698.     {
  699.       scan_test(NULL, RDP_T_TITLE, & dir_stop); 
  700.       scan_(); 
  701.       scan_test(NULL, RDP_T_19 /* ( */ , & dir_stop); 
  702.       scan_(); 
  703.       s = String(); 
  704.       rdp_dir_title = s; 
  705.       scan_test(NULL, RDP_T_21 /* ) */ , & dir_stop); 
  706.       scan_(); 
  707.     }
  708.     else
  709.       if (scan_test(NULL, RDP_T_MAX_ERRORS, NULL))
  710.     {
  711.       scan_test(NULL, RDP_T_MAX_ERRORS, & dir_stop); 
  712.       scan_(); 
  713.       scan_test(NULL, RDP_T_19 /* ( */ , & dir_stop); 
  714.       scan_(); 
  715.       scan_test(NULL, SCAN_P_INTEGER, & dir_stop); 
  716.       n = SCAN_CAST->data.i; 
  717.       scan_(); 
  718.       rdp_dir_max_errors =(unsigned) n; 
  719.       scan_test(NULL, RDP_T_21 /* ) */ , & dir_stop); 
  720.       scan_(); 
  721.     }
  722.     else
  723.       if (scan_test(NULL, RDP_T_MAX_WARNINGS, NULL))
  724.     {
  725.       scan_test(NULL, RDP_T_MAX_WARNINGS, & dir_stop); 
  726.       scan_(); 
  727.       scan_test(NULL, RDP_T_19 /* ( */ , & dir_stop); 
  728.       scan_(); 
  729.       scan_test(NULL, SCAN_P_INTEGER, & dir_stop); 
  730.       n = SCAN_CAST->data.i; 
  731.       scan_(); 
  732.       rdp_dir_max_warnings =(unsigned) n; 
  733.       scan_test(NULL, RDP_T_21 /* ) */ , & dir_stop); 
  734.       scan_(); 
  735.     }
  736.     else
  737.       if (scan_test(NULL, RDP_T_PASSES, NULL))
  738.     {
  739.       scan_test(NULL, RDP_T_PASSES, & dir_stop); 
  740.       scan_(); 
  741.       scan_test(NULL, RDP_T_19 /* ( */ , & dir_stop); 
  742.       scan_(); 
  743.       scan_test(NULL, SCAN_P_INTEGER, & dir_stop); 
  744.       n = SCAN_CAST->data.i; 
  745.       scan_(); 
  746.       rdp_dir_passes =(unsigned) n; 
  747.       scan_test(NULL, RDP_T_21 /* ) */ , & dir_stop); 
  748.       scan_(); 
  749.     }
  750.     else
  751.       if (scan_test(NULL, RDP_T_TAB_WIDTH, NULL))
  752.     {
  753.       scan_test(NULL, RDP_T_TAB_WIDTH, & dir_stop); 
  754.       scan_(); 
  755.       scan_test(NULL, RDP_T_19 /* ( */ , & dir_stop); 
  756.       scan_(); 
  757.       scan_test(NULL, SCAN_P_INTEGER, & dir_stop); 
  758.       n = SCAN_CAST->data.i; 
  759.       scan_(); 
  760.       rdp_dir_tab_width =(unsigned) n; 
  761.       scan_test(NULL, RDP_T_21 /* ) */ , & dir_stop); 
  762.       scan_(); 
  763.     }
  764.     else
  765.       if (scan_test(NULL, RDP_T_TEXT_SIZE, NULL))
  766.     {
  767.       scan_test(NULL, RDP_T_TEXT_SIZE, & dir_stop); 
  768.       scan_(); 
  769.       scan_test(NULL, RDP_T_19 /* ( */ , & dir_stop); 
  770.       scan_(); 
  771.       scan_test(NULL, SCAN_P_INTEGER, & dir_stop); 
  772.       n = SCAN_CAST->data.i; 
  773.       scan_(); 
  774.       rdp_dir_text_size =(unsigned) n; 
  775.       scan_test(NULL, RDP_T_21 /* ) */ , & dir_stop); 
  776.       scan_(); 
  777.     }
  778.     else
  779.       if (scan_test_set(NULL, & rdp_dir_33_first, NULL))
  780.     {
  781.       {                       /* Start of rdp_dir_30 */
  782.         while (1)
  783.         {
  784.           scan_test_set(NULL, & rdp_dir_30_first, & dir_stop); 
  785.           {
  786.             if (scan_test(NULL, RDP_T_ANNOTATED_EPSILON_TREE, NULL))
  787.             {
  788.               scan_test(NULL, RDP_T_ANNOTATED_EPSILON_TREE, & dir_stop); 
  789.               scan_(); 
  790.               rdp_dir_annotated_epsilon_tree = 1; rdp_dir_epsilon_tree = 1; 
  791.             }
  792.             else
  793.               if (scan_test(NULL, RDP_T_EPSILON_TREE, NULL))
  794.             {
  795.               scan_test(NULL, RDP_T_EPSILON_TREE, & dir_stop); 
  796.               scan_(); 
  797.               rdp_dir_epsilon_tree = 1; 
  798.             }
  799.             else
  800.               if (scan_test(NULL, RDP_T_TREE, NULL))
  801.             {
  802.               scan_test(NULL, RDP_T_TREE, & dir_stop); 
  803.               scan_(); 
  804.             }
  805.             else
  806.               scan_test_set(NULL, & rdp_dir_30_first, & dir_stop); 
  807.           }
  808.           break;              /* hi limit is 1! */
  809.         }
  810.       }                       /* end of rdp_dir_30 */
  811.       if (rdp_pass == 1){ \
  812.           rdp_dir_tree = 1; \
  813.         \
  814.       }
  815.       if (scan_test(NULL, RDP_T_19 /* ( */ , NULL))
  816.       {                       /* Start of rdp_dir_32 */
  817.         while (1)
  818.         {
  819.           {
  820.             scan_test(NULL, RDP_T_19 /* ( */ , & dir_stop); 
  821.             scan_(); 
  822.             str = code(); 
  823.             rdp_dir_tree_fields = str; 
  824.             scan_test(NULL, RDP_T_21 /* ) */ , & dir_stop); 
  825.             scan_(); 
  826.           }
  827.           break;              /* hi limit is 1! */
  828.         }
  829.       }                       /* end of rdp_dir_32 */
  830.     }
  831.     else
  832.       if (scan_test(NULL, RDP_T_CASE_INSENSITIVE, NULL))
  833.     {
  834.       scan_test(NULL, RDP_T_CASE_INSENSITIVE, & dir_stop); 
  835.       scan_(); 
  836.       rdp_dir_case_insensitive = 1; 
  837.     }
  838.     else
  839.       if (scan_test(NULL, RDP_T_SHOW_SKIPS, NULL))
  840.     {
  841.       scan_test(NULL, RDP_T_SHOW_SKIPS, & dir_stop); 
  842.       scan_(); 
  843.       rdp_dir_show_skips = 1; 
  844.     }
  845.     else
  846.       if (scan_test(NULL, RDP_T_OPTION, NULL))
  847.     {
  848.       scan_test(NULL, RDP_T_OPTION, & dir_stop); 
  849.       scan_(); 
  850.       text_message(TEXT_ERROR_ECHO, "Obsolete directive: OPTION replaced by ARG_* at version 1.5\n"); 
  851.       scan_test(NULL, RDP_T_19 /* ( */ , & dir_stop); 
  852.       scan_(); 
  853.       String(); 
  854.       if (scan_test(NULL, RDP_T_74 /* [* */ , NULL))
  855.       {                       /* Start of rdp_dir_37 */
  856.         while (1)
  857.         {
  858.           {
  859.             code(); 
  860.           }
  861.           break;              /* hi limit is 1! */
  862.         }
  863.       }                       /* end of rdp_dir_37 */
  864.       scan_test(NULL, RDP_T_21 /* ) */ , & dir_stop); 
  865.       scan_(); 
  866.     }
  867.     else
  868.       if (scan_test(NULL, RDP_T_PRE_PROCESS, NULL))
  869.     {
  870.       scan_test(NULL, RDP_T_PRE_PROCESS, & dir_stop); 
  871.       scan_(); 
  872.       text_message(TEXT_ERROR_ECHO, "Obsolete directive: PRE_PROCESS renamed PRE_PARSE at version 1.3\n"); 
  873.       scan_test(NULL, RDP_T_19 /* ( */ , & dir_stop); 
  874.       scan_(); 
  875.       code(); 
  876.       scan_test(NULL, RDP_T_21 /* ) */ , & dir_stop); 
  877.       scan_(); 
  878.     }
  879.     else
  880.       if (scan_test(NULL, RDP_T_POST_PROCESS, NULL))
  881.     {
  882.       scan_test(NULL, RDP_T_POST_PROCESS, & dir_stop); 
  883.       scan_(); 
  884.       text_message(TEXT_ERROR_ECHO, "Obsolete directive: POST_PROCESS renamed POST_PARSE at version 1.3\n"); 
  885.       scan_test(NULL, RDP_T_19 /* ( */ , & dir_stop); 
  886.       scan_(); 
  887.       code(); 
  888.       scan_test(NULL, RDP_T_21 /* ) */ , & dir_stop); 
  889.       scan_(); 
  890.     }
  891.     else
  892.       if (scan_test(NULL, RDP_T_SET_SIZE, NULL))
  893.     {
  894.       scan_test(NULL, RDP_T_SET_SIZE, & dir_stop); 
  895.       scan_(); 
  896.       text_message(TEXT_ERROR_ECHO, "Obsolete directive: SET_SIZE deleted at version 1.4\n"); 
  897.       scan_test(NULL, RDP_T_19 /* ( */ , & dir_stop); 
  898.       scan_(); 
  899.       scan_test(NULL, SCAN_P_INTEGER, & dir_stop); 
  900.       scan_(); 
  901.       scan_test(NULL, RDP_T_21 /* ) */ , & dir_stop); 
  902.       scan_(); 
  903.     }
  904.     else
  905.       if (scan_test(NULL, RDP_T_HASH_SIZE, NULL))
  906.     {
  907.       scan_test(NULL, RDP_T_HASH_SIZE, & dir_stop); 
  908.       scan_(); 
  909.       text_message(TEXT_ERROR_ECHO, "Obsolete directive: HASH_SIZE replaced by SYMBOL_TABLE at version 1.4\n"); 
  910.       scan_test(NULL, RDP_T_19 /* ( */ , & dir_stop); 
  911.       scan_(); 
  912.       scan_test(NULL, SCAN_P_INTEGER, & dir_stop); 
  913.       scan_(); 
  914.       scan_test(NULL, RDP_T_21 /* ) */ , & dir_stop); 
  915.       scan_(); 
  916.     }
  917.     else
  918.       if (scan_test(NULL, RDP_T_HASH_PRIME, NULL))
  919.     {
  920.       scan_test(NULL, RDP_T_HASH_PRIME, & dir_stop); 
  921.       scan_(); 
  922.       text_message(TEXT_ERROR_ECHO, "Obsolete directive: HASH_PRIME replaced by SYMBOL_TABLE at version 1.4\n"); 
  923.       scan_test(NULL, RDP_T_19 /* ( */ , & dir_stop); 
  924.       scan_(); 
  925.       scan_test(NULL, SCAN_P_INTEGER, & dir_stop); 
  926.       scan_(); 
  927.       scan_test(NULL, RDP_T_21 /* ) */ , & dir_stop); 
  928.       scan_(); 
  929.     }
  930.     else
  931.       if (scan_test(NULL, RDP_T_INTERPRETER, NULL))
  932.     {
  933.       scan_test(NULL, RDP_T_INTERPRETER, & dir_stop); 
  934.       scan_(); 
  935.       text_message(TEXT_ERROR_ECHO, "Obsolete directive: INTERPRETER mode deleted at version 1.4\n"); 
  936.       scan_test(NULL, RDP_T_19 /* ( */ , & dir_stop); 
  937.       scan_(); 
  938.       scan_test(NULL, SCAN_P_INTEGER, & dir_stop); 
  939.       scan_(); 
  940.       scan_test(NULL, RDP_T_21 /* ) */ , & dir_stop); 
  941.       scan_(); 
  942.     }
  943.     else
  944.       scan_test_set(NULL, & dir_first, & dir_stop); 
  945.     scan_test_set(NULL, & dir_stop, & dir_stop); 
  946.   }
  947. }
  948.  
  949. static rdp_data * item_com(void)
  950. {
  951.   rdp_data * result; 
  952.   char * name; 
  953.   char * close; 
  954.   {
  955.     if (scan_test(NULL, RDP_T_COMMENT, NULL))
  956.     {
  957.       scan_test(NULL, RDP_T_COMMENT, & item_com_stop); 
  958.       scan_(); 
  959.       scan_test(NULL, RDP_T_19 /* ( */ , & item_com_stop); 
  960.       scan_(); 
  961.       name = token(); 
  962.       close = token(); 
  963.       scan_test(NULL, RDP_T_21 /* ) */ , & item_com_stop); 
  964.       scan_(); 
  965.       if (rdp_pass == 2){ \
  966.           result = rdp_find_extended(name, close, SCAN_P_COMMENT); \
  967.       }
  968.     }
  969.     else
  970.       if (scan_test(NULL, RDP_T_COMMENT_LINE, NULL))
  971.     {
  972.       scan_test(NULL, RDP_T_COMMENT_LINE, & item_com_stop); 
  973.       scan_(); 
  974.       scan_test(NULL, RDP_T_19 /* ( */ , & item_com_stop); 
  975.       scan_(); 
  976.       name = token(); 
  977.       scan_test(NULL, RDP_T_21 /* ) */ , & item_com_stop); 
  978.       scan_(); 
  979.       if (rdp_pass == 2){ \
  980.           result = rdp_find_extended(name, NULL, SCAN_P_COMMENT_LINE); \
  981.       }
  982.     }
  983.     else
  984.       if (scan_test(NULL, RDP_T_COMMENT_NEST, NULL))
  985.     {
  986.       scan_test(NULL, RDP_T_COMMENT_NEST, & item_com_stop); 
  987.       scan_(); 
  988.       scan_test(NULL, RDP_T_19 /* ( */ , & item_com_stop); 
  989.       scan_(); 
  990.       name = token(); 
  991.       close = token(); 
  992.       scan_test(NULL, RDP_T_21 /* ) */ , & item_com_stop); 
  993.       scan_(); 
  994.       if (rdp_pass == 2){ \
  995.           result = rdp_find_extended(name, close, SCAN_P_COMMENT_NEST); \
  996.       }
  997.     }
  998.     else
  999.       scan_test_set(NULL, & item_com_first, & item_com_stop); 
  1000.     scan_test_set(NULL, & item_com_stop, & item_com_stop); 
  1001.   }
  1002.   return result; 
  1003. }
  1004.  
  1005. static rdp_data * item_inl(void)
  1006. {
  1007.   rdp_data * result; 
  1008.   char * name; 
  1009.   long int pass; 
  1010.   rdp_list * body; 
  1011.   long int val; 
  1012.   char * delimiter; 
  1013.   {
  1014.     int promote_op = PROMOTE_DEFAULT; 
  1015.     {                         /* Start of rdp_item_inl_21 */
  1016.       while (1)
  1017.       {
  1018.         scan_test_set(NULL, & rdp_item_inl_21_first, & item_inl_stop); 
  1019.         {
  1020.           if (scan_test(NULL, RDP_T_74 /* [* */ , NULL))
  1021.           {
  1022.             name = code(); 
  1023.             if (rdp_pass == 2){ \
  1024.                 result = rdp_find(name, K_CODE, RDP_ANY); \
  1025.               result->contains_null = 1; \
  1026.               result->call_count++;  /* increment call count */ \
  1027.               \
  1028.             }
  1029.             if (scan_test(NULL, RDP_T_29 /* @ */ , NULL))
  1030.             {                 /* Start of rdp_item_inl_1 */
  1031.               while (1)
  1032.               {
  1033.                 {
  1034.                   scan_test(NULL, RDP_T_29 /* @ */ , & item_inl_stop); 
  1035.                   scan_(); 
  1036.                   scan_test(NULL, SCAN_P_INTEGER, & item_inl_stop); 
  1037.                   pass = SCAN_CAST->data.i; 
  1038.                   scan_(); 
  1039.                   if (rdp_pass == 2){ \
  1040.                       result->code_pass =(unsigned) pass; \
  1041.                   }
  1042.                 }
  1043.                 break;        /* hi limit is 1! */
  1044.               }
  1045.             }                 /* end of rdp_item_inl_1 */
  1046.           }
  1047.           else
  1048.             if (scan_test(NULL, RDP_T_19 /* ( */ , NULL))
  1049.           {
  1050.             scan_test(NULL, RDP_T_19 /* ( */ , & item_inl_stop); 
  1051.             scan_(); 
  1052.             body = prod(); 
  1053.             scan_test(NULL, RDP_T_21 /* ) */ , & item_inl_stop); 
  1054.             scan_(); 
  1055.             if (rdp_pass == 2){ \
  1056.                 result = rdp_find(text_insert_substring("rdp", rdp_primary_id, rdp_component++), K_LIST, RDP_ANY); \
  1057.               result->promote = promote_op; \
  1058.               result->list = body; \
  1059.               result->call_count++; \
  1060.               result->lo = 1; \
  1061.               result->hi = 1; \
  1062.               \
  1063.             }
  1064.             if (scan_test_set(NULL, & rdp_item_inl_16_first, NULL))
  1065.             {                 /* Start of rdp_item_inl_16 */
  1066.               while (1)
  1067.               {
  1068.                 {
  1069.                   if (scan_test(NULL, SCAN_P_INTEGER, NULL))
  1070.                   {           /* Start of rdp_item_inl_4 */
  1071.                     while (1)
  1072.                     {
  1073.                       {
  1074.                         scan_test(NULL, SCAN_P_INTEGER, & item_inl_stop); 
  1075.                         val = SCAN_CAST->data.i; 
  1076.                         scan_(); 
  1077.                         if (rdp_pass == 2){ \
  1078.                             result->lo = val; \
  1079.                         }
  1080.                       }
  1081.                       break;  /* hi limit is 1! */
  1082.                     }
  1083.                   }           /* end of rdp_item_inl_4 */
  1084.                   scan_test(NULL, RDP_T_29 /* @ */ , & item_inl_stop); 
  1085.                   scan_(); 
  1086.                   if (rdp_pass == 2){ \
  1087.                       result->hi = 0;  /* iterate for ever by default */ \
  1088.                   }
  1089.                   if (scan_test(NULL, SCAN_P_INTEGER, NULL))
  1090.                   {           /* Start of rdp_item_inl_6 */
  1091.                     while (1)
  1092.                     {
  1093.                       {
  1094.                         scan_test(NULL, SCAN_P_INTEGER, & item_inl_stop); 
  1095.                         val = SCAN_CAST->data.i; 
  1096.                         scan_(); 
  1097.                         if (rdp_pass == 2){ \
  1098.                             result->hi = val; \
  1099.                         }
  1100.                       }
  1101.                       break;  /* hi limit is 1! */
  1102.                     }
  1103.                   }           /* end of rdp_item_inl_6 */
  1104.                   if (rdp_pass == 2){ \
  1105.                       if (result->lo == 0) result->contains_null = 1; \
  1106.                       if (result->hi != 0 &&(result->hi < result->lo))\
  1107.                       text_message(TEXT_ERROR_ECHO, "Iterator high count must be greater than low count"); \
  1108.                     \
  1109.                   }if (rdp_pass == 2){ \
  1110.                       result->delimiter_promote = PROMOTE_DONT; \
  1111.                   }
  1112.                   {           /* Start of rdp_item_inl_9 */
  1113.                     while (1)
  1114.                     {
  1115.                       scan_test_set(NULL, & rdp_item_inl_9_first, & item_inl_stop); 
  1116.                       {
  1117.                         if (scan_test(NULL, RDP_T_18 /* ' */ , NULL))
  1118.                         {
  1119.                           delimiter = token(); 
  1120.                           if (rdp_pass == 2){ \
  1121.                               result->supplementary_token = rdp_find(delimiter, K_TOKEN, RDP_ANY); \
  1122.                           }
  1123.                         }
  1124.                         else
  1125.                           if (scan_test(NULL, RDP_T_17 /* # */ , NULL))
  1126.                         {
  1127.                           scan_test(NULL, RDP_T_17 /* # */ , & item_inl_stop); 
  1128.                           scan_(); 
  1129.                         }
  1130.                         else
  1131.                           scan_test_set(NULL, & rdp_item_inl_9_first, & item_inl_stop); 
  1132.                       }
  1133.                       break;  /* hi limit is 1! */
  1134.                     }
  1135.                   }           /* end of rdp_item_inl_9 */
  1136.                   if (scan_test_set(NULL, & rdp_item_inl_14_first, NULL))
  1137.                   {           /* Start of rdp_item_inl_14 */
  1138.                     while (1)
  1139.                     {
  1140.                       {
  1141.                         if (scan_test(NULL, RDP_T_79 /* ^_ */ , NULL))
  1142.                         {
  1143.                           scan_test(NULL, RDP_T_79 /* ^_ */ , & item_inl_stop); 
  1144.                           scan_(); 
  1145.                           if (rdp_pass == 2){ \
  1146.                               result->delimiter_promote = PROMOTE_DONT; \
  1147.                           }
  1148.                         }
  1149.                         else
  1150.                           if (scan_test(NULL, RDP_T_76 /* ^ */ , NULL))
  1151.                         {
  1152.                           scan_test(NULL, RDP_T_76 /* ^ */ , & item_inl_stop); 
  1153.                           scan_(); 
  1154.                           if (rdp_pass == 2){ \
  1155.                               result->delimiter_promote = PROMOTE; \
  1156.                           }
  1157.                         }
  1158.                         else
  1159.                           if (scan_test(NULL, RDP_T_77 /* ^^ */ , NULL))
  1160.                         {
  1161.                           scan_test(NULL, RDP_T_77 /* ^^ */ , & item_inl_stop); 
  1162.                           scan_(); 
  1163.                           if (rdp_pass == 2){ \
  1164.                               result->delimiter_promote = PROMOTE_AND_COPY; \
  1165.                           }
  1166.                         }
  1167.                         else
  1168.                           if (scan_test(NULL, RDP_T_78 /* ^^^ */ , NULL))
  1169.                         {
  1170.                           scan_test(NULL, RDP_T_78 /* ^^^ */ , & item_inl_stop); 
  1171.                           scan_(); 
  1172.                           if (rdp_pass == 2){ \
  1173.                               result->delimiter_promote = PROMOTE_ABOVE; \
  1174.                           }
  1175.                         }
  1176.                       }
  1177.                       break;  /* hi limit is 1! */
  1178.                     }
  1179.                   }           /* end of rdp_item_inl_14 */
  1180.                 }
  1181.                 break;        /* hi limit is 1! */
  1182.               }
  1183.             }                 /* end of rdp_item_inl_16 */
  1184.           }
  1185.           else
  1186.             if (scan_test(NULL, RDP_T_80 /* { */ , NULL))
  1187.           {
  1188.             scan_test(NULL, RDP_T_80 /* { */ , & item_inl_stop); 
  1189.             scan_(); 
  1190.             body = prod(); 
  1191.             scan_test(NULL, RDP_T_82 /* } */ , & item_inl_stop); 
  1192.             scan_(); 
  1193.             if (rdp_pass == 2){ \
  1194.                 result = rdp_find(text_insert_substring("rdp", rdp_primary_id, rdp_component++), K_LIST, RDP_ANY); \
  1195.               result->promote = promote_op; \
  1196.               result->list = body; result->contains_null = 1; \
  1197.               result->call_count++; \
  1198.               result->lo = 0; \
  1199.               result->hi = 0; \
  1200.               \
  1201.             }
  1202.           }
  1203.           else
  1204.             if (scan_test(NULL, RDP_T_73 /* [ */ , NULL))
  1205.           {
  1206.             scan_test(NULL, RDP_T_73 /* [ */ , & item_inl_stop); 
  1207.             scan_(); 
  1208.             body = prod(); 
  1209.             scan_test(NULL, RDP_T_75 /* ] */ , & item_inl_stop); 
  1210.             scan_(); 
  1211.             if (rdp_pass == 2){ \
  1212.                 result = rdp_find(text_insert_substring("rdp", rdp_primary_id, rdp_component++), K_LIST, RDP_ANY); \
  1213.               result->promote = promote_op; \
  1214.               result->list = body; result->contains_null = 1; \
  1215.               result->call_count++; \
  1216.               result->lo = 0; \
  1217.               result->hi = 1; \
  1218.               \
  1219.             }
  1220.           }
  1221.           else
  1222.             if (scan_test(NULL, RDP_T_27 /* < */ , NULL))
  1223.           {
  1224.             scan_test(NULL, RDP_T_27 /* < */ , & item_inl_stop); 
  1225.             scan_(); 
  1226.             body = prod(); 
  1227.             scan_test(NULL, RDP_T_28 /* > */ , & item_inl_stop); 
  1228.             scan_(); 
  1229.             if (rdp_pass == 2){ \
  1230.                 result = rdp_find(text_insert_substring("rdp", rdp_primary_id, rdp_component++), K_LIST, RDP_ANY); \
  1231.               result->promote = promote_op; \
  1232.               result->list = body; \
  1233.               result->call_count++; \
  1234.               result->lo = 1; \
  1235.               result->hi = 0; \
  1236.               \
  1237.             }
  1238.           }
  1239.           else
  1240.             scan_test_set(NULL, & rdp_item_inl_21_first, & item_inl_stop); 
  1241.         }
  1242.         break;                /* hi limit is 1! */
  1243.       }
  1244.     }                         /* end of rdp_item_inl_21 */
  1245.     scan_test_set(NULL, & item_inl_stop, & item_inl_stop); 
  1246.   }
  1247.   return result; 
  1248. }
  1249.  
  1250. static rdp_data * item_ret(void)
  1251. {
  1252.   rdp_data * result; 
  1253.   char * name; 
  1254.   long int n; 
  1255.   double r; 
  1256.   char * str; 
  1257.   char * quote; 
  1258.   char * close; 
  1259.   {
  1260.     if (scan_test(NULL, SCAN_P_ID, NULL))
  1261.     {
  1262.       scan_test(NULL, SCAN_P_ID, & item_ret_stop); 
  1263.       name = SCAN_CAST->id; 
  1264.       scan_(); 
  1265.       if (rdp_pass == 2){ \
  1266.           result = rdp_find(name, K_PRIMARY, RDP_OLD); \
  1267.         rdp_check_eoln(name); \
  1268.         result->call_count++;  /* increment call count */ \
  1269.         result->actuals = NULL; \
  1270.         \
  1271.       }if (rdp_pass == 2 && result->parameterised){
  1272.           scan_test(NULL, RDP_T_19 /* ( */ , & item_ret_stop); 
  1273.         scan_(); 
  1274.         if (scan_test_set(NULL, & rdp_item_ret_6_first, NULL))
  1275.         {                     /* Start of rdp_item_ret_6 */
  1276.           while (1)
  1277.           {
  1278.             {
  1279.               rdp_param_list * param; 
  1280.               {               /* Start of rdp_item_ret_4 */
  1281.                 while (1)
  1282.                 {
  1283.                   scan_test_set(NULL, & rdp_item_ret_4_first, & item_ret_stop); 
  1284.                   {
  1285.                     if (scan_test(NULL, SCAN_P_INTEGER, NULL))
  1286.                     {
  1287.                       scan_test(NULL, SCAN_P_INTEGER, & item_ret_stop); 
  1288.                       n = SCAN_CAST->data.i; 
  1289.                       scan_(); 
  1290.                       if (rdp_pass == 2){ \
  1291.                           param =(rdp_param_list *) mem_calloc(sizeof(rdp_param_list), 1); \
  1292.                         param->n = n; \
  1293.                         param->next = result->actuals; \
  1294.                         result->actuals = param; \
  1295.                         param->flavour = PARAM_INTEGER; \
  1296.                         \
  1297.                       }
  1298.                     }
  1299.                     else
  1300.                       if (scan_test(NULL, SCAN_P_REAL, NULL))
  1301.                     {
  1302.                       scan_test(NULL, SCAN_P_REAL, & item_ret_stop); 
  1303.                       r = SCAN_CAST->data.r; 
  1304.                       scan_(); 
  1305.                       if (rdp_pass == 2){ \
  1306.                           param =(rdp_param_list *) mem_calloc(sizeof(rdp_param_list), 1); \
  1307.                         param->r = r; \
  1308.                         param->next = result->actuals; \
  1309.                         result->actuals = param; \
  1310.                         param->flavour = PARAM_REAL; \
  1311.                         \
  1312.                       }
  1313.                     }
  1314.                     else
  1315.                       if (scan_test(NULL, RDP_T_16 /* " */ , NULL))
  1316.                     {
  1317.                       str = String(); 
  1318.                       if (rdp_pass == 2){ \
  1319.                           param =(rdp_param_list *) mem_calloc(sizeof(rdp_param_list), 1); \
  1320.                         param->id = str; \
  1321.                         param->next = result->actuals; \
  1322.                         result->actuals = param; \
  1323.                         param->flavour = PARAM_STRING; \
  1324.                         \
  1325.                       }
  1326.                     }
  1327.                     else
  1328.                       if (scan_test(NULL, SCAN_P_ID, NULL))
  1329.                     {
  1330.                       scan_test(NULL, SCAN_P_ID, & item_ret_stop); 
  1331.                       name = SCAN_CAST->id; 
  1332.                       scan_(); 
  1333.                       if (rdp_pass == 2){ \
  1334.                           param =(rdp_param_list *) mem_calloc(sizeof(rdp_param_list), 1); \
  1335.                         param->id = name; \
  1336.                         param->next = result->actuals; \
  1337.                         result->actuals = param; \
  1338.                         param->flavour = PARAM_ID; \
  1339.                         \
  1340.                       }
  1341.                     }
  1342.                     else
  1343.                       scan_test_set(NULL, & rdp_item_ret_4_first, & item_ret_stop); 
  1344.                   }
  1345.                   break;      /* hi limit is 1! */
  1346.                 }
  1347.               }               /* end of rdp_item_ret_4 */
  1348.             }
  1349.             if (!scan_test_set(NULL, & rdp_item_ret_6_first, NULL)) break; 
  1350.             }
  1351.         }                     /* end of rdp_item_ret_6 */
  1352.         scan_test(NULL, RDP_T_21 /* ) */ , & item_ret_stop); 
  1353.         scan_(); 
  1354.       }
  1355.     }
  1356.     else
  1357.       if (scan_test(NULL, RDP_T_18 /* ' */ , NULL))
  1358.     {
  1359.       name = token(); 
  1360.       if (rdp_pass == 2){ \
  1361.           result =(rdp_data *) rdp_process_token(name); \
  1362.       }
  1363.     }
  1364.     else
  1365.       if (scan_test(NULL, RDP_T_CHAR, NULL))
  1366.     {
  1367.       scan_test(NULL, RDP_T_CHAR, & item_ret_stop); 
  1368.       scan_(); 
  1369.       scan_test(NULL, RDP_T_19 /* ( */ , & item_ret_stop); 
  1370.       scan_(); 
  1371.       name = token(); 
  1372.       scan_test(NULL, RDP_T_21 /* ) */ , & item_ret_stop); 
  1373.       scan_(); 
  1374.       if (rdp_pass == 2){ \
  1375.           result = rdp_find_extended(name, NULL, SCAN_P_CHAR); \
  1376.       }
  1377.     }
  1378.     else
  1379.       if (scan_test(NULL, RDP_T_CHAR_ESC, NULL))
  1380.     {
  1381.       scan_test(NULL, RDP_T_CHAR_ESC, & item_ret_stop); 
  1382.       scan_(); 
  1383.       scan_test(NULL, RDP_T_19 /* ( */ , & item_ret_stop); 
  1384.       scan_(); 
  1385.       name = token(); 
  1386.       quote = token(); 
  1387.       scan_test(NULL, RDP_T_21 /* ) */ , & item_ret_stop); 
  1388.       scan_(); 
  1389.       if (rdp_pass == 2){ \
  1390.           result = rdp_find_extended(name, quote, SCAN_P_CHAR_ESC); \
  1391.       }
  1392.     }
  1393.     else
  1394.       if (scan_test(NULL, RDP_T_STRING, NULL))
  1395.     {
  1396.       scan_test(NULL, RDP_T_STRING, & item_ret_stop); 
  1397.       scan_(); 
  1398.       scan_test(NULL, RDP_T_19 /* ( */ , & item_ret_stop); 
  1399.       scan_(); 
  1400.       name = token(); 
  1401.       scan_test(NULL, RDP_T_21 /* ) */ , & item_ret_stop); 
  1402.       scan_(); 
  1403.       if (rdp_pass == 2){ \
  1404.           result = rdp_find_extended(name, NULL, SCAN_P_STRING); \
  1405.       }
  1406.     }
  1407.     else
  1408.       if (scan_test(NULL, RDP_T_STRING_ESC, NULL))
  1409.     {
  1410.       scan_test(NULL, RDP_T_STRING_ESC, & item_ret_stop); 
  1411.       scan_(); 
  1412.       scan_test(NULL, RDP_T_19 /* ( */ , & item_ret_stop); 
  1413.       scan_(); 
  1414.       name = token(); 
  1415.       quote = token(); 
  1416.       scan_test(NULL, RDP_T_21 /* ) */ , & item_ret_stop); 
  1417.       scan_(); 
  1418.       if (rdp_pass == 2){ \
  1419.           result = rdp_find_extended(name, quote, SCAN_P_STRING_ESC); \
  1420.       }
  1421.     }
  1422.     else
  1423.       if (scan_test(NULL, RDP_T_COMMENT_VISIBLE, NULL))
  1424.     {
  1425.       scan_test(NULL, RDP_T_COMMENT_VISIBLE, & item_ret_stop); 
  1426.       scan_(); 
  1427.       scan_test(NULL, RDP_T_19 /* ( */ , & item_ret_stop); 
  1428.       scan_(); 
  1429.       name = token(); 
  1430.       close = token(); 
  1431.       scan_test(NULL, RDP_T_21 /* ) */ , & item_ret_stop); 
  1432.       scan_(); 
  1433.       if (rdp_pass == 2){ \
  1434.           result = rdp_find_extended(name, close, SCAN_P_COMMENT_VISIBLE); \
  1435.       }
  1436.     }
  1437.     else
  1438.       if (scan_test(NULL, RDP_T_COMMENT_NEST_VISIBLE, NULL))
  1439.     {
  1440.       scan_test(NULL, RDP_T_COMMENT_NEST_VISIBLE, & item_ret_stop); 
  1441.       scan_(); 
  1442.       scan_test(NULL, RDP_T_19 /* ( */ , & item_ret_stop); 
  1443.       scan_(); 
  1444.       name = token(); 
  1445.       close = token(); 
  1446.       scan_test(NULL, RDP_T_21 /* ) */ , & item_ret_stop); 
  1447.       scan_(); 
  1448.       if (rdp_pass == 2){ \
  1449.           result = rdp_find_extended(name, close, SCAN_P_COMMENT_NEST_VISIBLE); \
  1450.       }
  1451.     }
  1452.     else
  1453.       if (scan_test(NULL, RDP_T_COMMENT_LINE_VISIBLE, NULL))
  1454.     {
  1455.       scan_test(NULL, RDP_T_COMMENT_LINE_VISIBLE, & item_ret_stop); 
  1456.       scan_(); 
  1457.       scan_test(NULL, RDP_T_19 /* ( */ , & item_ret_stop); 
  1458.       scan_(); 
  1459.       name = token(); 
  1460.       scan_test(NULL, RDP_T_21 /* ) */ , & item_ret_stop); 
  1461.       scan_(); 
  1462.       if (rdp_pass == 2){ \
  1463.           result = rdp_find_extended(name, NULL, SCAN_P_COMMENT_LINE_VISIBLE); \
  1464.       }
  1465.     }
  1466.     else
  1467.       if (scan_test(NULL, RDP_T_NUMBER, NULL))
  1468.     {
  1469.       scan_test(NULL, RDP_T_NUMBER, & item_ret_stop); 
  1470.       scan_(); 
  1471.       text_message(TEXT_ERROR_ECHO, "Obsolete scanner primitive: NUMBER renamed INTEGER at version 1.3\n"); 
  1472.     }
  1473.     else
  1474.       if (scan_test(NULL, RDP_T_NEW_ID, NULL))
  1475.     {
  1476.       scan_test(NULL, RDP_T_NEW_ID, & item_ret_stop); 
  1477.       scan_(); 
  1478.       text_message(TEXT_ERROR_ECHO, "Obsolete scanner primitive: NEW_ID deleted at version 1.4\n"); 
  1479.     }
  1480.     else
  1481.       if (scan_test(NULL, RDP_T_ALT_ID, NULL))
  1482.     {
  1483.       scan_test(NULL, RDP_T_ALT_ID, & item_ret_stop); 
  1484.       scan_(); 
  1485.       text_message(TEXT_ERROR_ECHO, "Obsolete scanner primitive: ALT_ID deleted at version 1.4\n"); 
  1486.     }
  1487.     else
  1488.       if (scan_test(NULL, RDP_T_16 /* " */ , NULL))
  1489.     {
  1490.       str = String(); 
  1491.       if (rdp_pass == 2){ \
  1492.           text_message(TEXT_ERROR_ECHO, "Illegal grammar element: perhaps you intended to write \'%s\'\n", str); \
  1493.       }
  1494.     }
  1495.     else
  1496.       if (scan_test(NULL, SCAN_P_INTEGER, NULL))
  1497.     {
  1498.       scan_test(NULL, SCAN_P_INTEGER, & item_ret_stop); 
  1499.       scan_(); 
  1500.       if (rdp_pass == 2){ \
  1501.           text_message(TEXT_ERROR_ECHO, "Illegal grammar element: an integer may not appear here\n"); \
  1502.       }
  1503.     }
  1504.     else
  1505.       if (scan_test(NULL, SCAN_P_REAL, NULL))
  1506.     {
  1507.       scan_test(NULL, SCAN_P_REAL, & item_ret_stop); 
  1508.       scan_(); 
  1509.       if (rdp_pass == 2){ \
  1510.           text_message(TEXT_ERROR_ECHO, "Illegal grammar element: a real may not appear here\n"); \
  1511.       }
  1512.     }
  1513.     else
  1514.       scan_test_set(NULL, & item_ret_first, & item_ret_stop); 
  1515.     scan_test_set(NULL, & item_ret_stop, & item_ret_stop); 
  1516.   }
  1517.   return result; 
  1518. }
  1519.  
  1520. static rdp_list * prod(void)
  1521. {
  1522.   rdp_list * result; 
  1523.   rdp_list * body; 
  1524.   {
  1525.     rdp_list * end; if (rdp_pass == 2){ \
  1526.         end = result =(rdp_list *) mem_calloc(sizeof(rdp_list), 1); \
  1527.     }
  1528.     {                         /* Start of rdp_prod_1 */
  1529.       while (1)
  1530.       {
  1531.         scan_test_set(NULL, & rdp_prod_1_first, & prod_stop); 
  1532.         {
  1533.           body = seq(); 
  1534.           if (rdp_pass == 2){ \
  1535.               end->next =(rdp_list *) mem_calloc(sizeof(rdp_list), 1); \
  1536.             end = end->next; \
  1537.             end->production = rdp_find(text_insert_substring("rdp", rdp_primary_id, rdp_component++), K_SEQUENCE, RDP_NEW); \
  1538.             end->production->call_count++; \
  1539.             end->production->list = body; \
  1540.             \
  1541.           }
  1542.         }
  1543.         if (SCAN_CAST->token != RDP_T_81 /* | */) break; 
  1544.           scan_(); 
  1545.       }
  1546.     }                         /* end of rdp_prod_1 */
  1547.     if (rdp_pass == 2){ \
  1548.         result = result->next; \
  1549.     }
  1550.     scan_test_set(NULL, & prod_stop, & prod_stop); 
  1551.   }
  1552.   return result; 
  1553. }
  1554.  
  1555. static rdp_data * rule(void)
  1556. {
  1557.   rdp_data * result; 
  1558.   char * name; 
  1559.   char * type; 
  1560.   rdp_list * body; 
  1561.   {
  1562.     unsigned stars; 
  1563.     scan_test(NULL, SCAN_P_ID, & rule_stop); 
  1564.     name = SCAN_CAST->id; 
  1565.     scan_(); 
  1566.     rdp_primary_id = name; rdp_component = 0; \
  1567.     rdp_rule_count++; \
  1568.     result = rdp_find(rdp_primary_id, K_PRIMARY, rdp_pass == 1 ? RDP_NEW: RDP_OLD); \
  1569.     if (rdp_start_prod == NULL)\
  1570.     { \
  1571.       rdp_start_prod = result; \
  1572.       result->call_count++; \
  1573.     } \
  1574.     
  1575.     if (scan_test(NULL, RDP_T_19 /* ( */ , NULL))
  1576.     {                         /* Start of rdp_rule_7 */
  1577.       while (1)
  1578.       {
  1579.         {
  1580.           scan_test(NULL, RDP_T_19 /* ( */ , & rule_stop); 
  1581.           scan_(); 
  1582.           result->parameterised = 1; 
  1583.           if (scan_test(NULL, SCAN_P_ID, NULL))
  1584.           {                   /* Start of rdp_rule_5 */
  1585.             while (1)
  1586.             {
  1587.               {
  1588.                 rdp_param_list * param; type = "void"; 
  1589.                 scan_test(NULL, SCAN_P_ID, & rule_stop); 
  1590.                 name = SCAN_CAST->id; 
  1591.                 scan_(); 
  1592.                 if (scan_test(NULL, RDP_T_24 /* : */ , NULL))
  1593.                 {             /* Start of rdp_rule_3 */
  1594.                   while (1)
  1595.                   {
  1596.                     {
  1597.                       scan_test(NULL, RDP_T_24 /* : */ , & rule_stop); 
  1598.                       scan_(); 
  1599.                       scan_test(NULL, SCAN_P_ID, & rule_stop); 
  1600.                       type = SCAN_CAST->id; 
  1601.                       scan_(); 
  1602.                       stars = 0; 
  1603.                       if (scan_test(NULL, RDP_T_22 /* * */ , NULL))
  1604.                       {       /* Start of rdp_rule_1 */
  1605.                         while (1)
  1606.                         {
  1607.                           {
  1608.                             scan_test(NULL, RDP_T_22 /* * */ , & rule_stop); 
  1609.                             scan_(); 
  1610.                             stars++; 
  1611.                           }
  1612.                           if (!scan_test(NULL, RDP_T_22 /* * */ , NULL)) break; 
  1613.                           }
  1614.                       }       /* end of rdp_rule_1 */
  1615.                     }
  1616.                     break;    /* hi limit is 1! */
  1617.                   }
  1618.                 }             /* end of rdp_rule_3 */
  1619.                 if (rdp_pass == 1){ \
  1620.                     param =(rdp_param_list *) mem_calloc(sizeof(rdp_param_list), 1); \
  1621.                   param->id = name; \
  1622.                   param->type = type; \
  1623.                   param->stars = stars; \
  1624.                   param->next = result->params; \
  1625.                   result->params = param; \
  1626.                   \
  1627.                 }
  1628.               }
  1629.               if (!scan_test(NULL, SCAN_P_ID, NULL)) break; 
  1630.               }
  1631.           }                   /* end of rdp_rule_5 */
  1632.           scan_test(NULL, RDP_T_21 /* ) */ , & rule_stop); 
  1633.           scan_(); 
  1634.         }
  1635.         break;                /* hi limit is 1! */
  1636.       }
  1637.     }                         /* end of rdp_rule_7 */
  1638.     type = "void"; stars = 0; 
  1639.     if (scan_test(NULL, RDP_T_24 /* : */ , NULL))
  1640.     {                         /* Start of rdp_rule_11 */
  1641.       while (1)
  1642.       {
  1643.         {
  1644.           scan_test(NULL, RDP_T_24 /* : */ , & rule_stop); 
  1645.           scan_(); 
  1646.           scan_test(NULL, SCAN_P_ID, & rule_stop); 
  1647.           type = SCAN_CAST->id; 
  1648.           scan_(); 
  1649.           if (scan_test(NULL, RDP_T_22 /* * */ , NULL))
  1650.           {                   /* Start of rdp_rule_9 */
  1651.             while (1)
  1652.             {
  1653.               {
  1654.                 scan_test(NULL, RDP_T_22 /* * */ , & rule_stop); 
  1655.                 scan_(); 
  1656.                 stars++; 
  1657.               }
  1658.               if (!scan_test(NULL, RDP_T_22 /* * */ , NULL)) break; 
  1659.               }
  1660.           }                   /* end of rdp_rule_9 */
  1661.         }
  1662.         break;                /* hi limit is 1! */
  1663.       }
  1664.     }                         /* end of rdp_rule_11 */
  1665.     if (rdp_pass == 2){ \
  1666.         result->promote_default = PROMOTE_DONT; \
  1667.     }
  1668.     if (scan_test_set(NULL, & rdp_rule_16_first, NULL))
  1669.     {                         /* Start of rdp_rule_16 */
  1670.       while (1)
  1671.       {
  1672.         {
  1673.           if (scan_test(NULL, RDP_T_79 /* ^_ */ , NULL))
  1674.           {
  1675.             scan_test(NULL, RDP_T_79 /* ^_ */ , & rule_stop); 
  1676.             scan_(); 
  1677.             if (rdp_pass == 2){ \
  1678.                 result->promote_default = PROMOTE_DONT; \
  1679.             }
  1680.           }
  1681.           else
  1682.             if (scan_test(NULL, RDP_T_76 /* ^ */ , NULL))
  1683.           {
  1684.             scan_test(NULL, RDP_T_76 /* ^ */ , & rule_stop); 
  1685.             scan_(); 
  1686.             if (rdp_pass == 2){ \
  1687.                 result->promote_default = PROMOTE; \
  1688.             }
  1689.           }
  1690.           else
  1691.             if (scan_test(NULL, RDP_T_77 /* ^^ */ , NULL))
  1692.           {
  1693.             scan_test(NULL, RDP_T_77 /* ^^ */ , & rule_stop); 
  1694.             scan_(); 
  1695.             if (rdp_pass == 2){ \
  1696.                 result->promote_default = PROMOTE_AND_COPY; \
  1697.             }
  1698.           }
  1699.           else
  1700.             if (scan_test(NULL, RDP_T_78 /* ^^^ */ , NULL))
  1701.           {
  1702.             scan_test(NULL, RDP_T_78 /* ^^^ */ , & rule_stop); 
  1703.             scan_(); 
  1704.             if (rdp_pass == 2){ \
  1705.                 result->promote_default = PROMOTE_ABOVE; \
  1706.             }
  1707.           }
  1708.         }
  1709.         break;                /* hi limit is 1! */
  1710.       }
  1711.     }                         /* end of rdp_rule_16 */
  1712.     rdp_comment_only = 1;     /* set comments only flag */
  1713.     scan_test(NULL, RDP_T_26  /* ::= */ , & rule_stop); 
  1714.     scan_(); 
  1715.     body = prod(); 
  1716.     if (rdp_pass == 2){ \
  1717.         rdp_rule_count++; \
  1718.       result->list = body; \
  1719.       result->been_defined = 1; \
  1720.       result->return_type = type; \
  1721.       result->return_type_stars = stars; \
  1722.       result->comment_only = rdp_comment_only; \
  1723.       \
  1724.     }
  1725.     scan_test(NULL, RDP_T_23  /* . */ , & rule_stop); 
  1726.     scan_(); 
  1727.     scan_test_set(NULL, & rule_stop, & rule_stop); 
  1728.   }
  1729.   return result; 
  1730. }
  1731.  
  1732. static rdp_list * seq(void)
  1733. {
  1734.   rdp_list * result; 
  1735.   rdp_data * body; 
  1736.   char * ret_name; 
  1737.   char * default_action; 
  1738.   {
  1739.     rdp_list * end; int promote_op; int promote_epsilon; if (rdp_pass == 2){ \
  1740.         end = result =(rdp_list *) mem_calloc(sizeof(rdp_list), 1); \
  1741.     }
  1742.     {                         /* Start of rdp_seq_31 */
  1743.       while (1)
  1744.       {
  1745.         scan_test_set(NULL, & rdp_seq_31_first, & seq_stop); 
  1746.         {
  1747.           if (rdp_pass == 2){ \
  1748.               ret_name = NULL; promote_epsilon = PROMOTE_DONT; promote_op = PROMOTE_DEFAULT; \
  1749.           }
  1750.           {                   /* Start of rdp_seq_29 */
  1751.             while (1)
  1752.             {
  1753.               scan_test_set(NULL, & rdp_seq_29_first, & seq_stop); 
  1754.               {
  1755.                 if (scan_test_set(NULL, & rdp_seq_10_first, NULL))
  1756.                 {
  1757.                   {           /* Start of rdp_seq_2 */
  1758.                     while (1)
  1759.                     {
  1760.                       scan_test_set(NULL, & rdp_seq_2_first, & seq_stop); 
  1761.                       {
  1762.                         if (scan_test_set(NULL, & rdp_seq_0_first, NULL))
  1763.                         {
  1764.                           body = item_ret(); 
  1765.                           rdp_comment_only = 0; 
  1766.                         }
  1767.                         else
  1768.                           if (scan_test_set(NULL, & rdp_seq_1_first, NULL))
  1769.                         {
  1770.                           body = item_com(); 
  1771.                         }
  1772.                         else
  1773.                           scan_test_set(NULL, & rdp_seq_2_first, & seq_stop); 
  1774.                       }
  1775.                       break;  /* hi limit is 1! */
  1776.                     }
  1777.                   }           /* end of rdp_seq_2 */
  1778.                   if (scan_test(NULL, RDP_T_24 /* : */ , NULL))
  1779.                   {           /* Start of rdp_seq_4 */
  1780.                     while (1)
  1781.                     {
  1782.                       {
  1783.                         scan_test(NULL, RDP_T_24 /* : */ , & seq_stop); 
  1784.                         scan_(); 
  1785.                         scan_test(NULL, SCAN_P_ID, & seq_stop); 
  1786.                         ret_name = SCAN_CAST->id; 
  1787.                         scan_(); 
  1788.                       }
  1789.                       break;  /* hi limit is 1! */
  1790.                     }
  1791.                   }           /* end of rdp_seq_4 */
  1792.                   if (scan_test_set(NULL, & rdp_seq_9_first, NULL))
  1793.                   {           /* Start of rdp_seq_9 */
  1794.                     while (1)
  1795.                     {
  1796.                       {
  1797.                         if (scan_test(NULL, RDP_T_79 /* ^_ */ , NULL))
  1798.                         {
  1799.                           scan_test(NULL, RDP_T_79 /* ^_ */ , & seq_stop); 
  1800.                           scan_(); 
  1801.                           if (rdp_pass == 2){ \
  1802.                               promote_op = PROMOTE_DONT; \
  1803.                           }
  1804.                         }
  1805.                         else
  1806.                           if (scan_test(NULL, RDP_T_76 /* ^ */ , NULL))
  1807.                         {
  1808.                           scan_test(NULL, RDP_T_76 /* ^ */ , & seq_stop); 
  1809.                           scan_(); 
  1810.                           if (rdp_pass == 2){ \
  1811.                               promote_op = PROMOTE; \
  1812.                           }
  1813.                         }
  1814.                         else
  1815.                           if (scan_test(NULL, RDP_T_77 /* ^^ */ , NULL))
  1816.                         {
  1817.                           scan_test(NULL, RDP_T_77 /* ^^ */ , & seq_stop); 
  1818.                           scan_(); 
  1819.                           if (rdp_pass == 2){ \
  1820.                               promote_op = PROMOTE_AND_COPY; \
  1821.                           }
  1822.                         }
  1823.                         else
  1824.                           if (scan_test(NULL, RDP_T_78 /* ^^^ */ , NULL))
  1825.                         {
  1826.                           scan_test(NULL, RDP_T_78 /* ^^^ */ , & seq_stop); 
  1827.                           scan_(); 
  1828.                           if (rdp_pass == 2){ \
  1829.                               promote_op = PROMOTE_ABOVE; \
  1830.                           }
  1831.                         }
  1832.                       }
  1833.                       break;  /* hi limit is 1! */
  1834.                     }
  1835.                   }           /* end of rdp_seq_9 */
  1836.                 }
  1837.                 else
  1838.                   if (scan_test_set(NULL, & rdp_seq_28_first, NULL))
  1839.                 {
  1840.                   body = item_inl(); 
  1841.                   rdp_comment_only = 0; 
  1842.                   if (rdp_pass == 2){ \
  1843.                       promote_op = body->promote; default_action = NULL; \
  1844.                   }
  1845.                   if (scan_test(NULL, RDP_T_24 /* : */ , NULL))
  1846.                   {           /* Start of rdp_seq_27 */
  1847.                     while (1)
  1848.                     {
  1849.                       {
  1850.                         scan_test(NULL, RDP_T_24 /* : */ , & seq_stop); 
  1851.                         scan_(); 
  1852.                         if (scan_test(NULL, SCAN_P_ID, NULL))
  1853.                         {     /* Start of rdp_seq_12 */
  1854.                           while (1)
  1855.                           {
  1856.                             {
  1857.                               scan_test(NULL, SCAN_P_ID, & seq_stop); 
  1858.                               scan_(); 
  1859.                               if (rdp_pass == 2){ \
  1860.                                   text_message(TEXT_ERROR_ECHO, "Illegal grammar element: expressions may not retun a value"); \
  1861.                               }
  1862.                             }
  1863.                             break;  /* hi limit is 1! */
  1864.                           }
  1865.                         }     /* end of rdp_seq_12 */
  1866.                         if (scan_test_set(NULL, & rdp_seq_25_first, NULL))
  1867.                         {     /* Start of rdp_seq_25 */
  1868.                           while (1)
  1869.                           {
  1870.                             {
  1871.                               if (scan_test(NULL, RDP_T_74 /* [* */ , NULL))
  1872.                               {
  1873.                                 default_action = code(); 
  1874.                                 if (scan_test_set(NULL, & rdp_seq_17_first, NULL))
  1875.                                 { /* Start of rdp_seq_17 */
  1876.                                   while (1)
  1877.                                   {
  1878.                                     {
  1879.                                       if (scan_test(NULL, RDP_T_79 /* ^_ */ , NULL))
  1880.                                       {
  1881.                                         scan_test(NULL, RDP_T_79 /* ^_ */ , & seq_stop); 
  1882.                                         scan_(); 
  1883.                                         if (rdp_pass == 2){ \
  1884.                                             promote_epsilon = PROMOTE_DONT; \
  1885.                                         }
  1886.                                       }
  1887.                                       else
  1888.                                         if (scan_test(NULL, RDP_T_76 /* ^ */ , NULL))
  1889.                                       {
  1890.                                         scan_test(NULL, RDP_T_76 /* ^ */ , & seq_stop); 
  1891.                                         scan_(); 
  1892.                                         if (rdp_pass == 2){ \
  1893.                                             promote_epsilon = PROMOTE; \
  1894.                                         }
  1895.                                       }
  1896.                                       else
  1897.                                         if (scan_test(NULL, RDP_T_77 /* ^^ */ , NULL))
  1898.                                       {
  1899.                                         scan_test(NULL, RDP_T_77 /* ^^ */ , & seq_stop); 
  1900.                                         scan_(); 
  1901.                                         if (rdp_pass == 2){ \
  1902.                                             promote_epsilon = PROMOTE_AND_COPY; \
  1903.                                         }
  1904.                                       }
  1905.                                       else
  1906.                                         if (scan_test(NULL, RDP_T_78 /* ^^^ */ , NULL))
  1907.                                       {
  1908.                                         scan_test(NULL, RDP_T_78 /* ^^^ */ , & seq_stop); 
  1909.                                         scan_(); 
  1910.                                         if (rdp_pass == 2){ \
  1911.                                             promote_epsilon = PROMOTE_ABOVE; \
  1912.                                         }
  1913.                                       }
  1914.                                     }
  1915.                                     break;  /* hi limit is 1! */
  1916.                                   }
  1917.                                 } /* end of rdp_seq_17 */
  1918.                               }
  1919.                               else
  1920.                                 if (scan_test_set(NULL, & rdp_seq_24_first, NULL))
  1921.                               {
  1922.                                 { /* Start of rdp_seq_23 */
  1923.                                   while (1)
  1924.                                   {
  1925.                                     scan_test_set(NULL, & rdp_seq_23_first, & seq_stop); 
  1926.                                     {
  1927.                                       if (scan_test(NULL, RDP_T_79 /* ^_ */ , NULL))
  1928.                                       {
  1929.                                         scan_test(NULL, RDP_T_79 /* ^_ */ , & seq_stop); 
  1930.                                         scan_(); 
  1931.                                         if (rdp_pass == 2){ \
  1932.                                             promote_epsilon = PROMOTE_DONT; \
  1933.                                         }
  1934.                                       }
  1935.                                       else
  1936.                                         if (scan_test(NULL, RDP_T_76 /* ^ */ , NULL))
  1937.                                       {
  1938.                                         scan_test(NULL, RDP_T_76 /* ^ */ , & seq_stop); 
  1939.                                         scan_(); 
  1940.                                         if (rdp_pass == 2){ \
  1941.                                             promote_epsilon = PROMOTE; \
  1942.                                         }
  1943.                                       }
  1944.                                       else
  1945.                                         if (scan_test(NULL, RDP_T_77 /* ^^ */ , NULL))
  1946.                                       {
  1947.                                         scan_test(NULL, RDP_T_77 /* ^^ */ , & seq_stop); 
  1948.                                         scan_(); 
  1949.                                         if (rdp_pass == 2){ \
  1950.                                             promote_epsilon = PROMOTE_AND_COPY; \
  1951.                                         }
  1952.                                       }
  1953.                                       else
  1954.                                         if (scan_test(NULL, RDP_T_78 /* ^^^ */ , NULL))
  1955.                                       {
  1956.                                         scan_test(NULL, RDP_T_78 /* ^^^ */ , & seq_stop); 
  1957.                                         scan_(); 
  1958.                                         if (rdp_pass == 2){ \
  1959.                                             promote_epsilon = PROMOTE_ABOVE; \
  1960.                                         }
  1961.                                       }
  1962.                                       else
  1963.                                         scan_test_set(NULL, & rdp_seq_23_first, & seq_stop); 
  1964.                                     }
  1965.                                     break;  /* hi limit is 1! */
  1966.                                   }
  1967.                                 } /* end of rdp_seq_23 */
  1968.                               }
  1969.                             }
  1970.                             break;  /* hi limit is 1! */
  1971.                           }
  1972.                         }     /* end of rdp_seq_25 */
  1973.                       }
  1974.                       break;  /* hi limit is 1! */
  1975.                     }
  1976.                   }           /* end of rdp_seq_27 */
  1977.                 }
  1978.                 else
  1979.                   scan_test_set(NULL, & rdp_seq_29_first, & seq_stop); 
  1980.               }
  1981.               break;          /* hi limit is 1! */
  1982.             }
  1983.           }                   /* end of rdp_seq_29 */
  1984.           if (rdp_pass == 2){ \
  1985.               end->next =(rdp_list *) mem_calloc(sizeof(rdp_list), 1); \
  1986.             end = end->next; \
  1987.             end->production = body; \
  1988.             end->actuals = body->actuals; \
  1989.             end->return_name = ret_name; \
  1990.             end->promote = promote_op; \
  1991.             end->promote_epsilon = promote_epsilon; \
  1992.             end->default_action = default_action; \
  1993.             \
  1994.           }
  1995.         }
  1996.         if (!scan_test_set(NULL, & rdp_seq_31_first, NULL)) break; 
  1997.         }
  1998.     }                         /* end of rdp_seq_31 */
  1999.     if (rdp_pass == 2){ \
  2000.         result = result->next; \
  2001.     }
  2002.     scan_test_set(NULL, & seq_stop, & seq_stop); 
  2003.   }
  2004.   return result; 
  2005. }
  2006.  
  2007. static char * token(void)
  2008. {
  2009.   char * result; 
  2010.   {
  2011.     scan_test(NULL, RDP_T_18  /* ' */ , & token_stop); 
  2012.     result = SCAN_CAST->id; 
  2013.     scan_(); 
  2014.     scan_test_set(NULL, & token_stop, & token_stop); 
  2015.   }
  2016.   return result; 
  2017. }
  2018.  
  2019. void unit(void)
  2020. {
  2021.   {
  2022.     if (scan_test_set(NULL, & rdp_unit_2_first, NULL))
  2023.     {                         /* Start of rdp_unit_2 */
  2024.       while (1)
  2025.       {
  2026.         {
  2027.           if (scan_test(NULL, SCAN_P_ID, NULL))
  2028.           {
  2029.             rule(); 
  2030.           }
  2031.           else
  2032.             if (scan_test_set(NULL, & rdp_unit_1_first, NULL))
  2033.           {
  2034.             dir(); 
  2035.           }
  2036.         }
  2037.         if (!scan_test_set(NULL, & rdp_unit_2_first, NULL)) break; 
  2038.         }
  2039.     }                         /* end of rdp_unit_2 */
  2040.     if (rdp_rule_count == 0) text_message(TEXT_FATAL, "no rule definitions found\n"); 
  2041.       scan_test_set(NULL, & unit_stop, & unit_stop); 
  2042.   }
  2043. }
  2044.  
  2045. int main(int argc, char * argv[])
  2046. {
  2047.   clock_t rdp_finish_time, rdp_start_time = clock(); 
  2048.   int
  2049.   rdp_symbol_statistics = 0,  /* show symbol_ table statistics flag */
  2050.   rdp_line_echo_all = 0,      /* make a listing on all passes flag */
  2051.   rdp_filter = 0,             /* filter flag */
  2052.   rdp_line_echo = 0;          /* make listing flag */
  2053.   
  2054.   unsigned long rdp_textsize = 34000l;  /* size of scanner text array */
  2055.   
  2056.   unsigned long rdp_tabwidth = 8l;  /* tab expansion width */
  2057.   
  2058.   char * rdp_vcg_filename = NULL;  /* filename for -V option */
  2059.   
  2060.   arg_message("Recursive descent parser generator V1.50 (c) Adrian Johnstone 1997\n" RDP_STAMP "\n\n" "Usage: rdp [options] source[.BNF]"); 
  2061.   
  2062.   arg_message(""); 
  2063.   arg_boolean('f', "Filter mode (read from stdin and write to stdout)", & rdp_filter); 
  2064.   arg_boolean('l', "Make a listing", & rdp_line_echo); 
  2065.   arg_string('o', "Write output to filename", & rdp_outputfilename); 
  2066.   arg_boolean('s', "Echo each scanner symbol as it is read", & rdp_symbol_echo); 
  2067.   arg_boolean('S', "Print summary symbol table statistics", & rdp_symbol_statistics); 
  2068.   arg_numeric('t', "Tab expansion width (default 8)", & rdp_tabwidth); 
  2069.   arg_numeric('T', "Text buffer size in bytes for scanner (default 20000)", & rdp_textsize); 
  2070.   arg_boolean('v', "Set verbose mode", & rdp_verbose); 
  2071.   arg_string('V', "(Write derivation tree to filename in VCG format - not available in this parser)", & rdp_vcg_filename); 
  2072.   arg_message(""); 
  2073.   arg_boolean('e', "Write out expanded BNF along with first and follow sets", & rdp_expanded); 
  2074.   arg_boolean('E', "Add rule name to error messages in generated parser", & rdp_error_production_name); 
  2075.   arg_boolean('F', "Force creation of output files", & rdp_force); 
  2076.   arg_boolean('p', "Make parser only (omit semantic actions from generated code)", & rdp_parser_only); 
  2077.   arg_boolean('R', "Add rule entry and exit messages", & rdp_trace); 
  2078.   arg_message(""); 
  2079.   arg_message("You can contact the author (Adrian Johnstone) at:"); 
  2080.   arg_message(""); 
  2081.   arg_message("Computer Science Department, Royal Holloway, University of London"); 
  2082.   arg_message("Egham, Surrey, TW20 0EX UK. Email: A.Johnstone@rhbnc.ac.uk"); 
  2083.   
  2084.   rdp_sourcefilename = * arg_process(argc, argv); 
  2085.   
  2086.   if (rdp_filter)
  2087.   {
  2088.     rdp_sourcefilename = "-"; 
  2089.     rdp_outputfilename = "-"; 
  2090.     
  2091.   }
  2092.   if (rdp_sourcefilename == NULL)
  2093.     arg_help("No source file specified"); 
  2094.   
  2095.   rdp_sourcefilename = text_default_filetype(rdp_sourcefilename, "BNF"); 
  2096.   text_init(rdp_textsize, 50, 120, (int) rdp_tabwidth); 
  2097.   scan_init(0, 0, 1, rdp_symbol_echo, rdp_tokens); 
  2098.   locals = symbol_new_table("locals", 101, 31, symbol_compare_string, symbol_hash_string, symbol_print_string); 
  2099.   codes = symbol_new_table("codes", 101, 31, symbol_compare_string, symbol_hash_string, symbol_print_string); 
  2100.   tokens = symbol_new_table("tokens", 101, 31, symbol_compare_string, symbol_hash_string, symbol_print_string); 
  2101.   rdp = symbol_new_table("rdp", 101, 31, symbol_compare_string, symbol_hash_string, symbol_print_string); 
  2102.   rdp_set_initialise(); 
  2103.   rdp_load_keywords(); 
  2104.   if (rdp_verbose)
  2105.     text_printf("\nRecursive descent parser generator V1.50 (c) Adrian Johnstone 1997\n" RDP_STAMP "\n\n"); 
  2106.   rdp_pre_parse(); 
  2107.   for (rdp_pass = 1; rdp_pass <= RDP_PASSES; rdp_pass++)
  2108.   {
  2109.     text_echo(rdp_line_echo_all ||(rdp_line_echo && rdp_pass == RDP_PASSES)); 
  2110.     if (text_open(rdp_sourcefilename)== NULL)
  2111.       arg_help("unable to open source file"); 
  2112.     
  2113.     text_get_char(); 
  2114.     scan_(); 
  2115.     
  2116.     unit();                   /* call parser at top level */
  2117.     if (text_total_errors()!= 0)
  2118.       text_message(TEXT_FATAL, "error%s detected in source file\n", text_total_errors()== 1 ? "": "s");  /* crash quietly */
  2119.   }
  2120.   if (rdp_symbol_statistics)
  2121.     symbol_print_all_table_statistics(11); 
  2122.   
  2123.   rdp_post_parse(rdp_outputfilename, rdp_force); 
  2124.   text_print_total_errors(); 
  2125.   if (rdp_verbose)
  2126.   {
  2127.     rdp_finish_time = clock(); 
  2128.     text_message(TEXT_INFO, "%.3f CPU seconds used\n", ((double)(rdp_finish_time - rdp_start_time))/ CLOCKS_PER_SEC); 
  2129.   }
  2130.   return rdp_error_return; 
  2131. }
  2132.  
  2133. /* End of rdp.c */
  2134.