home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 5 / 05.iso / a / a014 / 1.ddi / CDBINC.EXE / NSCR.C < prev    next >
Encoding:
C/C++ Source or Header  |  1991-11-20  |  33.7 KB  |  1,393 lines
  1. #include <stdio.h>
  2. #include <dos.h>
  3. #include <alloc.h>
  4. #include "screen.h"
  5. #define pr(x) fprintf(fp,x)
  6. #define black  0
  7. #define blue   1
  8. #define green  2
  9. #define cyan   3
  10. #define red    4
  11. #define magenta 5
  12. #define brown    6
  13. #define white  7
  14. #define intense 8
  15. #define yellow 14
  16. #define ewhite 15
  17. #define blue_back 16
  18. #define green_back 32
  19. #define cyan_back  48
  20. #define red_back   64
  21. #define magenta_back 80
  22. #define brown_back 96
  23. #define white_back 112
  24. #define ESC    27
  25. #define L_ARROW 275
  26. #define R_ARROW 277
  27. #define U_ARROW 272
  28. #define D_ARROW 280
  29. #define PgUp 273
  30. #define PgDn 281
  31. #define BACKSPACE 8
  32. #define INS    282
  33. #define DEL    283
  34. #define ENTER   13
  35. #define YES    1
  36. #define NO    -1
  37. #define FILE1 0
  38. #define EDIT 1
  39. #define LINE 2
  40. #define CCPP 3
  41. #define GENE 4
  42. #define FIELD 5
  43. #define QUIT 6
  44. #define COUNT 40
  45.  
  46. typedef struct ss {
  47.              char scr[24][80];
  48.              long int  fff[24][80];
  49.              int no, row, col;
  50.              long int range[20][2]    ;    /* field of N is ranged */
  51.              struct ss *next;
  52.            }screen;
  53.  
  54. /**typedef struct ss {
  55.              char scr[20][80];
  56.              int  fff[20][80];
  57.              int no;
  58.              struct ss *next;
  59.            }screen;**/
  60. extern  screen *myscr,*first;
  61. struct DBF {  struct DB {  char field[11];                 /* ╫╓╢╬├√ */
  62.                char type;                      /* ╫╓╢╬└α╨═ */
  63.                int len;                        /* ╫╓╢╬│ñ╢╚ */
  64.                int dec;                        /* ╨í╩²╬╗ */
  65.             } db[COUNT];
  66.           struct DBF *last;
  67.           struct DBF *next;
  68.           int ctc;                                     /* ╡▒╟░┐Γ╨┼╧ó┐Θ─┌╩╡╝╩┐Γ╡─╕÷╩² */
  69.        }  /** *fcon;**/;
  70. struct BASE {  struct BS {  char mean[31];                 /* ┐Γ║¼╥σ├√ */
  71.                 char name[9];                  /* ┐Γ╬─╝■├√ */
  72.                 struct DBF *dbs;               /* ╓╕╧≥┐Γ╜ß╣╣┐Θ═╖╡╪╓╖ */
  73.              } base[10];
  74.            struct BASE *last;
  75.            struct BASE *next;
  76.            int ctc;                                    /* ╡▒╟░┐Γ╜ß╣╣┐Θ─┌╩╡╝╩┐Γ╫╓╢╬╡─╕÷╩² */
  77.         }  *fbase;
  78. extern struct BASE *wb,*rb,*newb;
  79. extern struct BS ldb[6];
  80. extern struct DBF *wd,*rd,*newd;
  81. extern char *sele;/*road name in scr.prg */
  82. extern int linkflag,no,cod;  /*number of db*/
  83. extern int MAR[6][128];/*mar=1 in fff*/
  84. extern int NB,repeat,I,J,m12;/*fff retrun judge*/;
  85. extern char link[5][31],*explain,path[30],PATH[30];
  86. extern int ss0[10];
  87. /**char *hlp[]={
  88.         "Enter ..... ╢¿╬╗             Home ..... ╗¡┐≥/╧▀",
  89.         "  End ..... ╔╛│²┐≥/╧▀         Ins ..... ╢╘╜╟╧▀╥╞╢»",
  90.         "  Del ..... ╔╛│²╡▒╟░╫╓╖√     íⁿí² ..... ╔╧╧┬╥╞╢»",
  91.         "í·í√  ..... ╫≤╙╥╥╞╢»          Tab ..... ╙╥╥╞8╕±",
  92.         "Bksp  ..... ╫≤╥╞8╕±           Esc ..... ═╦│÷",
  93.          };
  94. char table[11][3]={"⌐│","⌐╖","⌐Ñ","⌐º","⌐╗","⌐┐","⌐∩","⌐╫","⌐▀","⌐╟","⌐╧"};**/
  95. /**int prow=23,pcol=66,attr=14|16;**/
  96.   char *tmp;
  97.   int crow[2],ccol[2];
  98.   int in,def=0;
  99.   int count=0,temp,total,update=0;
  100.   int just;
  101.  
  102.  
  103. int pp,cc;
  104. int insstate=YES;
  105. /**char tab[16][3]={
  106. "  ","⌐ñ","⌐ñ","⌐ñ","⌐º","⌐▓","⌐╢","⌐╘","⌐º"
  107. ,"⌐║","⌐╛","⌐▄","⌐º","⌐─","⌐╠","⌐µ"};**/
  108. int mpos;
  109. extern int n1;/*instead of extern no+1*/
  110.  
  111. /*============================checktab=============================*/
  112. /**int checktab(line,col)
  113. int line,col;
  114. {
  115. int i;
  116. for(i=1;i<16;i++)
  117. {
  118. if(myscr->scr[line][col]==tab[i][0]&&myscr->scr[line][col+1]==tab[i][1])
  119.     return(1);
  120. };
  121. return(0);
  122. }**/
  123.  
  124.  
  125.  
  126. int add(k,tj)
  127. int k;
  128. char tj[9];
  129. { FILE *fq;
  130.   char s[3];
  131.  int i=1,j=0;
  132.  strcpy(s,tj);
  133.  if(k==0)
  134.  {while(i==1)
  135.     {j++;
  136.     if (j<10)
  137.           {
  138.           tj[2]=j+'0';
  139.           tj[3]='\0';
  140.           }
  141.     else
  142.       {
  143.         tj[2]=j/10+'0';
  144.         tj[3]=j%10+'0';
  145.         tj[4]='\0';
  146.           }
  147.         strcat(tj,".txt");
  148.         if((fq=fopen(tj,"r"))==NULL) i=0;
  149.         fclose(fq);
  150.         }   /*end while*/
  151.         j--;
  152.         return(j);
  153.  }
  154.  else if(k==1)
  155.  {i=1;j=0;
  156.   while(i==1)
  157.     {j++;
  158.     if (j<10)
  159.           {
  160.           tj[2]=j+'0';
  161.           tj[3]='\0';
  162.           }
  163.     else
  164.       {
  165.         tj[2]=j/10+'0';
  166.         tj[3]=j%10+'0';
  167.         tj[4]='\0';
  168.           }
  169.         strcat(tj,".txt");
  170.         if((fq=fopen(tj,"r"))==NULL) i=0;
  171.         else{if(strncmp(s,"li",2)==0)system("del li*.* > oztom");else
  172.          if(strncmp(s,"lp",2)==0)system("del lp*.* > oztom");else
  173.          if(strncmp(s,"lf",2)==0)system("del lf*.* > oztom");else
  174.          if(strncmp(s,"lm",2)==0)system("del lm*.* > oztom");
  175.         }
  176.         }   /*end while*/
  177. }
  178. }
  179.  
  180. /*-----------------------------CLEAR SCREEN---------------------------------*/
  181. /**
  182. cls(S_X,S_Y,E_X,E_Y,attr)
  183. int S_X,S_Y,E_X,E_Y,attr;
  184. {
  185.  _AH=(unsigned char)6;
  186.  _AL=(unsigned char)0;
  187.  _BH=(unsigned char)attr;
  188.  _CH=(unsigned char)S_X;
  189.  _CL=(unsigned char)S_Y;
  190.  _DH=(unsigned char)E_X;
  191.  _DL=(unsigned char)E_Y;
  192.  geninterrupt(0x10);
  193. }
  194. **/
  195. /*----------------------READ A CHARACTER FROM KEYBOARD----------------*/
  196. /**
  197. get_key()
  198. {
  199.  union REGS r;
  200.  r.h.ah=0;
  201.  int86(0x16,&r,&r);
  202.  return(r.x.ax);
  203. }
  204. **/
  205. /*------------------------END OF GET_KEY() FUNCTION-------------------*/
  206. /*----------------------------CURSOR POSITION-------------------------------*/
  207. /**
  208. gotoxy(int row,int col)
  209. {
  210.     _AH=(unsigned char)2;
  211.     _BH=(unsigned char)0;
  212.     _DH=(unsigned char)row-1;
  213.     _DL=(unsigned char)col-1;
  214.     geninterrupt(0x10);
  215. }
  216. **/
  217. /*-----------------------------JUSTFY THE TAB-----------------------------*/
  218. /**
  219. justfy(trow,tcol,scr)
  220. int trow,tcol;
  221. char scr[20][80];
  222. {
  223.     int i;
  224.     for(i=0;i<11;i++)
  225.         if((scr[trow][tcol]==table[i][0])&&(scr[trow][tcol+1]==table[i][1]))
  226.         return(i);
  227.     return(99);
  228. }
  229. **/
  230. /*--------------------------------END OF JUSTFY---------------------------*/
  231. /*-------------------------JUSTFY IF A CHARACTER IS CHINESE--------------*/
  232. /**readc(int row,int col)
  233. {
  234.     _AH = (unsigned char) 2;
  235.     _BH = (unsigned char) 0;
  236.     _DH = (unsigned char) row;
  237.     _DL = (unsigned char) col;
  238.     geninterrupt(0x10);
  239.     _AH = (unsigned char) 8;
  240.     geninterrupt(0x10);
  241.     return(_AL);
  242. }       **/
  243. /*----------------------------SAVE DEFINE OF SCREEN---------------------------*/
  244. savedef(sele)
  245. char *sele;/*5.15*/
  246. {
  247.  
  248.     char um[3];
  249.     FILE *fp,*dp;
  250.     int i,j,k,l,m,n,no,p,row,col;
  251.     struct BASE *midbase;
  252.     char *buff,db[10],fd[10],ty,textname[30],pg[4];
  253.     um[2]='\0';
  254.     strcat(sele,"scr");
  255.     itoa(n1,um,10);
  256.     strcat(sele,um);
  257.     strcat(sele,".prg");
  258.     fp=fopen(sele,"w");
  259.     buff=(char *)malloc(60);
  260. /*    for(i=0;i<=cc;i++)*/
  261.     for (i=0,myscr=first;myscr!=NULL;i++)
  262.      {  pr("set color to w+/b\nclear\n");
  263. /**    for(k=1;k<=24;k++)
  264.       {if(myscr->scr[k][0]!='\0')
  265.         {fprintf(fp,"@%d,0 say '",k);
  266.            for(j=0;j<80;j++)
  267.               { if((j==40)||(j==79)){fprintf(fp,"'+'");}
  268.             if(myscr->scr[k][j]!='\0')
  269.             {   fprintf(fp,"%c",myscr->scr[k][j]);}
  270.  
  271.  
  272.  
  273.                }
  274.          fprintf(fp,"'\n");
  275.         }
  276.        }    **/
  277.  
  278.  
  279.     for(j=1;j<24;j++)
  280.      for(k=1;k<80;k++)
  281.       if(myscr->scr[j][k]!='\0'&&myscr->scr[j][k]!='*'&&myscr->scr[j][k-1]=='\0')
  282.         {
  283.         buff = &myscr->scr[j][k]    ;
  284.         fprintf(fp,"@%d,%d say '%s'\n",j,k,buff);
  285.         }
  286.  
  287.     strcpy(textname,"txt");
  288.     itoa(i+1,pg,10);
  289.     strcat(textname,pg);
  290.     strcat(textname,".txt");
  291. /**    dp=fopen("scrfff.txt","r");**/
  292.     dp=fopen(textname,"r");
  293.     while(fgets(buff,58,dp))
  294.       {
  295.         m=1;
  296.         p=0;
  297.         while(buff[m]!='#')
  298.           p=p*10+buff[m++]-'0';
  299.         if(p!=i)
  300.           continue;
  301.         m++;
  302.         row=0;
  303.         while(buff[m]!='#')
  304.           row=row*10+buff[m++]-'0';
  305.         m++;
  306.         col=0;
  307.         while(buff[m]!='#')
  308.           col=col*10+buff[m++]-'0';
  309.             m++;
  310.         no=0;
  311.         while(buff[m]!='#')
  312.           no=no*10+buff[m++]-'0';
  313.         m++;
  314.         n=0;
  315.         while(buff[m]!='#')
  316.           db[n++]=buff[m++];
  317.         db[n]='\0';
  318.         m++;
  319.         n=0;
  320.         while(buff[m]!='#')
  321.           fd[n++]=buff[m++];
  322.         fd[n]='\0';
  323.         fprintf(fp,"select %s\n",db);
  324.         fprintf(fp,"@%d,%d say %s\n",row,col,fd);
  325.                  if (cod==1)
  326.                     {if (fopen("codep.prg","r")!=NULL)
  327.                     {fprintf(fp,"if TYPE('%s')='C'\n",fd);
  328.                     fprintf(fp,"   do codep with %d,%d,'%s',%s,'%s'\nendif\n",row,col,\
  329.                     fd,fd,db);}
  330.                     }
  331.       }
  332.     fclose(dp);
  333. /*    fprintf(fp,"@24,15 say \"\"\n");
  334.     fprintf(fp,"wait\n"); */ /*5.17 wait*/
  335. /*    if(i!=cc)*/
  336.     if (myscr->next!=NULL)
  337.      {
  338.        pr("cp=' '\n");
  339.        pr("@24,0 say '░┤ ╚╬ ╥Γ ╝ⁿ ┐┤ ╧┬ ╥│ ' get cp\n");
  340.        pr("read\n");
  341.  
  342.       }
  343.      myscr=myscr->next;
  344.      }
  345.      pr("set color to w+/b\n@24,0 clear\nset color to w+/b\nch=' '\n");
  346.      pr("do while ch<>'Y'.and.ch<>'y' .and. ch<>'N'.and.ch<>'n'\n@24,5 say '╩╟╖±╝╠╨°▓Θ╤» ?' get ch\n");
  347.      pr("read\nenddo\nif ch='Y'.or.ch='y'\nw=.t.\nww=.t.\nelse\n");
  348.      pr("w=.f.\nww=.f.\nendif\n");
  349.      pr("sele 1\nreturn\n"); fclose(fp);
  350.      for (myscr=first->next;first!=NULL;)
  351.     {
  352.     free(first);
  353.     first=myscr;
  354.     myscr=myscr->next;
  355.     }
  356.  }
  357. /*-----------------------------HLINE FUNCTION-------------------------*/
  358.  
  359. /*-----------------------------DHLINE FUNCTION---------------------------*/
  360. /**
  361. dhline(crow,ccol,scr)
  362. int crow[2],ccol[2];
  363. char scr[20][80];
  364. {
  365.     int tcol,trow,just;
  366.     tcol=ccol[0];
  367.     trow=crow[0];
  368.     if(scr[trow][tcol]!='\0')
  369.     {
  370.         just=justfy(trow,tcol,scr);
  371.         switch(just){
  372.             case 2:
  373.                 scr[trow][tcol]=scr[trow][tcol+1]='\0';
  374.                 prow=trow;pcol=tcol;attr=0|0;
  375.                 print("%s","  ");attr=0|30;
  376.                 tcol+=2;
  377.                 goto again;
  378.             case 3:
  379.                 prow=trow;pcol=tcol;
  380.                 print("%s","⌐º");
  381.                 tcol+=2;
  382.                 goto again;
  383.             case 6:
  384.                 prow=trow;pcol=tcol;
  385.                 print("%s","⌐╧");
  386.                 scr[trow][tcol]=table[10][0];
  387.                 scr[trow][tcol+1]=table[10][1];
  388.                 tcol+=2;
  389.                 goto again;
  390.             case 0:
  391.             case 1:
  392.             case 4:
  393.             case 5:
  394.             case 7:
  395.             case 8:
  396.             case 9:
  397.             case 10:
  398.                 prow=trow;pcol=tcol;
  399.                 print("%s","⌐º");
  400.                 scr[trow][tcol]=table[3][0];
  401.                 scr[trow][tcol+1]=table[3][1];tcol+=2;
  402.                 goto again;
  403.             }
  404.         }
  405. again: if(tcol!=ccol[1])
  406.     {
  407.     if(scr[trow][tcol]=='\0')
  408.     {
  409.         prow=trow;pcol=tcol;attr=0|0;
  410.         print("%s","  ");attr=0|30;
  411.         tcol+=2;
  412.         goto again;
  413.     }
  414.     else
  415.     {
  416.         just=justfy(trow,tcol,scr);
  417.         switch(just){
  418.             case 0:
  419.             case 1:
  420.             case 4:
  421.             case 5:
  422.             case 6:
  423.             case 7:
  424.             case 8:
  425.             case 9:
  426.             case 10:
  427.                 prow=trow;pcol=tcol;
  428.                 print("%s","⌐º");
  429.                 scr[trow][tcol]=table[3][0];
  430.                 scr[trow][tcol+1]=table[3][1];
  431.                 tcol+=2;
  432.                 goto again;
  433.             case 2:
  434.                 if(readc(trow-1,tcol-1)>128&&justfy(trow,tcol,myscr)==99)
  435.                 {
  436.                     tcol+=2;
  437.                     goto again;
  438.                 }
  439.                 prow=trow;pcol=tcol;attr=0|0;
  440.                 print("%s","  ");attr=0|30;
  441.                 scr[trow][tcol]=scr[trow][tcol+1]='\0';
  442.                 tcol+=2;
  443.                 goto again;
  444.             case 3:
  445.                 tcol+=2;
  446.                 goto again;
  447.             default:
  448.                 tcol+=2;
  449.                 goto again;
  450.             }
  451.         }
  452.     }
  453.     else
  454.     {
  455.         if(scr[trow][tcol]!='\0')
  456.         {
  457.             just=justfy(trow,tcol,scr);
  458.             switch(just){
  459.                 case 0:
  460.                 case 1:
  461.                 case 4:
  462.                 case 5:
  463.                 case 7:
  464.                 case 8:
  465.                 case 9:
  466.                 case 10:
  467.                     prow=trow;pcol=tcol;
  468.                     print("%s","⌐º");
  469.                     scr[trow][tcol]=table[3][0];
  470.                     scr[trow][tcol+1]=table[3][1];
  471.                     tcol+=2;
  472.                     break;
  473.                 case 2:
  474.                     prow=trow;pcol=tcol;attr=0|0;
  475.                     print("%s","  "); attr=0|30;
  476.                     scr[trow][tcol]=scr[trow][tcol+1]='\0';
  477.                     tcol+=2;
  478.                     break;
  479.                 case 3:
  480.                     tcol+=2;
  481.                     break;
  482.                 case 6:
  483.                     prow=trow;pcol=tcol;
  484.                     print("%s","⌐╟");
  485.                     scr[trow][tcol]=table[9][0];
  486.                     scr[trow][tcol+1]=table[9][1];
  487.                     tcol+=2;
  488.                     break;
  489.             }
  490.         }
  491.         else
  492.             {
  493.             prow=trow;pcol=tcol;attr=0|0;
  494.             print("%s","  ");attr=0|30;
  495.             }
  496.     }
  497. }
  498.  
  499. **/
  500. /*------------------------END OF DHLINE FUNCTION---------------------------*/
  501.  
  502. /*-----------------------------DVLINE   FUNCTION--------------------------*/
  503. /**
  504. dvline(crow,ccol,scr)
  505. int crow[2],ccol[2];
  506. char scr[20][80];
  507. {
  508.     int trow,tcol,just;
  509.     trow=crow[0];tcol=ccol[0];
  510.     if(scr[trow][tcol]!='\0')
  511.     {
  512.         just=justfy(trow,tcol,scr);
  513.         switch(just){
  514.             case 3:
  515.                 scr[trow][tcol]=scr[trow][tcol+1]='\0';
  516.                 prow=trow;pcol=tcol;attr=0|0;
  517.                 print("%s","  ");attr=0|30;
  518.                 trow++;
  519.                 goto again;
  520.             case 2:
  521.                 prow=trow;pcol=tcol;
  522.                 print("%s","⌐Ñ");
  523.                 trow++;
  524.                 goto again;
  525.             case 6:
  526.                 prow=trow;pcol=tcol;
  527.                 print("%s","⌐▀");
  528.                 scr[trow][tcol]=table[8][0];
  529.                 scr[trow][tcol+1]=table[8][1];
  530.                 trow++;
  531.                 goto again;
  532.             case 0:
  533.             case 1:
  534.             case 4:
  535.             case 5:
  536.             case 7:
  537.             case 8:
  538.             case 9:
  539.             case 10:
  540.                 prow=trow;pcol=tcol;
  541.                 print("%s","⌐Ñ");
  542.                 scr[trow][tcol]=table[2][0];
  543.                 scr[trow][tcol+1]=table[2][1];trow++;
  544.                 goto again;
  545.             }
  546.         }
  547. again: if(trow!=crow[1])
  548.     {
  549.     if(scr[trow][tcol]=='\0')
  550.     {
  551.         prow=trow;pcol=tcol;attr=0|0;
  552.         print("%s","  "); attr=0|30;
  553.         trow++;
  554.         goto again;
  555.     }
  556.     else
  557.     {
  558.         just=justfy(trow,tcol,scr);
  559.         switch(just){
  560.             case 0:
  561.             case 1:
  562.             case 4:
  563.             case 5:
  564.             case 6:
  565.             case 7:
  566.             case 8:
  567.             case 9:
  568.             case 10:
  569.                 prow=trow;pcol=tcol;
  570.                 print("%s","⌐Ñ");
  571.                 scr[trow][tcol]=table[2][0];
  572.                 scr[trow][tcol+1]=table[2][1];
  573.                 trow++;
  574.                 goto again;
  575.             case 3:
  576.                 prow=trow;pcol=tcol;attr=0|0;
  577.                 print("%s","  ");attr=0|30;
  578.                 scr[trow][tcol]=scr[trow][tcol+1]='\0';
  579.                 trow++;
  580.                 goto again;
  581.             case 2:
  582.                 trow++;
  583.                 goto again;
  584.             default:
  585.                 trow++;
  586.                 goto again;
  587.             }
  588.         }
  589.     }
  590.     else
  591.     {
  592.         if(scr[trow][tcol]!='\0')
  593.         {
  594.             just=justfy(trow,tcol,scr);
  595.             switch(just){
  596.                 case 0:
  597.                 case 1:
  598.                 case 4:
  599.                 case 5:
  600.                 case 7:
  601.                 case 8:
  602.                 case 9:
  603.                 case 10:
  604.                     prow=trow;pcol=tcol;
  605.                     print("%s","⌐Ñ");
  606.                     scr[trow][tcol]=table[2][0];
  607.                     scr[trow][tcol+1]=table[2][1];
  608.                     trow++;
  609.                     break;
  610.                 case 3:
  611.                     prow=trow;pcol=tcol;attr=0|0;
  612.                     print("%s","  ");attr=0|30;
  613.                     scr[trow][tcol]=scr[trow][tcol+1]='\0';
  614.                     trow++;
  615.                     break;
  616.                 case 2:
  617.                     trow++;
  618.                     break;
  619.                 case 6:
  620.                     prow=trow;pcol=tcol;
  621.                     print("%s","⌐╫");
  622.                     scr[trow][tcol]=table[7][0];
  623.                     scr[trow][tcol+1]=table[7][1];
  624.                     trow++;
  625.                     break;
  626.             }
  627.         }
  628.         else
  629.             {prow=trow;pcol=tcol;attr=0|0;
  630.             print("%s","  ");attr=0|30;
  631.             }
  632.     }
  633. }
  634. **/
  635. /*--------------------------END OF DVLINE FUNCTION-------------------------*/
  636. /*================================change============================*/
  637. int change(u,d,l,r)
  638. int u,d,l,r;
  639. {
  640. return(u*8+d*4+l*2+r);
  641. }
  642.  
  643. /*=========================gframe============================*/
  644. gframe(startx,starty,endx,endy,sss,color)
  645. int startx,starty;
  646. int endx,endy;
  647. int sss;
  648. int color;
  649. {
  650. static char dd[3][6][3]={
  651.       "⌐Ñ","⌐º","⌐│","⌐╖","⌐╗","⌐┐",
  652.       "⌐ñ","⌐ª","⌐░","⌐┤","⌐╕","⌐╝" ,
  653.       "  ","  ","  ","  ","  ","  "
  654.                      };
  655. int row,col;
  656. char *s;
  657. clear(6,0,startx,starty,endx,endy);
  658. cursor(startx,starty);
  659. color_puts(dd[sss][2],color);
  660. for(col=starty+2; col<endy; col+=2){
  661.        cursor(startx,col);
  662.        color_puts(dd[sss][0],color);
  663.                                    }
  664. cursor(startx,endy);
  665. color_puts(dd[sss][3],color);
  666.  
  667. for(row=startx+1; row<endx; ++row){
  668.    cursor(row,starty);
  669.    color_puts(dd[sss][1],color);
  670.    cursor(row,endy);
  671.    color_puts(dd[sss][1],color);
  672.    cursor(row,starty+2);
  673.                                  }
  674.    cursor(endx,starty);
  675.   color_puts(dd[sss][4],color);
  676.  
  677.   for(col=starty+2; col<endy; ++col,++col){
  678.        cursor(endx,col);
  679.        color_puts(dd[sss][0],color);
  680.      }
  681.   cursor(endx,endy);
  682.   color_puts(dd[sss][5],color);
  683.    return;
  684. }
  685. getchb()
  686. { int t,m;
  687. union REGS regs;
  688. int page,limline,step;
  689.   regs.x.ax=0;
  690.   int86(0x16,®s,®s);
  691.   t=regs.x.ax & 0x00ff;
  692.   m=(regs.x.ax-t)/256;
  693.   if (t!=0) return(t);
  694.   return(m+200);
  695. }
  696.  
  697.  
  698. /*----------------------------------------------------------------*/
  699. /*          ╔· │╔ ▓Θ ╤» ╜ß ╣√ ┐Γ ╡─ ┐Γ ╜ß ╣╣ ╩² ╛▌ ╬─ ╝■          */
  700. /*----------------------------------------------------------------*/
  701. cre(m,str)
  702. int m;
  703. char *str;
  704. {  FILE *sp;
  705.    int n,i,j,k;
  706.    char *st;
  707.    struct DBF *p;
  708.    st=(char *)malloc(10*sizeof(char));
  709.    strcpy(st,str);
  710.    n=m+1;
  711.    if (n<10)
  712.       {
  713.       st[2]=n+'0';
  714.       st[3]='\0';
  715.       }
  716.    else
  717.       {
  718.       st[2]=n/10+'0';
  719.       st[3]=n%10+'0';
  720.       st[4]='\0';
  721.       }
  722.    strcat(st,".txt");
  723.     sp=fopen(st,"w");
  724.    for (i=0;ldb[i].dbs!=NULL;i++)
  725.      {  p=ldb[i].dbs;
  726.     m=0;
  727.     n=0;
  728.     while (n<p->ctc)
  729.     { if (MAR[i][m]==1)
  730.         fprintf(sp,"#%s#,#%c#,%d,%d\n",p->db[n].field,p->db[n].type,p->db[n].len,p->db[n].dec);
  731.       n++;m++;
  732.       if (n==p->ctc&&p->next!=NULL) {  n=0;  p=p->next;  }
  733.       }
  734.      }
  735.    fclose(sp);
  736.    return(0);
  737. }
  738. /*-------------------------------------------------*/
  739. /*          ╔· │╔ ╙ª ╙├ │╠ ╨≥ ╧╘ ╩╛ ▒Σ ┴┐          */
  740. /*-------------------------------------------------*/
  741. cre1(m,sp)
  742. int m;
  743. FILE *sp;
  744. {  int i,j,n,k;
  745.    struct DBF *p;
  746.    n='A';
  747.    fprintf(sp,"f%d='",m+1);
  748.    for (i=0;ldb[i].dbs!=NULL;i++)
  749.      {  p=ldb[i].dbs;
  750.     j=0;
  751.     k=0;
  752.     while (k<p->ctc)
  753.       {  if (MAR[i][j++]) fprintf(sp,"%c",n);
  754.          k++;
  755.          if (k==p->ctc&&p->next!=NULL)  {  k=0;  p=p->next;  }
  756.       }
  757.     n++;
  758.      }
  759.    fprintf(sp,"'\n");
  760. }
  761. /*-------------------------------------------------------------*/
  762. /*          ╔· │╔ ▓Θ ╤» ╧ε ╧╘ ╩╛ ▓╦ ╡Ñ ╡─ ╩² ╛▌ ╬─ ╝■          */
  763. /*-------------------------------------------------------------*/
  764. cre2(name,n,op,dd)
  765. int n;
  766. char *name;
  767. FILE *op;
  768. int dd;
  769. {  int i=0;
  770.    if (ldb[1].dbs!=NULL)
  771.      {  fprintf(op,"#%d#,#%d#,#%s#,%d",dd,linkflag,name,n);
  772.     while (i<6) fprintf(op,",#%s#",ldb[i++].name);
  773.     i=0;
  774.     while (i<5) fprintf(op,",#%s#",link[i++]);
  775.      }
  776.    else fprintf(op,"#%d#,##,#%s#,%d,#%s#",dd,ldb[0].mean,n,ldb[0].name);
  777.     fprintf(op,"\n");
  778. }
  779. inc(i)
  780. int *i;
  781. {  int n=0,j=0;
  782.    clear(6,0,22,2,23,76);
  783.    if (ldb[1].dbs!=NULL)
  784.      {  cursor(22,10);
  785.         color_puts("╟δ╤í╘±▓┘╫≈╫╓╢╬ (íⁿ/í²: ╤í┐Γ, PgUp/PgDn: ╖¡╞┴): ",10);
  786.      }
  787.    else
  788.      {  cursor(22,20);
  789.     color_puts("╟δ╤í╘±▓┘╫≈╫╓╢╬(PgUp/PgDn: ╖¡╞┴): ",10);
  790.      }
  791.    while (n==0)
  792.      {  if (ldb[1].dbs!=NULL)
  793.       {  while ((n=get(22,57))!=0)
  794.            {  if (n=='u'||n=='d')
  795.             {  if (n=='u'&&*i>0)  {  (*i)--;  rd=ldb[*i].dbs;  wd=ldb[*i].dbs;j--;}
  796.                else if (*i<5&&ldb[*i+1].dbs!=NULL)  {  (*i)++;  rd=ldb[*i].dbs;  wd=ldb[*i].dbs;j++;}
  797.                m12=judge(0);
  798.             }
  799.           else  if (n=='U'||n=='D')
  800.               {  m12=judge(n);
  801.                  continue;
  802.               }
  803.             else break;
  804.            }
  805.       }
  806.     else
  807.       {  n=get(22,53);
  808.          if (n=='U'||n=='D')
  809.            {  m12=judge(n);
  810.           n=0;
  811.           continue;
  812.            }
  813.          if (n=='u'||n=='d') {  n=0;  continue;  }
  814.       }
  815.     if (n==0) error();
  816.      }
  817.    if (n%COUNT==0) {MAR[j][COUNT-1]=1;return(COUNT);}
  818.    else {MAR[j][n%COUNT-1]=1;return(n%COUNT);}
  819. }
  820. /*------------------------------------------------------------------------*/
  821.  print1(int attr,char *format,...)
  822. {
  823.     va_list arg;
  824.     int row,col;
  825.     char print_str[254],*string;
  826.     va_start(arg,format);
  827.     vsprintf(print_str,format,arg);
  828.     string=print_str;
  829.   _AH =(unsigned char)3;
  830.   _BH =(unsigned char)0;
  831.   geninterrupt(0x10);
  832.   _DL++;
  833.  _SI =(unsigned int) string;
  834.   _CX=1;
  835.    while(*((char *)_SI)){
  836.    _AH=(unsigned char)2;
  837.    _BH=(unsigned char)0;
  838.    geninterrupt(0x10);
  839.    ++_DL;
  840.   _AH=(unsigned char)9;
  841.   _AL=*((char *)_SI);
  842.   _SI++;
  843.   _BH=(unsigned char)0;
  844.   _BL=(unsigned char)attr;
  845.   geninterrupt(0x10);
  846.  }
  847. }
  848. read_string(string,length)
  849. char *string;
  850. int length;
  851. {
  852.    char middstr[41];
  853.    int  ctc,charact;
  854.    int x,y;
  855.    for (ctc=0;ctc<20;ctc++) middstr[ctc]='\0';
  856.    ctc=0;
  857.    while (ctc<length-1)
  858.       {
  859.       charact=getchb();
  860.       if (charact==13) break;
  861.       if ((charact==8)&&(ctc>0)) {
  862.      now_cursor(&x,&y);
  863.      go_to(x+1,y); printf(" ");
  864.      go_to(x+1,y); middstr[--ctc]='\0';
  865.      continue;
  866.      }
  867.       if (charact<=30 || charact>=128) continue;
  868.       printf("%c",charact);
  869.       middstr[ctc++]=charact;
  870.       }
  871.    if (strcmp(middstr,NULL)!=0)
  872.       strcpy(string,middstr);
  873.    return(0);
  874. }
  875. /*----------------------------CURSOR POSITION-------------------------------*/
  876. go_to(int row,int col)
  877. {
  878.     _AH=(unsigned char)2;
  879.     _BH=(unsigned char)0;
  880.     _DH=(unsigned char)row-1;
  881.     _DL=(unsigned char)col-1;
  882.     geninterrupt(0x10);
  883. }
  884. /*---------------------------------------------------------------------------------*/
  885. frame(s_r,s_c,e_r,e_c,attr)
  886. int s_r,s_c,e_r,e_c,attr;
  887. {
  888.   int i,j;
  889.   char line[80];
  890.   union REGS r;
  891.   r.h.ah=6;
  892.   r.h.al=0;
  893.   r.h.bh=attr;
  894.   r.h.ch=s_r-1;
  895.   r.h.cl=s_c-1;
  896.   r.h.dh=e_r-1;
  897.   r.h.dl=e_c-1;
  898.   int86(0x10,&r,&r);
  899.   strcpy(line,"⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ");
  900.   prt(s_r-1,s_c-1,attr,"⌐│");
  901.   prt(s_r-1,s_c+1,attr,"%-.*s",e_c-s_c-2,line);
  902.   prt(s_r-1,e_c-1,attr,"⌐╖");
  903.   for(i=s_r+1;i<e_r;i++)
  904.   {
  905.     prt(i-1,s_c-1,attr,"⌐º");
  906.     prt(i-1,e_c-1,attr,"⌐º");
  907.   }
  908.   prt(e_r-1,s_c-1,attr,"⌐╗");
  909.   prt(e_r-1,s_c+1,attr,"%-.*s",e_c-s_c-2,line);
  910.   prt(e_r-1,e_c-1,attr,"⌐┐");
  911. }
  912.  
  913. savedef_xits(sele)
  914. char *sele;/*5.15*/
  915. {
  916.  
  917.     char um[3];
  918.     FILE *fp,*dp;
  919.     int i,j,k,l,m,n,no,p,row,col,code;
  920.     struct BASE *midbase;
  921.     char *buff,db[10],fd[10],ty;
  922.     um[2]='\0';
  923.     if ((fp=fopen("code.dbf","r"))!=NULL) code=1;
  924.     else code=0;
  925.     fclose(fp);
  926.     strcat(sele,"scr");
  927.     itoa(n1,um,10);
  928.     strcat(sele,um);
  929.     strcat(sele,".prg");
  930.     fp=fopen(sele,"w");
  931.     fprintf(fp,"set color to w+/b\nclea\n");
  932.    row = 3; col = 12;
  933.    i=0;
  934.    while (ldb[i].dbs!=NULL)
  935.      {   wd=ldb[i].dbs;
  936.      k=0;
  937.      j=0;
  938.      while (k<wd->ctc&&j<128)
  939.            { if (MAR[i][j]==1)
  940.             {
  941.             m=11+wd->db[k].len;
  942.             if (col + m >70) {col=12; row=row+2;}
  943.             if (row > 21)
  944.                {
  945.                fprintf(fp,"@24,0 clea\nwait\nclea\n");
  946.                row=3; col=12;
  947.                }
  948.             if (col + m <=70)
  949.                {
  950.                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);
  951.                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);
  952.                col=col+m+2;
  953.                }
  954.             else
  955.                {
  956.             fprintf(fp,"@%d,%d say '%-10s:'\n",row,col,wd->db[k].field);
  957.             n=1;
  958.             while ((n-1)*47 < m-11)
  959.                {
  960.                fprintf(fp,"@%d,%d say substr(%c->%s,%d,47)\n",row,col+11,i+65,wd->db[k].field,(n-1)*47+1);
  961.                row++; n++;
  962.                }
  963.             row++;
  964.                }
  965.             }
  966.             j++;  k++;
  967.             if (k==wd->ctc&&wd->next!=NULL) {  k=0;  wd=wd->next;  }
  968.          }
  969.      i++;
  970.      }
  971. /*    if(i!=cc)
  972.      {
  973.        pr("cp=' '\n");
  974.        pr("@24,0 say '░┤ ╚╬ ╥Γ ╝ⁿ ┐┤ ╧┬ ╥│ ' get cp\n");
  975.        pr("read\n");
  976.  
  977.       }*/
  978.      fprintf(fp,"set color to w+/b\n@24,0 clear\nset color to w+/b\nch=' '\n");
  979.      fprintf(fp,"do while ch<>'Y'.and.ch<>'y' .and. ch<>'N'.and.ch<>'n'\n@24,5 say '╩╟╖±╝╠╨°▓Θ╤» ?' get ch\n");
  980.      fprintf(fp,"read\nenddo\nif ch='Y'.or.ch='y'\nw=.t.\nww=.t.\nelse\n");
  981.      fprintf(fp,"w=.f.\nww=.f.\nendif\n");
  982.      fprintf(fp,"sele 1\nreturn\n"); fclose(fp);
  983.  }
  984. /*-------------------------------------*/
  985. /*          ╢┴ ┐Γ ╙╨ ╣╪ ╨┼ ╧ó          */
  986. /*-------------------------------------*/
  987. getbase(path)
  988. char *path;
  989. {  FILE *fp;
  990.    char c[2],key[4][11],c1[2],pathbak[30],buff[80];
  991.    int i=0;
  992.    fp=fopen("db.txt","r");
  993.    getmemb();
  994.    rb=newb;
  995.    wb=newb;
  996.    while (fgets(buff,80,fp)!=NULL)
  997.      {  if (i%10==0&&i!=0)
  998.       {  getmemb();
  999.          i=0;
  1000.          wb->next=newb;
  1001.          newb->last=wb;
  1002.          wb=newb;
  1003.       }
  1004.     sscanf(buff,"#%[^#]#,#%[^#]#,#%[^#]#,#%[^#]#,#%[^#]#,#%[^#]#,#%[^#]#,#%[^#]#,#%[^#]#\n",\
  1005.     wb->base[i].mean,key[0],key[1],key[2],key[3],wb->base[i].name,c,c1,pathbak);
  1006. /*    getmemd();
  1007.     wd=newd;
  1008.     wb->base[i].dbs=newd;
  1009.     getcontent(path,wb->base[i].name);*/
  1010.     i++;
  1011.     wb->ctc++;
  1012.      }
  1013.    fclose(fp);
  1014.    rd=rb->base[0].dbs;
  1015.    wb=rb;
  1016.    wd=rd;
  1017. }
  1018. /*----------------------------------------*/
  1019. /*          ╢┴ ╚δ ┐Γ ╜ß ╣╣ ╨┼ ╧ó          */
  1020. /*----------------------------------------*/
  1021. getcontent(path,dbf)
  1022. char *path,*dbf;
  1023. {  FILE *fp;
  1024.    char *s,buff[80];
  1025.    int i=0;
  1026.    s=(char *)malloc(30*sizeof(char));
  1027.    strcpy(s,path);
  1028.    strcat(s,dbf);
  1029.    strcat(s,".txt");
  1030.    i=0;
  1031.    fp=fopen(s,"r");
  1032.    while (fgets(buff,80,fp)!=NULL)
  1033.      {  if (wd->ctc%COUNT==0&&wd->ctc!=0)
  1034.       {  i=0;
  1035.          getmemd();
  1036.          wd->next=newd;
  1037.          newd->last=wd;
  1038.          wd=newd;
  1039.       }
  1040.     sscanf(buff,"#%[^#]#,#%c#,%d,%d\n",wd->db[i].field,&wd->db[i].type,&wd->db[i].len,&wd->db[i].dec);
  1041.     i++;
  1042.     wd->ctc++;
  1043.      }
  1044.    fclose(fp);
  1045. }
  1046. /*-------------------------------------------------*/
  1047. /*          ┼╨ ╢╧ ─ú ┐Θ ╩╟ ╖± ╥╤ ╔· │╔ ╣²          */
  1048. /*-------------------------------------------------*/
  1049.   int exist(s,t)
  1050. char *s,*t;
  1051. {  FILE *fp;
  1052.    char c;
  1053.    if ((fp=fopen(t,"r"))!=NULL)
  1054.      {cls(1,1,25,80,48|33);
  1055.    cls(11,20,16,63,0|1);
  1056.    cls(10,19,15,61,0|30);
  1057.    frame(9,18,15,60,0|30);
  1058.    prt(6,15,48|33,"***** %s ─ú┐Θ╣²╚Ñ╥╤╛¡╔·│╔╣² *****",s);
  1059.    prt(10,25,0|30,"1. ╓╪╨┬╔·│╔");
  1060.    prt(11,25,0|30,"2. ╠φ╝╙╔·│╔ ");
  1061.    prt(12,25,0|30,"3. ▒ú│╓╘¡╙╨ ");
  1062.    prt(19,28,48|33," ╟δ╤í╘±(1--3): ");
  1063.    while ((c=getchar())!='1'&&c!='2'&&c!='3') ;
  1064.      }
  1065.    else fclose(fp);
  1066.    cod=1;/*add cod with scr.c code*/
  1067.    if(c=='1') return(1);
  1068.    if(c=='2') return(2);
  1069.    if(c=='3') return(3);
  1070. }
  1071. /*----------------------------------------------*/
  1072. /*          ╧╘ ╩╛ ╧╡ ═│ ╩² ╛▌ ┐Γ ▓╦ ╡Ñ          */
  1073. /*----------------------------------------------*/
  1074. disp()
  1075. {  int i,x,y,n=0;
  1076.    struct BASE *p;
  1077.    p=rb;
  1078.    while (p!=wb)  {  n+=p->ctc;  p=p->next;  }
  1079.    cls(1,1,25,80,48|33);
  1080.    prt(0,1,0|30,"%s",explain);
  1081.    prt(0,44,48|33,"F1-Help  Esc-Exit  ╗╪│╡: ═╦│÷▒╛─ú┐Θ");
  1082.    prt(2,18,48|33,"▒╛╧╡═│╓╨╡─╚½▓┐╩²╛▌┐Γ╚τ╧┬");
  1083.    cls(7,4,12,79,0|1);
  1084.    cls(6,3,11,77,0|30);
  1085.    frame(5,2,11,76,0|30);
  1086.    x=5;
  1087.    y=4;
  1088.    for (i=0;i<wb->ctc;i++)
  1089.       {  cursor(x,y);
  1090.      prt(x,y,0|30,"%2d - %-30s",n+i+1,wb->base[i].mean);
  1091.      y+=36;
  1092. /**     y+=26;**/
  1093.      if (y+10>80)
  1094.        {  x++;
  1095. /**          y=1;**/
  1096.           y=4;
  1097.        }
  1098.       }
  1099. }
  1100. /*----------------------------------------*/
  1101. /*          ╧╘ ╩╛ ┐Γ ╜ß ╣╣ ▓╦ ╡Ñ          */
  1102. /*----------------------------------------*/
  1103. disp_base(m)
  1104. int m;
  1105. {  int row,col,i,n=0;
  1106.    struct DBF *p;
  1107. /*   p=wb->base[m].dbs;*/
  1108.    p=ldb[m].dbs;
  1109.    while (p!=wd)  {  n+=p->ctc;  p=p->next;  }
  1110.    cls(1,1,17,78,48|33);
  1111.    cls(6,6,17,73,0|1);
  1112.    cls(5,5,16,71,0|30);
  1113.    frame(4,4,16,70,0|30);
  1114.    prt(0,1,0|30,"%s",explain);
  1115.    prt(1,10,48|33,"┐Γ # %s # ╓╨║¼╙╨╥╘╧┬╫╓╢╬",ldb[m].mean);
  1116.    row=5;
  1117.    col=7;
  1118.    for (i=0;i<wd->ctc;i++)
  1119.       {  prt(row,col,0|30,"%2d. %-s",n+i+1,wd->db[i].field);
  1120.      col+=16;
  1121.      if (col>70)
  1122.        {  row++;
  1123.           col=7;
  1124.        }
  1125.       }
  1126. }
  1127. /*-------------------------------*/
  1128. /*          ┤░ ┐┌ ╠ß ╩╛          */
  1129. /*-------------------------------*/
  1130. helplo()
  1131. {  char c;
  1132.    cursor(11,5);
  1133.    color_puts("⌐│⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐╖\
  1134.    \n⌐º    ─·┐╔╤í╘±╔╧╩÷┐Γ, ╜°╨╨╡Ñ┐Γ╗≥╢α┐Γ▓┘╫≈. ╚⌠╥¬╔·│╔╢╘╢α┐Γ▓Θ╤», ╘≥╕≈┐Γ╝Σ⌐º\
  1135.    \n⌐º▒╪╨δ╙╨╧α═¼╫╓╢╬, ╟╥╧α═¼╫╓╢╬╘┌▒╗┴¼╜╙┐Γ╓╨╙ª╩╟╣╪╝ⁿ╫╓.                   ⌐º\
  1136.    \n⌐º    ╘┌╤í┐Γ╩▒, ╚τ╣√─·╓╗╤í╘±┴╦╥╗╕÷┐Γ, ╘≥▒φ╩╛╢╘╡Ñ┐Γ▓┘╫≈; ╚τ╣√─·╤í╘±┴╦┴╜⌐º\
  1137.    \n⌐º╕÷╥╘╔╧╡─┐Γ, ╘≥▒φ╩╛╢╘╢α┐Γ▓┘╫≈, ╧╡═│╜½╫╘╢»╕∙╛▌─·╤í╘±╡─╦│╨≥░╤╕≈┐Γ┴¼╜╙╞≡⌐º\
  1138.    \n⌐º└┤.                                                                 ⌐º\
  1139.    \n⌐º                    ╫ó╥Γ : ┐╔┴¼╜╙╡─┐Γ╫ε╢α─▄╙╨6╕÷                    ⌐º\
  1140.    \n⌐╗⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐Ñ⌐┐",15);
  1141.    color_puts(" ",10);
  1142.    go_on();
  1143.    clear(6,0,11,0,18,79);
  1144.    cursor(20,50);
  1145. }
  1146. /*-------------------------------------*/
  1147. /*          ┤φ ╬≤ ╨┼ ╧ó ╠ß ╩╛          */
  1148. /*-------------------------------------*/
  1149. error()
  1150. {  cursor(23,15);
  1151.    prt(23,15,48|33,"###### ╩Σ╚δ┤φ╬≤! ╟δ╓╪╨┬╘┘╩Σ ######");
  1152.    dela();
  1153.    cursor(23,15);
  1154.    prt(23,15,48|33,"                                   ");
  1155. }
  1156. /*----------------------------------------*/
  1157. /*          ╢¿ ╥σ ▓Θ ╤» ▓┘ ╫≈ ┐Γ          */
  1158. /*----------------------------------------*/
  1159. getroad(l)
  1160. int l;
  1161. {  int i,n,x,y,col,j,cir,min=1,max,m,dbctc;
  1162.    system("cls");
  1163.    wb=rb;
  1164.    disp();
  1165.    prt(19,20,48|33,"╟δ╢¿╥σ╡┌ %d ╕÷▓Θ╤»▓┘╫≈┐Γ",l+1);
  1166.    prt(20,5,48|33,"╩Σ╚δ┐Γ╡─┤·║┼(PgUp/PgDn: ╖¡╞┴, 0: ╜ß╩°) -- A:   B:   C:   D:   E:   F:   ");
  1167.    for (i=0;i<6;i++) {ldb[i].dbs=NULL; strcpy(ldb[i].name,"");}
  1168.    max=wb->ctc;
  1169.    i=0;
  1170.    while ((n=getn(min,max,20,49))!=0)
  1171.      {
  1172. /**/          ss0[i]=n;
  1173.        if (n=='H')
  1174.       {  helplo();
  1175.          while ((n=getn(min,max,20,49))=='H') helplo();
  1176.          if (n==0) return(0);
  1177.       }
  1178.     if (n=='U') {
  1179.             if (wb->last!=NULL)
  1180.                {  max-=wb->ctc;  wb=wb->last; min-=10;  disp(); }
  1181.             prt(19,20,48|33,"╟δ╢¿╥σ╡┌ %d ╕÷▓Θ╤»▓┘╫≈┐Γ",l+1);
  1182.             prt(20,5,48|33,"╩Σ╚δ┐Γ╡─┤·║┼(PgUp/PgDn: ╖¡╞┴, 0: ╜ß╩°) -- A:   B:   C:   D:   E:   F:   ");
  1183.             continue;
  1184.             }
  1185.     if (n=='D') {
  1186.             if (wb->next!=NULL)
  1187.                {  min+=10;  wb=wb->next; max+=wb->ctc;  disp(); }
  1188.             prt(19,20,48|33,"╟δ╢¿╥σ╡┌ %d ╕÷▓Θ╤»▓┘╫≈┐Γ",l+1);
  1189.             prt(20,5,48|33,"╩Σ╚δ┐Γ╡─┤·║┼(PgUp/PgDn: ╖¡╞┴, 0: ╜ß╩°) -- A:   B:   C:   D:   E:   F:   ");
  1190.             continue;
  1191.             }
  1192.     y=((n-1)%2)*36+3;
  1193.     x=(n%10-1)/2+5;
  1194.     if (n%10==0) x=((n-1)%10-1)/2+5;
  1195.     prt(x,y,0|30,"*");
  1196.     if (n%10==0) m=9;
  1197.     else m=n%10-1;
  1198.     ldb[i]=wb->base[m];
  1199.     rd=ldb[i].dbs;
  1200.     wd=rd;
  1201.     i++;
  1202.     col=54;
  1203.     while ((n=getn(min,max,20,col))!=0)
  1204.       {  ss0[i]=n;
  1205.          if (n=='H')  {  helplo();  continue;  }
  1206.          if (n=='U')  {
  1207.               if (wb->last!=NULL)
  1208.                  {  max-=wb->ctc;  wb=wb->last;  min-=10;  disp(); }
  1209.               prt(19,20,48|33,"╟δ╢¿╥σ╡┌ %d ╕÷▓Θ╤»▓┘╫≈┐Γ",l+1);
  1210.               prt(20,5,48|33,"╩Σ╚δ┐Γ╡─┤·║┼(PgUp/PgDn: ╖¡╞┴, 0: ╜ß╩°) -- A:   B:   C:   D:   E:   F:   ");
  1211.               continue;
  1212.               }
  1213.          if (n=='D')  {
  1214.               if (wb->next!=NULL)
  1215.                  {  min+=10;  wb=wb->next;  max+=wb->ctc;  disp(); }
  1216.               prt(19,20,48|33,"╟δ╢¿╥σ╡┌ %d ╕÷▓Θ╤»▓┘╫≈┐Γ",l+1);
  1217.               prt(20,5,48|33,"╩Σ╚δ┐Γ╡─┤·║┼(PgUp/PgDn: ╖¡╞┴, 0: ╜ß╩°) -- A:   B:   C:   D:   E:   F:   ");
  1218.               continue;
  1219.               }
  1220.          if (n%10==0) m=9;
  1221.          else m=n%10-1;
  1222.          for (j=0;j<i;j++)
  1223.            if (strcmp(ldb[j].mean,wb->base[m].mean)==0) {  cir=1;  break;  }
  1224.            else cir=0;
  1225.          if (cir)  {  error();
  1226.               continue;
  1227.                }
  1228.          if (n!=0)
  1229.            {
  1230.  
  1231.  
  1232.           y=((n-1)%2)*36+3;
  1233.           x=(n%10-1)/2+5;
  1234.           if (n%10==0) x=((n-1)%10-1)/2+5;
  1235.           prt(x,y,0|30,"*");
  1236.           col+=5;
  1237.           ldb[i]=wb->base[m];
  1238.           i++;
  1239.           if (i==6) break;
  1240.            }
  1241.       }
  1242. /*    check();*/
  1243.     for (dbctc=0;strcmp(ldb[dbctc].name,"")!=0;dbctc++)
  1244.         {
  1245.         getmemd();
  1246.         wd=newd;
  1247.         ldb[dbctc].dbs=newd;
  1248.         getcontent(PATH,ldb[dbctc].name);
  1249.         }
  1250.     wb=rb;
  1251.  
  1252.     if (i==1) return(i);
  1253.     cursor(22,15);
  1254.     prt(22,15,48|33,"╟δ╤í╘±╢α┐Γ┴¬╜╙╖╜╩╜(╨╟╨═B/┤«╨═C)");
  1255. bcstart:n=getcc();
  1256.     if (n!='B'&&n!='b'&&n!='C'&&n!='c') goto bcstart;
  1257.     else linkflag=(n=='b'||n=='B')?0:1;
  1258.     return(i);
  1259.      }
  1260.    wb=rb;
  1261.    return(0);
  1262. }
  1263. /*-------------------------------------------------------*/
  1264. /*          ▒╚ ╜╧ ┐Γ ╓« ╝Σ ╩╟ ╖± ╙╨ ╧α ═¼ ╫╓ ╢╬          */
  1265. /*-------------------------------------------------------*/
  1266. check()
  1267. {  int i,j,k,n;
  1268.    struct DBF *p;
  1269.    char b[128][11];
  1270.    p=ldb[0].dbs;
  1271.    i=0;
  1272.    j=0;
  1273.    while (i<p->ctc)
  1274.      {  strcpy(b[j++],p->db[i].field);
  1275.     i++;
  1276.     if (i==p->ctc&&p->next!=NULL) {  p=p->next;  i=0;  }
  1277.      }
  1278.    k=1;
  1279.    while (ldb[k].dbs!=NULL)
  1280.      {  n=0;
  1281.     for (i=0;i<j;i++)
  1282.       if (cmp(b[i],ldb[k].dbs)>=0)  {  strcpy(b[n],b[i]);  n++;  }
  1283.     if (n==0)
  1284.       {  cursor(23,5);
  1285.          color_puts(ldb[0].mean,14|16);
  1286.          color_puts(" ║═ ",12);
  1287.          color_puts(ldb[k].mean,14|16);
  1288.          color_puts(" ╬▐╧α═¼╫╓╢╬, ▓╗─▄╜°╨╨┴¼╜╙, ╟δ╓╪╨┬╢¿╥σ┴¼╜╙┐Γ",12);
  1289.          dela();
  1290.          color_puts(" ",10);
  1291.          repeat=0;
  1292.          break;
  1293.       }
  1294.     if (n<j) j=n;
  1295.     k++;
  1296.      }
  1297. }
  1298. /*-------------------------------------------------------*/
  1299. /*          ▒╚ ╜╧ ╥╗ ╫╓ ╢╬ ╩╟ ╖± ╘┌ ─│ ╥╗ ┐Γ ╓╨          */
  1300. /*-------------------------------------------------------*/
  1301. cmp(str,p)
  1302. char *str;
  1303. struct DBF *p;
  1304. {  int i=0,j=0;
  1305.    while (i<p->ctc)
  1306.      {  if (strcmp(str,p->db[i].field)==0)  return(j);
  1307.     i++;
  1308.     j++;
  1309.     if (i==p->ctc&&p->next!=NULL) {  p=p->next;  i=0;  }
  1310.      }
  1311.    return(-1);
  1312. }
  1313. /*-------------------------------------*/
  1314. /*          ╢¿ ╥σ ┴¼ ╜╙ ╫╓ ╢╬          */
  1315. /*-------------------------------------*/
  1316. deflink(dname)
  1317. char *dname;
  1318. {  int i,c,n,flag,ctcn;
  1319.    FILE *fp;
  1320.    char ph[30],middst[31];
  1321.    strcpy(ph,PATH);
  1322.    for (i=0;i<5;i++) strcpy(link[i],"");
  1323.    strcat(ph,"NDX.TXT");
  1324.    fp=fopen(ph,"a");
  1325.    prt(22,15,48|33,"╟δ╢¿╥σ┴¼╜╙┐Γ╡─╩╢▒≡├√(╫ε╢α30╕÷╫╓╖√): ");
  1326.    scanf("%30s",dname);
  1327.    cls(1,1,25,80,48|33);
  1328.    i=0; ctcn=1;
  1329.    while (repeat)
  1330.      {
  1331.      wd=ldb[i].dbs; rd=ldb[i].dbs; flag=1;
  1332.      while (flag) {
  1333.      prt(16,10,48|33,"╟δ╚╖╢¿╦∙╢¿╥σ╡─┴¼╜╙┐Γ╡─┴¼╜╙╫╓╢╬(PgUp/PgDn: ╖¡╞┴):");
  1334.      prt(19,13,48|33,"╫ó╥Γ: ┴¼╜╙╫╓╢╬▒╪╨δ─▄╬¿╥╗╡╪╩╢▒≡╥╗╕÷╝╟┬╝!");
  1335.      judge(0);
  1336.      c=get(16,60);
  1337.      /*i=1;*/
  1338.      if (c=='U'||c=='D')
  1339.        {  judge(c);
  1340.           continue;
  1341.        }
  1342.      /*flag=1;*/
  1343.      if (c%COUNT==0) c=COUNT-1;
  1344.      else c=c%COUNT-1;
  1345.      if (c==39)
  1346.         {
  1347.         if (strcmp(link[i],"")==0) continue;
  1348.         else {flag=0; continue;}
  1349.         }
  1350.      if (ldb[i].dbs->db[c].type!='C'&&ldb[i].dbs->db[c].type!='D'&&ldb[i].dbs->db[c].type!='N')
  1351.        {  prt(21,10,48|33,"╟δ╤í╘±╫╓╖√╨═, ╩²╫╓╨═, ╚╒╞┌╨═╡─╫╓╢╬╫≈╬¬┴¼╜╙╫╓╢╬!");
  1352.           go_on();
  1353.           prt(21,10,48|33,"                                                   ");
  1354.           continue;
  1355.        }
  1356.      if (ldb[ctcn].dbs!=NULL)
  1357.        {   if (cmp(ldb[i].dbs->db[c].field,ldb[ctcn].dbs)<0)
  1358.          {  prt(21,10,48|33,"%s",ldb[ctcn].mean);
  1359.             print1(48|33," ▓╗┤µ╘┌ ");
  1360.             print1(48|33,"%s",ldb[i].dbs->db[c].field);
  1361.             print1(48|33," ╫╓╢╬, ╬▐╖¿┴¼╜╙. ╟δ╓╪╨┬╤í╘±┴¼╜╙╫╓╢╬");
  1362.             go_on();
  1363.             prt(21,10,48|33,"                                                                       ");
  1364.          }
  1365.            else {if (strcmp(link[ctcn-1],"")!=0) strcat(link[ctcn-1],"+");
  1366.             if (ldb[i].dbs->db[c].type=='D')
  1367.                {
  1368.                strcpy(middst,NULL); strcat(middst,"DTOC(");
  1369.                strcat(middst,ldb[i].dbs->db[c].field); strcat(middst,")");
  1370.                }
  1371.             if (ldb[i].dbs->db[c].type=='N')
  1372.                {
  1373.                strcpy(middst,NULL); strcat(middst,"STR(");
  1374.                strcat(middst,ldb[i].dbs->db[c].field); strcat(middst,",");
  1375.                strcat(middst,"19");strcat(middst,")");
  1376.                }
  1377.             if (ldb[i].dbs->db[c].type=='C')
  1378.                strcpy(middst,ldb[i].dbs->db[c].field);
  1379.             strcat(link[ctcn-1],middst);
  1380.             }
  1381.        }
  1382.        }
  1383.      if (linkflag==1) {i=ctcn; ctcn++;}
  1384.      else {i=0; ctcn++;}
  1385.      if (ldb[ctcn].dbs==NULL) break;
  1386.     /* if (flag) {  strcpy(link,ldb[0].dbs->db[c].field);
  1387.               break;
  1388.            }*/
  1389.      }
  1390.    for (i=1;ldb[i].dbs!=NULL;i++) fprintf(fp,"#%s#,#%s#,##,0,0\n",ldb[i].name,link[i-1]);
  1391.    fclose(fp);
  1392.    wd=rd=ldb[0].dbs;
  1393. }