home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1995 April / Internet Tools.iso / infoserv / www / ncsa / tools / gsql / gsql.c.Z / gsql.c
Encoding:
C/C++ Source or Header  |  1994-06-26  |  19.5 KB  |  876 lines
  1. /*
  2. *
  3. * GSQL - a Mosaic gateway to SQL applications.
  4. * 
  5. * Jason Ng, NCSA, 
  6. * University of Illinois Urbana-Champaign 
  7. * 1994
  8. * 
  9. * This is public domain software. There is one requirement: if you use this
  10. * software, you should include a link in your forms or documents that
  11. * would mention GSQL and NCSA, and would point to the Tutorial on GSQL,
  12. * ie http://www.ncsa.uiuc.edu/SDG/People/jason/pub/gsql/starthere.html
  13. * 
  14. * */
  15.  
  16.  
  17. #include <string.h>
  18. #include <stdio.h>
  19.  
  20. #define SELECTKEYWORD "SELECT"
  21.  
  22. static int dbg = 0;
  23. static int dd  = 0;
  24.  
  25. static char *sqlprogram = NULL;
  26.  
  27. static FILE * fstream = NULL; /* procfile file descriptor */
  28.  
  29. #define NM 101
  30. #define NITEMS 2010
  31. static int nmenus = 0;
  32. static char *menuvname[NM];
  33. static char *menutitle[NM];
  34. static char *mitem[NITEMS][NM];
  35. static int nitems[NM];
  36. static int menutype[NM];
  37.  
  38. #define M_BUTTON   0
  39. #define M_FIELD    1
  40. #define M_SCROLL   2
  41. #define M_PULLDOWN 3
  42. #define M_RADIO    4
  43. #define M_BUTTONSET 5
  44.  
  45. static int g_widgettypes[] =
  46. { M_FIELD, M_BUTTON, M_SCROLL, M_PULLDOWN, M_RADIO, M_BUTTONSET };
  47. static char *g_widgetnames[] =
  48. { "FIELD", "BUTTON", "SCROLL", "PULLDOWN", "RADIO", "BUTTONSET" };
  49. #define g_ndefwidtypes (sizeof(g_widgettypes)/sizeof(int))
  50.  
  51. #define LLEN 5000
  52. newmenu(title, vname,type) char *title, *vname; char *type;
  53. {
  54.   int i,t, id;
  55.   char mtype[50];
  56.   /* fprintf(stderr, "NEWMENU [%s] [%s] type [%s]\n", title, vname, type);  */
  57.  
  58.   sscanf(type,"%s", mtype);
  59.   for(t=-1, i=0;i<g_ndefwidtypes;i++) 
  60.     if(!strcmp(mtype,g_widgetnames[i])) { t = g_widgettypes[i]; break; }
  61.  
  62.   if(t==-1) return(-1);
  63.  
  64.   menuvname[nmenus] = strdup(vname);
  65.   menutitle[nmenus] = strdup(title);
  66.   menutype[nmenus] = t;
  67.   nitems[nmenus] = 0;
  68.   id = nmenus; nmenus++;
  69.   return(id);
  70. }
  71.  
  72. addmenuitem(id, itemname) int id; char *itemname;
  73. {
  74.   int n = nitems[id];
  75.    /* fprintf(stderr,"added [%s] ",itemname);  */
  76.   mitem[n][id] = strdup(itemname);
  77.   nitems[id]++;
  78. }
  79.  
  80. makeform () {
  81.   int a;
  82.   char buf[LLEN];
  83.  
  84.   printf("<H1> New Mosaic-SQL interface </H1> <HR>\n");
  85.   if (getdirective("HEADING", buf))  
  86.       printf("%s\n",buf);
  87.   else
  88.       printf("<H1> Type-2 SQL Forms <H2>\n",buf);
  89.  
  90.   printf("<FORM>\n");
  91.   for (a=0; a< (int) getitemcount(); a++) {
  92.       int itemid;
  93.       char type[10];
  94.      fetchitem (a , type, &itemid);
  95.       if (!strcmp(type,"TEXT"))
  96.          displaytext(itemid);
  97.       else if (!strcmp(type,"MENU"))
  98.          displaymenu(itemid);
  99.       else if (!strcmp(type,"EXEC")) {
  100.             getscript(itemid, buf);
  101.          execscript (buf);
  102.             }
  103.       }
  104.   printf(" <p> <INPUT TYPE=\"submit\" VALUE=\"Doit!\"> <P>\n");
  105.   printf("</FORM>\n");
  106.  
  107.  if (dbg)  showmenus(); 
  108. }
  109.  
  110. /* displays the menu specified by id - index into the menu structure */
  111. displaymenu(id) int id;
  112. {
  113.       int j, maxsize;
  114.       printf("<p> %s ", menutitle[id]);
  115.      if     (menutype[id]==M_FIELD ) { /* input field */
  116.         printf(" <INPUT NAME=\"%s\">\n", menuvname[id]);
  117.      }
  118.      else if (menutype[id]==M_BUTTON) { /* toggle button */
  119.         printf("<INPUT TYPE=\"checkbox\" NAME=\"%s\" > \n", 
  120.                  menuvname[id]);
  121.      }
  122.      else if (menutype[id]==M_BUTTONSET || menutype[id]==M_RADIO) { /* buttons */
  123.        for(j=0;j<nitems[id];j++) {
  124.          if(menutype[id]==M_BUTTONSET)
  125.             printf("<INPUT TYPE=\"checkbox\" NAME=\"%s\" VALUE=\"%s\"> %s\n", 
  126.                  menuvname[id], mitem[j][id] , mitem[j][id]);
  127.          else if(menutype[id]==M_RADIO)
  128.             printf("<INPUT TYPE=\"radio\" NAME=\"%s\" VALUE=\"%s\"> %s\n", 
  129.                  menuvname[id], mitem[j][id] , mitem[j][id]);
  130.         }
  131.      }
  132.      else if (menutype[id]==M_SCROLL || menutype[id]==M_PULLDOWN) { /* menus */
  133.        maxsize  = nitems[id] -1 ; if (maxsize<2) maxsize=2;
  134.        if(menutype[id]==M_SCROLL)
  135.           printf("<SELECT NAME=\"%s\" MULTIPLE>\n", menuvname[id], maxsize);
  136.        else if(menutype[id]==M_PULLDOWN)
  137.           printf("<SELECT NAME=\"%s\">\n", menuvname[id]);
  138.        for(j=0;j<nitems[id];j++) {
  139.              if(j==0)
  140.                printf(" <OPTION SELECTED>  %s\n", mitem[j][id]);
  141.              else
  142.                 printf(" <OPTION>  %s\n", mitem[j][id]);
  143.             }
  144.        printf("</SELECT><p>\n");
  145.           }
  146. }
  147.  
  148. showmenus() {
  149.   int i,j;
  150.   fprintf(stderr,"SHOWALL\n");
  151.   for(i=0;i<nmenus;i++) {
  152.     fprintf(stderr, "MENU title [%s] [%s][%d]\n", 
  153.                         menutitle[i],menuvname[i], menutype[i]);
  154.      for(j=0;j<nitems[i];j++) {
  155.          fprintf(stderr, "\t [%s]\n", mitem[j][i]);
  156.         }
  157.     }
  158. }
  159.  
  160. /* ARGS: arg[1] = procfilename 
  161.          arg[2-..] user inputs from form output 
  162.             Minimally, procfilename is needed.
  163. */
  164. main(ac,av) int ac; char**av; {
  165.  
  166.  int i;
  167.  char * procfilename;
  168.  
  169.  printf("Content-type: text/html \n\n");
  170.  
  171.  /*
  172.  printf("NEW STUFF "); fflush(stdout);
  173.  printf("NARGS %d \n", ac); if (ac>3) { printf(" SHOULD BE 3 <p>"); }
  174.  for(i=0;i<ac;i++) { printf("<b>%d</b> [%s]\n", i,av[i]); } printf("<p>");
  175.  */
  176.  
  177.  if(ac<2) {
  178.      printf("Usage: %s procfilename user-inputs...\n",av[0]); 
  179.      exit(0); 
  180.      }
  181.  else if(ac==2) { 
  182.       procfilename = av[1];
  183.      parsefile1(procfilename);
  184.      makeform();
  185.      exit(0);
  186.       }
  187.   else {
  188.      char buf[LLEN];
  189.      procfilename = av[1];
  190.      combineargs(ac,av,buf);
  191.      /* printf("AFTER COMBINE args is <pre><tt> [%s]</tt></pre> \n", buf); */ 
  192.     parseinputs(buf); /* buf: "v1=n1&v2=b2&...&vx=bx", b's can be empty */
  193.  
  194.     parsefile2(procfilename);
  195.      mergeall();
  196.    }
  197.  }
  198.  
  199.  
  200.  combineargs(ac,av,buf) 
  201.  int ac;
  202.  char *av[], *buf;
  203.  {
  204.     int i;
  205.  
  206.      /* av[1] is the procfilename - skip over */
  207.      if(ac<3) return;
  208.     strcpy(buf,av[2]);
  209.      for(i=3;i<ac;i++) {
  210.       strcat(buf,av[i]);
  211.          }
  212.  }
  213.  
  214.  /* data structure to receive user inputs - conv to name-value pairs */
  215. #define NU 200
  216.  static char *u_vname[NU];
  217.  static char *u_vval[NU];
  218.  static int  u_vspecial[NU]; /* 1 if that varname starts with "_" */
  219.  static int  n_u = 0;
  220.  
  221.  
  222.  parseinputs (inbuf) char *inbuf;
  223.  {
  224.     char *s, *s1=inbuf;
  225.     char *headv, *tailv;
  226.     int i;
  227.  
  228.     for(i=0;i<NU;i++) { /* init */
  229.       u_vname[i]    = u_vval[i] = NULL;
  230.       u_vspecial[i] = 0;
  231.       }
  232.  
  233.     i = 0;
  234.     printf("<pre>");
  235.    while(NULL!=( s = strtok(s1,"&"))) {
  236.        {{
  237.         char *b1, *b2;
  238.         b1 = strchr(s,'='); if(b1==NULL) continue;
  239.         *b1 = '\0';
  240.         headv = strdup(s);
  241.         b1++;
  242.         if(b1) tailv = strdup(b1); 
  243.        }}
  244.        if(headv[0]=='_') u_vspecial[i] = 1; 
  245.        u_vname[i] = strdup(headv);
  246.        u_vval[i]  = strdup(tailv);
  247.        if(dd) { printf(" <li> userinput [%s] [%s]",u_vname[i], u_vval[i]);
  248.                  if (u_vspecial[i] ) printf(" <b> special </b>\n");
  249.                     }
  250.        i++;
  251.       s1=NULL;
  252.        }
  253.     n_u = i;
  254.  
  255.    printf("</pre>");
  256.  }
  257.  
  258. /* parses only display and exec directives */
  259. parsefile1 (filename) char *filename; 
  260. {
  261.  char buf[LLEN];
  262.  char title[LLEN];
  263.  char vname[LLEN];
  264.  int id;
  265.  
  266.  if (NULL == (fstream= fopen(filename,"r"))) {
  267.      printf("parsefile1: Cannot open procfile [%s]\n", filename); 
  268.      exit(0);
  269.      }
  270.  
  271.  while( getword(buf)) {
  272.     if (buf[0]=='#') {  /* comment - ignore */
  273.       flushline(); 
  274.       }
  275.     else if (!strcmp(buf,"TEXT")) {
  276.       getline(buf);
  277.       id = savetext(buf);
  278.       registeritem ("TEXT", id);
  279.       }
  280.     else if (!strcmp(buf,"HEADING")) {
  281.       getline(buf);
  282.       savedirective("HEADING", buf);
  283.       }
  284.     else if (!strcmp(buf,"SHOW")) {
  285.       getword(vname);
  286.       if (dbg) fprintf(stderr,"VARIABLE [%s]\n", vname);
  287.       getword(buf);
  288.       getquotedline(title); 
  289.  
  290.       getline(buf); 
  291.       id = newmenu(title,vname, buf);
  292.       makemenu (id, buf);
  293.       registeritem ("MENU", id);
  294.  
  295.       }
  296.     else if (!strcmp(buf,"EXEC")) {
  297.       getline(buf);
  298.       id = savescript(buf);
  299.       registeritem ("EXEC", id);
  300.      }
  301.    }
  302.   fclose (fstream);
  303.  }
  304.  
  305. /* will scan to last semi-colon, and truncate the rest of line */
  306. getline(ss) char*ss;
  307. {
  308.       char *sp, sbuf[LLEN];
  309.  
  310.       ss[0] ='\0';
  311.       while(1) {
  312.         if (NULL==fgets(sbuf,LLEN,fstream)) { 
  313.               return(0); 
  314.               }
  315.          if(sbuf[0] =='#') {
  316.               if(dbg) fprintf(stderr," found comment [%s]\n", sbuf);
  317.               continue;  /* ignore comment, get another line  */
  318.               }
  319.          sp = strrchr(sbuf,';');
  320.          if (sp) { /* found semicolon - concat and return  */ 
  321.               sp[0] = '\0'; /* chop off rest of line */
  322.              strcat(ss,sbuf);
  323.              return(1);
  324.              }
  325.         /* semicolon not found, concat and get more lines */
  326.              strcat(ss,sbuf);
  327.         }
  328. }
  329.  
  330. /* look for and return the next quoted string "xxx"  */
  331. getquotedline(ss) char*ss;
  332. {
  333.       char  sbuf[LLEN], *sp = sbuf;
  334.       int c;
  335.  
  336.       ss[0] ='\0';
  337.  
  338.       while (EOF != (c = fgetc(fstream)) ) {
  339.             if (c== '\"')  /* opening quote */
  340.                 break;
  341.             }
  342.  
  343.       while (EOF != (c = fgetc(fstream)) ) {
  344.  
  345.             if (c== '\"') { /* closing quote */
  346.                *sp++ = '\0';
  347.                 strcpy(ss,sbuf);
  348.                 return(1);
  349.                 }
  350.             else {
  351.                *sp++ = c; 
  352.                }
  353.          }
  354. }
  355.  
  356. flushline() { /* throw away rst of line in input stream */
  357.     char  sbuf[LLEN];
  358.    fgets(sbuf,LLEN,fstream);
  359.     }
  360.  
  361. getword(ss) char*ss;
  362. {
  363. char *sp;
  364. char sbuf[LLEN];
  365.  
  366. if( EOF== fscanf(fstream,"%s",sbuf) ) return(0);
  367.  
  368. if (sp = strrchr(sbuf,';')) { *sp = '\0';  } /* remove semicolon */ 
  369.  
  370. sscanf(sbuf,"%s", ss);
  371. return(1); 
  372. }
  373.  
  374.  
  375. /* for each item, need to remove leading and trailing blanks */ 
  376. /* Note that mline  must have a first word of the menu type keyword */ 
  377. makemenu (menuid, mline ) int menuid; char *mline ; {
  378. #define PATTERN  ","
  379.  
  380.  char *s, *s1;
  381.  char *zz = mline;
  382.  
  383.  /* skip past first word  */
  384.   while( zz && isspace(*zz) ) { zz++; }  if (zz==NULL) return; 
  385.   while( zz && !isspace(*zz) ) { zz++; }  if (zz==NULL) return; 
  386.  
  387.  if (dbg) fprintf(stderr,"DOIT rest ID %d[%s]\n", menuid, zz);
  388.  
  389.  if (NULL!=(s1 = strstr(zz,"EXEC"))) {
  390.     FILE *f;
  391.     char buf[LLEN];
  392.     execcommand((s1+4), &f); 
  393.     while(NULL!=fgets(buf, LLEN, f)){
  394.       addmenuitem(menuid, buf);
  395.       }
  396.    fclose(f);
  397.     return;
  398.     }
  399.  
  400.  s1=zz;
  401.  while(NULL!=( s = strtok(s1,PATTERN))) {
  402.     chopblanks(&s);
  403.     addmenuitem(menuid, s);
  404.    s1=NULL;
  405.  }
  406.  
  407. }
  408. chopblanks(ss) char **ss;
  409. {
  410.   char *sp = *ss;
  411.   int n;
  412.   while(isspace(*sp) ) sp++;
  413.   *ss = sp;
  414.   
  415.   sp = *ss;
  416.   n = strlen(*ss);
  417.   sp = *ss+(n-1);
  418.   while(isspace(*sp)) { *sp = '\0'; sp--; }
  419.     
  420. }
  421.  
  422. /* ================================================================== */
  423. /* list of graphic objects */
  424. #define NOBJ 200
  425. static int obj_ref[NOBJ]; /* actually a unique reference int */ 
  426. static int obj_type[NOBJ]; /* t - text, m - menu, e -exec */
  427. static int n_obj = 0;
  428.  
  429. /* rets its ordering , or -1 if error */
  430. int registeritem(type, ref) char *type; int ref;
  431. {
  432.     int t , n;
  433.  
  434.    if (!strcmp(type,"TEXT")) {
  435.         t = 't';
  436.         }
  437.    else if (!strcmp(type,"MENU")) {
  438.         t = 'm';
  439.         }
  440.    else if (!strcmp(type,"EXEC")) {
  441.         t = 'e';
  442.         }
  443.    else { return(-1); }
  444.  
  445.     n = n_obj;
  446.     obj_ref[n]  = ref;
  447.     obj_type[n] = t;
  448.     n_obj++;
  449.     return (n);
  450. }
  451.  
  452. getitemcount() { return (n_obj); }
  453.  
  454. fetchitem (which, type, ref )
  455. int which; /* its ordering as ret from registeritem() */
  456. int  *ref; /* output */
  457. char *type; /* output */
  458. {
  459.    *ref = obj_ref[which];
  460.    switch (obj_type[which]) {
  461.         case 't': strcpy(type,"TEXT"); break;
  462.         case 'm': strcpy(type,"MENU"); break;
  463.         case 'e': strcpy(type,"EXEC"); break;
  464.         default : strcpy(type,"NONE"); return(0);  break;
  465.         }
  466.    return(1);
  467.         
  468. }
  469.  
  470. /* ================================================================== */
  471. /* storage for user's scripts and executables */
  472. #define NEX 80
  473. static char * d_ex[NEX];
  474. static int   n_ex  = 0;
  475.  
  476. /* rets id of script , else -1 */
  477. int savescript(ex) char *ex;
  478. {
  479.   int id;
  480.   d_ex[n_ex] = strdup ( ex );
  481.   id = n_ex;  n_ex++; 
  482.   return (id);
  483. }
  484.  
  485. getscript (id, ex) int id; char *ex;
  486. {
  487.   strcpy(ex, d_ex[id] );
  488. }
  489. execscript (ex) char *ex;
  490. {
  491.   char tfile[500];
  492.   char buf[LLEN];
  493.   FILE *f;
  494.  
  495.   tmpnam(tfile);
  496.   sprintf(buf, "%s > %s ", ex, tfile);
  497.  
  498.   system( buf );
  499.   f = fopen(tfile,"r");
  500.   if(f==NULL) { printf("cannot open %s \n", tfile); return; }
  501.  
  502.   while(NULL!= fgets(buf, LLEN, f)) printf("%s",buf);
  503.   fclose(f);
  504. }     
  505.  
  506. execcommand (ex,fhandle) char *ex; FILE **fhandle;
  507. {
  508.   char tfile[500];
  509.   char buf[LLEN];
  510.   FILE *f;
  511.  
  512.  
  513.   tmpnam(tfile);
  514.   sprintf(buf, "%s > %s ", ex, tfile);
  515.  
  516.   system( buf );
  517.   f = fopen(tfile,"r");
  518.   if(f==NULL) { printf("cannot open %s \n", tfile); *fhandle = NULL; return; }
  519.   *fhandle = f;
  520.  
  521. }
  522.  
  523. /* ================================================================== */
  524. /* storage for user's text */
  525. #define NTXT 80
  526. static char * d_text[NTXT];
  527. static int   n_txt = 0;
  528.  
  529. /* rets id of text, else -1 */
  530. int savetext(text) char *text;
  531. {
  532.   int id;
  533.   d_text[n_txt] = strdup ( text);
  534.   id = n_txt;  n_txt++; 
  535.   return (id);
  536. }
  537.  
  538. gettext (id, text) int id; char *text;
  539. {
  540.   strcpy(text, d_text[id] );
  541. }
  542. displaytext ( id) int id;
  543. {
  544.   char text[LLEN];
  545.   gettext(id, text);
  546.   printf("%s", text);
  547. }
  548.  
  549. /* ================================================================== */
  550. /* defines from DEFINE */
  551. /* sql directives and the expansion */
  552.  
  553. /* general sql directives */
  554. static char * d_cmd[] = { "FROMLIST", "SELECTLIST", "WHERELIST", "SORTLIST", "HEADING" };
  555. #define NW   ( sizeof(d_cmd)/sizeof(char *) )
  556. static char * d_mean[NW];
  557. static int   n_cmd = NW;
  558.  
  559. /* defines from DEFINE */
  560. #define MDEF 40
  561. static char * d_defvar[MDEF];
  562. static char * d_defval[MDEF];
  563. static int n_def = 0;
  564.  
  565. /* variables from SUB */
  566. #define NV 200
  567. static char * var_name[NV];
  568. static char * var_mean[NV];
  569. static char * var_kind[NV]; /* what list it's part of eg SELECT or WHERE */
  570. static char * var_fmt[NV]; /* string to format output as */
  571. static int   var_used[NV]; /* 1 if has user input */
  572. static int n_var = 0;
  573.  
  574. parsefile2 (filename) char *filename; 
  575. {
  576.  char buf[LLEN], tbuf[LLEN];
  577.  char vname[LLEN];
  578.  int id, i;
  579.  
  580.  if (NULL == (fstream= fopen(filename,"r"))) {
  581.      printf("parsefile2: Cannot open procfile [%s]\n", filename); 
  582.      exit(0);
  583.      }
  584.  
  585. for(i=0;i<NW;i++) {  d_mean[i] = NULL; }
  586.  
  587. for(i=0;i<NV;i++) { /* init */
  588.   var_name[i] = var_mean[i] = var_kind[i] = NULL; 
  589.   var_used[i] = 0;
  590.   var_fmt[i] = NULL;
  591.   }
  592.  
  593.  printf("<PRE>");
  594.  while( getword(buf)) {
  595.     if (buf[0]=='#') { 
  596.       if(dbg) fprintf(stderr,"comment word [%s]\n", buf);
  597.       flushline(); 
  598.     }
  599.     else if (!strcmp(buf,"HEADING")) {
  600.       getline(buf);
  601.       savedirective("HEADING", buf);
  602.       }
  603.     else if (!strcmp(buf,"SUB")) {
  604.       getword(vname); 
  605.       var_name[n_var] = strdup(vname);
  606.       getword(buf); /* kind */
  607.       var_kind[n_var] = strdup(buf);
  608.       getword(buf); /* AS */
  609.       getline(buf); /* meaning */
  610.       var_mean[n_var] = strdup(buf);
  611.       if(dd) printf("<li> FILE VAR [%s] [%s] [%s] \n", 
  612.                     var_name[n_var], var_kind[n_var], var_mean[n_var]);
  613.       n_var++;
  614.       }
  615.     else if (!strcmp(buf,"SQLPROG")) {
  616.         getline(tbuf);
  617.         sqlprogram = strdup(tbuf);
  618.         }
  619.     else if (!strcmp(buf,"DEFINE")) {
  620.        getword(tbuf);
  621.         sscanf(tbuf,"%s",buf);
  622.        d_defvar[n_def] = strdup(buf);
  623.        getline(tbuf);
  624.         sscanf(tbuf,"%s",buf);
  625.        d_defval[n_def] = strdup(buf);
  626.        if(dd) printf("<li> usrdefine [%s] [%s]\n", d_defvar[n_def], d_defval[n_def]);
  627.        n_def++;
  628.       }
  629.     else { /* save if is a sql directive */
  630.        getline(tbuf);
  631.         savedirective (buf, tbuf);
  632.  
  633.         }
  634.   }
  635.  printf("</PRE>");
  636.   fclose (fstream);
  637. }
  638.  
  639. /* ------------------------------------------------------------------ */
  640. /* returns the meaning of a SUB variable */
  641. lookupmean (var, meaning) char *var, *meaning;
  642. {
  643.     int i;
  644.    for (i=0;i<n_var;i++) 
  645.         if (!strcmp(var, var_name[i])) {
  646.           strcpy(meaning, var_mean[i]);
  647.           return(1);
  648.           }
  649.    return(0);        
  650. }
  651. /* ------------------------------------------------------------------ */
  652. /* updates the var_xxx structures with info from user */
  653. /* doesn't account for duplicate vars for now */
  654.  
  655. mergeall() 
  656. {
  657.    
  658.     int i, j, t, num;
  659.     char *vname;
  660.     char buf[LLEN]; /* contains all matches (comma-separated) for a variable */
  661.     int match[200], nm;
  662.     char sqlstr[LLEN];
  663.  
  664.     /* -- sub user inputs in the variables --- */
  665.     /* some vars (arrays) can have multiple userinput values */
  666.    for (i=0;i<n_var;i++) {
  667.         vname = var_name[i];
  668.         for (nm=0, t=0; t<n_u; t++) {
  669.           if (!strcmp(vname, u_vname[t])) {
  670.                  if (strlen(u_vval[t])>0) { /* don't bother if empty value */
  671.                    var_used[i] = 1;
  672.                    match[nm] = t; nm++;
  673.                    }
  674.                  }
  675.             }
  676.         if (nm>0) { /* build the match string */
  677.             buf[0]='\0';
  678.            for (j=0;j<nm;j++) {
  679.                 t = match[j];
  680.               if (u_vspecial[t]) { /* look up its meaning */
  681.                     char tbuf[LLEN];
  682.                     if (!lookupmean (u_vval[t], tbuf)) {
  683.                         strcpy(tbuf,"Undefined"); 
  684.                         printf("<li>UNDEFINED [%s]\n", u_vval[t]);
  685.                         }
  686.                else {
  687.                      if (j!=0) strcat(buf, ",");
  688.                     strcat(buf, tbuf);
  689.                     }
  690.                   }
  691.             else { /* just use the input */
  692.                    if (j!=0) strcat(buf, ",");
  693.                   strcat(buf, u_vval[t]);
  694.                }
  695.             }
  696.            substitute(&var_mean[i], buf);
  697.          }
  698.       }
  699.  
  700.   /* --- build the sql string from the pieces ---  */
  701.  
  702.      sqlstr[0] ='\0';
  703.      strcat (sqlstr," \" " );
  704.      strcat( sqlstr, SELECTKEYWORD);
  705.  
  706.        num = 0;
  707.      if( getdirective("SELECTLIST", buf)) {
  708.        strcat(sqlstr,  buf );
  709.          num = 1;
  710.         }
  711.     for (i=0;i<n_var;i++) {
  712.         if (var_used[i]) { 
  713.               if (!strcmp(var_kind[i],"SELECTLIST")) {
  714.                  if(num>0) strcat(sqlstr, ", ");
  715.              strcat(sqlstr, var_mean[i]);
  716.                  num++;
  717.                  }
  718.              }
  719.         }
  720.      if (num==0) { /* yikes..no user-selected values, & no default select list */
  721.          printf(" <H1> You must select field(s) to display. </H1> "); 
  722.          return; 
  723.          }
  724.  
  725.  
  726.      if( getdirective("FROMLIST", buf)) {
  727.        strcat(sqlstr, " FROM ");
  728.        strcat(sqlstr,  buf );
  729.          }
  730.  
  731.      num = 0;
  732.     strcat(sqlstr, " WHERE ");
  733.     for (i=0;i<n_var;i++) {
  734.           if (var_used[i]) {
  735.               if (!strcmp(var_kind[i],"WHERELIST")) {
  736.                  if(num>0) strcat(sqlstr, " AND ");
  737.              strcat(sqlstr, var_mean[i]);
  738.                  num++;
  739.               }
  740.            }
  741.         }
  742.      if( getdirective("WHERELIST", buf)) {
  743.        if (num>0) strcat(sqlstr, " AND  ");
  744.        strcat(sqlstr,  buf );
  745.         }
  746.  
  747.      if( getdirective("SORTLIST", buf)) {
  748.        strcat(sqlstr,  buf );
  749.         }
  750.  
  751.     strcat(sqlstr, " \" "); /* entire sql string is quoted */
  752.  
  753.      if(dd) printf("<b> SQL </b> <tt> %s </tt> <p> \n", sqlstr);
  754.  
  755.     stuffmenu("Here is the SQL Query ", sqlstr );
  756.  
  757.     strcat(sqlstr," ");
  758.    for(i=0;i<n_def;i++) {
  759.          char zz[LLEN];
  760.          sprintf(zz," \"%s %s\" ",d_defvar[i], d_defval[i]);
  761.          strcat(sqlstr,zz);
  762.          }
  763.  
  764.   if (getdirective("HEADING", buf))  printf("%s\n",buf);
  765.    printf("<P>");
  766.  
  767.     {{ char cmd[LLEN];
  768.         if (sqlprogram==0) {
  769.             printf("<H1> Sorry..I don't know what SQL program to run.");
  770.             printf("<p>SQLPROG is not specified! </H1>");
  771.             exit(0);
  772.             }
  773.         sprintf(cmd," %s %s ", sqlprogram, sqlstr);
  774.         /* stuffmenu("Here is the cmd ", cmd); */
  775.  
  776.         fflush(stdout);
  777.       system(cmd);
  778.     }}
  779.  
  780. }
  781.  
  782. savedirective(cmd, meaning) 
  783. char * cmd , *meaning;
  784. {
  785.    int i;
  786.  
  787.     for(i=0;i<NW;i++)  
  788.         if (!strcmp(cmd , d_cmd[i])) {
  789.          d_mean[i] = strdup(meaning); 
  790.             return(1);
  791.             break;
  792.         }
  793.     return(0);
  794. }
  795.  
  796. getdirective (cmd , meaning)
  797. char * cmd , *meaning;
  798. {
  799.     int i;
  800.     for (i=0;i<n_cmd;i++) 
  801.         if (!strcmp(d_cmd[i], cmd)) {
  802.             if(NULL==d_mean[i]) return (0);
  803.             strcpy(meaning, d_mean[i]);
  804.             return(1);
  805.           }
  806.     return(0);
  807. }
  808.  
  809.  
  810. /* substitute all occurences of $ in x1 with x2 */
  811. /* this means reallocing the string at x1 */
  812. substitute(x1, x2) char **x1, *x2; {
  813.     char buf[LLEN];
  814.     char *orig = *x1;
  815.     char *sp;
  816.  
  817.     /* printf("<p> sub [%s] inside [%s] ", x2, orig); */
  818.     sp = strchr(orig,'$');
  819.     if (sp==NULL) return;
  820.  
  821.     buf[0] = '\0';
  822.    
  823.     *sp ='\0';
  824.    strcat(buf,orig);  /* first portion */
  825.  
  826.    strcat(buf,x2);    /* substituted portion */
  827.  
  828.    sp++;
  829.     if(sp) {        /* end portion */
  830.       strcat(buf,sp);
  831.      }
  832.  
  833.    *x1 = strdup(buf);
  834.     /* printf("new string is [%s] ", *x1); */
  835. }
  836.  
  837. /* stuff some text into a menu */
  838. stuffmenu(title, string) char *title, *string;
  839. {
  840.        int n;
  841.          char *stringbuf;
  842.          char buf[LLEN];
  843.          char *ss, *s2, *s1;
  844.  
  845.  
  846.          stringbuf = strdup(string);
  847.          /* remove quotes */
  848.          s1 = strchr(stringbuf,  '\"'); if(s1) *s1 = ' ';
  849.          s1 = strrchr(stringbuf,  '\"'); if(s1) *s1 = ' ';
  850.  
  851.          printf("<FORM>");
  852.         printf("<SELECT NAME=\"sql-query\">\n" );
  853.         printf(" <OPTION>  %s \n", title);
  854.  
  855.        s1 = ss = stringbuf;
  856.        while(1) {
  857.              s2 = strchr(s1, ' ');
  858.              if(s2==NULL) break;
  859.              n = s2 - ss;
  860.           if (n > 80) {
  861.                 strncpy(buf,ss,n); buf[n]='\0';
  862.                 printf(" <OPTION>  %s\n", buf);
  863.                 ss = ++s2; if(ss==NULL) break;
  864.                 }
  865.           else {
  866.              s1 = s2+1;
  867.                 }
  868.  
  869.           }
  870.          if (ss) printf(" <OPTION>  %s\n", ss); /* trailing text */
  871.        printf("</SELECT><p>\n");
  872.          printf("</FORM>");
  873.  
  874.          fflush(stdout);
  875. }
  876.