home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume3 / trc / part7 < prev    next >
Encoding:
Text File  |  1986-11-30  |  51.1 KB  |  1,609 lines
  1. Newsgroups: mod.sources
  2. Subject: TRC - expert system building tool (part 7 of 8)
  3. Approved: jpn@panda.UUCP
  4.  
  5. Mod.sources:  Volume 3, Issue 115
  6. Submitted by: ihnp4!dicomed!ndsuvax!nckary (Daniel D. Kary)
  7.  
  8. This is NOT a shell archive.  Simply delete everything up to and including
  9. the cut mark and save the result as output.c.
  10.  
  11. Dan Kary
  12. ihnp4!dicomed!ndsuvax!nckary
  13.  
  14. -------------- cut here ---------------
  15. #include    <stdio.h>
  16. #include     "main.h"
  17.  
  18. char *type_names[4] = {
  19.             "int ",
  20.             "double ",
  21.             "char *",
  22.             "struct "
  23. };
  24.  
  25.  
  26. gen_test()
  27. /* generate the myalloc procedure for allocating data structures */
  28. /* generate procedures to test each data type and return a relop code */
  29. {
  30.     int i;
  31.     FILE *fp;
  32.  
  33.     fp = misc;
  34.     fprintf(fp,"\n\nchar* %smyalloc(n)\nint n;\n{\n", prefix);
  35.     fprintf(fp,"\tchar *r;\n\n\tr = (char *) malloc(n);\n");
  36.     fprintf(fp,"\tif(r == NULL){\n\t\tfprintf(stderr,\"OUT OF MEMORY\\n\");\n");
  37.     fprintf(fp,"\t\tfprintf(stderr,\"TRC IS EXITING\\n\");\n");
  38.     fprintf(fp,"\t\texit(0);\n\t}\n\treturn(r);\n}");
  39.     for(i = 0; i < 2; i++){
  40.         fprintf(fp,"\n\n%stest_%s(a,b)\n%s a, b;\n{\n", prefix,type_names[i], type_names[i]);
  41.         fprintf(fp,"\tif(a < b) return(4);\n");
  42.         fprintf(fp,"\tif(a == b) return(2);\n");
  43.         fprintf(fp,"\treturn(1);\n}\n");
  44.     }
  45.     fprintf(fp,"\n\n%stest_string(a,b)\nchar *a, *b;\n{\n",prefix);
  46.     fprintf(fp,"\tint i;\n\n\ti = strcmp(a, b);\n");
  47.     fprintf(fp,"\tif(i < 0) return(4);\n");
  48.     fprintf(fp,"\tif(i == 0) return(2);\n");
  49.     fprintf(fp,"\treturn(1);\n}\n");
  50. }
  51.  
  52.  
  53. gen_search()
  54. /* generate procedures to search each structure for a compound match */
  55. {
  56.     int    i;
  57.     struct def_list *temp;
  58.     struct data_type *temp2;
  59.     struct case_list *c_temp;
  60.     FILE *fp;
  61.  
  62.     temp = token_list;
  63.     while(temp){
  64.         if(temp->data_types){
  65.         fp = loop;
  66.         fprintf(fp,"\nextern struct %s%s_struct *search_%s%s_struct();\n", prefix, temp->name, prefix, temp->name);
  67.         fp = search;
  68.         fprintf(fp,"\n\nstruct %s%s_struct *search_%s%s_struct(index", prefix, temp->name, prefix, temp->name);
  69.         temp2 = temp->data_types;
  70.         while(temp2){
  71.             if(temp2->type <= 2){
  72.                 fprintf(fp,",\n\t\t\t\t");
  73.                 for(i = 0; i < strlen(temp2->name)-2; i++)
  74.                 fprintf(fp,"  ");
  75.                 fprintf(fp," ");
  76.                 fprintf(fp,"%s, %s_relop",temp2->name, temp2->name);
  77.             if(temp2->elts)
  78.                 fprintf(fp,", %s_case",temp2->name);
  79.             }
  80.             temp2 = temp2->next;
  81.         }
  82.         fprintf(fp,")\n");
  83.         if(temp->data_types) fprintf(fp,"int  index");
  84.         temp2 = temp->data_types;
  85.         while(temp2){
  86.             if(temp2->type <= 2)
  87.                 fprintf(fp,", %s_relop",temp2->name);
  88.             temp2 = temp2->next;
  89.         }
  90.         if(temp->data_types) fprintf(fp,";\n");
  91.         temp2 = temp->data_types;
  92.         while(temp2){
  93.             if(temp2->type <= 2)
  94.                 fprintf(fp,"%s%s;\n",type_names[temp2->type], temp2->name);
  95.             temp2 = temp2->next;
  96.         }
  97.         fprintf(fp,"{\n");
  98.         if(temp->data_types){
  99.             fprintf(fp,"\tint\tflag;\n");
  100.             fprintf(fp,"\tstruct %s%s_struct *temp;\n\n", prefix,temp->name);
  101.             fprintf(fp,"\ttemp = %s%s_temp[index];\n\twhile(temp){", prefix,temp->name);
  102.             temp2 = temp->data_types;
  103.             fprintf(fp,"\n\t\tif(temp->MARK == 0){");
  104.             fprintf(fp,"\n\t\t\tflag = 7;");
  105.             while(temp2){
  106.               if(temp2->type <= 2){
  107.             if(temp2->elts){
  108.                 fprintf(fp,"\n\t\t\tswitch(%s_case){",temp2->name);
  109.                 fprintf(fp,"\n\t\t\tcase 0:");
  110.             }
  111.             fprintf(fp,"\n");
  112.             if(temp2->elts) fprintf(fp,"\t");
  113.                 fprintf(fp,"\t\t\tif(flag & %stest_", prefix);
  114.                 switch(temp2->type){
  115.                     case 0: fprintf(fp,"int");
  116.                         break;
  117.                     case 1: fprintf(fp,"double");
  118.                         break;
  119.                     case 2: fprintf(fp,"string");
  120.                 default: break;
  121.                 }
  122.                 fprintf(fp,"(temp->%s, %s) & %s_relop);",
  123.                 temp2->name, temp2->name, temp2->name);
  124.             fprintf(fp,"\n\t\t\t\telse flag = 0;");
  125.             if(temp2->elts){
  126.                 fprintf(fp,"\n\t\t\t\tbreak;");
  127.                 c_temp = temp2->elts;
  128.                 while(c_temp){
  129.                 fprintf(fp,"\n\t\t\tcase %d:", c_temp->id);
  130.                     fprintf(fp,"\n\t\t\t\tif(flag & test_");
  131.                     switch(temp2->type){
  132.                             case 0: fprintf(fp,"int");
  133.                                 break;
  134.                             case 1: fprintf(fp,"double");
  135.                                 break;
  136.                             case 2: fprintf(fp,"string");
  137.                         default: break;
  138.                     }
  139.                     fprintf(fp,"(temp->%s, temp->%s) & %s_relop);",
  140.                         temp2->name, c_temp->name, temp2->name);
  141.                 fprintf(fp,"\n\t\t\t\telse flag = 0;");
  142.                 fprintf(fp,"\n\t\t\t\tbreak;");
  143.                 c_temp = c_temp->next;
  144.                 }
  145.                 fprintf(fp,"\n\t\t\tdefault: flag = 0;\n\t\t\t}");
  146.             }
  147.               }
  148.               temp2 = temp2->next;
  149.             }
  150.             fprintf(fp,"\n\t\t\tif(flag){\n\t\t\t\ttemp->MARK = 1;\n");
  151.             fprintf(fp,"\t\t\t\treturn(temp);\n\t\t\t}\n\t\t}\n\t\ttemp = temp->next;\n");
  152.             fprintf(fp,"\t}\n\treturn(NULL);\n}\n");
  153.                 
  154.         }
  155.         }
  156.         temp = temp->next;
  157.     }
  158. }
  159.  
  160.  
  161. gen_free()
  162. /* generate procedures to free a structure */
  163. {
  164.     int     i;
  165.     struct def_list *temp;
  166.     struct data_type *temp2;
  167.     FILE *fp;
  168.  
  169.     fp = fre;
  170.     temp = token_list;
  171.     while(temp){
  172.       if(temp->data_types){
  173.         fprintf(fp,"\n\nfree_%s%s_struct(start)\nint start;\n{\n", prefix,temp->name);
  174.         fprintf(fp,"\tint i;\n\n");
  175.         fprintf(fp,"\tfor(i = start; i < %s%s_max; i++)\n", prefix,temp->name);
  176.         fprintf(fp,"\t\tif(%s%s_list[i]){\n", prefix,temp->name);
  177.         fprintf(fp,"\t\t\tif(%s%s_list[i]->prev == NULL)\n", prefix,temp->name);
  178.         fprintf(fp,"\t\t\t\t%s%s_list[0] = %s%s_list[i]->next;\n", prefix, temp->name, prefix, temp->name);
  179.         fprintf(fp,"\t\t\telse\n\t\t\t\t%s%s_list[i]->prev->next = %s%s_list[i]->next;\n", prefix, temp->name, prefix, temp->name);
  180.         fprintf(fp,"\t\t\tif(%s%s_list[i]->next)\n\t\t\t\t%s%s_list[i]->next->prev = %s%s_list[i]->prev;\n",
  181.         prefix, temp->name, prefix, temp->name, prefix, temp->name);
  182.         temp2 = temp->data_types;
  183.         while(temp2){
  184.                if(temp2->type == 2)
  185.             fprintf(fp,"\t\t\tfree(%s%s_list[i]->%s);\n", prefix,temp->name, temp2->name);
  186.                 temp2 = temp2->next;
  187.         }
  188.         fprintf(fp,"\t\t\tfree(%s%s_list[i]);\n", prefix,temp->name);
  189.         fprintf(fp,"\t\t\t%s%s_list[i] = NULL;\n", prefix,temp->name);
  190.         fprintf(fp,"\t\t\ti = %s%s_max;\n", prefix,temp->name);
  191.         fprintf(fp,"\t\t\t%stoken[%s%s]--;\n\t\t}", prefix, prefix,temp->name);
  192.         fprintf(fp,"\n}\n");
  193.       }
  194.       temp = temp->next;
  195.     }
  196. }
  197.  
  198.  
  199. gen_relink()
  200. /* generate procedures to relink a structure */
  201. {
  202.     int     i;
  203.     struct def_list *temp;
  204.     struct data_type *temp2;
  205.     FILE *fp;
  206.  
  207.     fp = relink;
  208.     temp = token_list;
  209.     while(temp){
  210.         fprintf(fp,"\n\n%srelink_%s_struct(start)\nint start;\n{\n", prefix,temp->name);
  211.         fprintf(fp,"\tint i, j;\n");
  212.         if(temp->data_types){
  213.             fprintf(fp,"\tstruct %s%s_struct *temp;\n\n", prefix,temp->name);
  214.             fprintf(fp,"\tfor(i = start; i < %s%s_max; i++)\n", prefix,temp->name);
  215.             fprintf(fp,"\t\tif(%s%s_list[i]){\n", prefix,temp->name);
  216.         fprintf(fp,"\t\t\ttemp = %s%s_list[0];\n", prefix,temp->name);
  217.         fprintf(fp,"\t\t\tj = 0;\n");
  218.         fprintf(fp,"\t\t\twhile(temp != %s%s_list[i]){\n", prefix,temp->name);
  219.         fprintf(fp,"\t\t\t\ttemp = temp->next;\n");
  220.         fprintf(fp,"\t\t\t\tj++;\n\t\t\t}\n");
  221.         fprintf(fp,"\t\t\tif(%s%s_list[i]->prev == NULL)\n", prefix,temp->name);
  222.         fprintf(fp,"\t\t\t\t%s%s_list[0] = %s%s_list[i]->next;\n", prefix, temp->name, prefix, temp->name);
  223.         fprintf(fp,"\t\t\telse\n\t\t\t\t%s%s_list[i]->prev->next = %s%s_list[i]->next;\n", prefix, temp->name, prefix, temp->name);
  224.         fprintf(fp,"\t\t\tif(%s%s_list[i]->next)\n\t\t\t\t%s%s_list[i]->next->prev = %s%s_list[i]->prev;\n",
  225.         prefix, temp->name, prefix, temp->name, prefix, temp->name);
  226.         fprintf(fp,"\t\t\t%s%s_list[i]->MARK = j;\n", prefix, temp->name);
  227.         fprintf(fp,"\t\t\t%s%s_list[i]->next = %sbacktrack->mark_%s;\n",prefix , temp->name, prefix, temp->name);
  228.         fprintf(fp,"\t\t\t%sbacktrack->mark_%s = %s%s_list[i];\n", prefix, temp->name, prefix, temp->name);
  229.             fprintf(fp,"\t\t\t%s%s_list[i] = NULL;\n", prefix,temp->name);
  230.             fprintf(fp,"\t\t\ti = %s%s_max;\n", prefix,temp->name);
  231.             fprintf(fp,"\t\t\t%stoken[%s%s]--;\n\t\t}", prefix, prefix,temp->name);
  232.         }
  233.         else{
  234.         fprintf(fp,"\t\t\t%sbacktrack->mark_%s++;\n", prefix, temp->name);
  235.             fprintf(fp,"\t\t\t%stoken[%s%s]--;\n", prefix, prefix,temp->name);
  236.         }
  237.         fprintf(fp,"\n}\n");
  238.         temp = temp->next;
  239.     }
  240. }
  241.  
  242.  
  243. gen_restore()
  244. /* generate procedure to restore structures */
  245. {
  246.     int     i;
  247.     struct def_list *temp;
  248.     FILE *fp;
  249.  
  250.     fp = misc;
  251.     temp = token_list;
  252.     fprintf(fp,"\n\n%srestore()\n{\n\tint i;\n", prefix);
  253.     while(temp){
  254.       if(temp->data_types){
  255.         fprintf(fp,"\n\tfor(i = 1; i < %s%s_max; i++)\n", prefix,temp->name);
  256.         fprintf(fp,"\t\tif(%s%s_list[i]){\n", prefix,temp->name);
  257.         fprintf(fp,"\t\t\t%s%s_list[i]->MARK = 0;\n", prefix, temp->name);
  258.         fprintf(fp,"\t\t\t%s%s_list[i] = NULL;\n\t\t}\n", prefix,temp->name);
  259.       }
  260.       temp = temp->next;
  261.     }
  262.     fprintf(fp,"}\n");
  263. }
  264.  
  265.  
  266. gen_add()
  267. /* generate procedures to add each structure to a list */
  268. {
  269.     int     i;
  270.     struct def_list *temp;
  271.     struct data_type *temp2;
  272.     FILE *fp;
  273.  
  274.     fp = add;
  275.     temp = token_list;
  276.     while(temp){
  277.         fprintf(fp,"\n%sadd_%s_struct(", prefix,temp->name);
  278.         if(temp->data_types){
  279.         temp2 = temp->data_types;
  280.         i = 0;
  281.         while(temp2){
  282.             if((temp2->type >= 0) && (temp2->type <= 2)){
  283.             if(i) fprintf(fp,",");
  284.                 fprintf(fp," %s",temp2->name);
  285.             }
  286.             i = 1;
  287.             temp2 = temp2->next;
  288.         }
  289.         }
  290.         fprintf(fp,")\n");
  291.         if(temp->data_types){
  292.         temp2 = temp->data_types;
  293.         while(temp2){
  294.             switch(temp2->type){
  295.             case 0: fprintf(fp,"int \t");
  296.                 break;
  297.             case 1: fprintf(fp,"double\t");
  298.                 break;
  299.             case 2: fprintf(fp,"char\t*");
  300.             default: break;
  301.             }
  302.             if((temp2->type >= 0) && (temp2->type <= 2))
  303.                 fprintf(fp,"%s;\n",temp2->name);
  304.             temp2 = temp2->next;
  305.         }
  306.         }
  307.         fprintf(fp,"{\n");
  308.         if(temp->data_types){
  309.         fprintf(fp,"\n\tstruct %s%s_struct *temp;\n\n", prefix,temp->name);
  310.  
  311.             fprintf(fp,"\ttemp = (struct %s%s_struct *) %smyalloc(sizeof(struct %s%s_struct));\n", prefix, temp->name, prefix, prefix, temp->name);
  312.             temp2 = temp->data_types;
  313.             while(temp2){
  314.             if((temp2->type == 0) || (temp2->type == 1))
  315.                 fprintf(fp,"\ttemp->%s = %s;\n",temp2->name, temp2->name);
  316.             else{
  317.             fprintf(fp,"\ttemp->%s = (char *) %smyalloc((strlen(%s)) + 1);\n",
  318.                   temp2->name, prefix, temp2->name);
  319.             fprintf(fp,"\tstrcpy(temp->%s, %s);\n",temp2->name, temp2->name);
  320.             }
  321.               temp2 = temp2->next;
  322.             }
  323.         fprintf(fp,"\ttemp->MARK = 0;\n");
  324.             fprintf(fp,"\ttemp->next = %s%s_list[0];\n", prefix,temp->name);
  325.             fprintf(fp,"\ttemp->prev = NULL;\n");
  326.             fprintf(fp,"\tif(%s%s_list[0])\n", prefix, temp->name);
  327.             fprintf(fp,"\t\t%s%s_list[0]->prev = temp;\n", prefix,temp->name);
  328.             fprintf(fp,"\t%s%s_list[0] = temp;\n", prefix,temp->name);
  329.         }
  330.         fprintf(fp,"\t%stoken[%s%s]++;\n", prefix, prefix,temp->name);
  331.         if(backtracking){
  332.         fprintf(fp,"\tif(%srestoring == 0)\n", prefix);
  333.         fprintf(fp,"\t\t%sbacktrack->Add_%s++;\n", prefix, temp->name);
  334.         }
  335.         fprintf(fp,"\n}\n\n");
  336.         temp = temp->next;
  337.     }
  338. }
  339.  
  340.  
  341. gen_save(test, fire)
  342. int test, fire;
  343. /* generate procedures to save the contents of 
  344.    dynamically allocated structures on a file */
  345. {
  346.     int i, j;
  347.     struct def_list *temp;
  348.     struct data_type *temp2;
  349.     FILE *fp;
  350.  
  351.     fp = save;
  352.     /* profiling arrays */
  353.     if(profiling)
  354.         fprintf(fp,"extern int %sfire_profile[], %stest_profile[];\n", prefix, prefix);
  355.     /* boolean shared by scan and load procedures */
  356.     fprintf(fp,"int %seof_flag;\n", prefix);
  357.     /* procedure to read a line from a file */
  358.     fprintf(fp,"\n\nchar *%sscan(fp)\nFILE *fp;\n{\n", prefix);
  359.     fprintf(fp,"\tchar *s, c[512];\n\tint i;\n");
  360.     fprintf(fp,"\n\ti = 0;\n\twhile(1){\n");
  361.     fprintf(fp,"\t\tc[i] = getc(fp);\n");
  362.     fprintf(fp,"\t\tif((c[i] == '\\n') || (c[i] == EOF)){\n");
  363.     fprintf(fp,"\t\t\tif(c[i] == EOF)\n\t\t\t\t%seof_flag = 0;\n", prefix);
  364.     fprintf(fp,"\t\t\tc[i] = '\\0';\n");
  365.     fprintf(fp,"\t\t\ts = (char *) %smyalloc (i + 1);\n", prefix);
  366.     fprintf(fp,"\t\t\tstrcpy(s,c);\n\t\t\treturn(s);\n");
  367.     fprintf(fp,"\t\t}\n\t\tif(i < 511)\n\t\t\ti++;\n");
  368.     fprintf(fp,"\t}\n}\n");
  369.     /* procedures to save stm on a file */
  370.     fprintf(fp,"\n\n%ssave_stm(fp)\n", prefix);
  371.     fprintf(fp,"FILE *fp;\n{\n");
  372.     temp = token_list;
  373.     while(temp){
  374.         fprintf(fp,"\tsave_%s%s_struct(fp);\n", prefix,temp->name);
  375.         temp = temp->next;
  376.     }
  377.     fprintf(fp,"}\n\n");
  378.     temp = token_list;
  379.     while(temp){
  380.         fprintf(fp,"\nsave_%s%s_struct(fp)\n", prefix,temp->name);
  381.         fprintf(fp,"FILE *fp;\n{\n");
  382.         if(temp->data_types){
  383.         fprintf(fp,"\tstruct %s%s_struct *temp;\n\n", prefix,temp->name);
  384.         fprintf(fp,"\ttemp = %s%s_list[0];\n", prefix,temp->name);
  385.         fprintf(fp,"\twhile(temp->next != NULL)\n");
  386.         fprintf(fp,"\t\ttemp = temp->next;\n");
  387.         fprintf(fp,"\twhile(temp){\n");
  388.         }
  389.         fprintf(fp,"\t\tfprintf(fp,\"%s%s\\n\");\n", prefix, temp->name);
  390.         if(temp->data_types){
  391.         temp2 = temp->data_types;
  392.         while(temp2){
  393.             if((temp2->type <= 2) && (temp2->type >= 0)){
  394.                     fprintf(fp,"\t\tfprintf(fp,\"");
  395.                 switch(temp2->type){
  396.                     case 0: fprintf(fp,"%cd", '%');
  397.                         break;
  398.                     case 1: fprintf(fp,"%cf", '%');
  399.                         break;
  400.                     case 2: fprintf(fp,"%cs", '%');
  401.                     default: break;
  402.                 }
  403.                     fprintf(fp,"\\n\",temp->%s);\n", temp2->name);
  404.             }
  405.             temp2 = temp2->next;
  406.         }
  407.         fprintf(fp,"\t\ttemp = temp->prev;\n\t}\n");
  408.         }
  409.         else{
  410.         fprintf(fp,"\t\tfprintf(fp,\"%cd\\n\",%stoken[%s%s]);\n",'%', prefix, prefix,temp->name);
  411.         }
  412.         fprintf(fp,"}\n\n");
  413.         temp = temp->next;
  414.     }
  415.  
  416.     /* procedure to load stm from a file */
  417.     fprintf(fp,"\n\n%sload_stm(fp)\nFILE *fp;\n{\n\tchar *s;\n", prefix);
  418.     temp = token_list;
  419.     while(temp){
  420.         temp2 = temp->data_types;
  421.         while(temp2){
  422.         if((temp2->type <= 2) && (temp2->type >= 0))
  423.             fprintf(fp,"\t%s%s%s_%s;\n",type_names[temp2->type], prefix,
  424.                           temp->name, temp2->name);
  425.         temp2 = temp2->next;
  426.         }
  427.         temp = temp->next;
  428.     }
  429.     temp = token_list;
  430.     fprintf(fp,"\t%srestoring = 1;\n", prefix);
  431.     fprintf(fp,"\n\n\t%seof_flag = 1;\n", prefix);
  432.     fprintf(fp,"\twhile(%seof_flag){\n", prefix);
  433.     fprintf(fp,"\t\ts = %sscan(fp);\n", prefix);
  434.     i = 0;
  435.     while(temp){
  436.         fprintf(fp,"\t\t");
  437.         if(i)
  438.         fprintf(fp,"else ");
  439.         fprintf(fp,"if(strcmp(s, \"%s%s\") == 0){\n", prefix,temp->name);
  440.         fprintf(fp,"\t\t\tfree(s);\n");
  441.         if(temp->data_types){
  442.             temp2 = temp->data_types;
  443.             while(temp2){
  444.                 fprintf(fp,"\t\t\ts = %sscan(fp);\n", prefix);
  445.                 switch(temp2->type){
  446.                     case 0: fprintf(fp,"\t\t\t%s%s_%s = atoi(s);\n", prefix,temp->name, temp2->name);
  447.                             fprintf(fp,"\t\t\tfree(s);\n");
  448.                         break;
  449.                     case 1: fprintf(fp,"\t\t\t%s%s_%s = atoi(s);\n", prefix,temp->name, temp2->name);
  450.                             fprintf(fp,"\t\t\tfree(s);\n");
  451.                         break;
  452.                     case 2: fprintf(fp,"\t\t\t%s%s_%s = s;\n", prefix,temp->name, temp2->name);
  453.                     default: break;
  454.                 }
  455.                     temp2 = temp2->next;
  456.         }
  457.         /* generate the add statement here */
  458.         fprintf(fp,"\t\t\t%sadd_%s_struct(", prefix, temp->name);
  459.         i = 0;
  460.         temp2 = temp->data_types;
  461.         while(temp2){
  462.             if(i)
  463.             fprintf(fp," ,");
  464.             i = 1;
  465.             fprintf(fp,"%s%s_%s", prefix,temp->name, temp2->name);
  466.             temp2 = temp2->next;
  467.         }
  468.         fprintf(fp,");\n");
  469.         temp2 = temp->data_types;
  470.         while(temp2){
  471.             if(temp2->type == 2)
  472.                 fprintf(fp,"\t\t\tfree(%s%s_%s);\n", prefix,temp->name, temp2->name);
  473.             temp2 = temp2->next;
  474.         }
  475.         }
  476.         else{
  477.             /* read in the count and increment token[] */
  478.         fprintf(fp,"\t\t\ts = %sscan(fp);\n", prefix);
  479.         fprintf(fp,"\t\t\t%stoken[%s%s] += atoi(s);\n", prefix, prefix, temp->name);
  480.         fprintf(fp,"\t\t\tfree(s);\n");
  481.         }
  482.         fprintf(fp,"\t\t}\n");
  483.         i = 1;
  484.         temp = temp->next;
  485.     }
  486.     fprintf(fp,"\t}\n");
  487.     fprintf(fp,"\t%srestoring = 0;\n", prefix);
  488.     fprintf(fp,"}\n");
  489.     if(backtracking){
  490.         fprintf(fp,"\n%ssave_backtrack(fp)\nFILE *fp;\n{\n", prefix);
  491.         fprintf(fp,"\tstruct %sback_track_stack *temp;\n",prefix);
  492.         temp = token_list;
  493.         while(temp){
  494.         if(temp->data_types)
  495.                 fprintf(fp,"\tstruct %s%s_struct *%s_tmp;\n",prefix, temp->name, temp->name);
  496.         temp = temp->next;
  497.         }
  498.         fprintf(fp,"\n\ttemp = %sbacktrack;\n\twhile(temp){\n", prefix);
  499.         fprintf(fp,"\t\tfprintf(fp,\"%sbacktrack\\n\");\n", prefix);
  500.         fprintf(fp,"\t\tfprintf(fp,\"%cd\\n\",temp->next_rule);\n",'%');
  501.         temp = token_list;
  502.         while(temp){
  503.                 fprintf(fp,"\t\tfprintf(fp,\"%cd\\n\",temp->Add_%s);\n", '%', 
  504.             temp->name);
  505.             if(temp->data_types == NULL)
  506.                 fprintf(fp,"\t\tfprintf(fp,\"%cd\\n\",temp->mark_%s);\n",
  507.                 '%', temp->name);
  508.             temp = temp->next;
  509.         }
  510.         temp = token_list;
  511.         while(temp){
  512.         if(temp->data_types){
  513.             fprintf(fp,"\t\t%s_tmp = temp->mark_%s;\n", temp->name, temp->name);
  514.             fprintf(fp,"\t\twhile(%s_tmp){\n", temp->name);
  515.                 fprintf(fp,"\t\t\tfprintf(fp,\"%s%s\\n\");\n", prefix, temp->name);
  516.                 fprintf(fp,"\t\t\tfprintf(fp,\"%cd\\n\",%s_tmp->MARK);\n", '%', temp->name);
  517.             temp2 = temp->data_types;
  518.             while(temp2){
  519.               if((temp2->type >= 0) && (temp2->type <= 2)){
  520.                     fprintf(fp,"\t\t\tfprintf(fp,\"%c", '%');
  521.             switch(temp2->type){
  522.                 case 0: fprintf(fp,"d");
  523.                     break;
  524.                 case 1: fprintf(fp,"f");
  525.                     break;
  526.                 case 2: fprintf(fp,"s");
  527.                 default:break;
  528.             }
  529.             fprintf(fp,"\\n\",%s_tmp->%s);\n", temp->name, temp2->name);
  530.               }
  531.               temp2 = temp2->next;
  532.             }
  533.             fprintf(fp,"\t\t\t%s_tmp = %s_tmp->next;\n", temp->name, temp->name);
  534.             fprintf(fp,"\t\t}\n");
  535.             }
  536.         temp = temp->next;
  537.         }
  538.         fprintf(fp,"\t\ttemp = temp->next;\n\t}\n");
  539.         fprintf(fp,"}\n");
  540.         fprintf(fp,"\n%sload_backtrack(fp)\nFILE *fp;\n{\n", prefix);
  541.         fprintf(fp,"\tchar *s;\n");
  542.         fprintf(fp,"\tstruct %sback_track_stack *temp;\n",prefix);
  543.         temp = token_list;
  544.         while(temp){
  545.         if(temp->data_types)
  546.                 fprintf(fp,"\tstruct %s%s_struct *%s_tmp;\n",prefix, temp->name, temp->name);
  547.         temp = temp->next;
  548.         }
  549.         fprintf(fp,"\n\t%seof_flag = 1;\n\ttemp = NULL;\n", prefix);
  550.         fprintf(fp,"\twhile(%seof_flag){\n", prefix);
  551.         fprintf(fp,"\t\ts = %sscan(fp);\n", prefix);
  552.         fprintf(fp,"\t\tif(strcmp(s,\"%sbacktrack\") == 0){\n", prefix);
  553.         fprintf(fp,"\t\t\tfree(s);\n");
  554.         fprintf(fp,"\t\t\tif(temp == NULL)\n\t\t\t\t%sbacktrack = temp = ", prefix);
  555.         fprintf(fp,"(struct %sback_track_stack *) %smyalloc ", prefix, prefix);
  556.         fprintf(fp,"(sizeof(struct %sback_track_stack));\n",prefix);
  557.         fprintf(fp,"\t\t\telse{\n\t\t\t\ttemp->next = ", prefix);
  558.         fprintf(fp,"(struct %sback_track_stack *) %smyalloc ", prefix, prefix);
  559.         fprintf(fp,"(sizeof(struct %sback_track_stack));\n",prefix);
  560.         fprintf(fp,"\t\t\t\ttemp = temp->next;\n\t\t\t}\n");
  561.         fprintf(fp,"\t\t\ts = %sscan(fp);\n", prefix);
  562.         fprintf(fp,"\t\t\ttemp->next_rule = atoi(s);\n");
  563.         fprintf(fp,"\t\t\tfree(s);\n");
  564.         temp = token_list;
  565.         while(temp){
  566.             fprintf(fp,"\t\t\ts = %sscan(fp);\n", prefix);
  567.             fprintf(fp,"\t\t\ttemp->Add_%s = atoi(s);\n", temp->name);
  568.             fprintf(fp,"\t\t\tfree(s);\n");
  569.         if(temp->data_types)
  570.                 fprintf(fp,"\t\t\t%s_tmp = temp->mark_%s = NULL;\n", temp->name, temp->name);
  571.         else{
  572.                 fprintf(fp,"\t\t\ts = %sscan(fp);\n", prefix);
  573.                 fprintf(fp,"\t\t\ttemp->mark_%s = atoi(s);\n", temp->name);
  574.                 fprintf(fp,"\t\t\tfree(s);\n");
  575.         }
  576.         temp = temp->next;
  577.         }
  578.         fprintf(fp,"\t\t\ttemp->next = NULL;\n");
  579.         fprintf(fp,"\t\t}\n");
  580.         temp = token_list;
  581.         while(temp){
  582.         if(temp->data_types){
  583.             fprintf(fp,"\t\telse if(strcmp(s,\"%s%s\") == 0){\n", prefix,temp->name);
  584.             fprintf(fp,"\t\t\tfree(s);\n");
  585.                 fprintf(fp,"\t\t\tif(%s_tmp == NULL)\n\t\t\t\ttemp->mark_%s = %s_tmp = ", temp->name, temp->name, temp->name);
  586.                 fprintf(fp,"(struct %s%s_struct *) %smyalloc ", prefix, temp->name, prefix);
  587.                 fprintf(fp,"(sizeof(struct %s%s_struct));\n",prefix, temp->name);
  588.                 fprintf(fp,"\t\t\telse{\n\t\t\t\t%s_tmp->next = ", temp->name);
  589.                 fprintf(fp,"(struct %s%s_struct *) %smyalloc ", prefix, temp->name, prefix);
  590.                 fprintf(fp,"(sizeof(struct %s%s_struct));\n",prefix, temp->name);
  591.                 fprintf(fp,"\t\t\t\t%s_tmp = %s_tmp->next;\n\t\t\t}\n", temp->name, temp->name);
  592.             temp2 = temp->data_types;
  593.                 fprintf(fp,"\t\t\ts = %sscan(fp);\n", prefix);
  594.             fprintf(fp,"\t\t\t%s_tmp->MARK = atoi(s);\n",temp->name);
  595.                 fprintf(fp,"\t\t\tfree(s);\n");
  596.             while(temp2){
  597.               if((temp2->type >= 0) && (temp2->type <= 2)){
  598.             fprintf(fp,"\t\t\ts = %sscan(fp);\n", prefix);
  599.                     fprintf(fp,"\t\t\t%s_tmp->%s = ",temp->name, temp2->name);
  600.             switch(temp2->type){
  601.                 case 0: fprintf(fp,"atoi(s);\n");
  602.                     fprintf(fp,"\t\t\tfree(s);\n");
  603.                     break;
  604.                 case 1: fprintf(fp,"atof(s);\n");
  605.                     fprintf(fp,"\t\t\tfree(s);\n");
  606.                     break;
  607.                 case 2: fprintf(fp,"s;\n");
  608.                 default:break;
  609.             }
  610.               }
  611.               temp2 = temp2->next;
  612.             }
  613.             fprintf(fp,"\t\t}\n");
  614.             }
  615.         temp = temp->next;
  616.         }
  617.         fprintf(fp,"\t}\n");
  618.         fprintf(fp,"}\n");
  619.     }
  620.     if(profiling){
  621.         fprintf(fp,"\n%ssave_profile(fp)\nFILE *fp;\n{\n", prefix);
  622.         fprintf(fp,"\tint i;\n\n");
  623.         fprintf(fp,"\tfor(i = 0; i < %d; i++)\n",fire);
  624.         fprintf(fp,"\t\tfprintf(fp,\"%cd\\n\",%sfire_profile[i]);\n", '%', prefix);
  625.         fprintf(fp,"\tfor(i = 0; i < %d; i++)\n",test);
  626.         fprintf(fp,"\t\tfprintf(fp,\"%cd\\n\",%stest_profile[i]);\n", '%', prefix);
  627.         fprintf(fp,"}\n");
  628.         fprintf(fp,"\n%sload_profile(fp)\nFILE *fp;\n{\n", prefix);
  629.         fprintf(fp,"\tchar *s;\n\tint i;\n\n");
  630.         fprintf(fp,"\tfor(i = 0; i < %d; i++){\n",fire);
  631.         fprintf(fp,"\t\t%sfire_profile[i] = atoi(s = %sscan(fp));\n", prefix, prefix);
  632.         fprintf(fp,"\t\tfree(s);\n\t}\n");
  633.         fprintf(fp,"\tfor(i = 0; i < %d; i++){\n",test);
  634.         fprintf(fp,"\t\t%stest_profile[i] = atoi(s = %sscan(fp));\n", prefix, prefix);
  635.         fprintf(fp,"\t\tfree(s);\n\t}\n");
  636.         fprintf(fp,"}\n");
  637.     }
  638.     if(tracing){
  639.         fprintf(fp,"\n%ssave_trace(fp)\nFILE *fp;\n{\n", prefix);
  640.         fprintf(fp,"\tstruct %strace *temp;\n\n", prefix);
  641.         fprintf(fp,"\ttemp = %strace_front;\n", prefix);
  642.         fprintf(fp,"\twhile(temp){\n");
  643.         fprintf(fp,"\t\tfprintf(fp,\"%cd\\n\", temp->rule);\n",'%');
  644.         fprintf(fp,"\t\ttemp = temp->next;\n\t}\n}\n");
  645.         fprintf(fp,"\n%sload_trace(fp)\nFILE *fp;\n{\n\tchar *s;\n\n", prefix);
  646.         fprintf(fp,"\t%seof_flag = 1;\n\ts = %sscan(fp);\n",prefix ,prefix);
  647.         fprintf(fp,"\twhile(%seof_flag){\n", prefix);
  648.         fprintf(fp,"\t\tif(%strace_back){\n", prefix);
  649.         fprintf(fp,"\t\t\t%strace_back->next = (struct %strace *) ",prefix, prefix);
  650.         fprintf(fp,"%smyalloc (sizeof(struct %strace));\n", prefix, prefix);
  651.         fprintf(fp,"\t\t\t%strace_back = %strace_back->next;\n", prefix, prefix);
  652.         fprintf(fp,"\t\t}\n\t\telse\n");
  653.         fprintf(fp,"\t\t\t%strace_front = %strace_back = (struct %strace *) ",prefix, prefix, prefix);
  654.         fprintf(fp,"%smyalloc (sizeof(struct %strace));\n", prefix, prefix);
  655.         fprintf(fp,"\t\t%strace_back->rule = atoi(s);\n", prefix);
  656.         fprintf(fp,"\t\tfree(s);\n\t\ts = %sscan(fp);\n", prefix);
  657.         fprintf(fp,"\t}\n}\n");
  658.     }
  659. }
  660.  
  661.  
  662. gen_print()
  663. /* generate procedures to print the contents of stm on the standard output */
  664. {
  665.     struct def_list *temp;
  666.     struct data_type *temp2;
  667.     FILE *fp;
  668.  
  669.     fp = dump;
  670.     fprintf(fp,"\n\n%sdump_stm()\n{\n", prefix);
  671.     temp = token_list;
  672.     while(temp){
  673.         fprintf(fp,"\t%sdump_%s_struct();\n", prefix,temp->name);
  674.         temp = temp->next;
  675.     }
  676.     fprintf(fp,"}\n\n");
  677.     temp = token_list;
  678.     while(temp){
  679.         fprintf(fp,"\n%sdump_%s_struct()\n{\n", prefix,temp->name);
  680.         if(temp->data_types){
  681.         fprintf(fp,"\tint\ti;\n\tstruct %s%s_struct *temp;\n\n", prefix,temp->name);
  682.         fprintf(fp,"\ti = 1;\n");
  683.         }
  684.         fprintf(fp,"\tprintf(\"\\nDumping %s list (%cd)\\n\",%stoken[%s%s]);\n", temp->name, '%', prefix, prefix, temp->name);
  685.         if(temp->data_types){
  686.         fprintf(fp,"\ttemp = %s%s_list[0];\n\twhile(temp){\n", prefix,temp->name);
  687.         fprintf(fp,"\t\tprintf(\"%cd.\\t",'%');
  688.         temp2 = temp->data_types;
  689.         while(temp2){
  690.             switch(temp2->type){
  691.                 case 0: fprintf(fp,"%cd\\t", '%');
  692.                     break;
  693.                 case 1: fprintf(fp,"%cf\\t", '%');
  694.                     break;
  695.                 case 2: fprintf(fp,"%cs\\t", '%');
  696.                 default: break;
  697.             }
  698.             temp2 = temp2->next;
  699.         }
  700.         fprintf(fp,"\\n\", i");
  701.         temp2 = temp->data_types;
  702.         while(temp2){
  703.             if((temp2->type >= 0) && (temp2->type <= 2))
  704.                 fprintf(fp,"\n\t\t\t, temp->%s",temp2->name);
  705.             temp2 = temp2->next;
  706.         }
  707.         fprintf(fp,");\n\t\ttemp = temp->next;\n\t\ti++;\n\t}\n");
  708.         }
  709.         fprintf(fp,"}\n\n");
  710.         temp = temp->next;
  711.     }
  712. }
  713.  
  714.  
  715. gen_init(mode)
  716. /* generate procedure to initialize stm */
  717. /* if mode is zero, then generate only code to add to stm */
  718. int mode;
  719. {
  720.     int i;
  721.     struct init *temp;
  722.     struct fields *temp2;
  723.     struct def_list *t;
  724.     struct data_type *t2;
  725.     FILE *fp;
  726.  
  727.     if(mode)
  728.         fp = add;
  729.     else
  730.         fp = loop;
  731.     temp = init_list->next;            /* the first one is a place holder */
  732.     if(mode){
  733.         fprintf(fp,"\n\n%sinit()\n{\n\tint i;\n", prefix);
  734.         if(backtracking){
  735.         fprintf(fp,"\n\t%sbacktrack = (struct %sback_track_stack *)", prefix, prefix);
  736.         fprintf(fp," %smyalloc (sizeof(struct %sback_track_stack));\n", prefix, prefix);
  737.         }
  738.     }
  739.  
  740.     while(temp){
  741.         if(temp->count){
  742.             if(mode == 0) fprintf(fp,"\t\t");
  743.         fprintf(fp,"\tfor(i = 0; i < %d; i++)\n\t",temp->count);
  744.         }
  745.         if(mode == 0) fprintf(fp,"\t\t");
  746.         fprintf(fp,"\t%sadd_%s_struct(" , prefix, temp->object);
  747.         t = token_list;
  748.         while(strcmp(t->name, temp->object) != 0)
  749.         t = t->next;
  750.         i = 0;
  751.         t2 = t->data_types;
  752.         while(t2){
  753.         temp2 = temp->items;
  754.         while((temp2) && (strcmp(temp2->element, t2->name) != 0))
  755.             temp2 = temp2->next;
  756.         if((temp2) && (temp2->type != 3)){
  757.             if(i) fprintf(fp,", "); i = 1;
  758.             if(temp2->type >= 0){
  759.                 if(temp2->type == 2) fprintf(fp,"\"");
  760.                 fprintf(fp,"%s",temp2->value);
  761.                 if(temp2->type == 2) fprintf(fp,"\"");
  762.             }
  763.             else{
  764.             if(temp2->empty)
  765.                fprintf(fp,"%s%s_empty[%d].%s", prefix,temp2->object,
  766.                 temp2->index, temp2->value);
  767.             else
  768.                fprintf(fp,"%s%s_list[%d]->%s", prefix,temp2->object,
  769.                 temp2->index, temp2->value);
  770.             }
  771.         }
  772.         else if(t2->type != 3){
  773.             if(i) fprintf(fp,", "); i = 1;
  774.             if(t2->type == 2)
  775.             fprintf(fp,"\"\"");
  776.             if(t2->type == 1)
  777.             fprintf(fp,"0.0");
  778.             if(t2->type == 0)
  779.             fprintf(fp,"0");
  780.         }
  781.         t2 = t2->next;
  782.         }
  783.         fprintf(fp,");\n");
  784.         temp = temp->next;
  785.     }
  786.     if(mode){
  787.         if(backtracking){
  788.             fprintf(fp,"\tfree(%sbacktrack);\n", prefix);
  789.             fprintf(fp,"\t%sbacktrack = NULL;\n", prefix);
  790.         }
  791.         fprintf(fp,"}\n\n\n");
  792.     }
  793. }
  794.  
  795.  
  796. gen_structs()
  797. /*
  798. generate structure definitions from token list
  799. */
  800. {
  801.     int i;
  802.     struct def_list *temp;
  803.     struct data_type *temp2;
  804.     FILE *fp;
  805.  
  806.     i = 0;
  807.     fp = header;
  808.     temp = token_list;
  809.     while(temp){
  810.       if(temp->data_types){
  811.         fprintf(fp,"\nstruct %s%s_struct {\n", prefix,temp->name);
  812.         if(temp->data_types){
  813.         temp2 = temp->data_types;
  814.         while(temp2){
  815.             if(temp2->type != 3)
  816.                 fprintf(fp,"\t\t%s%s;\n",type_names[temp2->type],temp2->name);
  817.             else
  818.                 fprintf(fp,"\t\tstruct %s%s_struct *%s;\n", prefix,temp->name, temp2->name);
  819.             temp2 = temp2->next;
  820.         }
  821.         }
  822.         fprintf(fp,"\t\tint MARK;\n");
  823.         fprintf(fp,"\t\tstruct %s%s_struct *prev;\n", prefix,temp->name);
  824.         fprintf(fp,"\t\tstruct %s%s_struct *next;\n", prefix,temp->name);
  825.         fprintf(fp,"} *%s%s_list[%s%s_max],", prefix,temp->name, prefix, temp->name);
  826.         if(max_empty[i])
  827.             fprintf(fp," %s%s_empty[%d],", prefix,temp->name, max_empty[i]);
  828.         fprintf(fp," *%s%s_temp[%s%s_max];\n", prefix,temp->name, prefix, temp->name);
  829.       }
  830.       i++;
  831.       temp = temp->next;
  832.     }
  833.     if(backtracking){
  834.         fprintf(fp,"\nstruct %sback_track_stack {\n", prefix);
  835.         temp = token_list;
  836.         while(temp){
  837.             fprintf(fp,"\tint Add_%s;\n",temp->name);
  838.             if(temp->data_types)
  839.                 fprintf(fp,"\tstruct %s%s_struct *mark_%s;\n", prefix,temp->name, temp->name);
  840.             else
  841.                 fprintf(fp,"\tint mark_%s;\n", temp->name);
  842.             temp = temp->next;
  843.         }
  844.         fprintf(fp,"\tint next_rule;\n");
  845.         fprintf(fp,"\tstruct %sback_track_stack *next;\n} *%sbacktrack;\n", prefix, prefix);
  846.     }
  847. }
  848.  
  849.  
  850. gen_back()
  851. /* generate procedures required for backtracking */
  852. {
  853.     struct def_list *temp;
  854.     FILE *fp;
  855.  
  856.     fp = backtrack;
  857.     temp = token_list;
  858.     fprintf(fp,"\n%sinsert_backtrack(rule)\nint rule;\n{\n", prefix);
  859.     fprintf(fp,"\tstruct %sback_track_stack *temp;\n\n", prefix);
  860.     fprintf(fp,"\ttemp = (struct %sback_track_stack *) %smyalloc", prefix, prefix);
  861.     fprintf(fp,"(sizeof(struct %sback_track_stack));\n", prefix);
  862.     fprintf(fp,"\ttemp->next_rule = rule;\n");
  863.     while(temp){
  864.         fprintf(fp,"\ttemp->Add_%s = 0;\n", temp->name);
  865.         if(temp->data_types)
  866.         fprintf(fp,"\ttemp->mark_%s = NULL;\n", temp->name);
  867.         else
  868.             fprintf(fp,"\ttemp->mark_%s = 0;\n", temp->name);
  869.         temp = temp->next;
  870.     }
  871.     fprintf(fp,"\ttemp->next = %sbacktrack;\n", prefix);
  872.     fprintf(fp,"\t%sbacktrack = temp;\n}\n", prefix);
  873.  
  874.     fprintf(fp,"\n%sbackup()\n{\n\tint i;\n", prefix);
  875.     fprintf(fp,"\tstruct %sback_track_stack *temp;\n", prefix);
  876.     temp = token_list;
  877.     while(temp){
  878.         if(temp->data_types)
  879.         fprintf(fp,"\tstruct %s%s_struct *%s_temp, *%s_temp2;\n",
  880.             prefix, temp->name, temp->name, temp->name);
  881.         temp = temp->next;
  882.     }
  883.     fprintf(fp,"\n\tif(%sbacktrack == NULL)\n\t\treturn;\n", prefix);
  884.     temp = token_list;
  885.     while(temp){
  886.         if(temp->data_types){
  887.         fprintf(fp,"\twhile(%sbacktrack->mark_%s){\n", prefix, temp->name);
  888.         fprintf(fp,"\t\t%s_temp2 = %sbacktrack->mark_%s;\n",
  889.             temp->name, prefix, temp->name);
  890.         fprintf(fp,"\t\t%sbacktrack->mark_%s = %sbacktrack->mark_%s->next;\n", prefix,
  891.             temp->name, prefix, temp->name);
  892.         fprintf(fp,"\t\t%s_temp2->prev = NULL;\n", temp->name);
  893.         fprintf(fp,"\t\t%s_temp2->next = NULL;\n", temp->name);
  894.         fprintf(fp,"\t\t%s_temp = %s%s_list[0];\n", temp->name, prefix, temp->name);
  895.         fprintf(fp,"\t\tif(%s_temp){\n", temp->name);
  896.         fprintf(fp,"\t\t\tfor(i = 0; i < %s_temp2->MARK; i++)\n", temp->name);
  897.         fprintf(fp,"\t\t\t\tif(%s_temp->next)\n", temp->name);
  898.         fprintf(fp,"\t\t\t\t\t%s_temp = %s_temp->next;\n",
  899.  
  900.             temp->name, temp->name);
  901.         fprintf(fp,"\t\t\t\telse\n");
  902.         fprintf(fp,"\t\t\t\t\ti = %s_temp2->MARK + 1;\n", temp->name);
  903.         fprintf(fp,"\t\t}\n\t\telse i = -1;\n");
  904.         fprintf(fp,"\t\tif(i == %s_temp2->MARK){\n", temp->name);
  905.         fprintf(fp,"\t\t\t%s_temp2->next = %s_temp;\n", temp->name, temp->name);
  906.         fprintf(fp,"\t\t\t%s_temp2->prev = %s_temp->prev;\n",
  907.             temp->name, temp->name);
  908.         fprintf(fp,"\t\t\tif(%s_temp->prev)\n", temp->name);
  909.         fprintf(fp,"\t\t\t\t%s_temp->prev->next = %s_temp2;\n",
  910.             temp->name, temp->name);
  911.         fprintf(fp,"\t\t\telse\n");
  912.         fprintf(fp,"\t\t\t\t%s%s_list[0] = %s_temp2;\n", prefix, temp->name, temp->name);
  913.         fprintf(fp,"\t\t\t%s_temp->prev = %s_temp2;\n", temp->name, temp->name);
  914.         fprintf(fp,"\t\t}\n\t\telse{\n");
  915.         fprintf(fp,"\t\t\tif(%s_temp){\n", temp->name);
  916.         fprintf(fp,"\t\t\t\t%s_temp->next = %s_temp2;\n", temp->name, temp->name);
  917.         fprintf(fp,"\t\t\t\t%s_temp2->prev = %s_temp;\n", temp->name, temp->name);
  918.         fprintf(fp,"\t\t\t\t%s_temp2->next = NULL;\n", temp->name);
  919.         fprintf(fp,"\t\t\t}\n\t\t\telse %s%s_list[0] = %s_temp2;\n", prefix, temp->name, temp->name);
  920.         fprintf(fp,"\t\t}\n");
  921.         fprintf(fp,"\t\t%s_temp2->MARK = 0;\n", temp->name);
  922.         fprintf(fp,"\t\t%stoken[%s%s]++;\n", prefix, prefix, temp->name);
  923.         fprintf(fp,"\t}\n");
  924.             fprintf(fp,"\tfor(i = 0; i < %sbacktrack->Add_%s; i++){\n", prefix, temp->name);
  925.             fprintf(fp,"\t\t%s%s_list[1] = %s%s_list[0];\n", prefix,temp->name, prefix, temp->name);
  926.             fprintf(fp,"\t\tfree_%s%s_struct(1);\n\t}\n", prefix, temp->name);
  927.         }
  928.         else{
  929.         fprintf(fp,"\t%stoken[%s%s] += %sbacktrack->mark_%s;\n", prefix, prefix,
  930.             temp->name, prefix, temp->name);
  931.         fprintf(fp,"\t%stoken[%s%s] -= %sbacktrack->Add_%s;\n",
  932.         prefix, prefix, temp->name, prefix, temp->name);
  933.         }
  934.         temp = temp->next;
  935.     }
  936.     fprintf(fp,"\ttemp = %sbacktrack;\n", prefix);
  937.     fprintf(fp,"\t%sbacktrack = %sbacktrack->next;\n", prefix, prefix);
  938.     fprintf(fp,"\tfree(temp);\n");
  939.     fprintf(fp,"}\n");
  940. }
  941.  
  942.  
  943. gen_trace()
  944. /* generate code to support building a trace list */
  945. {
  946.     int i;
  947.     struct rule *temp;
  948.     FILE *fp;
  949.  
  950.     fp = header;
  951.     fprintf(fp,"\nstruct %strace{\n\tint rule;\n", prefix);
  952.     fprintf(fp,"\tstruct %strace *next;\n} ", prefix);
  953.     fprintf(fp,"*%strace_front, *%strace_back;\n\n", prefix, prefix);
  954.     temp = rule_list;
  955.     i = 1;
  956.     while(temp->next){
  957.         temp = temp->next;
  958.         i++;
  959.     }
  960.     fp = loop;
  961.     fprintf(fp,"char *%srule_names[%d] = {\n", prefix,i+2);
  962.     fprintf(fp,"\t\"%sStart\",\n", prefix);
  963.     while(temp){
  964.         fprintf(fp,"\t\"%s%s\",\n", prefix,temp->label);
  965.         temp = temp->prev;
  966.     }
  967.     fprintf(fp,"\t\"%sEnd\"\n};\n\n", prefix);
  968.     fp = misc;
  969.     fprintf(fp,"\n%sappend_trace(i)\nint i;\n{\n", prefix);
  970.     fprintf(fp,"\tstruct %strace *temp;\n\n\t", prefix);
  971.     fprintf(fp,"temp = (struct %strace *) %smyalloc (sizeof(struct %strace));\n", prefix, prefix, prefix);
  972.     fprintf(fp,"\ttemp->rule = i;\n\ttemp->next = NULL;\n");
  973.     fprintf(fp,"\tif(%strace_front){\n\t\t%strace_back->next = temp;\n", prefix, prefix);
  974.     fprintf(fp,"\t\t%strace_back = %strace_back->next;\n\t}\n", prefix, prefix);
  975.     fprintf(fp,"\telse %strace_front = %strace_back = temp;\n}\n\n", prefix, prefix);
  976. }
  977.  
  978.  
  979. gen_profile(n,d)
  980. int n,d;
  981. /* generate procedures and structures to generate profile */
  982. {
  983.     struct list *temp;
  984.     struct rule *r_temp;
  985.     FILE *fp;
  986.  
  987.     fp = profile;
  988.     temp = label_list;
  989.     fprintf(fp,"\nint %stest_profile[%d];\n\n", prefix, n);
  990.     fprintf(fp,"\nint %sfire_profile[%d];\n\n", prefix, d);
  991.     fprintf(fp,"char *%slabel_names[%d] = {\n", prefix, n);
  992.     while(temp){
  993.         fprintf(fp,"\t\"%s%s\"", prefix, temp->name);
  994.         if(temp->next)
  995.         fprintf(fp,",\n");
  996.         temp = temp->next;
  997.     }
  998.     r_temp = rule_list;
  999.     while(r_temp->next)
  1000.         r_temp = r_temp->next;
  1001.     fprintf(fp,"};\n\nchar *%srules[%d] = {\n\t\"\",\n", prefix, d);
  1002.     while(r_temp){
  1003.         fprintf(fp,"\t\"%s%s\"", prefix, r_temp->label);
  1004.         if(r_temp->prev)
  1005.         fprintf(fp,",\n");
  1006.         r_temp = r_temp->prev;
  1007.     }
  1008.     fprintf(fp,"};\n\n%sprint_profile()\n{\n", prefix);
  1009.     fprintf(fp,"\tint i, t;\n\n\tt = 0;\n\tprintf(\"\\nRules Tested\\n\");\n", n);
  1010.     fprintf(fp,"\tfor(i = 0; i < %d; i++){\n", n);
  1011.     fprintf(fp,"\t\tprintf(\"%cd",'%');
  1012.     fprintf(fp,"\\t%cs\\n\",%stest_profile[i],", '%', prefix);
  1013.     fprintf(fp," %slabel_names[i]);\n", prefix);
  1014.     fprintf(fp,"\t\tt += %stest_profile[i];\n\t}\n", prefix);
  1015.     fprintf(fp,"\tprintf(\"%cd\\n\", t);\n\tt = 0;\n", '%');
  1016.     fprintf(fp,"\tprintf(\"\\nRules Fired\\n\");\n", n);
  1017.     fprintf(fp,"\n\tfor(i = 1; i < %d; i++){\n", d);
  1018.     fprintf(fp,"\t\tprintf(\"%cd",'%');
  1019.     fprintf(fp,"\\t%cs\\n\",%sfire_profile[i],", '%', prefix);
  1020.     fprintf(fp," %srules[i]);\n", prefix);
  1021.     fprintf(fp,"\t\tt += %sfire_profile[i];\n\t}\n", prefix);
  1022.     fprintf(fp,"\tprintf(\"%cd\\n\", t);\n}\n", '%');
  1023. }
  1024.  
  1025.  
  1026. gen_zero(test,fire)
  1027. int test, fire;
  1028. /*
  1029. generate a procedure that will free or zero all data
  1030. structures generated by trc
  1031. */
  1032. {
  1033.     int i;
  1034.     FILE *fp;
  1035.     struct def_list *d_temp;
  1036.     struct data_type *dt_temp;
  1037.  
  1038.     fp = zero;
  1039.     if(profiling)
  1040.         fprintf(fp,"extern int %stest_profile[], %sfire_profile[];\n",prefix, prefix);
  1041.     fprintf(fp,"\n\n%szero()\n{\n\tint i;\n",prefix);
  1042.     if(backtracking)
  1043.         fprintf(fp,"\tstruct %sback_track_stack *b_temp;\n", prefix);
  1044.     /* pointer definitions */
  1045.     d_temp = token_list;
  1046.     while(d_temp){
  1047.         if(d_temp->data_types)
  1048.             fprintf(fp,"\tstruct %s%s_struct *%s_tmp;\n", prefix,d_temp->name,d_temp->name);
  1049.         d_temp = d_temp->next;
  1050.     }
  1051.     /* free struct lists */
  1052.     d_temp = token_list;
  1053.     while(d_temp){
  1054.         if(d_temp->data_types){
  1055.             fprintf(fp,"\twhile(%s%s_list[0]){\n", prefix,d_temp->name);
  1056.             fprintf(fp,"\t\t%s%s_list[1] = %s%s_list[0];\n", prefix,d_temp->name, prefix,d_temp->name);
  1057.             fprintf(fp,"\t\tfree_%s%s_struct(1);\n\t}\n", prefix,d_temp->name);
  1058.         }
  1059.         d_temp = d_temp->next;
  1060.     }
  1061.     /* free backtracking data */
  1062.     if(backtracking){
  1063.         fprintf(fp,"\twhile(%sbacktrack){\n", prefix);
  1064.         fprintf(fp,"\t\tb_temp = %sbacktrack;\n", prefix);
  1065.         fprintf(fp,"\t\t%sbacktrack = %sbacktrack->next;\n", prefix, prefix);
  1066.         d_temp = token_list;
  1067.         while(d_temp){
  1068.             if(d_temp->data_types){
  1069.                 fprintf(fp,"\t\t%s_tmp = b_temp->mark_%s;\n",d_temp->name,d_temp->name);
  1070.                 fprintf(fp,"\t\twhile(%s_tmp){\n",d_temp->name);
  1071.                 fprintf(fp,"\t\t\tb_temp->mark_%s = b_temp->mark_%s->next;\n",d_temp->name,d_temp->name);
  1072.             dt_temp = d_temp->data_types;
  1073.             while(dt_temp){
  1074.             if(dt_temp->type == 2)
  1075.                         fprintf(fp,"\t\t\tfree(%s_tmp->%s);\n",d_temp->name,dt_temp->name);
  1076.             dt_temp = dt_temp->next;
  1077.             }
  1078.                 fprintf(fp,"\t\t\tfree(%s_tmp);\n",d_temp->name);
  1079.                 fprintf(fp,"\t\t\t%s_tmp = b_temp->mark_%s;\n\t\t}\n",d_temp->name,d_temp->name);
  1080.             }
  1081.             d_temp = d_temp->next;
  1082.         }
  1083.         fprintf(fp,"\t\tfree(b_temp);\n");
  1084.         fprintf(fp,"\t}\n");
  1085.     }
  1086.     /* zero structure pointers */
  1087.     d_temp = token_list;
  1088.     while(d_temp){
  1089.         if(d_temp->data_types){
  1090.             fprintf(fp,"\tfor(i = 0; i < %s%s_max; i++)\n", prefix,d_temp->name);
  1091.             fprintf(fp,"\t\t%s%s_list[i] = %s%s_temp[i] = NULL;\n", prefix,d_temp->name, prefix,d_temp->name);
  1092.         }
  1093.         d_temp = d_temp->next;
  1094.     }
  1095.     /* zero integer arrays */
  1096.     fprintf(fp,"\tfor(i = 0; i < %d; i++)\n",total_tokens);
  1097.     fprintf(fp,"\t\t%stoken[i] = 0;\n", prefix);
  1098.     if(profiling){
  1099.         fprintf(fp,"\tfor(i = 0; i < %d; i++)\n",fire);
  1100.         fprintf(fp,"\t\t%sfire_profile[i] = 0;\n", prefix);
  1101.         fprintf(fp,"\tfor(i = 0; i < %d; i++)\n",test);
  1102.         fprintf(fp,"\t\t%stest_profile[i] = 0;\n", prefix);
  1103.     }
  1104.     /* zero trace list */
  1105.     if(tracing){
  1106.         fprintf(fp,"\twhile(%strace_front){\n", prefix);
  1107.         fprintf(fp,"\t\t%strace_back = %strace_front;\n", prefix, prefix);
  1108.         fprintf(fp,"\t\t%strace_front = %strace_front->next;\n", prefix, prefix);
  1109.         fprintf(fp,"\t\tfree(%strace_back);\n", prefix);
  1110.         fprintf(fp,"\t}\n\t%strace_back = NULL;\n", prefix);
  1111.     }
  1112.     fprintf(fp,"}\n");
  1113. }
  1114.  
  1115.  
  1116. trans_code(rule, list, fp, label)
  1117. /* translate references to objects in embedded C code */
  1118. struct rule *rule;
  1119. struct list *list;
  1120. FILE *fp;
  1121. char *label;
  1122. {
  1123.     struct match *m_temp;
  1124.     struct list *l_temp;
  1125.     int i, j;
  1126.     char c[512];
  1127.  
  1128.     l_temp = list;
  1129.     while(l_temp){
  1130.             i = 0;
  1131.             while(l_temp->name[i]){
  1132.             if(l_temp->name[i] == '$'){
  1133.                 i++; j = 0;
  1134.                 while(l_temp->name[i] != '.'){
  1135.                 c[j] = l_temp->name[i];
  1136.                 if(c[j] == '\0'){
  1137.                     fprintf(stderr,"cannot translate %s in rule %s\n",c, rule->label);
  1138.                     fprintf(stderr,"%s\n", l_temp->name);
  1139.                     return;
  1140.                 }
  1141.                 i++; j++;
  1142.                 }
  1143.                 i++;
  1144.                 c[j] = '\0';
  1145.                 m_temp = rule->complex;
  1146.                 if((strcmp(c, "FAIL")) == 0){
  1147.                 fprintf(fp,"{");
  1148.                 if(rule->recurs == 0)
  1149.                     fprintf(fp,"%srestore();\n", prefix);
  1150.                 fprintf(fp,"goto %s;}\n", label);
  1151.                 }
  1152.                 else{
  1153.                   while(m_temp && j){
  1154.                 if((strcmp(c, m_temp->free_name)) == 0){
  1155.                     fprintf(fp,"%s%s_", prefix , m_temp->object);
  1156.                     if(m_temp->empty)
  1157.                         fprintf(fp,"empty[%d].", m_temp->index);
  1158.                     else
  1159.                         fprintf(fp,"list[%d]->", m_temp->index);
  1160.                     j = 0;
  1161.                 }
  1162.                 m_temp = m_temp->next;
  1163.                   }
  1164.                   if(j){
  1165.                 fprintf(stderr,"cannot translate %s in rule %s\n",c, rule->label);
  1166.                 fprintf(stderr,"%s\n", l_temp->name);
  1167.                 return;
  1168.                   }
  1169.                 }
  1170.             }
  1171.             else{
  1172.                 fprintf(fp,"%c",l_temp->name[i]);
  1173.                 i++;
  1174.             }
  1175.             }
  1176.         fprintf(fp,"\n");
  1177.         l_temp = l_temp->next;
  1178.     }
  1179. }
  1180.  
  1181.  
  1182. translate()
  1183. /*
  1184. Produce the output code
  1185. */
  1186. {
  1187.     int i, j, k, l, count, prev_index, label_count;
  1188.     char s[512];
  1189.     struct list *l_temp;
  1190.     struct def_list *d_temp, *d_temp2;
  1191.     struct data_type *dt_temp;
  1192.     struct rule *r_temp, *r_temp2, *r_const;
  1193.     struct match *m_temp, *m_temp2, *m_temp3, *m_temp4;
  1194.     struct test *t_temp;
  1195.     struct list *label_temp;
  1196.     FILE *fp;
  1197.  
  1198.     fp = header;
  1199.     l_temp = header_code;
  1200.     while(l_temp){
  1201.         fprintf(fp,"%s\n",l_temp->name);
  1202.         l_temp = l_temp->next;
  1203.     }
  1204.     fprintf(fp,"\n#include\t<stdio.h>\n\n");
  1205.     d_temp = token_list;
  1206.     for(i = 0; i < total_tokens; i++)
  1207.         {
  1208.         fprintf(fp,"#define %s%s %d\n", prefix,d_temp->name, i);
  1209.         j = max_free[i];
  1210.         if(j <= 2) j = 2;
  1211.         fprintf(fp,"#define %s%s_max %d\n", prefix,d_temp->name, j);
  1212.         d_temp = d_temp->next;
  1213.     }
  1214.     fprintf(fp,"\n");
  1215.     fp = loop;
  1216.     fprintf(fp,"int %stotal_tokens = %d;\n", prefix,total_tokens);
  1217.     fprintf(fp,"int %stoken[%d];\n", prefix,total_tokens);
  1218.     if(profiling){
  1219.         fprintf(fp,"extern int %stest_profile[];\n", prefix);
  1220.         fprintf(fp,"extern int %sfire_profile[];\n", prefix);
  1221.     }
  1222.     d_temp = token_list;
  1223.     fprintf(fp,"char *%stoken_name[%d] = {\n", prefix,total_tokens);
  1224.     for(i = 0; i < total_tokens; i++)
  1225.     {
  1226.  
  1227.         fprintf(fp,"\t\t\t\042%s%s\042", prefix,d_temp->name);
  1228.         d_temp = d_temp->next;
  1229.         if(d_temp)
  1230.         fprintf(fp,",\n");
  1231.     }
  1232.     fprintf(fp,"};\n");
  1233.     fp = header;
  1234.     gen_structs();
  1235.     gen_test();
  1236.     if(backtracking){
  1237.         gen_back();
  1238.         gen_relink();
  1239.     }
  1240.     if(tracing)
  1241.         gen_trace();
  1242.     if(dumping)
  1243.         gen_print();
  1244.     gen_free();
  1245.     gen_restore();
  1246.     gen_search();
  1247.     gen_add();
  1248.     init_list = init_list2;
  1249.     gen_init(1);
  1250.     fp = loop;
  1251.     fprintf(fp,"\n%sloop()\n{\n\tint i;\n", prefix);
  1252.     fprintf(fp,"\twhile(1){\n%sStart:\n", prefix);
  1253.     if(profiling){
  1254.         label_list = (struct list *) malloc(sizeof(struct list));
  1255.         label_list->name = (char *) malloc(strlen(prefix) + 6);
  1256.         label_temp = label_list;
  1257.         label_count = 1;
  1258.         strcpy(label_list->name, prefix );
  1259.         strcat(label_list->name, "Start");
  1260.         fprintf(fp,"\t%stest_profile[0]++;\n", prefix);
  1261.     }
  1262.     r_temp = rule_list;
  1263.     while(r_temp->next != NULL)
  1264.         r_temp = r_temp->next;
  1265.     r_const = r_temp;
  1266.     while(r_temp){
  1267.  
  1268.         /* label of this rule */
  1269.         fprintf(fp,"%s%s:\n", prefix,r_temp->label);
  1270.  
  1271.         if(profiling){
  1272.             label_temp->next = (struct list *) malloc(sizeof(struct list));
  1273.         label_temp = label_temp->next;
  1274.             label_temp->name = (char *) malloc(strlen(prefix) + strlen(r_temp->label) + 1);
  1275.             strcpy(label_temp->name, prefix);
  1276.             strcat(label_temp->name, r_temp->label);
  1277.             fprintf(fp,"\t%stest_profile[%d]++;\n", prefix, label_count);
  1278.             label_count++;
  1279.         }
  1280.  
  1281.         /* test for code that must precede all tests */
  1282.         m_temp3 = NULL;
  1283.         m_temp = r_temp->complex;
  1284.         /* skip over empty definitions */
  1285.         while((m_temp) && (m_temp->empty)){
  1286.         m_temp3 = m_temp;
  1287.         m_temp = m_temp->next;
  1288.         }
  1289.         /* if the first non empty entry is c_code it must precede all tests */
  1290.           if(m_temp)
  1291.            if(m_temp->c_code){
  1292.         if(r_temp->prev)
  1293.             sprintf(s,"%s%s\0",prefix, r_temp->prev->label);
  1294.         else
  1295.             sprintf(s,"%sEnd\0",prefix);
  1296.         trans_code(r_temp, m_temp->c_code, fp, s);
  1297.         /* unlink the code so it isn't inserted twice */
  1298.         if(m_temp3)
  1299.             m_temp3->next = m_temp->next;
  1300.         else
  1301.             r_temp->complex = r_temp->complex->next;
  1302.         }
  1303.  
  1304.         /* test for object counts */
  1305.         fprintf(fp,"\t\tif(");
  1306.         d_temp = token_list;
  1307.         for(i = 0; i < total_tokens; i++){
  1308.         if(r_temp->search[i] > 0)
  1309.             fprintf(fp,"(%stoken[%s%s] >= %d) &&\n\t\t\t", prefix, prefix,d_temp->name,r_temp->search[i]);
  1310.         if(r_temp->search[i] < 0)
  1311.             fprintf(fp,"(%stoken[%s%s] <= 0) &&\n\t\t\t", prefix, prefix,d_temp->name);
  1312.         d_temp = d_temp->next;
  1313.         }
  1314.         d_temp = token_list;
  1315.         fprintf(fp,"1){");
  1316.  
  1317.         /* generate complex matching code */
  1318.  
  1319.         /* first initialize the current free variable matrix */
  1320.         for(i = 0; i < total_tokens; i++)
  1321.         current_free[i] = 1;
  1322.  
  1323.             m_temp = m_temp3 = r_temp->complex;
  1324.         prev_index = 0;
  1325.             while(m_temp){
  1326.          if(m_temp->c_code){
  1327.             if((prev_index == 0) || (r_temp->recurs == 0)){
  1328.                 if(r_temp->prev)
  1329.                     sprintf(s,"%s%s\0", prefix,r_temp->prev->label);
  1330.                 else
  1331.                     sprintf(s,"%sEnd\0", prefix);
  1332.             }
  1333.             else
  1334.             sprintf(s,"%s%s_%s_%d\0", prefix,
  1335.                 r_temp->label, m_temp3->object, prev_index);
  1336.             trans_code(r_temp, m_temp->c_code, fp, s);
  1337.          }
  1338.          else if(m_temp->empty){
  1339.              /* declaration only - don't generate any code */
  1340.              i = 0;
  1341.          }
  1342.          else{
  1343.          i = 0;
  1344.          d_temp = token_list;
  1345.          while(strcmp(m_temp->object, d_temp->name) != 0){
  1346.              i++;
  1347.              d_temp = d_temp->next;
  1348.          }
  1349.          if(d_temp->data_types){
  1350.           for(count = 0; count < m_temp->count; count++){
  1351.  
  1352.             /* initialize temp */
  1353.             fprintf(fp,"\n\t\t\t%s%s_temp[%d] = %s%s_list[0];\n"
  1354.             , prefix, m_temp->object, current_free[i], prefix, m_temp->object);
  1355.  
  1356.             /* print a label */
  1357.             if((r_temp->recurs) || (profiling)){
  1358.             fprintf(fp,"%s%s_%s_%d:\n", prefix, r_temp->label, m_temp->object, current_free[i]);
  1359.                 if(profiling){
  1360.                     label_temp->next = (struct list *) malloc(sizeof(struct list));
  1361.                 label_temp = label_temp->next;
  1362.                     label_temp->name = (char *) malloc(strlen(r_temp->label) + strlen(m_temp->object) + strlen(prefix) + 10);
  1363.                 sprintf(label_temp->name,"%s%s_%s_%d", prefix, 
  1364.                     r_temp->label, m_temp->object, current_free[i]);
  1365.                     fprintf(fp,"\t%stest_profile[%d]++;\n", prefix, label_count);
  1366.                     label_count++;
  1367.                 }
  1368.             }
  1369.  
  1370.             /* free the previously found item */
  1371.             if(r_temp->recurs){
  1372.             fprintf(fp,"\t\t\tif(%s%s_list[%d])\n", prefix, m_temp->object, current_free[i]);
  1373.             fprintf(fp,"\t\t\t\t%s%s_list[%d]->MARK = 0;\n", prefix, m_temp->object, current_free[i]);
  1374.             }
  1375.  
  1376.             /* do the search */
  1377.             fprintf(fp,"\t\t\tif((%s%s_list[%d] = search_%s%s_struct(%d"
  1378.            , prefix , m_temp->object, current_free[i], prefix, m_temp->object, current_free[i]);
  1379.             dt_temp = d_temp->data_types;
  1380.             while(dt_temp){
  1381.                 if(dt_temp->type <= 2){
  1382.                 t_temp = m_temp->tests;
  1383.                 j = 1;
  1384.                 while(j && t_temp){
  1385.                     if(strcmp(t_temp->element, dt_temp->name) == 0){
  1386.                     j = 0;
  1387.                     if((t_temp->type == 0) || (t_temp->type == 1))
  1388.                         fprintf(fp,", %s",t_temp->value);
  1389.                     if(t_temp->type == 2)
  1390.                         fprintf(fp,", \"%s\"",t_temp->value);
  1391.                     if(t_temp->type == -1){
  1392.                     if(t_temp->id)
  1393.                         fprintf(fp,", 0");
  1394.                     else{
  1395.                             l = 0;
  1396.                             m_temp2 = r_temp->complex;
  1397.                             while(m_temp2){
  1398.                             if(strcmp(m_temp2->free_name, t_temp->free_name) == 0){
  1399.                                 l = m_temp2->index;
  1400.                             m_temp4 = m_temp2;
  1401.                                 m_temp2 = NULL;
  1402.                             }
  1403.                             else
  1404.                                 m_temp2 = m_temp2->next;
  1405.                             }
  1406.                         if(m_temp4->empty)
  1407.                                 fprintf(fp,", %s%s_empty[%d].%s", prefix,m_temp4->object,l,t_temp->value);
  1408.                         else
  1409.                                 fprintf(fp,", %s%s_list[%d]->%s", prefix,m_temp4->object,l,t_temp->value);
  1410.                         }
  1411.                     }
  1412.                     fprintf(fp,", %d", t_temp->relop);
  1413.                         if(dt_temp->elts)
  1414.                     fprintf(fp,", %d",t_temp->id);
  1415.                     }
  1416.                     else
  1417.                     t_temp = t_temp->next;
  1418.                 }
  1419.                 if(j){
  1420.                     switch(dt_temp->type){
  1421.                     case 0: fprintf(fp,", 0, 7");
  1422.                         break;
  1423.                     case 1: fprintf(fp,", 0.0, 7");
  1424.                         break;
  1425.                     case 2: fprintf(fp,", \"\", 7");
  1426.                     default: break;
  1427.                     }
  1428.                     if(dt_temp->elts)
  1429.                     fprintf(fp,", 0");
  1430.                 }
  1431.                 }
  1432.                 dt_temp = dt_temp->next;
  1433.             }
  1434.             fprintf(fp,")) == NULL){\n");
  1435.             /* search failed on first of rule */
  1436.  
  1437.             if((prev_index == 0) || (r_temp->recurs == 0)){
  1438.                 fprintf(fp,"\t\t\t\t%srestore();\n", prefix);
  1439.                 if(r_temp->prev)
  1440.                     fprintf(fp,"\t\t\t\tgoto %s%s;\n\t\t\t}", prefix,r_temp->prev->label);
  1441.                 else
  1442.                     fprintf(fp,"\t\t\t\tgoto %sEnd;\n\t\t\t}", prefix);
  1443.             }
  1444.  
  1445.             /* search failed - not first of rule */
  1446.             else{
  1447.             fprintf(fp,"\t\t\t\tgoto %s%s_%s_%d;\n\t\t\t}", prefix,
  1448.                 r_temp->label, m_temp3->object, prev_index);
  1449.             }
  1450.  
  1451.             /* move index one beyond the one currently found */
  1452.             if(r_temp->recurs) fprintf(fp,"\n\t\t\t%s%s_temp[%d] = %s%s_list[%d]->next;", prefix,
  1453.                 m_temp->object, current_free[i], prefix,
  1454.                 m_temp->object, current_free[i]);
  1455.  
  1456.             m_temp3 = m_temp;
  1457.             prev_index = current_free[i];
  1458.             current_free[i]++;
  1459.            }
  1460.           }
  1461.          }
  1462.          m_temp = m_temp->next;
  1463.             }
  1464.  
  1465.         /* get rule number for next 3 statements */
  1466.  
  1467.         i = 1;
  1468.         r_temp2 = r_const;
  1469.         while(r_temp != r_temp2){
  1470.             r_temp2 = r_temp2->prev;
  1471.             i++;
  1472.         }
  1473.  
  1474.         /* generate profile code if profiling */
  1475.  
  1476.         if(profiling){
  1477.             fprintf(fp,"\n\t\t\t%sfire_profile[%d]++;", prefix, i);
  1478.         }
  1479.  
  1480.         /* generate append code if tracing */
  1481.  
  1482.         if(tracing){
  1483.             fprintf(fp,"\n\t\t\t%sappend_trace(%d);", prefix, i);
  1484.         }
  1485.  
  1486.         /* generate insert code if backtracking */
  1487.  
  1488.         if(backtracking){
  1489.             fprintf(fp,"\n\t\t\t%sinsert_backtrack(%d);", prefix, i);
  1490.         }
  1491.  
  1492.         /* generate ADD code */
  1493.  
  1494.         fprintf(fp,"\n");
  1495.         init_list = r_temp->add;
  1496.         gen_init(0);
  1497.  
  1498.         /*
  1499.         generate MARK code
  1500.         */
  1501.         /* first MARK objects deleted by name */
  1502.         m_temp = r_temp->complex;
  1503.         while(m_temp){
  1504.         if(m_temp->mark){
  1505.             if(backtracking)
  1506.                 fprintf(fp,"\n\t\t\t\t%srelink_%s_struct(%d);", prefix,m_temp->object, m_temp->index);
  1507.             else{
  1508.             d_temp = token_list;
  1509.             while(strcmp(m_temp->object, d_temp->name))
  1510.                 d_temp = d_temp->next;
  1511.             if(d_temp->data_types)
  1512.                     fprintf(fp,"\n\t\t\t\tfree_%s%s_struct(%d);", prefix,m_temp->object, m_temp->index);
  1513.             else
  1514.                     fprintf(fp,"\n\t\t\t\t%stoken%s[%s]--;", prefix, prefix,d_temp->name);
  1515.             }
  1516.         }
  1517.         m_temp = m_temp->next;
  1518.         }
  1519.  
  1520.         /* now MARK the rest of the objects */
  1521.         d_temp = token_list;
  1522.         for(i = 0; i < total_tokens; i++){
  1523.         if(r_temp->mark[i]){
  1524.             fprintf(fp,"\n\t\t\tfor(i = 0; i < %d; i++)",r_temp->mark[i]);
  1525.             if(backtracking)
  1526.                 fprintf(fp,"\n\t\t\t\t%srelink_%s_struct(1);", prefix,d_temp->name);
  1527.             else{
  1528.             if(d_temp->data_types)
  1529.                     fprintf(fp,"\n\t\t\t\tfree_%s%s_struct(1);", prefix,d_temp->name);
  1530.             else
  1531.                     fprintf(fp,"\n\t\t\t\t%stoken[%s%s]--;", prefix, prefix,d_temp->name);
  1532.             }
  1533.         }
  1534.         d_temp = d_temp->next;
  1535.         }
  1536.         d_temp = token_list;
  1537.  
  1538.         fprintf(fp,"\n\t\t\t%srestore();", prefix);
  1539.  
  1540.         l_temp = r_temp->c_code;
  1541.         trans_code(r_temp, l_temp, fp);
  1542.         if(find_name(r_temp->opt))
  1543.             fprintf(fp,"\t\t\tgoto %s%s;\n\t\t}\n", prefix, r_temp->opt);
  1544.         else
  1545.             fprintf(fp,"\t\t\tgoto %sStart;\n\t\t}\n", prefix);
  1546.         r_temp = r_temp->prev;
  1547.     }
  1548.     fprintf(fp,"\n%sEnd:\n", prefix);
  1549.  
  1550.         if(profiling){
  1551.             label_temp->next = (struct list *) malloc(sizeof(struct list));
  1552.         label_temp = label_temp->next;
  1553.             label_temp->name = (char *) malloc(strlen(prefix) + 4);
  1554.             strcpy(label_temp->name, prefix);
  1555.             strcat(label_temp->name, "End");
  1556.             fprintf(fp,"\t%stest_profile[%d]++;\n", prefix, label_count);
  1557.             label_count++;
  1558.         }
  1559.  
  1560.     if(tracing){
  1561.         i = 1;
  1562.         r_temp2 = r_const;
  1563.         while(r_temp2){
  1564.             r_temp2 = r_temp2->prev;
  1565.             i++;
  1566.         }
  1567.         fprintf(fp,"\t\t\t%sappend_trace(%d);\n", prefix,i);
  1568.     }
  1569.     if(backtracking){
  1570.         fprintf(fp,"\t\t\tif(%sbacktrack){\n", prefix);
  1571.         fprintf(fp,"\t\t\t\ti = %sbacktrack->next_rule;\n", prefix);
  1572.         fprintf(fp,"\t\t\t\t%sbackup();\n", prefix);
  1573.         fprintf(fp,"\t\t\t\tswitch(i){\n");
  1574.         i = 1;
  1575.         r_temp2 = r_const;
  1576.         while(r_temp2){
  1577.             fprintf(fp,"\t\t\t\t\tcase %d: goto ", i);
  1578.             if(r_temp2->prev)
  1579.                 fprintf(fp,"%s%s;\n", prefix, r_temp2->prev->label);
  1580.             else
  1581.                 fprintf(fp,"%sEnd;\n", prefix);
  1582.             r_temp2 = r_temp2->prev;
  1583.         i++;
  1584.         }
  1585.         fprintf(fp,"\t\t\t\t\tdefault: goto %sEnd;", prefix);
  1586.         fprintf(fp,"\n\t\t\t\t}\n\t\t\t}\n");
  1587.     }
  1588.     fprintf(fp,"\t\t\treturn(1);\n\t}\n}\n");
  1589.     l_temp = trailer_code;
  1590.     while(l_temp){
  1591.         fprintf(fp,"%s\n",l_temp->name);
  1592.         l_temp = l_temp->next;
  1593.     }
  1594.  
  1595.         i = 0;
  1596.         r_temp2 = r_const;
  1597.         while(r_temp2){
  1598.             r_temp2 = r_temp2->prev;
  1599.             i++;
  1600.         }
  1601.     if(profiling)
  1602.         gen_profile(label_count, i+1);
  1603.     if(zeroing)
  1604.         gen_zero(label_count, i+1);
  1605.     if(saving)
  1606.         gen_save(label_count, i+1);
  1607. }
  1608.  
  1609.