home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 5 / 05.iso / a / a014 / 1.ddi / CDBINC.EXE / FIX.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-01-07  |  33.5 KB  |  1,218 lines
  1. /**************************************************/
  2. /*                                                */
  3. /*        ╚╬    ╥Γ    ╠⌡    ╝■    ▓Θ    ╤»        */
  4. /*                                                */
  5. /*           ╘┤    │╠    ╨≥    ╟σ    ╡Ñ           */
  6. /*                                                */
  7. /*                ╔Φ ╝╞ ╚╦: ┴°   ┴╒               */
  8. /*                                                */
  9. /*                                  1990─Ω6╘┬     */
  10. /*                                                */
  11. /**************************************************/
  12.  
  13. #include <stdio.h>
  14. #include <string.h>
  15. #include <dos.h>
  16. #define COUNT 40
  17. struct DBF {  struct DB {  char field[11];
  18.                char type;
  19.                int len;
  20.                int dec;
  21.             } db[COUNT];
  22.           struct DBF *last;
  23.           struct DBF *next;
  24.           int ctc;
  25.        }  *wd,*rd,*newd;
  26. struct BASE {  struct BS {  char mean[31];
  27.                 char name[9];
  28.                 char coflag,copath[20];
  29. /*                char key[11];*/
  30.                 struct DBF *dbs;
  31.              } base[10];
  32.            struct BASE *last;
  33.            struct BASE *next;
  34.            int ctc;
  35.         }  *wb,*rb,*newb;
  36. int repeat,MAR[6][128];
  37. struct BS ldb[6];
  38. int linkflag,ss0[10];
  39. char PATH[30],link[5][31];
  40. main(argc,argv)
  41. int argc;
  42. char *argv[];
  43. {  int i,j,k,c,rep=1,id,ic,sn,cn,dn,tn;
  44.    char name[31];
  45.    FILE *fp,*dp;
  46.    strcpy(PATH,argv[1]);
  47.    getbase(argv[1]);
  48.    cls(0,0,24,79,48|33);
  49.    color_puts(" ",0|63);
  50.    while (rep)
  51.      {  repeat=1;
  52.     c=getroad();
  53.     if (repeat==0) continue;
  54.     if (c!=0)
  55.       {  if (c>1)  deflink(link);
  56.          fp=fopen("lr.prg","w");
  57.          fprintf(fp,"LINK=''\n");
  58.          get_fc(fp);
  59.          sele_disp();
  60.          cre("lr.txt");
  61.          cre1(fp);
  62.          fprintf(fp,"name='lr'\ndo cre_df with name\n*do ag\n");
  63.          if (ldb[0].coflag=='Y'||ldb[0].coflag=='y')
  64.         fprintf(fp,"path='%s'\n",ldb[0].copath);
  65.          fprintf(fp,"sele 1\nuse &path\\%s\n",ldb[0].name);
  66.          for (i=1;ldb[i].dbs!=NULL;i++)
  67.            {
  68.           if (ldb[i].coflag=='Y'||ldb[i].coflag=='y')
  69.              fprintf(fp,"path='%s'\n",ldb[i].copath);
  70.           else fprintf(fp,"path='%s'\n",PATH);
  71.           fprintf(fp,"sele 10\nuse &path\\NDX\nloca for TRIM(╦≈╥²╫╓╢╬)='%s'.AND.TRIM(┐Γ├√)='%s'\n",link[i-1],ldb[i].name);
  72.           fprintf(fp,"blin2='%s'\ncty='C'\n",link[i-1]);
  73.           fprintf(fp,"if .not.eof()\nfname=TRIM(╦≈╥²╬─╝■)\nsele %d\nuse &path\\%s index &PATH\\&fname\n",i+1,ldb[i].name);
  74.           fprintf(fp,"else\n");
  75.           fprintf(fp,"sele %d\nuse &path\\%s\nindex on %s to linkwind\nuse &path\\%s inde linkwind\nendif\n",i+1,ldb[i].name,link[i-1],ldb[i].name);
  76.           if (linkflag==0)
  77.              fprintf(fp,"sele A\nset rela to %s into %c addi\n",link[i-1],'A'+i);
  78.           else
  79.              fprintf(fp,"sele %c\nset rela to %s into %c \n",'A'+i-1,link[i-1],'A'+i);
  80.            }
  81.          fprintf(fp,"path='%s'\n",PATH);
  82. /*         j='B';
  83.          while ((i--)>1)
  84.          fprintf(fp,"sele %c\nset rela to %s into %c\n",j-2,link,j++);*/
  85.       }
  86.     rep=0;
  87.      }
  88.    fprintf(fp,"sele 1\nftprg=fmtprg\nduo=\"0\"\ndo lcr with duo\nreturn\n");
  89.    fprintf(fp,"************************************\n");
  90.    fclose(fp);
  91. }
  92. /*----------------------------------*/
  93. /*          ╤╙ │┘ ╫╙ │╠ ╨≥          */
  94. /*----------------------------------*/
  95. dela()
  96. {  int i,j;
  97.    for (i=0;i<10;i++)
  98.       for (j=-30000;j<30000;j++) ;
  99. }
  100. /*-------------------------------------------------*/
  101. /*          ╜╙ ╩╒ ╝ⁿ ┼╠ ╩Σ ╚δ ╥╗ ╕÷ ╫╓ ╖√          */
  102. /*-------------------------------------------------*/
  103. getcc()
  104. {  union REGS r;
  105.    r.h.ah=0;
  106.    int86(0x16,&r,&r);
  107.    if (r.h.al==27) exit(0);
  108.    if (r.h.al) return(r.h.al);
  109.    return(r.x.ax);
  110. }
  111. /*-------------------------------------*/
  112. /*          ╢┴ ╚í ╥╗ ╕÷ ╩² ╫╓          */
  113. /*-------------------------------------*/
  114. getn(i,j,row,col)
  115. int i,j,row,col;
  116. {  int key,n=0;
  117.    cursor(row,col);
  118.    while ((key=getcc())!=0x0D)
  119.      {  putchar(key);
  120.     switch (key)
  121.       {  case 18688 : return('U');
  122.          case 20736 : return('D');
  123.          case 15104 : return('H');
  124.          case    8  : if (n!=0) n=n/10;
  125.               else  {  error();  cursor(row,col);  }
  126.               break;
  127.          default    : n=10*n+key%256-'0';
  128.               break;
  129.       }
  130.      }
  131.    if ((n>=i&&n<=j)||n==0) return(n);
  132.    else {  error();
  133.        getn(i,j,row,col);
  134.     }
  135. }
  136. /*-------------------------------------*/
  137. /*          ╢┴ ╚í ╥╗ ╕÷ ╫╓ ╖√          */
  138. /*-------------------------------------*/
  139. get(row,col)
  140. int row,col;
  141. {  int key,c=0,n=0;
  142.    struct DBF *p;
  143. /*   cursor(row,col);
  144.    printf("   ");*/
  145.    cursor(row,col);
  146.    while ((key=getcc())!=0x0D)
  147.      {  putchar(key);
  148.     switch (key)
  149.       {  case 18432 : return('u');
  150.          case 18688 : return('U');
  151.          case 20480 : return('d');
  152.          case 20736 : return('D');
  153.          case    8  : if (n!=0) n=n/10;
  154.               else  { error();  cursor(row,col);  }
  155.               break;
  156.          default    : n=10*n+key%256-'0';
  157.               break;
  158.       }
  159.      }
  160.    p=rd;
  161.    while (p!=wd) {  c+=p->ctc;  p=p->next;  }
  162.    if ((n>=c+1&&n<=c+wd->ctc)||n==0) return(n);
  163.       else{    error();
  164.        get(row,col);
  165.     }
  166. }
  167. /*-------------------------------*/
  168. /*          ╣Γ ▒Ω ╢¿ ╬╗          */
  169. /*-------------------------------*/
  170. cursor(x,y)
  171. int x,y;
  172. {  union REGS inregs;
  173.    union REGS outregs;
  174.    inregs.h.ah=2;
  175.    inregs.h.bh=0;
  176.    inregs.h.dh=x;
  177.    inregs.h.dl=y;
  178.    int86(0x10,&inregs,&outregs);
  179. }
  180.  
  181. /*----------------------------------------------*/
  182. /*          ░┤ ╤╒ ╔½ ╩Σ │÷ ╥╗ ╫╓ ╖√ ┤«          */
  183. /*----------------------------------------------*/
  184.  
  185. color_puts(s,color)
  186. char *s;
  187. int color;
  188. {  union REGS r;
  189.    int x,y,z;
  190.    now_cursor(&x,&z);
  191.    y=z;
  192.    while (*s)
  193.      {  if (*s=='\n')
  194.       {  s++;
  195.          x++;
  196.          y=z;
  197.          continue;
  198.       }
  199.     cursor(x,y);
  200.     r.h.ah=9;
  201.     r.h.al=*s++;
  202.     r.h.bl=color;
  203.     r.h.bh=0;
  204.     r.x.cx=1;
  205.     int86(0x10,&r,&r);
  206.     y++;
  207.     cursor(x,y);
  208.      }
  209.    return;
  210. }
  211. /*----------------------------------------*/
  212. /*          ╚í ╣Γ ▒Ω ╡▒ ╟░ ╬╗ ╓├          */
  213. /*----------------------------------------*/
  214. now_cursor(x,y)
  215. int *x,*y;
  216. {  union REGS r;
  217.    r.h.ah=3;
  218.    r.h.bh=0;
  219.    int86(0x10,&r,&r);
  220.    *x = r.h.dh;
  221.    *y = r.h.dl;
  222.    return;
  223. }
  224. /*-------------------------------------------------------------------*/
  225. /*          ╚╖ ╢¿ ╡▒ ╟░ ╣ñ ╫≈ ╓╕ ╒δ ▓ó ╧╘ ╩╛ ┐Γ ╜ß ╣╣ ▓╦ ╡Ñ          */
  226. /*-------------------------------------------------------------------*/
  227. judge(c)
  228. int c;
  229. {  int n=0;
  230. /*   while (wb->base[n].dbs!=rd&&n<10) {  n++;
  231.      if (n%10==0&&n!=0&&wb->next!=NULL) {
  232.      wb=wb->next; n=0;  }  }*/
  233.    while (ldb[n].dbs!=rd) n++;
  234.    if (c=='U'&&wd->last!=NULL) {wd=wd->last;}
  235.    if (c=='D'&&wd->next!=NULL) {wd=wd->next;}
  236.    disp_base(n);
  237.    cursor(3,10);
  238.    return(n);
  239. }
  240. /*-------------------------------------*/
  241. /*          ╩Σ │÷ ╠ß ╩╛ ▒Ω ╓╛          */
  242. /*-------------------------------------*/
  243. mark(n,c)
  244. int n;
  245. char *c;
  246. {  int x,y;
  247.    x=(n%COUNT-1)/4+5;/*3;*/
  248.    if (n%COUNT==0) x=((n-1)%COUNT-1)/4+5;
  249.    y=(n-1)%4*16+6;
  250.    cursor(x,y);
  251.    prt(x,y,0|30,"%s",c);
  252. /*   putchar(c);*/
  253. }
  254.  
  255. /*-------------------------------------------------*/
  256. /*          ╡╚ ┤² ╝ⁿ ╚δ ╥╗ ╫╓ ╖√ ║≤ ╝╠ ╨°          */
  257. /*-------------------------------------------------*/
  258. go_on()
  259. {  cursor(23,5);
  260.    color_puts("░┤╚╬╥Γ╝ⁿ╝╠╨°íºíºíº",15);
  261.    bioskey(0);
  262.    cursor(23,5);
  263.    color_puts("                  ",10);
  264. }
  265. /*-------------------------------------*/
  266. /*          ╟σ │² ▓┐ ╖╓ ╞┴ ─╗          */
  267. /*-------------------------------------*/
  268. clear(d,line,lx,ly,rx,ry)
  269. int d,line,lx,ly,rx,ry;
  270. {  union REGS inregs,outregs;
  271.    inregs.h.ah=d;
  272.    inregs.h.al=line;
  273.    inregs.h.ch=lx;
  274.    inregs.h.cl=ly;
  275.    inregs.h.dh=rx;
  276.    inregs.h.dl=ry;
  277.    inregs.h.bh=0;
  278.    int86(0x10,&inregs,&outregs);
  279. }
  280. /*----------------------------------------*/
  281. /*          ╔Ω ╟δ ╥╗ ┐Γ ╨┼ ╧ó ┐Θ          */
  282. /*----------------------------------------*/
  283. getmemb()
  284. {  int i,n;
  285.    newb=(struct BASE *)malloc(sizeof(struct BASE));
  286.    newb->ctc=0;
  287.    newb->last=newb->next=NULL;
  288.    for (i=0;i<10;i++)
  289.       {  strcpy(newb->base[i].mean,"\0");
  290.      strcpy(newb->base[i].name,"\0");
  291. /*     for (n=0;n<4;n++)
  292.      strcpy(newb->base[i].key[n],"\0");*/
  293.      newb->base[i].dbs=NULL;
  294.       }
  295. }
  296. /*----------------------------------------------*/
  297. /*          ╔Ω ╟δ ╥╗ ┐Γ ╜ß ╣╣ ╨┼ ╧ó ┐Θ          */
  298. /*----------------------------------------------*/
  299. getmemd()
  300. {  int i;
  301.    newd=(struct DBF *)malloc(sizeof(struct DBF));
  302.    newd->ctc=0;
  303.    newd->last=newd->next=NULL;
  304.    for (i=0;i<COUNT;i++)
  305.       {  strcpy(newd->db[i].field,"\0");
  306.      newd->db[i].type=' ';
  307.      newd->db[i].len=0;
  308.      newd->db[i].dec=0;
  309.       }
  310. }
  311.  
  312. /*-------------------------------------*/
  313. /*          ╢┴ ┐Γ ╙╨ ╣╪ ╨┼ ╧ó          */
  314. /*-------------------------------------*/
  315. getbase(path)
  316. char *path;
  317. {  FILE *fp;
  318.    char c[2],key[4][11],c1[2],pathbak[30],buff[80];
  319.    int i=0;
  320.    fp=fopen("db.txt","r");
  321.    getmemb();
  322.    rb=newb;
  323.    wb=newb;
  324.    while (fgets(buff,80,fp)!=NULL)
  325.      {  if (i%10==0&&i!=0)
  326.       {  getmemb();
  327.          i=0;
  328.          wb->next=newb;
  329.          newb->last=wb;
  330.          wb=newb;
  331.       }
  332.     sscanf(buff,"#%[^#]#,#%[^#]#,#%[^#]#,#%[^#]#,#%[^#]#,#%[^#]#,#%[^#]#,#%[^#]#,#%[^#]#\n",\
  333.     wb->base[i].mean,key[0],key[1],key[2],key[3],wb->base[i].name,c,c1,wb->base[i].copath);
  334.     wb->base[i].coflag=c1[0];
  335. /*    getmemd();
  336.     wd=newd;
  337.     wb->base[i].dbs=newd;
  338.     getcontent(path,wb->base[i].name);*/
  339.     i++;
  340.     wb->ctc++;
  341.      }
  342.    fclose(fp);
  343.    rd=rb->base[0].dbs;
  344.    wb=rb;
  345.    wd=rd;
  346. }
  347. /*----------------------------------------*/
  348. /*          ╢┴ ╚δ ┐Γ ╜ß ╣╣ ╨┼ ╧ó          */
  349. /*----------------------------------------*/
  350. getcontent(path,dbf)
  351. char *path,*dbf;
  352. {  FILE *fp;
  353.    char *s,buff[80];
  354.    int i=0;
  355.    s=(char *)malloc(30*sizeof(char));
  356.    strcpy(s,path);
  357.    strcat(s,dbf);
  358.    strcat(s,".txt");
  359.    i=0;
  360.    fp=fopen(s,"r");
  361.    while (fgets(buff,80,fp)!=NULL)
  362.      {  if (wd->ctc%COUNT==0&&wd->ctc!=0)
  363.       {  i=0;
  364.          getmemd();
  365.          wd->next=newd;
  366.          newd->last=wd;
  367.          wd=newd;
  368.       }
  369.     sscanf(buff,"#%[^#]#,#%c#,%d,%d\n",wd->db[i].field,&wd->db[i].type,&wd->db[i].len,&wd->db[i].dec);
  370.     i++;
  371.     wd->ctc++;
  372.      }
  373.    fclose(fp);
  374. }
  375.  
  376. /*----------------------------------------------*/
  377. /*          ╧╘ ╩╛ ╧╡ ═│ ╩² ╛▌ ┐Γ ▓╦ ╡Ñ          */
  378. /*----------------------------------------------*/
  379. disp()
  380. {  int i,x,y,n=0;
  381.    struct BASE *p;
  382.    p=rb;
  383.    while (p!=wb)  {  n+=p->ctc;  p=p->next;  }
  384.    cls(0,0,24,79,48|33);
  385. /*   prt(0,1,0|30,"%s",explain);*/
  386.    prt(0,44,48|33,"F1-Help  Esc-Exit  ╗╪│╡: ═╦│÷▒╛─ú┐Θ");
  387.    prt(2,18,48|33,"▒╛╧╡═│╓╨╡─╚½▓┐╩²╛▌┐Γ╚τ╧┬");
  388. /*   cls(7,4,12,79,0|1);*/
  389.    cls(5,3,11,78,0|1);
  390.    frame(5,2,11,76,0|30);
  391.    x=5;
  392.    y=4;
  393.    for (i=0;i<wb->ctc;i++)
  394.       {  cursor(x,y);
  395.      prt(x,y,0|30,"%2d - %-30s",n+i+1,wb->base[i].mean);
  396.      y+=36;
  397. /**     y+=26;**/
  398.      if (y+10>80)
  399.        {  x++;
  400. /**          y=1;**/
  401.           y=4;
  402.        }
  403.       }
  404. }
  405. /*----------------------------------------*/
  406. /*          ╧╘ ╩╛ ┐Γ ╜ß ╣╣ ▓╦ ╡Ñ          */
  407. /*----------------------------------------*/
  408. disp_base(m)
  409. int m;
  410. {  int row,col,i,n=0;
  411.    struct DBF *p;
  412. /*   p=wb->base[m].dbs;*/
  413.    p=ldb[m].dbs;
  414.    while (p!=wd)  {  n+=p->ctc;  p=p->next;  }
  415.    cls(1,1,15,78,48|33);
  416. /*   cls(6,6,15,73,0|1);*/
  417.    cls(4,5,14,72,0|1);
  418.    frame(4,4,14,70,0|30);
  419. /*   prt(0,1,0|30,"%s",explain);*/
  420.    prt(1,10,48|33,"┐Γ # %s # ╓╨║¼╙╨╥╘╧┬╫╓╢╬",ldb[m].mean);
  421.    row=5;
  422.    col=7;
  423.    for (i=0;i<wd->ctc;i++)
  424.       {  prt(row,col,0|30,"%2d. %-s",n+i+1,wd->db[i].field);
  425.      col+=16;
  426.      if (col>70)
  427.        {  row++;
  428.           col=7;
  429.        }
  430.       }
  431. }
  432. /*-------------------------------*/
  433. /*          ┤░ ┐┌ ╠ß ╩╛          */
  434. /*-------------------------------*/
  435. helplo()
  436. {  char c;
  437.    cursor(11,5);
  438.    color_puts("⌐│⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐╖\
  439.    \n⌐º    ─·┐╔╤í╘±╔╧╩÷┐Γ, ╜°╨╨╡Ñ┐Γ╗≥╢α┐Γ▓┘╫≈. ╚⌠╥¬╔·│╔╢╘╢α┐Γ▓Θ╤», ╘≥╕≈┐Γ╝Σ⌐º\
  440.    \n⌐º▒╪╨δ╙╨╧α═¼╫╓╢╬, ╟╥╧α═¼╫╓╢╬╘┌▒╗┴¼╜╙┐Γ╓╨╙ª╩╟╣╪╝ⁿ╫╓.                   ⌐º\
  441.    \n⌐º    ╘┌╤í┐Γ╩▒, ╚τ╣√─·╓╗╤í╘±┴╦╥╗╕÷┐Γ, ╘≥▒φ╩╛╢╘╡Ñ┐Γ▓┘╫≈; ╚τ╣√─·╤í╘±┴╦┴╜⌐º\
  442.    \n⌐º╕÷╥╘╔╧╡─┐Γ, ╘≥▒φ╩╛╢╘╢α┐Γ▓┘╫≈, ╧╡═│╜½╫╘╢»╕∙╛▌─·╤í╘±╡─╦│╨≥░╤╕≈┐Γ┴¼╜╙╞≡⌐º\
  443.    \n⌐º└┤.                                                                 ⌐º\
  444.    \n⌐º                    ╫ó╥Γ : ┐╔┴¼╜╙╡─┐Γ╫ε╢α─▄╙╨6╕÷                    ⌐º\
  445.    \n⌐╗⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐┐",15);
  446.    color_puts(" ",10);
  447.    go_on();
  448.    clear(6,0,11,0,18,79);
  449.    cursor(20,50);
  450. }
  451. /*-------------------------------------*/
  452. /*          ┤φ ╬≤ ╨┼ ╧ó ╠ß ╩╛          */
  453. /*-------------------------------------*/
  454. error()
  455. {  cursor(23,15);
  456.    prt(23,15,48|33,"###### ╩Σ╚δ┤φ╬≤! ╟δ╓╪╨┬╘┘╩Σ ######");
  457.    dela();
  458.    cursor(23,15);
  459.    prt(23,15,48|33,"                                   ");
  460. }
  461. /*----------------------------------------*/
  462. /*          ╢¿ ╥σ ▓Θ ╤» ▓┘ ╫≈ ┐Γ          */
  463. /*----------------------------------------*/
  464. getroad()
  465. {  int i,n,x,y,col,j,cir,min=1,max,m,dbctc;
  466.    cls(0,0,24,79,48|33);
  467.    wb=rb;
  468.    disp();
  469. /*   prt(19,20,48|33,"╟δ╢¿╥σ╡┌ %d ╕÷▓Θ╤»▓┘╫≈┐Γ",l+1);*/
  470.    prt(20,5,48|33,"╩Σ╚δ┐Γ╡─┤·║┼(PgUp/PgDn: ╖¡╞┴, 0: ╜ß╩°) -- A:   B:   C:   D:   E:   F:   ");
  471.    for (i=0;i<6;i++) {ldb[i].dbs=NULL; strcpy(ldb[i].name,"");}
  472.    max=wb->ctc;
  473.    i=0;
  474.    while ((n=getn(min,max,20,49))!=0)
  475.      {
  476. /**/          ss0[i]=n;
  477.        if (n=='H')
  478.       {  helplo();
  479.          while ((n=getn(min,max,20,49))=='H') helplo();
  480.          if (n==0) return(0);
  481.       }
  482.     if (n=='U') {  if (wb->last!=NULL) {  max-=wb->ctc;  wb=wb->last; min-=10;  disp(); }  continue;  }
  483.     if (n=='D') {  if (wb->next!=NULL) {  min+=10;  wb=wb->next; max+=wb->ctc;  disp(); }  continue;  }
  484.     y=((n-1)%2)*36+3;
  485.     x=(n%10-1)/2+5;
  486.     if (n%10==0) x=((n-1)%10-1)/2+5;
  487.     prt(x,y,0|30,"*");
  488.     if (n%10==0) m=9;
  489.     else m=n%10-1;
  490.     ldb[i]=wb->base[m];
  491.     rd=ldb[i].dbs;
  492.     wd=rd;
  493.     i++;
  494.     col=54;
  495.     while ((n=getn(min,max,20,col))!=0)
  496.       {  ss0[i]=n;
  497.          if (n=='H')  {  helplo();  continue;  }
  498.          if (n=='U')  {  if (wb->last!=NULL) {  max-=wb->ctc;  wb=wb->last;  min-=10;  disp(); }  continue;  }
  499.          if (n=='D')  {  if (wb->next!=NULL) {  min+=10;  wb=wb->next;  max+=wb->ctc;  disp(); }  continue;  }
  500.          if (n%10==0) m=9;
  501.          else m=n%10-1;
  502.          for (j=0;j<i;j++)
  503.            if (strcmp(ldb[j].mean,wb->base[m].mean)==0) {  cir=1;  break;  }
  504.            else cir=0;
  505.          if (cir)  {  error();
  506.               continue;
  507.                }
  508.          if (n!=0)
  509.            {
  510.  
  511.  
  512.           y=((n-1)%2)*36+3;
  513.           x=(n%10-1)/2+5;
  514.           if (n%10==0) x=((n-1)%10-1)/2+5;
  515.           prt(x,y,0|30,"*");
  516.           col+=5;
  517.           ldb[i]=wb->base[m];
  518.           i++;
  519.           if (i==6) break;
  520.            }
  521.       }
  522. /*    check();*/
  523.     for (dbctc=0;strcmp(ldb[dbctc].name,"")!=0;dbctc++)
  524.         {
  525.         getmemd();
  526.         wd=newd;
  527.         ldb[dbctc].dbs=newd;
  528.         getcontent(PATH,ldb[dbctc].name);
  529.         }
  530.     wb=rb;
  531.  
  532.     if (i==1) return(i);
  533.     cursor(22,15);
  534.     prt(22,15,48|33,"╟δ╤í╘±╢α┐Γ┴¬╜╙╖╜╩╜(╨╟╨═B/┤«╨═C)");
  535. bcstart:n=getcc();
  536.     if (n!='B'&&n!='b'&&n!='C'&&n!='c') goto bcstart;
  537.     else linkflag=(n=='b'||n=='B')?0:1;
  538.     return(i);
  539.      }
  540.    wb=rb;
  541.    return(0);
  542. }
  543. /*-------------------------------------------------------*/
  544. /*          ▒╚ ╜╧ ┐Γ ╓« ╝Σ ╩╟ ╖± ╙╨ ╧α ═¼ ╫╓ ╢╬          */
  545. /*-------------------------------------------------------*/
  546. check()
  547. {  int i,j,k,n;
  548.    struct DBF *p;
  549.    char b[128][11];
  550.    p=ldb[0].dbs;
  551.    i=0;
  552.    j=0;
  553.    while (i<p->ctc)
  554.      {  strcpy(b[j++],p->db[i].field);
  555.     i++;
  556.     if (i==p->ctc&&p->next!=NULL) {  p=p->next;  i=0;  }
  557.      }
  558.    k=1;
  559.    while (ldb[k].dbs!=NULL)
  560.      {  n=0;
  561.     for (i=0;i<j;i++)
  562.       if (cmp(b[i],ldb[k].dbs)>=0)  {  strcpy(b[n],b[i]);  n++;  }
  563.     if (n==0)
  564.       {  cursor(23,5);
  565.          color_puts(ldb[0].mean,14|16);
  566.          color_puts(" ║═ ",12);
  567.          color_puts(ldb[k].mean,14|16);
  568.          color_puts(" ╬▐╧α═¼╫╓╢╬, ▓╗─▄╜°╨╨┴¼╜╙, ╟δ╓╪╨┬╢¿╥σ┴¼╜╙┐Γ",12);
  569.          dela();
  570.          color_puts(" ",10);
  571.          repeat=0;
  572.          break;
  573.       }
  574.     if (n<j) j=n;
  575.     k++;
  576.      }
  577. }
  578. /*-------------------------------------------------------*/
  579. /*          ▒╚ ╜╧ ╥╗ ╫╓ ╢╬ ╩╟ ╖± ╘┌ ─│ ╥╗ ┐Γ ╓╨          */
  580. /*-------------------------------------------------------*/
  581. cmp(str,p)
  582. char *str;
  583. struct DBF *p;
  584. {  int i=0,j=0;
  585.    while (i<p->ctc)
  586.      {  if (strcmp(str,p->db[i].field)==0)  return(j);
  587.     i++;
  588.     j++;
  589.     if (i==p->ctc&&p->next!=NULL) {  p=p->next;  i=0;  }
  590.      }
  591.    return(-1);
  592. }
  593. /*-------------------------------------*/
  594. /*          ╢¿ ╥σ ┴¼ ╜╙ ╫╓ ╢╬          */
  595. /*-------------------------------------*/
  596. deflink(dname)
  597. char *dname;
  598. {  int i,c,n,flag,ctcn;
  599.    FILE *fp;
  600.    char ph[30],middst[31];
  601.    strcpy(ph,PATH);
  602.    for (i=0;i<5;i++) strcpy(link[i],"");
  603. /*   strcat(ph,"NDX.TXT");
  604.    fp=fopen(ph,"a");
  605.    prt(22,15,48|33,"╟δ╢¿╥σ┴¼╜╙┐Γ╡─╩╢▒≡├√(╫ε╢α30╕÷╫╓╖√): ");
  606.    scanf("%30s",dname);*/
  607.    cls(0,0,24,79,48|33);
  608.    i=0; ctcn=1;
  609.    while (repeat)
  610.      {
  611.      wd=ldb[i].dbs; rd=ldb[i].dbs; flag=1;
  612.      while (flag) {
  613.      prt(16,10,48|33,"╟δ╚╖╢¿╦∙╢¿╥σ╡─┴¼╜╙┐Γ╡─┴¼╜╙╫╓╢╬(PgUp/PgDn: ╖¡╞┴):");
  614.      prt(19,13,48|33,"╫ó╥Γ: ┴¼╜╙╫╓╢╬▒╪╨δ─▄╬¿╥╗╡╪╩╢▒≡╥╗╕÷╝╟┬╝!");
  615.      judge(0);
  616.      c=get(16,60);
  617.      /*i=1;*/
  618.      if (c=='U'||c=='D')
  619.        {  judge(c);
  620.           continue;
  621.        }
  622.      /*flag=1;*/
  623.      if (c%COUNT==0) c=COUNT-1;
  624.      else c=c%COUNT-1;
  625.      if (c==39)
  626.         {
  627.         if (strcmp(link[i],"")==0) continue;
  628.         else {flag=0; continue;}
  629.         }
  630.      if (ldb[i].dbs->db[c].type!='C'&&ldb[i].dbs->db[c].type!='D'&&ldb[i].dbs->db[c].type!='N')
  631.        {  prt(21,10,48|33,"╟δ╤í╘±╫╓╖√╨═, ╩²╫╓╨═, ╚╒╞┌╨═╡─╫╓╢╬╫≈╬¬┴¼╜╙╫╓╢╬!");
  632.           go_on();
  633.           prt(21,10,48|33,"                                                   ");
  634.           continue;
  635.        }
  636.      if (ldb[ctcn].dbs!=NULL)
  637.        {   if (cmp(ldb[i].dbs->db[c].field,ldb[ctcn].dbs)<0)
  638.          {  prt(21,10,48|33,"%s",ldb[ctcn].mean);
  639.             print1(48|33," ▓╗┤µ╘┌ ");
  640.             print1(48|33,"%s",ldb[i].dbs->db[c].field);
  641.             print1(48|33," ╫╓╢╬, ╬▐╖¿┴¼╜╙. ╟δ╓╪╨┬╤í╘±┴¼╜╙╫╓╢╬");
  642.             go_on();
  643.             prt(21,10,48|33,"                                                                       ");
  644.          }
  645.            else {if (strcmp(link[ctcn-1],"")!=0) strcat(link[ctcn-1],"+");
  646.             if (ldb[i].dbs->db[c].type=='D')
  647.                {
  648.                strcpy(middst,NULL); strcat(middst,"DTOC(");
  649.                strcat(middst,ldb[i].dbs->db[c].field); strcat(middst,")");
  650.                }
  651.             if (ldb[i].dbs->db[c].type=='N')
  652.                {
  653.                strcpy(middst,NULL); strcat(middst,"STR(");
  654.                strcat(middst,ldb[i].dbs->db[c].field); strcat(middst,",");
  655.                strcat(middst,"19");strcat(middst,")");
  656.                }
  657.             if (ldb[i].dbs->db[c].type=='C')
  658.                strcpy(middst,ldb[i].dbs->db[c].field);
  659.             strcat(link[ctcn-1],middst);
  660.             }
  661.        }
  662.        }
  663.      if (linkflag==1) {i=ctcn; ctcn++;}
  664.      else {i=0; ctcn++;}
  665.      if (ldb[ctcn].dbs==NULL) break;
  666.     /* if (flag) {  strcpy(link,ldb[0].dbs->db[c].field);
  667.               break;
  668.            }*/
  669.      }
  670. /*   for (i=1;ldb[i].dbs!=NULL;i++) fprintf(fp,"#%s#,#%s#,##,0,0\n",ldb[i].name,link[i-1]);
  671.    fclose(fp);*/
  672.    wd=rd=ldb[0].dbs;
  673. }
  674. /*----------------------------------*/
  675. /*          ╤í ╧╘ ╩╛ ╫╓ ╢╬          */
  676. /*----------------------------------*/
  677. sele_disp()
  678. {  int r,i,j,n,c,t,k=0,bb=1;/*ldb[bb]*/
  679.    char sele[15];
  680.    cls(0,0,24,79,48|33);
  681.    cursor(0,1);
  682. /*   color_puts(explain,14|16);*/
  683.    cursor(8,10);
  684.    color_puts("     *** ╧┬├µ╟δ╢¿╥σ▓Θ╤»╜ß╣√╧╘╩╛╧ε ***\n\n─·╓╗╨Φ┤╙▒╗┴¼╜╙╡─╕≈╕÷┐Γ╓╨╖╓▒≡╤í╘±╚⌠╕╔╫╓╢╬╝┤┐╔.",11);
  685.    i=0;
  686.    color_puts(" ",10);
  687.    cursor(12,10);
  688.    if (ldb[1].dbs!=NULL)
  689.       {  printf("─·╢¿╥σ╡─┴¼╜╙┐Γ╬¬ :");  cursor(14,15);  }
  690.    else
  691.       printf("─·╓╗╤í╘±┴╦╡Ñ╕÷┐Γ : ");
  692.    while (ldb[i+1].dbs!=NULL)  printf("┐Γ # %s # --> ",ldb[i++].mean);
  693.    printf("┐Γ # %s #",ldb[i].mean);
  694.    go_on();
  695.  
  696. ll:   i=0;
  697.    cls(0,0,24,79,48|33);
  698.    while (ldb[i].dbs!=NULL)
  699.      {   wd=ldb[i].dbs;
  700.      rd=ldb[i].dbs;
  701.      for (k=0;k<128;k++) MAR[i][k]=0;
  702.      judge(0);
  703.      n=0;
  704.      t=0;
  705.      prt(16,10,48|33,"1--╚½▓┐╧╘╩╛        2--▓┐╖╓╧╘╩╛");
  706.      prt(18,15,48|33,"                                   ");
  707.      prt(18,20,48|33,"╟δ╤í╘±:");
  708.      if ((c=getn(1,2,18,28))==1)
  709.        while (t<wd->ctc)
  710.          {  MAR[i][n++]=1;
  711.         t++;
  712.         if (t==wd->ctc&&wd->next!=NULL) {  t=0;  wd=wd->next;  }
  713.          }
  714.      else
  715.        {  cls(17,1,19,80,48|33);
  716.           prt(18,15,48|33,"╨Φ╥¬╧╘╩╛╡─╫╓╢╬╙╨(PgUp/PgDn: ╖¡╞┴): ");          while ((c=get(18,50))!=0)
  717.         {   if (c=='U'||c=='D')
  718.               {  judge(c);
  719.              continue;
  720.               }
  721.      if (MAR[i][c-1]!=1) {  mark(c,"*");  MAR[i][c-1]=1;}
  722.             else {  mark(c," "); MAR[i][c-1]=0;  }
  723.         }
  724.        }
  725.      cls(17,1,19,80,48|33);
  726.      i++;
  727.      }
  728.    strcpy(sele,"rfy");
  729.    savedef_xits(sele);
  730.    i=0;
  731.    while (ldb[i].dbs!=NULL)
  732.      {   wd=ldb[i].dbs;
  733.      t=i+1;
  734.      while (ldb[t].dbs!=NULL)
  735.        {  k=0;
  736.           j=0;
  737.           while (k<wd->ctc&&j<128)
  738.          {  if ((c=cmp(wd->db[k].field,ldb[t].dbs))>=0)
  739.               if (MAR[i][j]==1)  MAR[t][c]=0;
  740.             j++;  k++;
  741.             if (k==wd->ctc&&wd->next!=NULL) {  k=0;  wd=wd->next;  }
  742.          }
  743.           t++;
  744.        }
  745.      i++;
  746.      }
  747.      return(r);
  748. }
  749.  
  750.  
  751. in_c(i)
  752. int *i;
  753. {  int n=0;
  754.    clear(6,0,22,0,23,79);
  755.    if (ldb[1].dbs!=NULL)
  756.      {  cursor(22,10);
  757.     printf("╟δ╤í╘±╠⌡╝■╫╓╢╬ (╝ⁿ╚δíⁿ/í²╤í╘±▓┘╫≈┐Γ) :");
  758.      }
  759.    else
  760.      {  cursor(22,20);
  761.     printf("╟δ╤í╘±╠⌡╝■╫╓╢╬ :");
  762.      }
  763.    while (n==0)
  764.      {  if (ldb[1].dbs!=NULL)
  765.       {  while ((n=get(22,50))!=0)
  766.            {  if (n=='u'||n=='d')
  767.             {  if (n=='u'&&*i>0)  {  (*i)--;  rd=ldb[*i].dbs;  wd=ldb[*i].dbs;  }
  768.                else if (*i<5&&ldb[*i+1].dbs!=NULL)  {  (*i)++;  rd=ldb[*i].dbs;  wd=ldb[*i].dbs;  }
  769.                judge(0);
  770.             }
  771.           else  if (n=='U'||n=='D')
  772.               {  judge(n);
  773.                  continue;
  774.               }
  775.             else break;
  776.            }
  777.       }
  778.     else
  779.       {  n=get(22,38);
  780.          if (n=='U'||n=='D')
  781.            {  judge(n);
  782.           n=0;
  783.           continue;
  784.            }
  785.          if (n=='u'||n=='d') {  n=0;  continue;  }
  786.       }
  787.     if (n==0) error();
  788.      }
  789.    if (n%COUNT==0) return(COUNT);
  790.    else return(n%COUNT);
  791. }
  792.  
  793. cre(str)
  794. char *str;
  795. {  FILE *sp;
  796.    int n,i,m;
  797.    struct DBF *p;
  798.    sp=fopen(str,"w");
  799.    for (i=0;ldb[i].dbs!=NULL;i++)
  800.      {  p=ldb[i].dbs;
  801.     m=0;
  802.     n=0;
  803.     while (n<p->ctc)
  804.       {  if (MAR[i][m++]==1) fprintf(sp,"#%s#,#%c#,%d,%d\n",p->db[n].field,p->db[n].type,p->db[n].len,p->db[n].dec);
  805.          n++;
  806.          if (n==p->ctc&&p->next!=NULL) {  n=0;  p=p->next;  }
  807.       }
  808.      }
  809.    fclose(sp);
  810.    return(1);
  811. }
  812.  
  813. cre1(sp)
  814. FILE *sp;
  815. {  int i,j,n,k;
  816.    struct DBF *p;
  817.    fprintf(sp,"df='");
  818.    n='A';
  819.    for (i=0;ldb[i].dbs!=NULL;i++)
  820.      {  p=ldb[i].dbs;
  821.     j=0;
  822.     k=0;
  823.     while (k<p->ctc)
  824.       {  if (MAR[i][j++]) fprintf(sp,"%c",n);
  825.          k++;
  826.          if (k==p->ctc&&p->next!=NULL)  {  k=0;  p=p->next;  }
  827.       }
  828.     n++;
  829.      }
  830.    fprintf(sp,"'\n");
  831.    return(1);
  832. }
  833.  
  834. get_fc(cp)
  835. FILE *cp;
  836. {  int i,n=0,N=0,mark;
  837.    int c,nf,nd,nt,nm,flag;
  838.    char ss[256]="#",dd[120]="#",tt[10],*str,*ms;
  839.    char DD[8],FF[11];
  840.    int row,col,m,con=1,j,k;
  841.    i=0;
  842.    cls(0,0,24,79,48|33);
  843.    rd=ldb[0].dbs;
  844.    wd=ldb[0].dbs;
  845.    judge(0);
  846.    n=in_c(&i);
  847.    col=1;
  848.    cursor(16,col);
  849.    printf("%s",wd->db[n-1].field);
  850.    strcat(ss,wd->db[n-1].field);
  851.    strcat(dd,ldb[i].name);
  852.    strcat(dd,"#");
  853.    tt[N++]=wd->db[n-1].type;
  854.    while (con!=0)
  855.      {  cursor(22,0);
  856.     printf("╠⌡╝■╣╪╧╡░ⁿ└¿: 1_.AND. 2_.OR. 3_.NOT. 4_.AND..NOT. 5_.OR..NOT.  ╟δ╤í╘±(0╜ß╩°):");
  857.     while ((con=getn(0,5,22,77))=='u'||con=='U'||con=='d'||con=='D') ;
  858.     col+=10;
  859.     cursor(16,col);
  860.     switch (con)
  861.       {   case 1 : printf(".AND.");
  862.                col+=5;
  863.                strcat(ss,"#.AND.#");
  864.                break;
  865.           case 2 : printf(".OR.");
  866.                col+=4;
  867.                strcat(ss,"#.OR.#");
  868.                break;
  869.           case 3 : printf(".NOT.");
  870.                col+=5;
  871.                strcat(ss,"#.NOT.#");
  872.                break;
  873.           case 4 : printf(".AND..NOT.");
  874.                col+=10;
  875.                strcat(ss,"#.AND..NOT.#");
  876.                break;
  877.           case 5 : printf(".OR..NOT.");
  878.                col+=9;
  879.                strcat(ss,"#.OR..NOT.#");
  880.                break;
  881.           case 0 : strcat(ss,"#");
  882.                tt[N]='\0';
  883.                fprintf(cp,"con=\"");
  884.                ms=(char *)malloc(300*sizeof(char));
  885.                for (nm=0;nm<300;nm++) ms[nm]='\0';
  886.                str=(char *)malloc(33*sizeof(char));
  887.                cls(0,0,24,79,48|33);
  888.                cursor(4,5);
  889.                printf("─·╢¿╥σ╡─▓Θ╤»╠⌡╝■╬¬:");
  890.                cursor(5,1);
  891.                printf("------------------------------------------------------------------------------");
  892.                cursor(6,3);
  893.                printf(ss,10);
  894.                cursor(8,5);
  895.                printf("▓Θ╤»╠⌡╝■╡─╛▀╠σ╓╡");
  896.                row=9;
  897.                nf=1;
  898.                nd=1;
  899.                nt=0;
  900.                nm=0;
  901.                while (ss[nf]!='\0')
  902.              {   cursor(row,3);
  903.                  j=0;
  904.                  while (ss[nf]!='#') {  printf("%c",ss[nf]); FF[j++]=ss[nf++];  }
  905.                  FF[j]='\0';
  906.                  j=0;
  907.                  while (dd[nd]!='#') DD[j++]=dd[nd++];
  908.                  DD[j]='\0';
  909.                  cursor(row,13);
  910.                  mark=0;
  911.                  k=0;
  912.                  flag=0;
  913.                  if (tt[nt]=='C') {  strcat(ms,"AT(");  nm+=3;  }
  914.                  else {  strcat(ms,DD);  strcat(ms,"->");  strcat(ms,FF);
  915.                      nm+=strlen(DD)+strlen(FF)+2;
  916.                   }
  917.                  switch (tt[nt])
  918.                    {   case 'C' :
  919.                    case 'L' : printf(" = ");
  920.                           if (tt[nt]=='L') ms[nm++]='=';
  921.                           ms[nm++]='"';
  922.                           fprintf(cp,"%s->%s='",DD,FF);
  923.                           while ((c=getchar())!='\n')
  924.                         {  fprintf(cp,"%c",c);  ms[nm++]=c;  }
  925.                           fprintf(cp,"'");
  926.                           ms[nm++]='"';
  927.                           break;
  928.                    case 'N' : printf(" >           =           <           ");
  929.                           cursor(row,15);
  930.                           while ((c=getchar())!='\n')
  931.                         {  if (k==0) {  fprintf(cp,"%s->%s>",DD,FF);  ms[nm++]='>';  }
  932.                            k=1;
  933.                            mark=1;
  934.                            fprintf(cp,"%c",c);
  935.                            ms[nm++]=c;
  936.                         }
  937.                           k=0;
  938.                           cursor(row,27);
  939.                           while ((c=getchar())!='\n')
  940.                         {  if (mark&&k==0)
  941.                              {  fprintf(cp,".OR.%s->%s=",DD,FF);
  942.                             strcat(ms,".OR.");  strcat(ms,DD);
  943.                             strcat(ms,"->");  strcat(ms,FF);
  944.                             nm+=strlen(DD)+strlen(FF)+6;  ms[nm++]='=';
  945.                              }
  946.                            else if (k==0) {  fprintf(cp,"%s->%s=",DD,FF);  ms[nm++]='=';  }
  947.                            fprintf(cp,"%c",c);
  948.                            ms[nm++]=c;
  949.                            k=1;
  950.                            mark=1;
  951.                            flag=1;
  952.                         }
  953.                           k=0;
  954.                           cursor(row,39);
  955.                           while ((c=getchar())!='\n')
  956.                         {  if (mark&&k==0) {  if (flag)
  957.                                     {  fprintf(cp,".OR.");  strcat(ms,".OR.");  nm+=4;  }
  958.                                       else
  959.                                     {  fprintf(cp,".AND.");  strcat(ms,".AND.");  nm+=5;  }
  960.                                       fprintf(cp,"%s->%s<",DD,FF);
  961.                                       strcat(ms,DD);  strcat(ms,"->");  strcat(ms,FF);
  962.                                       nm+=strlen(DD)+strlen(FF)+2;  ms[nm++]='<';
  963.                                    }
  964.                            else if (k==0) {  fprintf(cp,"%s->%s<",DD,FF);  ms[nm++]='<';  }
  965.                            fprintf(cp,"%c",c);
  966.                            ms[nm++]=c;
  967.                            k=1;
  968.                         }
  969.                           break;
  970.                    case 'D' : printf(" ╘τ╙┌    /   /     ╡╚╙┌    /   /     ═φ╙┌    /   /   ");
  971.                           if ((c=getn(0,12,row,19))!=0)
  972.                         {  fprintf(cp,"%s->%s<CTOD('",DD,FF);
  973.                            mark=1;
  974.                            strcat(ms,"<CTOD(");
  975.                            nm+=6;  ms[nm++]='"';
  976.                            fprintf(cp,"%d/",c);
  977.                            itoa(c,str,10);  strcat(ms,str);  nm+=strlen(str);  ms[nm++]='/';
  978.                            while ((c=getn(1,31,row,23))==0) error();
  979.                            fprintf(cp,"%d/",c);
  980.                            itoa(c,str,10);  strcat(ms,str);  nm+=strlen(str);  ms[nm++]='/';
  981.                            while ((c=getn(1,99,row,27))==0) error();
  982.                            fprintf(cp,"%d')",c);
  983.                            itoa(c,str,10);  strcat(ms,str);  nm+=strlen(str);
  984.                            ms[nm++]='"';  ms[nm++]=')';
  985.                         }
  986.                           if ((c=getn(0,12,row,37))!=0)
  987.                         {  if (mark)
  988.                              {  fprintf(cp,".OR.%s->%s=CTOD('",DD,FF);
  989.                             strcat(ms,".OR.");  strcat(ms,DD);  strcat(ms,"->");
  990.                             strcat(ms,FF);  strcat(ms,"=CTOD(");
  991.                             nm+=strlen(DD)+strlen(FF)+8;  ms[nm++]='"';
  992.                              }
  993.                            else {  fprintf(cp,"%s->%s=CTOD('",DD,FF);
  994.                                strcat(ms,"=CTOD(");  nm+=6;  ms[nm++]='"';
  995.                             }
  996.                            mark=1;
  997.                            fprintf(cp,"%d/",c);
  998.                            itoa(c,str,10);  strcat(ms,str);  nm+=strlen(str);  ms[nm++]='/';
  999.                            while ((c=getn(1,31,row,41))==0) error();
  1000.                            fprintf(cp,"%d/",c);
  1001.                            itoa(c,str,10);  strcat(ms,str);  nm+=strlen(str);  ms[nm++]='/';
  1002.                            while ((c=getn(1,99,row,45))==0) error();
  1003.                            fprintf(cp,"%d')",c);
  1004.                            itoa(c,str,10);  strcat(ms,str);  nm+=strlen(str);
  1005.                            ms[nm++]='"';  ms[nm++]=')';
  1006.                            flag=1;
  1007.                         }
  1008.                           if ((c=getn(0,12,row,55))!=0)
  1009.                         {  if (mark) {  if (flag) {  fprintf(cp,".OR.");
  1010.                                          strcat(ms,".OR.");  nm+=4;
  1011.                                       }
  1012.                                 else {  fprintf(cp,".AND.");  strcat(ms,".AND.");  nm+=5;  }
  1013.                                 fprintf(cp,"%s->%s>CTOD('",DD,FF);
  1014.                                 strcat(ms,DD);  strcat(ms,"->");  strcat(ms,FF);
  1015.                                 strcat(ms,">CTOD(");  nm+=strlen(DD)+strlen(FF)+8;  ms[nm++]='"';
  1016.                                  }
  1017.                            else {  fprintf(cp,"%s->%s>CTOD('",DD,FF);
  1018.                                strcat(ms,">CTOD(");  nm+=6;  ms[nm++]='"';
  1019.                             }
  1020.                            fprintf(cp,"%d/",c);
  1021.                            itoa(c,str,10);  strcat(ms,str);  nm+=strlen(str);  ms[nm++]='/';
  1022.                            while ((c=getn(1,31,row,59))==0) error();
  1023.                            fprintf(cp,"%d/",c);
  1024.                            itoa(c,str,10);  strcat(ms,str);  nm+=strlen(str);  ms[nm++]='/';
  1025.                            while ((c=getn(1,99,row,63))==0) error();
  1026.                            fprintf(cp,"%d')",c);
  1027.                            itoa(c,str,10);  strcat(ms,str);  nm+=strlen(str);
  1028.                            ms[nm++]='"';  ms[nm++]=')';
  1029.                         }
  1030.                           break;
  1031.                    }
  1032.                  if (tt[nt++]=='C')
  1033.                    {  ms[nm++]=',';  strcat(ms,DD);  strcat(ms,"->");
  1034.                   strcat(ms,FF);  strcat(ms,")>0");  nm+=strlen(DD)+strlen(FF)+5;
  1035.                    }
  1036.                  row++;
  1037.                  nf++;
  1038.                  while (ss[nf]!='#'&&ss[nf]!='\0') {  fprintf(cp,"%c",ss[nf]);  ms[nm++]=ss[nf++];  }
  1039.                  if (ss[nf]!='\0') nf++;
  1040.                  nd++;
  1041.              }
  1042.                fprintf(cp,"\"\n");
  1043.                if (strchr(tt,'C')!=NULL)  fprintf(cp,"mcon='%s'\ncty='C'\n",ms);
  1044.                free(ms);
  1045.                continue;
  1046.       }
  1047.     n=in_c(&i);
  1048.     if (col>68)  {  col=1;  cursor(17,col);  }
  1049.     else cursor(16,col);
  1050.     printf("%s",wd->db[n-1].field);
  1051.     strcat(ss,wd->db[n-1].field);
  1052.     strcat(dd,ldb[i].name);
  1053.     strcat(dd,"#");
  1054.     tt[N++]=wd->db[n-1].type;
  1055.      }
  1056. }
  1057. savedef_xits(sele)
  1058. char *sele;/*5.15*/
  1059. {
  1060.  
  1061.     char um[3];
  1062.     FILE *fp,*dp;
  1063.     int i,j,k,l,m,n,no,p,row,col,code;
  1064.     struct BASE *midbase;
  1065.     char *buff,db[10],fd[10],ty;
  1066.     um[2]='\0';
  1067.     if ((fp=fopen("code.dbf","r"))!=NULL) code=1;
  1068.     else code=0;
  1069.     fclose(fp);
  1070.     strcat(sele,"scr");
  1071. /*    itoa(n1,um,10);
  1072.     strcat(sele,um);*/
  1073.     strcat(sele,".prg");
  1074.     fp=fopen(sele,"w");
  1075.     fprintf(fp,"set color to w+/b\nclea\n");
  1076.    row = 3; col = 12;
  1077.    i=0;
  1078.    while (ldb[i].dbs!=NULL)
  1079.      {   wd=ldb[i].dbs;
  1080.      k=0;
  1081.      j=0;
  1082.      while (k<wd->ctc&&j<128)
  1083.            { if (MAR[i][j]==1)
  1084.             {
  1085.             m=11+wd->db[k].len;
  1086.             if (col + m >70) {col=12; row=row+2;}
  1087.             if (row > 21)
  1088.                {
  1089.                fprintf(fp,"@24,0 clea\nwait\nclea\n");
  1090.                row=3; col=12;
  1091.                }
  1092.             if (col + m <=70)
  1093.                {
  1094.                fprintf(fp,"@%d,%d say '%-10s:'\n@%d,%d say %c->%s\n",row,col,wd->db[k].field,row,col+11,i+65,wd->db[k].field);
  1095.                if (code && wd->db[k].type=='C') fprintf(fp,"do codep with %d,%d,'%s',%c->%-s,'%c'\n",row,col+11,wd->db[k].field,i+65,wd->db[k].field,i+65);
  1096.                col=col+m+2;
  1097.                }
  1098.             else
  1099.                {
  1100.             fprintf(fp,"@%d,%d say '%-10s:'\n",row,col,wd->db[k].field);
  1101.             n=1;
  1102.             while ((n-1)*47 < m-11)
  1103.                {
  1104.                fprintf(fp,"@%d,%d say substr(%c->%s,%d,47)\n",row,col+11,i+65,wd->db[k].field,(n-1)*47+1);
  1105.                row++; n++;
  1106.                }
  1107.             row++;
  1108.                }
  1109.             }
  1110.             j++;  k++;
  1111.             if (k==wd->ctc&&wd->next!=NULL) {  k=0;  wd=wd->next;  }
  1112.          }
  1113.      i++;
  1114.      }
  1115. /*    if(i!=cc)
  1116.      {
  1117.        pr("cp=' '\n");
  1118.        pr("@24,0 say '░┤ ╚╬ ╥Γ ╝ⁿ ┐┤ ╧┬ ╥│ ' get cp\n");
  1119.        pr("read\n");
  1120.  
  1121.       }*/
  1122.      fprintf(fp,"set color to w+/b\n@24,0 clear\nset color to w+/b\nch=' '\n");
  1123.      fprintf(fp,"do while ch<>'Y'.and.ch<>'y' .and. ch<>'N'.and.ch<>'n'\n@24,5 say '╩╟╖±╝╠╨°▓Θ╤» ?' get ch\n");
  1124.      fprintf(fp,"read\nenddo\nif ch='Y'.or.ch='y'\nw=.t.\nww=.t.\nelse\n");
  1125.      fprintf(fp,"w=.f.\nww=.f.\nendif\n");
  1126.      fprintf(fp,"sele 1\nreturn\n"); fclose(fp);
  1127.  }
  1128.  prt(int row,int col,int attr,char *format,...)
  1129. {
  1130.     va_list arg;
  1131.     char print_str[254],*string;
  1132.     va_start(arg,format);
  1133.     vsprintf(print_str,format,arg);
  1134.     string=print_str;
  1135.   _SI =(unsigned int) string;
  1136.   _DH =(unsigned char)row;
  1137.   _DL =(unsigned char)col;
  1138.   _CX=1;
  1139.    while(*((char *)_SI)){
  1140.    _AH=(unsigned char)2;
  1141.    _BH=(unsigned char)0;
  1142.    geninterrupt(0x10);
  1143.    ++_DL;
  1144.   _AH=(unsigned char)9;
  1145.   _AL=*((char *)_SI);
  1146.   _SI++;
  1147.   _BH=(unsigned char)0;
  1148.   _BL=(unsigned char)attr;
  1149.   geninterrupt(0x10);
  1150.  }
  1151. }
  1152. /*------------------------------------------------------------------------*/
  1153.  print1(int attr,char *format,...)
  1154. {
  1155.     va_list arg;
  1156.     int row,col;
  1157.     char print_str[254],*string;
  1158.     va_start(arg,format);
  1159.     vsprintf(print_str,format,arg);
  1160.     string=print_str;
  1161.   _AH =(unsigned char)3;
  1162.   _BH =(unsigned char)0;
  1163.   geninterrupt(0x10);
  1164.   _DL++;
  1165.  _SI =(unsigned int) string;
  1166.   _CX=1;
  1167.    while(*((char *)_SI)){
  1168.    _AH=(unsigned char)2;
  1169.    _BH=(unsigned char)0;
  1170.    geninterrupt(0x10);
  1171.    ++_DL;
  1172.   _AH=(unsigned char)9;
  1173.   _AL=*((char *)_SI);
  1174.   _SI++;
  1175.   _BH=(unsigned char)0;
  1176.   _BL=(unsigned char)attr;
  1177.   geninterrupt(0x10);
  1178.  }
  1179. }
  1180. frame(s_r,s_c,e_r,e_c,attr)
  1181. int s_r,s_c,e_r,e_c,attr;
  1182. {
  1183.   int i,j;
  1184.   char line[80];
  1185.   union REGS r;
  1186.   r.h.ah=6;
  1187.   r.h.al=0;
  1188.   r.h.bh=attr;
  1189.   r.h.ch=s_r-1;
  1190.   r.h.cl=s_c-1;
  1191.   r.h.dh=e_r-1;
  1192.   r.h.dl=e_c-1;
  1193.   int86(0x10,&r,&r);
  1194.   strcpy(line,"⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ");
  1195.   prt(s_r-1,s_c-1,attr,"⌐│");
  1196.   prt(s_r-1,s_c+1,attr,"%-.*s",e_c-s_c-2,line);
  1197.   prt(s_r-1,e_c-1,attr,"⌐╖");
  1198.   for(i=s_r+1;i<e_r;i++)
  1199.   {
  1200.     prt(i-1,s_c-1,attr,"⌐º");
  1201.     prt(i-1,e_c-1,attr,"⌐º");
  1202.   }
  1203.   prt(e_r-1,s_c-1,attr,"⌐╗");
  1204.   prt(e_r-1,s_c+1,attr,"%-.*s",e_c-s_c-2,line);
  1205.   prt(e_r-1,e_c-1,attr,"⌐┐");
  1206. }
  1207. cls(S_X,S_Y,E_X,E_Y,attr)
  1208. int S_X,S_Y,E_X,E_Y,attr;
  1209. {
  1210.  _AH=(unsigned char)6;
  1211.  _AL=(unsigned char)0;
  1212.  _BH=(unsigned char)attr;
  1213.  _CH=(unsigned char)S_X;
  1214.  _CL=(unsigned char)S_Y;
  1215.  _DH=(unsigned char)E_X;
  1216.  _DL=(unsigned char)E_Y;
  1217.  geninterrupt(0x10);
  1218. }