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_cs3460.tar / rdp.c < prev    next >
C/C++ Source or Header  |  1998-05-07  |  86KB  |  2,145 lines
  1. /*******************************************************************************
  2. *
  3. * Parser generated by RDP on May 04 1998 09:45:17 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\0" 
  31. "ID\0" "INTEGER\0" "REAL\0" "CHAR\0" "CHAR_ESC\0" "STRING\0" "STRING_ESC\0" "COMMENT\0" 
  32. "COMMENT_VISIBLE\0" "COMMENT_NEST\0" "COMMENT_NEST_VISIBLE\0" "COMMENT_LINE\0" "COMMENT_LINE_VISIBLE\0" "EOF\0" "EOLN\0" "'\"'\0" 
  33. "'#'\0" "'\''\0" "'('\0" "'(*'\0" "')'\0" "'*'\0" "'.'\0" "':'\0" 
  34. "'::'\0" "'::='\0" "'<'\0" "'>'\0" "'@'\0" "'ALT_ID'\0" "'ANNOTATED_EPSILON_TREE'\0" "'ARG_BLANK'\0" 
  35. "'ARG_BOOLEAN'\0" "'ARG_NUMERIC'\0" "'ARG_STRING'\0" "'CASE_INSENSITIVE'\0" "'CHAR'\0" "'CHAR_ESC'\0" "'COMMENT'\0" "'COMMENT_LINE'\0" 
  36. "'COMMENT_LINE_VISIBLE'\0" "'COMMENT_NEST'\0" "'COMMENT_NEST_VISIBLE'\0" "'COMMENT_VISIBLE'\0" "'EPSILON_TREE'\0" "'HASH_PRIME'\0" "'HASH_SIZE'\0" "'INCLUDE'\0" 
  37. "'INTERPRETER'\0" "'MAX_ERRORS'\0" "'MAX_WARNINGS'\0" "'NEW_ID'\0" "'NUMBER'\0" "'OPTION'\0" "'OUTPUT_FILE'\0" "'PARSER'\0" 
  38. "'PASSES'\0" "'POST_PARSE'\0" "'POST_PROCESS'\0" "'PRE_PARSE'\0" "'PRE_PROCESS'\0" "'SET_SIZE'\0" "'SHOW_SKIPS'\0" "'STRING'\0" 
  39. "'STRING_ESC'\0" "'SUFFIX'\0" "'SYMBOL_TABLE'\0" "'TAB_WIDTH'\0" "'TEXT_SIZE'\0" "'TITLE'\0" "'TREE'\0" "'USES'\0" 
  40. "'['\0" "'[*'\0" "']'\0" "'^'\0" "'^^'\0" "'^^^'\0" "'^_'\0" "'{'\0" 
  41. "'|'\0" "'}'\0" ;
  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.       if (scan_test(NULL, RDP_T_19 /* ( */, NULL))
  815.       { /* Start of rdp_dir_32 */
  816.         while (1)
  817.         {
  818.           {
  819.             scan_test(NULL, RDP_T_19 /* ( */, &dir_stop);
  820.             scan_();
  821.             str = code();
  822.              rdp_dir_tree_fields = str; 
  823.             scan_test(NULL, RDP_T_21 /* ) */, &dir_stop);
  824.             scan_();
  825.             }
  826.           break;   /* hi limit is 1! */
  827.         }
  828.       } /* end of rdp_dir_32 */
  829.     }
  830.     else
  831.     if (scan_test(NULL, RDP_T_CASE_INSENSITIVE, NULL))
  832.     {
  833.       scan_test(NULL, RDP_T_CASE_INSENSITIVE, &dir_stop);
  834.       scan_();
  835.        rdp_dir_case_insensitive = 1; 
  836.     }
  837.     else
  838.     if (scan_test(NULL, RDP_T_SHOW_SKIPS, NULL))
  839.     {
  840.       scan_test(NULL, RDP_T_SHOW_SKIPS, &dir_stop);
  841.       scan_();
  842.        rdp_dir_show_skips = 1; 
  843.     }
  844.     else
  845.     if (scan_test(NULL, RDP_T_OPTION, NULL))
  846.     {
  847.       scan_test(NULL, RDP_T_OPTION, &dir_stop);
  848.       scan_();
  849.        text_message(TEXT_ERROR_ECHO, "Obsolete directive: OPTION replaced by ARG_* at version 1.5\n"); 
  850.       scan_test(NULL, RDP_T_19 /* ( */, &dir_stop);
  851.       scan_();
  852.       String();
  853.       if (scan_test(NULL, RDP_T_74 /* [* */, NULL))
  854.       { /* Start of rdp_dir_37 */
  855.         while (1)
  856.         {
  857.           {
  858.             code();
  859.             }
  860.           break;   /* hi limit is 1! */
  861.         }
  862.       } /* end of rdp_dir_37 */
  863.       scan_test(NULL, RDP_T_21 /* ) */, &dir_stop);
  864.       scan_();
  865.     }
  866.     else
  867.     if (scan_test(NULL, RDP_T_PRE_PROCESS, NULL))
  868.     {
  869.       scan_test(NULL, RDP_T_PRE_PROCESS, &dir_stop);
  870.       scan_();
  871.        text_message(TEXT_ERROR_ECHO, "Obsolete directive: PRE_PROCESS renamed PRE_PARSE at version 1.3\n"); 
  872.       scan_test(NULL, RDP_T_19 /* ( */, &dir_stop);
  873.       scan_();
  874.       code();
  875.       scan_test(NULL, RDP_T_21 /* ) */, &dir_stop);
  876.       scan_();
  877.     }
  878.     else
  879.     if (scan_test(NULL, RDP_T_POST_PROCESS, NULL))
  880.     {
  881.       scan_test(NULL, RDP_T_POST_PROCESS, &dir_stop);
  882.       scan_();
  883.        text_message(TEXT_ERROR_ECHO, "Obsolete directive: POST_PROCESS renamed POST_PARSE at version 1.3\n"); 
  884.       scan_test(NULL, RDP_T_19 /* ( */, &dir_stop);
  885.       scan_();
  886.       code();
  887.       scan_test(NULL, RDP_T_21 /* ) */, &dir_stop);
  888.       scan_();
  889.     }
  890.     else
  891.     if (scan_test(NULL, RDP_T_SET_SIZE, NULL))
  892.     {
  893.       scan_test(NULL, RDP_T_SET_SIZE, &dir_stop);
  894.       scan_();
  895.        text_message(TEXT_ERROR_ECHO, "Obsolete directive: SET_SIZE deleted at version 1.4\n"); 
  896.       scan_test(NULL, RDP_T_19 /* ( */, &dir_stop);
  897.       scan_();
  898.       scan_test(NULL, SCAN_P_INTEGER, &dir_stop);
  899.       scan_();
  900.       scan_test(NULL, RDP_T_21 /* ) */, &dir_stop);
  901.       scan_();
  902.     }
  903.     else
  904.     if (scan_test(NULL, RDP_T_HASH_SIZE, NULL))
  905.     {
  906.       scan_test(NULL, RDP_T_HASH_SIZE, &dir_stop);
  907.       scan_();
  908.        text_message(TEXT_ERROR_ECHO, "Obsolete directive: HASH_SIZE replaced by SYMBOL_TABLE at version 1.4\n"); 
  909.       scan_test(NULL, RDP_T_19 /* ( */, &dir_stop);
  910.       scan_();
  911.       scan_test(NULL, SCAN_P_INTEGER, &dir_stop);
  912.       scan_();
  913.       scan_test(NULL, RDP_T_21 /* ) */, &dir_stop);
  914.       scan_();
  915.     }
  916.     else
  917.     if (scan_test(NULL, RDP_T_HASH_PRIME, NULL))
  918.     {
  919.       scan_test(NULL, RDP_T_HASH_PRIME, &dir_stop);
  920.       scan_();
  921.        text_message(TEXT_ERROR_ECHO, "Obsolete directive: HASH_PRIME replaced by SYMBOL_TABLE at version 1.4\n"); 
  922.       scan_test(NULL, RDP_T_19 /* ( */, &dir_stop);
  923.       scan_();
  924.       scan_test(NULL, SCAN_P_INTEGER, &dir_stop);
  925.       scan_();
  926.       scan_test(NULL, RDP_T_21 /* ) */, &dir_stop);
  927.       scan_();
  928.     }
  929.     else
  930.     if (scan_test(NULL, RDP_T_INTERPRETER, NULL))
  931.     {
  932.       scan_test(NULL, RDP_T_INTERPRETER, &dir_stop);
  933.       scan_();
  934.        text_message(TEXT_ERROR_ECHO, "Obsolete directive: INTERPRETER mode deleted at version 1.4\n"); 
  935.       scan_test(NULL, RDP_T_19 /* ( */, &dir_stop);
  936.       scan_();
  937.       scan_test(NULL, SCAN_P_INTEGER, &dir_stop);
  938.       scan_();
  939.       scan_test(NULL, RDP_T_21 /* ) */, &dir_stop);
  940.       scan_();
  941.     }
  942.     else
  943.       scan_test_set(NULL, &dir_first, &dir_stop)    ;
  944.     scan_test_set(NULL, &dir_stop, &dir_stop);
  945.    }
  946. }
  947.  
  948. static rdp_data* item_com(void)
  949. {
  950.   rdp_data* result;
  951.   char* name;
  952.   char* close;
  953.   {
  954.     if (scan_test(NULL, RDP_T_COMMENT, NULL))
  955.     {
  956.       scan_test(NULL, RDP_T_COMMENT, &item_com_stop);
  957.       scan_();
  958.       scan_test(NULL, RDP_T_19 /* ( */, &item_com_stop);
  959.       scan_();
  960.       name = token();
  961.       close = token();
  962.       scan_test(NULL, RDP_T_21 /* ) */, &item_com_stop);
  963.       scan_();
  964.       if (rdp_pass == 2) { \
  965.  result = rdp_find_extended(name, close, SCAN_P_COMMENT);  \
  966. }
  967.     }
  968.     else
  969.     if (scan_test(NULL, RDP_T_COMMENT_LINE, NULL))
  970.     {
  971.       scan_test(NULL, RDP_T_COMMENT_LINE, &item_com_stop);
  972.       scan_();
  973.       scan_test(NULL, RDP_T_19 /* ( */, &item_com_stop);
  974.       scan_();
  975.       name = token();
  976.       scan_test(NULL, RDP_T_21 /* ) */, &item_com_stop);
  977.       scan_();
  978.       if (rdp_pass == 2) { \
  979.  result = rdp_find_extended(name, NULL, SCAN_P_COMMENT_LINE);  \
  980. }
  981.     }
  982.     else
  983.     if (scan_test(NULL, RDP_T_COMMENT_NEST, NULL))
  984.     {
  985.       scan_test(NULL, RDP_T_COMMENT_NEST, &item_com_stop);
  986.       scan_();
  987.       scan_test(NULL, RDP_T_19 /* ( */, &item_com_stop);
  988.       scan_();
  989.       name = token();
  990.       close = token();
  991.       scan_test(NULL, RDP_T_21 /* ) */, &item_com_stop);
  992.       scan_();
  993.       if (rdp_pass == 2) { \
  994.  result = rdp_find_extended(name, close, SCAN_P_COMMENT_NEST);  \
  995. }
  996.     }
  997.     else
  998.       scan_test_set(NULL, &item_com_first, &item_com_stop)    ;
  999.     scan_test_set(NULL, &item_com_stop, &item_com_stop);
  1000.    }
  1001.   return result;
  1002. }
  1003.  
  1004. static rdp_data* item_inl(void)
  1005. {
  1006.   rdp_data* result;
  1007.   char* name;
  1008.   long int pass;
  1009.   rdp_list* body;
  1010.   long int val;
  1011.   char* delimiter;
  1012.   {
  1013.      int promote_op = PROMOTE_DEFAULT; 
  1014.     { /* Start of rdp_item_inl_21 */
  1015.       while (1)
  1016.       {
  1017.         scan_test_set(NULL, &rdp_item_inl_21_first, &item_inl_stop);
  1018.         {
  1019.           if (scan_test(NULL, RDP_T_74 /* [* */, NULL))
  1020.           {
  1021.             name = code();
  1022.             if (rdp_pass == 2) { \
  1023.  result = rdp_find(name, K_CODE, RDP_ANY); \
  1024.                         result->contains_null = 1; \
  1025.                         result->call_count++; /* increment call count */ \
  1026.                       \
  1027. }
  1028.             if (scan_test(NULL, RDP_T_29 /* @ */, NULL))
  1029.             { /* Start of rdp_item_inl_1 */
  1030.               while (1)
  1031.               {
  1032.                 {
  1033.                   scan_test(NULL, RDP_T_29 /* @ */, &item_inl_stop);
  1034.                   scan_();
  1035.                   scan_test(NULL, SCAN_P_INTEGER, &item_inl_stop);
  1036.                   pass = SCAN_CAST->data.i;
  1037.                   scan_();
  1038.                   if (rdp_pass == 2) { \
  1039.  result->code_pass = (unsigned) pass;  \
  1040. }
  1041.                   }
  1042.                 break;   /* hi limit is 1! */
  1043.               }
  1044.             } /* end of rdp_item_inl_1 */
  1045.           }
  1046.           else
  1047.           if (scan_test(NULL, RDP_T_19 /* ( */, NULL))
  1048.           {
  1049.             scan_test(NULL, RDP_T_19 /* ( */, &item_inl_stop);
  1050.             scan_();
  1051.             body = prod();
  1052.             scan_test(NULL, RDP_T_21 /* ) */, &item_inl_stop);
  1053.             scan_();
  1054.             if (rdp_pass == 2) { \
  1055.  result = rdp_find(text_insert_substring("rdp", rdp_primary_id, rdp_component++), K_LIST, RDP_ANY); \
  1056.                         result->promote = promote_op; \
  1057.                         result->list = body; \
  1058.                         result->call_count++; \
  1059.                         result->lo = 1; \
  1060.                         result->hi = 1; \
  1061.                       \
  1062. }
  1063.             if (scan_test_set(NULL, &rdp_item_inl_16_first, NULL))
  1064.             { /* Start of rdp_item_inl_16 */
  1065.               while (1)
  1066.               {
  1067.                 {
  1068.                   if (scan_test(NULL, SCAN_P_INTEGER, NULL))
  1069.                   { /* Start of rdp_item_inl_4 */
  1070.                     while (1)
  1071.                     {
  1072.                       {
  1073.                         scan_test(NULL, SCAN_P_INTEGER, &item_inl_stop);
  1074.                         val = SCAN_CAST->data.i;
  1075.                         scan_();
  1076.                         if (rdp_pass == 2) { \
  1077.  result->lo = val;  \
  1078. }
  1079.                         }
  1080.                       break;   /* hi limit is 1! */
  1081.                     }
  1082.                   } /* end of rdp_item_inl_4 */
  1083.                   scan_test(NULL, RDP_T_29 /* @ */, &item_inl_stop);
  1084.                   scan_();
  1085.                   if (rdp_pass == 2) { \
  1086.  result->hi = 0; /* iterate for ever by default */  \
  1087. }
  1088.                   if (scan_test(NULL, SCAN_P_INTEGER, NULL))
  1089.                   { /* Start of rdp_item_inl_6 */
  1090.                     while (1)
  1091.                     {
  1092.                       {
  1093.                         scan_test(NULL, SCAN_P_INTEGER, &item_inl_stop);
  1094.                         val = SCAN_CAST->data.i;
  1095.                         scan_();
  1096.                         if (rdp_pass == 2) { \
  1097.  result->hi = val;  \
  1098. }
  1099.                         }
  1100.                       break;   /* hi limit is 1! */
  1101.                     }
  1102.                   } /* end of rdp_item_inl_6 */
  1103.                   if (rdp_pass == 2) { \
  1104.  if (result->lo == 0) result->contains_null = 1; \
  1105.                           if (result->hi != 0 && (result->hi < result->lo)) \
  1106.                             text_message(TEXT_ERROR_ECHO,"Iterator high count must be greater than low count"); \
  1107.                         \
  1108. }if (rdp_pass == 2) { \
  1109.  result->delimiter_promote = PROMOTE_DONT;  \
  1110. }
  1111.                   { /* Start of rdp_item_inl_9 */
  1112.                     while (1)
  1113.                     {
  1114.                       scan_test_set(NULL, &rdp_item_inl_9_first, &item_inl_stop);
  1115.                       {
  1116.                         if (scan_test(NULL, RDP_T_18 /* ' */, NULL))
  1117.                         {
  1118.                           delimiter = token();
  1119.                           if (rdp_pass == 2) { \
  1120.  result->supplementary_token = rdp_find(delimiter, K_TOKEN, RDP_ANY);  \
  1121. }
  1122.                         }
  1123.                         else
  1124.                         if (scan_test(NULL, RDP_T_17 /* # */, NULL))
  1125.                         {
  1126.                           scan_test(NULL, RDP_T_17 /* # */, &item_inl_stop);
  1127.                           scan_();
  1128.                         }
  1129.                         else
  1130.                           scan_test_set(NULL, &rdp_item_inl_9_first, &item_inl_stop)                        ;
  1131.                         }
  1132.                       break;   /* hi limit is 1! */
  1133.                     }
  1134.                   } /* end of rdp_item_inl_9 */
  1135.                   if (scan_test_set(NULL, &rdp_item_inl_14_first, NULL))
  1136.                   { /* Start of rdp_item_inl_14 */
  1137.                     while (1)
  1138.                     {
  1139.                       {
  1140.                         if (scan_test(NULL, RDP_T_79 /* ^_ */, NULL))
  1141.                         {
  1142.                           scan_test(NULL, RDP_T_79 /* ^_ */, &item_inl_stop);
  1143.                           scan_();
  1144. if (rdp_pass == 2) { \
  1145.  result->delimiter_promote = PROMOTE_DONT;  \
  1146. }
  1147.                         }
  1148.                         else
  1149.                         if (scan_test(NULL, RDP_T_76 /* ^ */, NULL))
  1150.                         {
  1151.                           scan_test(NULL, RDP_T_76 /* ^ */, &item_inl_stop);
  1152.                           scan_();
  1153.                           if (rdp_pass == 2) { \
  1154.  result->delimiter_promote = PROMOTE;  \
  1155. }
  1156.                         }
  1157.                         else
  1158.                         if (scan_test(NULL, RDP_T_77 /* ^^ */, NULL))
  1159.                         {
  1160.                           scan_test(NULL, RDP_T_77 /* ^^ */, &item_inl_stop);
  1161.                           scan_();
  1162.                           if (rdp_pass == 2) { \
  1163.  result->delimiter_promote = PROMOTE_AND_COPY;  \
  1164. }
  1165.                         }
  1166.                         else
  1167.                         if (scan_test(NULL, RDP_T_78 /* ^^^ */, NULL))
  1168.                         {
  1169.                           scan_test(NULL, RDP_T_78 /* ^^^ */, &item_inl_stop);
  1170.                           scan_();
  1171.                           if (rdp_pass == 2) { \
  1172.  result->delimiter_promote = PROMOTE_ABOVE;  \
  1173. }
  1174.                         }
  1175.                         else
  1176.                           scan_test_set(NULL, &rdp_item_inl_14_first, &item_inl_stop)                        ;
  1177.                         }
  1178.                       break;   /* hi limit is 1! */
  1179.                     }
  1180.                   } /* end of rdp_item_inl_14 */
  1181.                   }
  1182.                 break;   /* hi limit is 1! */
  1183.               }
  1184.             } /* end of rdp_item_inl_16 */
  1185.           }
  1186.           else
  1187.           if (scan_test(NULL, RDP_T_80 /* { */, NULL))
  1188.           {
  1189.             scan_test(NULL, RDP_T_80 /* { */, &item_inl_stop);
  1190.             scan_();
  1191.             body = prod();
  1192.             scan_test(NULL, RDP_T_82 /* } */, &item_inl_stop);
  1193.             scan_();
  1194.             if (rdp_pass == 2) { \
  1195.  result = rdp_find(text_insert_substring("rdp", rdp_primary_id, rdp_component++), K_LIST, RDP_ANY); \
  1196.                         result->promote = promote_op; \
  1197.                         result->list = body; result->contains_null = 1; \
  1198.                         result->call_count++; \
  1199.                         result->lo = 0; \
  1200.                         result->hi = 0; \
  1201.                       \
  1202. }
  1203.           }
  1204.           else
  1205.           if (scan_test(NULL, RDP_T_73 /* [ */, NULL))
  1206.           {
  1207.             scan_test(NULL, RDP_T_73 /* [ */, &item_inl_stop);
  1208.             scan_();
  1209.             body = prod();
  1210.             scan_test(NULL, RDP_T_75 /* ] */, &item_inl_stop);
  1211.             scan_();
  1212.             if (rdp_pass == 2) { \
  1213.  result = rdp_find(text_insert_substring("rdp", rdp_primary_id, rdp_component++), K_LIST, RDP_ANY); \
  1214.                         result->promote = promote_op; \
  1215.                         result->list = body; result->contains_null = 1; \
  1216.                         result->call_count++; \
  1217.                         result->lo = 0; \
  1218.                         result->hi = 1; \
  1219.                       \
  1220. }
  1221.           }
  1222.           else
  1223.           if (scan_test(NULL, RDP_T_27 /* < */, NULL))
  1224.           {
  1225.             scan_test(NULL, RDP_T_27 /* < */, &item_inl_stop);
  1226.             scan_();
  1227.             body = prod();
  1228.             scan_test(NULL, RDP_T_28 /* > */, &item_inl_stop);
  1229.             scan_();
  1230.             if (rdp_pass == 2) { \
  1231.  result = rdp_find(text_insert_substring("rdp", rdp_primary_id, rdp_component++), K_LIST, RDP_ANY); \
  1232.                         result->promote = promote_op; \
  1233.                         result->list = body; \
  1234.                         result->call_count++; \
  1235.                         result->lo = 1; \
  1236.                         result->hi = 0; \
  1237.                       \
  1238. }
  1239.           }
  1240.           else
  1241.             scan_test_set(NULL, &rdp_item_inl_21_first, &item_inl_stop)          ;
  1242.           }
  1243.         break;   /* hi limit is 1! */
  1244.       }
  1245.     } /* end of rdp_item_inl_21 */
  1246.     scan_test_set(NULL, &item_inl_stop, &item_inl_stop);
  1247.    }
  1248.   return result;
  1249. }
  1250.  
  1251. static rdp_data* item_ret(void)
  1252. {
  1253.   rdp_data* result;
  1254.   char* name;
  1255.   long int n;
  1256.   double r;
  1257.   char* str;
  1258.   char* quote;
  1259.   char* close;
  1260.   {
  1261.     if (scan_test(NULL, SCAN_P_ID, NULL))
  1262.     {
  1263.       scan_test(NULL, SCAN_P_ID, &item_ret_stop);
  1264.       name = SCAN_CAST->id;
  1265.       scan_();
  1266.       if (rdp_pass == 2) { \
  1267.  result = rdp_find(name, K_PRIMARY, RDP_OLD); \
  1268.                                   rdp_check_eoln(name); \
  1269.                                   result->call_count++; /* increment call count */ \
  1270.                                   result->actuals = NULL; \
  1271.                                 \
  1272. } if (rdp_pass == 2 && result->parameterised ) { 
  1273.       scan_test(NULL, RDP_T_19 /* ( */, &item_ret_stop);
  1274.       scan_();
  1275.       if (scan_test_set(NULL, &rdp_item_ret_6_first, NULL))
  1276.       { /* Start of rdp_item_ret_6 */
  1277.         while (1)
  1278.         {
  1279.           {
  1280.              rdp_param_list *param; 
  1281.             { /* Start of rdp_item_ret_4 */
  1282.               while (1)
  1283.               {
  1284.                 scan_test_set(NULL, &rdp_item_ret_4_first, &item_ret_stop);
  1285.                 {
  1286.                   if (scan_test(NULL, SCAN_P_INTEGER, NULL))
  1287.                   {
  1288.                     scan_test(NULL, SCAN_P_INTEGER, &item_ret_stop);
  1289.                     n = SCAN_CAST->data.i;
  1290.                     scan_();
  1291.                     if (rdp_pass == 2) { \
  1292.  param = (rdp_param_list* ) mem_calloc(sizeof(rdp_param_list), 1); \
  1293.                                   param->n = n; \
  1294.                                   param->next = result->actuals; \
  1295.                                   result->actuals = param; \
  1296.                                   param->flavour = PARAM_INTEGER; \
  1297.                                 \
  1298. }
  1299.                   }
  1300.                   else
  1301.                   if (scan_test(NULL, SCAN_P_REAL, NULL))
  1302.                   {
  1303.                     scan_test(NULL, SCAN_P_REAL, &item_ret_stop);
  1304.                     r = SCAN_CAST->data.r;
  1305.                     scan_();
  1306.                     if (rdp_pass == 2) { \
  1307.  param = (rdp_param_list* ) mem_calloc(sizeof(rdp_param_list), 1); \
  1308.                                   param->r = r; \
  1309.                                   param->next = result->actuals; \
  1310.                                   result->actuals = param; \
  1311.                                   param->flavour = PARAM_REAL; \
  1312.                                 \
  1313. }
  1314.                   }
  1315.                   else
  1316.                   if (scan_test(NULL, RDP_T_16 /* " */, NULL))
  1317.                   {
  1318.                     str = String();
  1319.                     if (rdp_pass == 2) { \
  1320.  param = (rdp_param_list* ) mem_calloc(sizeof(rdp_param_list), 1); \
  1321.                                   param->id = str; \
  1322.                                   param->next = result->actuals; \
  1323.                                   result->actuals = param; \
  1324.                                   param->flavour = PARAM_STRING; \
  1325.                                 \
  1326. }
  1327.                   }
  1328.                   else
  1329.                   if (scan_test(NULL, SCAN_P_ID, NULL))
  1330.                   {
  1331.                     scan_test(NULL, SCAN_P_ID, &item_ret_stop);
  1332.                     name = SCAN_CAST->id;
  1333.                     scan_();
  1334.                     if (rdp_pass == 2) { \
  1335.  param = (rdp_param_list* ) mem_calloc(sizeof(rdp_param_list), 1); \
  1336.                                   param->id = name; \
  1337.                                   param->next = result->actuals; \
  1338.                                   result->actuals = param; \
  1339.                                   param->flavour = PARAM_ID; \
  1340.                                 \
  1341. }
  1342.                   }
  1343.                   else
  1344.                     scan_test_set(NULL, &rdp_item_ret_4_first, &item_ret_stop)                  ;
  1345.                   }
  1346.                 break;   /* hi limit is 1! */
  1347.               }
  1348.             } /* end of rdp_item_ret_4 */
  1349.             }
  1350.           if (!scan_test_set(NULL, &rdp_item_ret_6_first, NULL)) break;
  1351.         }
  1352.       } /* end of rdp_item_ret_6 */
  1353.       scan_test(NULL, RDP_T_21 /* ) */, &item_ret_stop);
  1354.       scan_();
  1355.        } 
  1356.     }
  1357.     else
  1358.     if (scan_test(NULL, RDP_T_18 /* ' */, NULL))
  1359.     {
  1360.       name = token();
  1361.       if (rdp_pass == 2) { \
  1362.  result = (rdp_data*) rdp_process_token(name);  \
  1363. }
  1364.     }
  1365.     else
  1366.     if (scan_test(NULL, RDP_T_CHAR, NULL))
  1367.     {
  1368.       scan_test(NULL, RDP_T_CHAR, &item_ret_stop);
  1369.       scan_();
  1370.       scan_test(NULL, RDP_T_19 /* ( */, &item_ret_stop);
  1371.       scan_();
  1372.       name = token();
  1373.       scan_test(NULL, RDP_T_21 /* ) */, &item_ret_stop);
  1374.       scan_();
  1375.       if (rdp_pass == 2) { \
  1376.  result = rdp_find_extended(name, NULL, SCAN_P_CHAR);  \
  1377. }
  1378.     }
  1379.     else
  1380.     if (scan_test(NULL, RDP_T_CHAR_ESC, NULL))
  1381.     {
  1382.       scan_test(NULL, RDP_T_CHAR_ESC, &item_ret_stop);
  1383.       scan_();
  1384.       scan_test(NULL, RDP_T_19 /* ( */, &item_ret_stop);
  1385.       scan_();
  1386.       name = token();
  1387.       quote = token();
  1388.       scan_test(NULL, RDP_T_21 /* ) */, &item_ret_stop);
  1389.       scan_();
  1390.       if (rdp_pass == 2) { \
  1391.  result = rdp_find_extended(name, quote, SCAN_P_CHAR_ESC);  \
  1392. }
  1393.     }
  1394.     else
  1395.     if (scan_test(NULL, RDP_T_STRING, NULL))
  1396.     {
  1397.       scan_test(NULL, RDP_T_STRING, &item_ret_stop);
  1398.       scan_();
  1399.       scan_test(NULL, RDP_T_19 /* ( */, &item_ret_stop);
  1400.       scan_();
  1401.       name = token();
  1402.       scan_test(NULL, RDP_T_21 /* ) */, &item_ret_stop);
  1403.       scan_();
  1404.       if (rdp_pass == 2) { \
  1405.  result = rdp_find_extended(name, NULL, SCAN_P_STRING);  \
  1406. }
  1407.     }
  1408.     else
  1409.     if (scan_test(NULL, RDP_T_STRING_ESC, NULL))
  1410.     {
  1411.       scan_test(NULL, RDP_T_STRING_ESC, &item_ret_stop);
  1412.       scan_();
  1413.       scan_test(NULL, RDP_T_19 /* ( */, &item_ret_stop);
  1414.       scan_();
  1415.       name = token();
  1416.       quote = token();
  1417.       scan_test(NULL, RDP_T_21 /* ) */, &item_ret_stop);
  1418.       scan_();
  1419.       if (rdp_pass == 2) { \
  1420.  result = rdp_find_extended(name, quote, SCAN_P_STRING_ESC);  \
  1421. }
  1422.     }
  1423.     else
  1424.     if (scan_test(NULL, RDP_T_COMMENT_VISIBLE, NULL))
  1425.     {
  1426.       scan_test(NULL, RDP_T_COMMENT_VISIBLE, &item_ret_stop);
  1427.       scan_();
  1428.       scan_test(NULL, RDP_T_19 /* ( */, &item_ret_stop);
  1429.       scan_();
  1430.       name = token();
  1431.       close = token();
  1432.       scan_test(NULL, RDP_T_21 /* ) */, &item_ret_stop);
  1433.       scan_();
  1434.       if (rdp_pass == 2) { \
  1435.  result = rdp_find_extended(name, close, SCAN_P_COMMENT_VISIBLE);  \
  1436. }
  1437.     }
  1438.     else
  1439.     if (scan_test(NULL, RDP_T_COMMENT_NEST_VISIBLE, NULL))
  1440.     {
  1441.       scan_test(NULL, RDP_T_COMMENT_NEST_VISIBLE, &item_ret_stop);
  1442.       scan_();
  1443.       scan_test(NULL, RDP_T_19 /* ( */, &item_ret_stop);
  1444.       scan_();
  1445.       name = token();
  1446.       close = token();
  1447.       scan_test(NULL, RDP_T_21 /* ) */, &item_ret_stop);
  1448.       scan_();
  1449.       if (rdp_pass == 2) { \
  1450.  result = rdp_find_extended(name, close, SCAN_P_COMMENT_NEST_VISIBLE);  \
  1451. }
  1452.     }
  1453.     else
  1454.     if (scan_test(NULL, RDP_T_COMMENT_LINE_VISIBLE, NULL))
  1455.     {
  1456.       scan_test(NULL, RDP_T_COMMENT_LINE_VISIBLE, &item_ret_stop);
  1457.       scan_();
  1458.       scan_test(NULL, RDP_T_19 /* ( */, &item_ret_stop);
  1459.       scan_();
  1460.       name = token();
  1461.       scan_test(NULL, RDP_T_21 /* ) */, &item_ret_stop);
  1462.       scan_();
  1463.       if (rdp_pass == 2) { \
  1464.  result = rdp_find_extended(name, NULL, SCAN_P_COMMENT_LINE_VISIBLE);  \
  1465. }
  1466.     }
  1467.     else
  1468.     if (scan_test(NULL, RDP_T_NUMBER, NULL))
  1469.     {
  1470.       scan_test(NULL, RDP_T_NUMBER, &item_ret_stop);
  1471.       scan_();
  1472.        text_message(TEXT_ERROR_ECHO, "Obsolete scanner primitive: NUMBER renamed INTEGER at version 1.3\n"); 
  1473.     }
  1474.     else
  1475.     if (scan_test(NULL, RDP_T_NEW_ID, NULL))
  1476.     {
  1477.       scan_test(NULL, RDP_T_NEW_ID, &item_ret_stop);
  1478.       scan_();
  1479.        text_message(TEXT_ERROR_ECHO, "Obsolete scanner primitive: NEW_ID deleted at version 1.4\n"); 
  1480.     }
  1481.     else
  1482.     if (scan_test(NULL, RDP_T_ALT_ID, NULL))
  1483.     {
  1484.       scan_test(NULL, RDP_T_ALT_ID, &item_ret_stop);
  1485.       scan_();
  1486.        text_message(TEXT_ERROR_ECHO, "Obsolete scanner primitive: ALT_ID deleted at version 1.4\n"); 
  1487.     }
  1488.     else
  1489.     if (scan_test(NULL, RDP_T_16 /* " */, NULL))
  1490.     {
  1491.       str = String();
  1492.       if (rdp_pass == 2) { \
  1493.  text_message(TEXT_ERROR_ECHO, "Illegal grammar element: perhaps you intended to write '%s'\n", str);  \
  1494. }
  1495.     }
  1496.     else
  1497.     if (scan_test(NULL, SCAN_P_INTEGER, NULL))
  1498.     {
  1499.       scan_test(NULL, SCAN_P_INTEGER, &item_ret_stop);
  1500.       scan_();
  1501.       if (rdp_pass == 2) { \
  1502.  text_message(TEXT_ERROR_ECHO, "Illegal grammar element: an integer may not appear here\n");  \
  1503. }
  1504.     }
  1505.     else
  1506.     if (scan_test(NULL, SCAN_P_REAL, NULL))
  1507.     {
  1508.       scan_test(NULL, SCAN_P_REAL, &item_ret_stop);
  1509.       scan_();
  1510.       if (rdp_pass == 2) { \
  1511.  text_message(TEXT_ERROR_ECHO, "Illegal grammar element: a real may not appear here\n");  \
  1512. }
  1513.     }
  1514.     else
  1515.       scan_test_set(NULL, &item_ret_first, &item_ret_stop)    ;
  1516.     scan_test_set(NULL, &item_ret_stop, &item_ret_stop);
  1517.    }
  1518.   return result;
  1519. }
  1520.  
  1521. static rdp_list* prod(void)
  1522. {
  1523.   rdp_list* result;
  1524.   rdp_list* body;
  1525.   {
  1526.      rdp_list* end; if (rdp_pass == 2) { \
  1527.  end = result = (rdp_list*) mem_calloc(sizeof(rdp_list), 1);  \
  1528. }
  1529.     { /* Start of rdp_prod_1 */
  1530.       while (1)
  1531.       {
  1532.         scan_test_set(NULL, &rdp_prod_1_first, &prod_stop);
  1533.         {
  1534.           body = seq();
  1535.           if (rdp_pass == 2) { \
  1536.  end->next = (rdp_list*) mem_calloc(sizeof(rdp_list), 1); \
  1537.                                   end = end->next; \
  1538.                                   end->production = rdp_find(text_insert_substring("rdp", rdp_primary_id, rdp_component++), K_SEQUENCE, RDP_NEW); \
  1539.                                   end->production->call_count++; \
  1540.                                   end->production->list = body; \
  1541.                                 \
  1542. }
  1543.           }
  1544.         if (SCAN_CAST->token != RDP_T_81 /* | */) break;
  1545.         scan_();
  1546.       }
  1547.     } /* end of rdp_prod_1 */
  1548.     if (rdp_pass == 2) { \
  1549.  result = result->next;  \
  1550. }
  1551.     scan_test_set(NULL, &prod_stop, &prod_stop);
  1552.    }
  1553.   return result;
  1554. }
  1555.  
  1556. static rdp_data* rule(void)
  1557. {
  1558.   rdp_data* result;
  1559.   char* name;
  1560.   char* type;
  1561.   rdp_list* body;
  1562.   {
  1563.      unsigned stars; 
  1564.     scan_test(NULL, SCAN_P_ID, &rule_stop);
  1565.     name = SCAN_CAST->id;
  1566.     scan_();
  1567.      rdp_primary_id = name; rdp_component = 0; \
  1568.                       rdp_rule_count++; \
  1569.                       result = rdp_find(rdp_primary_id, K_PRIMARY, rdp_pass == 1 ? RDP_NEW : RDP_OLD); \
  1570.                       if (rdp_start_prod == NULL) \
  1571.                       { \
  1572.                         rdp_start_prod = result; \
  1573.                         result->call_count++; \
  1574.                       } \
  1575.                    
  1576.     if (scan_test(NULL, RDP_T_19 /* ( */, NULL))
  1577.     { /* Start of rdp_rule_7 */
  1578.       while (1)
  1579.       {
  1580.         {
  1581.           scan_test(NULL, RDP_T_19 /* ( */, &rule_stop);
  1582.           scan_();
  1583.            result->parameterised = 1; 
  1584.           if (scan_test(NULL, SCAN_P_ID, NULL))
  1585.           { /* Start of rdp_rule_5 */
  1586.             while (1)
  1587.             {
  1588.               {
  1589.                  rdp_param_list *param; type = "void"; 
  1590.                 scan_test(NULL, SCAN_P_ID, &rule_stop);
  1591.                 name = SCAN_CAST->id;
  1592.                 scan_();
  1593.                 if (scan_test(NULL, RDP_T_24 /* : */, NULL))
  1594.                 { /* Start of rdp_rule_3 */
  1595.                   while (1)
  1596.                   {
  1597.                     {
  1598.                       scan_test(NULL, RDP_T_24 /* : */, &rule_stop);
  1599.                       scan_();
  1600.                       scan_test(NULL, SCAN_P_ID, &rule_stop);
  1601.                       type = SCAN_CAST->id;
  1602.                       scan_();
  1603.                        stars = 0; 
  1604.                       if (scan_test(NULL, RDP_T_22 /* * */, NULL))
  1605.                       { /* Start of rdp_rule_1 */
  1606.                         while (1)
  1607.                         {
  1608.                           {
  1609.                             scan_test(NULL, RDP_T_22 /* * */, &rule_stop);
  1610.                             scan_();
  1611.                              stars++; 
  1612.                             }
  1613.                           if (!scan_test(NULL, RDP_T_22 /* * */, NULL)) break;
  1614.                         }
  1615.                       } /* end of rdp_rule_1 */
  1616.                       }
  1617.                     break;   /* hi limit is 1! */
  1618.                   }
  1619.                 } /* end of rdp_rule_3 */
  1620.                 if (rdp_pass == 1) { \
  1621.  param = (rdp_param_list* ) mem_calloc(sizeof(rdp_param_list), 1); \
  1622.                              param->id = name; \
  1623.                              param->type = type; \
  1624.                              param->stars = stars; \
  1625.                              param->next = result->params; \
  1626.                              result->params = param; \
  1627.                            \
  1628. }
  1629.                 }
  1630.               if (!scan_test(NULL, SCAN_P_ID, NULL)) break;
  1631.             }
  1632.           } /* end of rdp_rule_5 */
  1633.           scan_test(NULL, RDP_T_21 /* ) */, &rule_stop);
  1634.           scan_();
  1635.           }
  1636.         break;   /* hi limit is 1! */
  1637.       }
  1638.     } /* end of rdp_rule_7 */
  1639.      type = "void"; stars = 0; 
  1640.     if (scan_test(NULL, RDP_T_24 /* : */, NULL))
  1641.     { /* Start of rdp_rule_11 */
  1642.       while (1)
  1643.       {
  1644.         {
  1645.           scan_test(NULL, RDP_T_24 /* : */, &rule_stop);
  1646.           scan_();
  1647.           scan_test(NULL, SCAN_P_ID, &rule_stop);
  1648.           type = SCAN_CAST->id;
  1649.           scan_();
  1650.           if (scan_test(NULL, RDP_T_22 /* * */, NULL))
  1651.           { /* Start of rdp_rule_9 */
  1652.             while (1)
  1653.             {
  1654.               {
  1655.                 scan_test(NULL, RDP_T_22 /* * */, &rule_stop);
  1656.                 scan_();
  1657.                  stars++; 
  1658.                 }
  1659.               if (!scan_test(NULL, RDP_T_22 /* * */, NULL)) break;
  1660.             }
  1661.           } /* end of rdp_rule_9 */
  1662.           }
  1663.         break;   /* hi limit is 1! */
  1664.       }
  1665.     } /* end of rdp_rule_11 */
  1666.     if (rdp_pass == 2) { \
  1667.  result->promote_default = PROMOTE_DONT;  \
  1668. }
  1669.     if (scan_test_set(NULL, &rdp_rule_16_first, NULL))
  1670.     { /* Start of rdp_rule_16 */
  1671.       while (1)
  1672.       {
  1673.         {
  1674.           if (scan_test(NULL, RDP_T_79 /* ^_ */, NULL))
  1675.           {
  1676.             scan_test(NULL, RDP_T_79 /* ^_ */, &rule_stop);
  1677.             scan_();
  1678.             if (rdp_pass == 2) { \
  1679.  result->promote_default = PROMOTE_DONT;  \
  1680. }
  1681.           }
  1682.           else
  1683.           if (scan_test(NULL, RDP_T_76 /* ^ */, NULL))
  1684.           {
  1685.             scan_test(NULL, RDP_T_76 /* ^ */, &rule_stop);
  1686.             scan_();
  1687.             if (rdp_pass == 2) { \
  1688.  result->promote_default = PROMOTE;  \
  1689. }
  1690.           }
  1691.           else
  1692.           if (scan_test(NULL, RDP_T_77 /* ^^ */, NULL))
  1693.           {
  1694.             scan_test(NULL, RDP_T_77 /* ^^ */, &rule_stop);
  1695.             scan_();
  1696.             if (rdp_pass == 2) { \
  1697.  result->promote_default = PROMOTE_AND_COPY;  \
  1698. }
  1699.           }
  1700.           else
  1701.           if (scan_test(NULL, RDP_T_78 /* ^^^ */, NULL))
  1702.           {
  1703.             scan_test(NULL, RDP_T_78 /* ^^^ */, &rule_stop);
  1704.             scan_();
  1705.             if (rdp_pass == 2) { \
  1706.  result->promote_default = PROMOTE_ABOVE;  \
  1707. }
  1708.           }
  1709.           else
  1710.             scan_test_set(NULL, &rdp_rule_16_first, &rule_stop)          ;
  1711.           }
  1712.         break;   /* hi limit is 1! */
  1713.       }
  1714.     } /* end of rdp_rule_16 */
  1715.      rdp_comment_only = 1; /* set comments only flag */ 
  1716.     scan_test(NULL, RDP_T_26 /* ::= */, &rule_stop);
  1717.     scan_();
  1718.     body = prod();
  1719.     if (rdp_pass == 2) { \
  1720.  rdp_rule_count++; \
  1721.                                      result->list = body; \
  1722.                                      result->been_defined = 1; \
  1723.                                      result->return_type = type; \
  1724.                                      result->return_type_stars = stars; \
  1725.                                      result->comment_only = rdp_comment_only; \
  1726.                                    \
  1727. }
  1728.     scan_test(NULL, RDP_T_23 /* . */, &rule_stop);
  1729.     scan_();
  1730.     scan_test_set(NULL, &rule_stop, &rule_stop);
  1731.    }
  1732.   return result;
  1733. }
  1734.  
  1735. static rdp_list* seq(void)
  1736. {
  1737.   rdp_list* result;
  1738.   rdp_data* body;
  1739.   char* ret_name;
  1740.   char* default_action;
  1741.   {
  1742.      rdp_list* end; int promote_op; int promote_epsilon; if (rdp_pass == 2) { \
  1743.  end = result = (rdp_list*) mem_calloc(sizeof(rdp_list), 1);  \
  1744. }
  1745.     { /* Start of rdp_seq_31 */
  1746.       while (1)
  1747.       {
  1748.         scan_test_set(NULL, &rdp_seq_31_first, &seq_stop);
  1749.         {
  1750.           if (rdp_pass == 2) { \
  1751.  ret_name = NULL; promote_epsilon = PROMOTE_DONT; promote_op = PROMOTE_DEFAULT;  \
  1752. }
  1753.           { /* Start of rdp_seq_29 */
  1754.             while (1)
  1755.             {
  1756.               scan_test_set(NULL, &rdp_seq_29_first, &seq_stop);
  1757.               {
  1758.                 if (scan_test_set(NULL, &rdp_seq_10_first, NULL))
  1759.                 {
  1760.                   { /* Start of rdp_seq_2 */
  1761.                     while (1)
  1762.                     {
  1763.                       scan_test_set(NULL, &rdp_seq_2_first, &seq_stop);
  1764.                       {
  1765.                         if (scan_test_set(NULL, &rdp_seq_0_first, NULL))
  1766.                         {
  1767.                           body = item_ret();
  1768.                            rdp_comment_only = 0; 
  1769.                         }
  1770.                         else
  1771.                         if (scan_test_set(NULL, &rdp_seq_1_first, NULL))
  1772.                         {
  1773.                           body = item_com();
  1774.                         }
  1775.                         else
  1776.                           scan_test_set(NULL, &rdp_seq_2_first, &seq_stop)                        ;
  1777.                         }
  1778.                       break;   /* hi limit is 1! */
  1779.                     }
  1780.                   } /* end of rdp_seq_2 */
  1781.                   if (scan_test(NULL, RDP_T_24 /* : */, NULL))
  1782.                   { /* Start of rdp_seq_4 */
  1783.                     while (1)
  1784.                     {
  1785.                       {
  1786.                         scan_test(NULL, RDP_T_24 /* : */, &seq_stop);
  1787.                         scan_();
  1788.                         scan_test(NULL, SCAN_P_ID, &seq_stop);
  1789.                         ret_name = SCAN_CAST->id;
  1790.                         scan_();
  1791.                         }
  1792.                       break;   /* hi limit is 1! */
  1793.                     }
  1794.                   } /* end of rdp_seq_4 */
  1795.                   if (scan_test_set(NULL, &rdp_seq_9_first, NULL))
  1796.                   { /* Start of rdp_seq_9 */
  1797.                     while (1)
  1798.                     {
  1799.                       {
  1800.                         if (scan_test(NULL, RDP_T_79 /* ^_ */, NULL))
  1801.                         {
  1802.                           scan_test(NULL, RDP_T_79 /* ^_ */, &seq_stop);
  1803.                           scan_();
  1804.                           if (rdp_pass == 2) { \
  1805.  promote_op = PROMOTE_DONT;  \
  1806. }
  1807.                         }
  1808.                         else
  1809.                         if (scan_test(NULL, RDP_T_76 /* ^ */, NULL))
  1810.                         {
  1811.                           scan_test(NULL, RDP_T_76 /* ^ */, &seq_stop);
  1812.                           scan_();
  1813.                           if (rdp_pass == 2) { \
  1814.  promote_op = PROMOTE;  \
  1815. }
  1816.                         }
  1817.                         else
  1818.                         if (scan_test(NULL, RDP_T_77 /* ^^ */, NULL))
  1819.                         {
  1820.                           scan_test(NULL, RDP_T_77 /* ^^ */, &seq_stop);
  1821.                           scan_();
  1822.                           if (rdp_pass == 2) { \
  1823.  promote_op = PROMOTE_AND_COPY;  \
  1824. }
  1825.                         }
  1826.                         else
  1827.                         if (scan_test(NULL, RDP_T_78 /* ^^^ */, NULL))
  1828.                         {
  1829.                           scan_test(NULL, RDP_T_78 /* ^^^ */, &seq_stop);
  1830.                           scan_();
  1831.                           if (rdp_pass == 2) { \
  1832.  promote_op = PROMOTE_ABOVE;  \
  1833. }
  1834.                         }
  1835.                         else
  1836.                           scan_test_set(NULL, &rdp_seq_9_first, &seq_stop)                        ;
  1837.                         }
  1838.                       break;   /* hi limit is 1! */
  1839.                     }
  1840.                   } /* end of rdp_seq_9 */
  1841.                 }
  1842.                 else
  1843.                 if (scan_test_set(NULL, &rdp_seq_28_first, NULL))
  1844.                 {
  1845.                   body = item_inl();
  1846.                    rdp_comment_only = 0; 
  1847. if (rdp_pass == 2) { \
  1848.  promote_op=body->promote; default_action = NULL;  \
  1849. }
  1850.                   if (scan_test(NULL, RDP_T_24 /* : */, NULL))
  1851.                   { /* Start of rdp_seq_27 */
  1852.                     while (1)
  1853.                     {
  1854.                       {
  1855.                         scan_test(NULL, RDP_T_24 /* : */, &seq_stop);
  1856.                         scan_();
  1857.                         if (scan_test(NULL, SCAN_P_ID, NULL))
  1858.                         { /* Start of rdp_seq_12 */
  1859.                           while (1)
  1860.                           {
  1861.                             {
  1862.                               scan_test(NULL, SCAN_P_ID, &seq_stop);
  1863.                               scan_();
  1864.                               if (rdp_pass == 2) { \
  1865.  text_message(TEXT_ERROR_ECHO,"Illegal grammar element: expressions may not retun a value");  \
  1866. }
  1867.                               }
  1868.                             break;   /* hi limit is 1! */
  1869.                           }
  1870.                         } /* end of rdp_seq_12 */
  1871.                         if (scan_test_set(NULL, &rdp_seq_25_first, NULL))
  1872.                         { /* Start of rdp_seq_25 */
  1873.                           while (1)
  1874.                           {
  1875.                             {
  1876.                               if (scan_test(NULL, RDP_T_74 /* [* */, NULL))
  1877.                               {
  1878.                                 default_action = code();
  1879.                                 if (scan_test_set(NULL, &rdp_seq_17_first, NULL))
  1880.                                 { /* Start of rdp_seq_17 */
  1881.                                   while (1)
  1882.                                   {
  1883.                                     {
  1884.                                       if (scan_test(NULL, RDP_T_79 /* ^_ */, NULL))
  1885.                                       {
  1886.                                         scan_test(NULL, RDP_T_79 /* ^_ */, &seq_stop);
  1887.                                         scan_();
  1888.                                         if (rdp_pass == 2) { \
  1889.  promote_epsilon = PROMOTE_DONT;  \
  1890. }
  1891.                                       }
  1892.                                       else
  1893.                                       if (scan_test(NULL, RDP_T_76 /* ^ */, NULL))
  1894.                                       {
  1895.                                         scan_test(NULL, RDP_T_76 /* ^ */, &seq_stop);
  1896.                                         scan_();
  1897.                                         if (rdp_pass == 2) { \
  1898.  promote_epsilon = PROMOTE;  \
  1899. }
  1900.                                       }
  1901.                                       else
  1902.                                       if (scan_test(NULL, RDP_T_77 /* ^^ */, NULL))
  1903.                                       {
  1904.                                         scan_test(NULL, RDP_T_77 /* ^^ */, &seq_stop);
  1905.                                         scan_();
  1906.                                         if (rdp_pass == 2) { \
  1907.  promote_epsilon = PROMOTE_AND_COPY;  \
  1908. }
  1909.                                       }
  1910.                                       else
  1911.                                       if (scan_test(NULL, RDP_T_78 /* ^^^ */, NULL))
  1912.                                       {
  1913.                                         scan_test(NULL, RDP_T_78 /* ^^^ */, &seq_stop);
  1914.                                         scan_();
  1915.                                         if (rdp_pass == 2) { \
  1916.  promote_epsilon = PROMOTE_ABOVE;  \
  1917. }
  1918.                                       }
  1919.                                       else
  1920.                                         scan_test_set(NULL, &rdp_seq_17_first, &seq_stop)                                      ;
  1921.                                       }
  1922.                                     break;   /* hi limit is 1! */
  1923.                                   }
  1924.                                 } /* end of rdp_seq_17 */
  1925.                               }
  1926.                               else
  1927.                               if (scan_test_set(NULL, &rdp_seq_24_first, NULL))
  1928.                               {
  1929.                                 { /* Start of rdp_seq_23 */
  1930.                                   while (1)
  1931.                                   {
  1932.                                     scan_test_set(NULL, &rdp_seq_23_first, &seq_stop);
  1933.                                     {
  1934.                                       if (scan_test(NULL, RDP_T_79 /* ^_ */, NULL))
  1935.                                       {
  1936.                                         scan_test(NULL, RDP_T_79 /* ^_ */, &seq_stop);
  1937.                                         scan_();
  1938.                                         if (rdp_pass == 2) { \
  1939.  promote_epsilon = PROMOTE_DONT;  \
  1940. }
  1941.                                       }
  1942.                                       else
  1943.                                       if (scan_test(NULL, RDP_T_76 /* ^ */, NULL))
  1944.                                       {
  1945.                                         scan_test(NULL, RDP_T_76 /* ^ */, &seq_stop);
  1946.                                         scan_();
  1947.                                         if (rdp_pass == 2) { \
  1948.  promote_epsilon = PROMOTE;  \
  1949. }
  1950.                                       }
  1951.                                       else
  1952.                                       if (scan_test(NULL, RDP_T_77 /* ^^ */, NULL))
  1953.                                       {
  1954.                                         scan_test(NULL, RDP_T_77 /* ^^ */, &seq_stop);
  1955.                                         scan_();
  1956.                                         if (rdp_pass == 2) { \
  1957.  promote_epsilon = PROMOTE_AND_COPY;  \
  1958. }
  1959.                                       }
  1960.                                       else
  1961.                                       if (scan_test(NULL, RDP_T_78 /* ^^^ */, NULL))
  1962.                                       {
  1963.                                         scan_test(NULL, RDP_T_78 /* ^^^ */, &seq_stop);
  1964.                                         scan_();
  1965.                                         if (rdp_pass == 2) { \
  1966.  promote_epsilon = PROMOTE_ABOVE;  \
  1967. }
  1968.                                       }
  1969.                                       else
  1970.                                         scan_test_set(NULL, &rdp_seq_23_first, &seq_stop)                                      ;
  1971.                                       }
  1972.                                     break;   /* hi limit is 1! */
  1973.                                   }
  1974.                                 } /* end of rdp_seq_23 */
  1975.                               }
  1976.                               else
  1977.                                 scan_test_set(NULL, &rdp_seq_25_first, &seq_stop)                              ;
  1978.                               }
  1979.                             break;   /* hi limit is 1! */
  1980.                           }
  1981.                         } /* end of rdp_seq_25 */
  1982.                         }
  1983.                       break;   /* hi limit is 1! */
  1984.                     }
  1985.                   } /* end of rdp_seq_27 */
  1986.                 }
  1987.                 else
  1988.                   scan_test_set(NULL, &rdp_seq_29_first, &seq_stop)                ;
  1989.                 }
  1990.               break;   /* hi limit is 1! */
  1991.             }
  1992.           } /* end of rdp_seq_29 */
  1993.           if (rdp_pass == 2) { \
  1994.  end->next = (rdp_list*) mem_calloc(sizeof(rdp_list), 1); \
  1995.                         end = end->next; \
  1996.                         end->production = body; \
  1997.                         end->actuals = body->actuals; \
  1998.                         end->return_name = ret_name; \
  1999.                         end->promote = promote_op; \
  2000.                         end->promote_epsilon = promote_epsilon; \
  2001.                         end->default_action = default_action; \
  2002.                       \
  2003. }
  2004.           }
  2005.         if (!scan_test_set(NULL, &rdp_seq_31_first, NULL)) break;
  2006.       }
  2007.     } /* end of rdp_seq_31 */
  2008.     if (rdp_pass == 2) { \
  2009.  result = result->next;  \
  2010. }
  2011.     scan_test_set(NULL, &seq_stop, &seq_stop);
  2012.    }
  2013.   return result;
  2014. }
  2015.  
  2016. static char* token(void)
  2017. {
  2018.   char* result;
  2019.   {
  2020.     scan_test(NULL, RDP_T_18 /* ' */, &token_stop);
  2021.     result = SCAN_CAST->id;
  2022.     scan_();
  2023.     scan_test_set(NULL, &token_stop, &token_stop);
  2024.    }
  2025.   return result;
  2026. }
  2027.  
  2028. void unit(void)
  2029. {
  2030.   {
  2031.     if (scan_test_set(NULL, &rdp_unit_2_first, NULL))
  2032.     { /* Start of rdp_unit_2 */
  2033.       while (1)
  2034.       {
  2035.         {
  2036.           if (scan_test(NULL, SCAN_P_ID, NULL))
  2037.           {
  2038.             rule();
  2039.           }
  2040.           else
  2041.           if (scan_test_set(NULL, &rdp_unit_1_first, NULL))
  2042.           {
  2043.             dir();
  2044.           }
  2045.           else
  2046.             scan_test_set(NULL, &rdp_unit_2_first, &unit_stop)          ;
  2047.           }
  2048.         if (!scan_test_set(NULL, &rdp_unit_2_first, NULL)) break;
  2049.       }
  2050.     } /* end of rdp_unit_2 */
  2051.      if (rdp_rule_count == 0) text_message(TEXT_FATAL,"no rule definitions found\n"); 
  2052.     scan_test_set(NULL, &unit_stop, &unit_stop);
  2053.    }
  2054. }
  2055.  
  2056. int main(int argc, char *argv[])
  2057. {
  2058.   clock_t rdp_finish_time, rdp_start_time = clock();
  2059.   int
  2060.     rdp_symbol_statistics = 0,    /* show symbol_ table statistics flag */
  2061.     rdp_line_echo_all = 0,        /* make a listing on all passes flag */
  2062.     rdp_filter = 0,               /* filter flag */
  2063.     rdp_line_echo = 0;            /* make listing flag */
  2064.  
  2065.   unsigned long rdp_textsize = 34000l;   /* size of scanner text array */
  2066.  
  2067.   unsigned long rdp_tabwidth = 8l;   /* tab expansion width */
  2068.  
  2069.   char* rdp_vcg_filename = NULL;      /* filename for -V option */
  2070.  
  2071.   arg_message("Recursive descent parser generator V1.50 (c) Adrian Johnstone 1997\n" RDP_STAMP "\n\n""Usage: rdp [options] source[.bnf]");
  2072.  
  2073.   arg_message("");
  2074.   arg_boolean('f', "Filter mode (read from stdin and write to stdout)", &rdp_filter);
  2075.   arg_boolean('l', "Make a listing", &rdp_line_echo);
  2076.   arg_string ('o', "Write output to filename", &rdp_outputfilename);
  2077.   arg_boolean('s', "Echo each scanner symbol as it is read", &rdp_symbol_echo);
  2078.   arg_boolean('S', "Print summary symbol table statistics", &rdp_symbol_statistics);
  2079.   arg_numeric('t', "Tab expansion width (default 8)", &rdp_tabwidth);
  2080.   arg_numeric('T', "Text buffer size in bytes for scanner (default 20000)", &rdp_textsize);
  2081.   arg_boolean('v', "Set verbose mode", &rdp_verbose);
  2082.   arg_string ('V', "Write derivation tree to filename in VCG format", &rdp_vcg_filename);
  2083.   arg_message("");
  2084.   arg_boolean('e', "Write out expanded BNF along with first and follow sets", &rdp_expanded);
  2085.   arg_boolean('E', "Add rule name to error messages in generated parser", &rdp_error_production_name);
  2086.   arg_boolean('F', "Force creation of output files", &rdp_force);
  2087.   arg_boolean('p', "Make parser only (omit semantic actions from generated code)", &rdp_parser_only);
  2088.   arg_boolean('R', "Add rule entry and exit messages", &rdp_trace);
  2089.   arg_message("");
  2090.   arg_message("You can contact the author (Adrian Johnstone) at:");
  2091.   arg_message("");
  2092.   arg_message("Computer Science Department, Royal Holloway, University of London");
  2093.   arg_message("Egham, Surrey, TW20 0EX UK. Email: A.Johnstone@rhbnc.ac.uk");
  2094.  
  2095.   rdp_sourcefilename = *arg_process(argc, argv);
  2096.  
  2097.   if (rdp_filter)
  2098. {
  2099.     rdp_sourcefilename = "-";
  2100.     rdp_outputfilename = "-";
  2101.  
  2102. }
  2103.   if (rdp_sourcefilename == NULL)
  2104.      arg_help("No source file specified");
  2105.  
  2106.   rdp_sourcefilename = text_default_filetype(rdp_sourcefilename, "bnf");
  2107.   text_init(rdp_textsize, 50, 120, (int) rdp_tabwidth);
  2108.   scan_init(0, 0, 1, rdp_symbol_echo, rdp_tokens);
  2109.   locals = symbol_new_table("locals", 101, 31, symbol_compare_string, symbol_hash_string, symbol_print_string);
  2110.   codes = symbol_new_table("codes", 101, 31, symbol_compare_string, symbol_hash_string, symbol_print_string);
  2111.   tokens = symbol_new_table("tokens", 101, 31, symbol_compare_string, symbol_hash_string, symbol_print_string);
  2112.   rdp = symbol_new_table("rdp", 101, 31, symbol_compare_string, symbol_hash_string, symbol_print_string);
  2113.   rdp_set_initialise();
  2114.   rdp_load_keywords();
  2115.   if (rdp_verbose)
  2116.      text_printf("\nRecursive descent parser generator V1.50 (c) Adrian Johnstone 1997\n" RDP_STAMP "\n\n");
  2117.    rdp_pre_parse(); 
  2118.   for (rdp_pass = 1; rdp_pass <= RDP_PASSES; rdp_pass++)
  2119.   {
  2120.     text_echo(rdp_line_echo_all || (rdp_line_echo && rdp_pass == RDP_PASSES));
  2121.     if (text_open(rdp_sourcefilename) == NULL)
  2122.       arg_help("unable to open source file");
  2123.  
  2124.     text_get_char();
  2125.     scan_();
  2126.  
  2127.     unit();            /* call parser at top level */
  2128.     if (text_total_errors() != 0)
  2129.       text_message(TEXT_FATAL, "error%s detected in source file\n", text_total_errors() == 1 ? "" : "s");   /* crash quietly */ 
  2130.   }
  2131.   if (rdp_symbol_statistics)
  2132.     symbol_print_all_table_statistics(11);
  2133.  
  2134.    rdp_post_parse(rdp_outputfilename, rdp_force); 
  2135.   text_print_total_errors();
  2136.   if (rdp_verbose)
  2137.   {
  2138.     rdp_finish_time = clock();
  2139.     text_message(TEXT_INFO, "%.3f CPU seconds used\n", ((double) (rdp_finish_time-rdp_start_time)) / CLOCKS_PER_SEC);
  2140.   }
  2141.   return rdp_error_return;
  2142. }
  2143.  
  2144. /* End of rdp.c */
  2145.