home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / cslio205.zip / EXAMPLES / 2 / DEMODB.CPP < prev    next >
C/C++ Source or Header  |  1996-10-09  |  20KB  |  771 lines
  1. /////////////////////////////////////////////////////////
  2. //     Implementation file of database class: DEMO.
  3. //                                                          
  4. //     Source generated by: CSDBGEN version 1.6.b.
  5. //     Date of generation:  Wednesday, 9 October 1996.
  6. //     Time of generation:  10:19:28.
  7. //                                                          
  8. //                                                          
  9. //     The next lines represent the database definition     
  10. //     file used as input for CSDBGEN.                      
  11. //                                                          
  12. //                                                          
  13. ////////////// Start of the .def file //////////////////
  14. /*
  15. class: DEMO
  16. record: Record
  17. file: DBdemo
  18. field: name s 50 Y
  19. field: data s 32 Y
  20. */
  21. /////////////// End of .def file //////////////////////////////////////////////
  22. /*
  23.  
  24.  
  25.  
  26.  
  27.                  █████     █                       █        
  28.                 ██   ██   ██                      ██        
  29.                 ███      ████     ███   ██ ███   ████       
  30.                   ███     ██        ██   ███ ██   ██        
  31.                     ███   ██     █████   ██       ██        
  32.                 ██   ██   ██ █  ██  ██   ██       ██ █      
  33.                  █████     ██    ███ ██  ██        ██       
  34.                                                             
  35.                                                             
  36.              ████     ████  ██  ██  ██ ███   █████   ████   
  37.             ██       ██  ██ ██  ██   ███ ██ ██   █  ██  ██  
  38.              ████    ██  ██ ██  ██   ██     ██      ██████  
  39.                 ██   ██  ██ ██  ██   ██     ██   █  ██      
  40.              ████     ████   ███ ██  ██      █████   █████  
  41.                                                             
  42.  
  43.  
  44.  
  45. */
  46. //////////////////////////////////////////////////////////////////////////////
  47.  
  48.  
  49. #include "csmess.h"
  50. #include "csendian.h"
  51. #include "demodb.h"
  52.  
  53. #ifdef _CP_010
  54. extern unsigned _stklen=7000;   // Under DOS, a large stack is needed.
  55. #endif
  56.  
  57.  
  58.  
  59. Record *record_p; 
  60.  
  61.  
  62. ///////////////////////////////// Constructor ////////////////////////////////
  63. DEMO::DEMO(void) 
  64. { 
  65.     static_rec=(Record *)malloc(sizeof(Record));
  66.     if(!static_rec) { csmess_p(" Out of memory "); exit(12); } 
  67.     is_open=FALSE; 
  68.     current=1; 
  69.     NeedSync=TRUE; 
  70.     errnr=0;;
  71.     e_name="DEMO-class";
  72.     use_lock_file(TRUE); 
  73. }
  74.  
  75. ///////////////////////////////// Destructor /////////////////////////////////
  76. DEMO::~DEMO(void) 
  77. { 
  78.     close();
  79.     free(static_rec);
  80. }
  81.  
  82. ///////////////////////////////// Errors /////////////////////////////////////
  83. int DEMO::error_nr(void) 
  84. {
  85.  
  86.     int RC=0;
  87.     int RCT;
  88.  
  89.     RCT=in1.error_nr(); if(RCT) RC=RCT;
  90.     RCT=in2.error_nr(); if(RCT) RC=RCT;
  91.  
  92.     RCT=db.error_nr();  if(RCT) RC=RCT;
  93.  
  94.     if(errnr) { RC=errnr; errnr=0; }
  95.  
  96.     return RC; 
  97. }
  98.  
  99. ///////////////////////////////// Display Error //////////////////////////////
  100. U16 DEMO::display_error(void) 
  101. {
  102.  
  103.     int RC;
  104.  
  105.     RC=db.display_error(); 
  106.  
  107.     if(!RC) RC=in1.display_error(); 
  108.     if(!RC) RC=in2.display_error(); 
  109.  
  110.  
  111.     if(!RC && errnr) { RC=errnr; csmess_p(RC,e_name); }
  112.  
  113.     error_nr();  // Just to reset all error variables.
  114.  
  115.     return RC; 
  116. }
  117.  
  118.  
  119. ///////////////////////////////// Messages ///////////////////////////////////
  120. void DEMO::visible_error(int ErrorNr,char *Parm) 
  121. { 
  122.     csmess_p(ErrorNr,e_name,Parm);
  123.     error_nr(ErrorNr);
  124. }
  125.  
  126. ///////////////////////////////// Test for Empty DB //////////////////////////
  127. void DEMO::te(void) 
  128. { 
  129.     if(numrec()) return;
  130.     visible_error(30010);
  131.     close(); 
  132.     exit(8); 
  133. }
  134.  
  135. ///////////////////////////////// test Begin Of File /////////////////////////
  136. int DEMO::tBOF(void) 
  137. {
  138.     if(!numrec()) return TRUE;  
  139.     if(NeedSync) synch_index();
  140.     return (this->*bof_fun)(); 
  141. }
  142.  
  143. ///////////////////////////////// test End Of File /////////////////////////
  144. int DEMO::tEOF(void) 
  145. {
  146.     if(!numrec()) return TRUE;  
  147.     if(NeedSync) synch_index();
  148.     return (this->*eof_fun)(); 
  149. }
  150.  
  151. ///////////////////////////////// Read Only //////////////////////////////////
  152. int DEMO::read_only(int ToF) 
  153. {
  154.     if(already_open()) { visible_error(30063); return FALSE; }
  155.  
  156.     db.read_only(ToF);
  157.  
  158.     in1.read_only(ToF); 
  159.     in2.read_only(ToF); 
  160.  
  161.     return TRUE; 
  162. }
  163.  
  164. ///////////////////////////////// Use lock files /////////////////////////////
  165. int DEMO::use_lock_file(int ToF) 
  166. {
  167.  
  168.     db.use_lock_file(ToF);
  169.  
  170.     in1.use_lock_file(FALSE); 
  171.     in2.use_lock_file(FALSE); 
  172.  
  173.     return TRUE; 
  174. }
  175.  
  176. ///////////////////////////////// Lock file exist/////////////////////////////
  177. int DEMO::lock_file_exist(void) 
  178. {
  179.  
  180.     if(db.lock_file_exist("DBdemo.dbf")) return TRUE; 
  181.  
  182.     return FALSE; 
  183. }
  184.  
  185. ///////////////////////////////// remove lock file ///////////////////////////
  186. int DEMO::remove_lock_file(void) 
  187. {
  188.  
  189.     db.remove_lock_file("DBdemo.dbf"); 
  190.  
  191.     return TRUE;  
  192. }
  193.  
  194. ///////////////////////////////// Sync Index /////////////////////////////////
  195. void DEMO::synch_index(void) 
  196. {
  197.  
  198.      switch(order())
  199.      {
  200.          case UNSORTED:
  201.                   break; 
  202.          case DEMO_NAME_INDEX:
  203.                  find1(static_rec->_name); 
  204.                  break; 
  205.          case DEMO_DATA_INDEX:
  206.                  find2(static_rec->_data); 
  207.                  break; 
  208.      }
  209.      NeedSync=FALSE; 
  210. }
  211.  
  212. ///////////////////////////////// reindex ////////////////////////////////////
  213. int DEMO::reindex(void) 
  214. {
  215.     if(!already_open()) { visible_error(30051); return FALSE; }
  216.  
  217.     write_rec();
  218.  
  219.     U32 l=current;  
  220.     Record *rp;  
  221.  
  222.     in1.empty(); 
  223.     in2.empty(); 
  224.     for(current=numrec(); current>0; current--)  
  225.     {                          
  226.        rp=locate_curr(); 
  227.        in1.insert(rp->_name,¤t); 
  228.        in2.insert(rp->_data,¤t); 
  229.     }                          
  230.     current=l;                 
  231.     NeedSync=TRUE;             
  232.  
  233.     return TRUE;               
  234. }
  235.  
  236. ///////////////////////////////// skip ///////////////////////////////////////
  237. int  DEMO::skip0(int delta) 
  238. {
  239.      long old_current=current; 
  240.      current=pMax(pMin(current+delta,db.numrec()),1); 
  241.      return (int)(current-old_current); 
  242. }
  243.  
  244. int  DEMO::skip(int delta) 
  245. {
  246.      int rc; 
  247.  
  248.      if(numrec()==0) return 0; 
  249.  
  250.      if(NeedSync) synch_index();
  251.  
  252.      write_rec(); 
  253.      rc=(this->*skip_fun)(delta); 
  254.      read_rec(); 
  255.  
  256.      return rc; 
  257. }
  258. /////////////// go_to ////////////////////////////////////////////
  259. int DEMO::go_to(long n) 
  260. {
  261.     if(n<1 || n>numrec()) return FALSE; 
  262.  
  263.     write_rec(); 
  264.     current=n; 
  265.     read_rec(); 
  266.  
  267.     NeedSync=(order()!=UNSORTED);
  268.  
  269.     return TRUE;
  270. }
  271.  
  272. /////////////// bottom() /////////////////////////////////////////
  273. int DEMO::bottom(void ) 
  274. {
  275.     if(numrec()==0) return FALSE; 
  276.  
  277.     write_rec(); 
  278.     (this->*bottom_fun)();
  279.     read_rec(); 
  280.  
  281.     NeedSync=FALSE;
  282.  
  283.     return TRUE;
  284. }
  285.  
  286. /////////////// top() ////////////////////////////////////////////
  287. int DEMO::top(void ) 
  288. {
  289.     if(numrec()==0) return FALSE; 
  290.  
  291.     write_rec(); 
  292.     (this->*top_fun)();
  293.     read_rec(); 
  294.  
  295.     NeedSync=FALSE;
  296.  
  297.     return TRUE;
  298. }
  299.  
  300. /////////////// search() /////////////////////////////////////////
  301. int DEMO::search(void *k) 
  302. {
  303.     if(numrec()==0) return FALSE; 
  304.  
  305.     int RC;      
  306.     write_rec(); 
  307.     if(0==(RC=(this->*search_fun)(k))) bottom(); 
  308.     read_rec(); 
  309.  
  310.     NeedSync=FALSE;
  311.  
  312.     return RC;
  313. }
  314.  
  315. /////////////// append blank//////////////////////////////////////
  316. void DEMO::append_blank(void) 
  317. {
  318.     append();
  319.     in1.insert(static_rec->_name,¤t); 
  320.     in2.insert(static_rec->_data,¤t); 
  321.     NeedSync=FALSE;
  322. }
  323.  
  324. ///////////////////////////////// append /////////////////////////////////////
  325. // This function doesn't update the indexes, which can save some 
  326. // disk I/O because you are likely to alter the fields 
  327. // immediately after you have appended the record.
  328. // However, if you have an index on a field you don't update, this 
  329. // record will NOT appear in that particular index! 
  330. // The 'append_blank' function does update all indexes, which 
  331. // makes it a safer, but slower option. 
  332. //  
  333. void DEMO::append(void) 
  334. {
  335.     write_rec();
  336.     memset(static_rec,0,sizeof(Record)); 
  337.     current=db.append_rec(static_rec); 
  338.     dirty=TRUE;    
  339.     NeedSync=TRUE;
  340. }
  341.  
  342. ///////////////////////////////// open ///////////////////////////////////////
  343. int DEMO::open(int kBbuf) 
  344. {
  345.      if(already_open()) { visible_error(30061); return FALSE; } 
  346.  
  347.      int   needs_reindex=FALSE;        
  348.      char *iname;        
  349.  
  350.      dirty=FALSE;     
  351.      current=1;       
  352.  
  353.      int fre=kBbuf/5; //kBbuf default = 100 Kb.  
  354.  
  355.      if(!db.open("DBdemo.dbf",fre)) 
  356.      {
  357.          visible_error(30020,"DBdemo.dbf");
  358.          error_nr(db.error_nr());
  359.          return FALSE;
  360.      }
  361.      if(db.lengthrec()!=sizeof(Record)) 
  362.      {
  363.          visible_error(30030);
  364.          db.close(); 
  365.          exit(1); 
  366.      }
  367.  
  368.      iname="DBdemo01.idx";
  369.  
  370.      if(!file_exist(iname))
  371.      { 
  372.        in1.multiple_keys(TRUE);
  373.        in1.define(iname,DEMO_NAME_LENGTH+1,sizeof(long));
  374.        needs_reindex=TRUE; 
  375.      } 
  376.      if(!in1.open(iname,fre*2))
  377.      { 
  378.          visible_error(30040,iname);
  379.          error_nr(in1.error_nr());
  380.          goto OnOpenError;
  381.      } 
  382.   
  383.  
  384.      iname="DBdemo02.idx";
  385.  
  386.      if(!file_exist(iname))
  387.      { 
  388.        in2.multiple_keys(TRUE);
  389.        in2.define(iname,DEMO_DATA_LENGTH+1,sizeof(long));
  390.        needs_reindex=TRUE; 
  391.      } 
  392.      if(!in2.open(iname,fre*2))
  393.      { 
  394.          visible_error(30040,iname);
  395.          error_nr(in2.error_nr());
  396.          goto OnOpenError;
  397.      } 
  398.   
  399.      is_open=TRUE; 
  400.      if(needs_reindex) reindex(); 
  401.      read_rec(); 
  402.   
  403.      order(UNSORTED);  
  404.  
  405.      return TRUE;    
  406.   
  407.   
  408.   
  409. OnOpenError: 
  410.  
  411.      close2();
  412.  
  413.      return FALSE;    
  414.  
  415. }
  416.  
  417. ///////////////////////////////// close //////////////////////////////////////
  418. int DEMO::close2(void) 
  419. {
  420.  
  421.      db.close(); 
  422.      in1.close();
  423.      in2.close();
  424.  
  425.      return TRUE;   
  426. }
  427.  
  428.  
  429.  
  430. int DEMO::close(void) 
  431. {
  432.      if(!already_open()) return TRUE; 
  433.  
  434.      int RC=close2(); 
  435.  
  436.      is_open=FALSE; 
  437.  
  438.      return RC;   
  439. }
  440.  
  441. ///////////////////////////////// define /////////////////////////////////////
  442. int  DEMO::define(void) 
  443. {
  444.      if(already_open()) { visible_error(30062); return FALSE; }
  445.  
  446.      int RC;
  447.  
  448.      RC=db.define("DBdemo.dbf",sizeof(Record)); 
  449.  
  450.      in1.multiple_keys(TRUE);
  451.      RC&=in1.define("DBdemo01.idx",DEMO_NAME_LENGTH+1,sizeof(long));
  452.      in2.multiple_keys(TRUE);
  453.      RC&=in2.define("DBdemo02.idx",DEMO_DATA_LENGTH+1,sizeof(long));
  454.  
  455.      if(!RC) visible_error(30070); 
  456.  
  457.      return RC; 
  458. }
  459.  
  460. ///////////////////////////////// pack ///////////////////////////////////////
  461. int DEMO::pack(void) 
  462. {
  463.      if(!is_open) { visible_error(30052); return FALSE; }
  464.  
  465.      write_rec(); 
  466.      db.pack();
  467.      reindex();
  468.      top();
  469.  
  470.      return TRUE;
  471. }
  472.  
  473. ///////////////////////////////// order //////////////////////////////////////
  474. int DEMO::order(int nr) 
  475. {
  476.      if(!is_open) { visible_error(30053); return FALSE; }
  477.  
  478.      switch(nr)
  479.      {
  480.          case UNSORTED:        //Unsorted 
  481.                   bof_fun   =&DEMO::bof0;
  482.                   eof_fun   =&DEMO::eof0;
  483.                   skip_fun  =&DEMO::skip0;
  484.                   top_fun   =&DEMO::top0;
  485.                   bottom_fun=&DEMO::bottom0;
  486.                   search_fun=&DEMO::search0;
  487.                   NeedSync=FALSE;
  488.                   break; 
  489.          case DEMO_NAME_INDEX:    //Index on field name
  490.                   bof_fun   =&DEMO::bof1;
  491.                   eof_fun   =&DEMO::eof1;
  492.                   skip_fun  =&DEMO::skip1;
  493.                   top_fun   =&DEMO::top1;
  494.                   bottom_fun=&DEMO::bottom1;
  495.                   search_fun=&DEMO::search1;
  496.                   NeedSync=TRUE;
  497.                   break; 
  498.          case DEMO_DATA_INDEX:    //Index on field data
  499.                   bof_fun   =&DEMO::bof2;
  500.                   eof_fun   =&DEMO::eof2;
  501.                   skip_fun  =&DEMO::skip2;
  502.                   top_fun   =&DEMO::top2;
  503.                   bottom_fun=&DEMO::bottom2;
  504.                   search_fun=&DEMO::search2;
  505.                   NeedSync=TRUE;
  506.                   break; 
  507.          default: { visible_error(30080); return FALSE; }
  508.      }
  509.      iOrder=nr;
  510.  
  511.      return TRUE;
  512. }
  513. /////////////////////////////reading record  ///////////////////////////////
  514. void DEMO::read_rec(void) 
  515. {
  516.     if(numrec()==0) return; 
  517.     *static_rec=*locate_curr(); 
  518. }
  519. /////////////////////////////writing record  ///////////////////////////////
  520. void DEMO::write_rec2(void) 
  521. {
  522.     Record *recp=locate_curr(); 
  523.     if(strcmp(recp->_name,static_rec->_name)) 
  524.     { 
  525.       in1.delet(recp->_name,¤t); 
  526.       in1.insert(static_rec->_name,¤t); 
  527.     } 
  528.     if(strcmp(recp->_data,static_rec->_data)) 
  529.     { 
  530.       in2.delet(recp->_data,¤t); 
  531.       in2.insert(static_rec->_data,¤t); 
  532.     } 
  533.     db.write_rec(current,static_rec); 
  534.     dirty=FALSE;   
  535. }
  536.  
  537. ///////////////////////////////// export /////////////////////////////////////
  538. int  DEMO::export(char *s) 
  539. {
  540.      if(!is_open) { visible_error(30054,s); return FALSE; }
  541.  
  542.      write_rec();
  543.  
  544.      FILE *fo=fopen(s,"w"); 
  545.      if(fo==NULL) { visible_error(30071,s); return FALSE; }
  546.  
  547.      fprintf(fo,"class:  DEMO");
  548.      fprintf(fo,"\nrecord: Record");
  549.      fprintf(fo,"\nfile:   DBdemo");
  550.      fprintf(fo,"\nfield:  name s 50 Y   ");
  551.      fprintf(fo,"\nfield:  data s 32 Y   ");
  552.  
  553.      if(ferror(fo)) { fclose(fo); visible_error(30072,s); return FALSE; } 
  554.  
  555.      Record *rp;
  556.      U32 lmax=numrec();
  557.      U32 l;
  558.      for(l=1;l<=lmax;l++) 
  559.      {
  560.         rp=( Record * )db.locate_rec(l);
  561.         fprintf(fo,"\n%c",12);
  562.         fprintf(fo,"\n%s",rp->_name);
  563.         fprintf(fo,"\n%s",rp->_data);
  564.         fprintf(fo,"\n"); //Additional linefeed
  565.  
  566.         if(ferror(fo)) { fclose(fo); visible_error(30072,s); return FALSE; } 
  567.      }
  568.  
  569.      if(fclose(fo)) { visible_error(30072,s); return FALSE; }
  570.  
  571.      return TRUE;  
  572. }
  573.  
  574. ///////////////////////////////// import /////////////////////////////////////
  575. int DEMO::import(char *s) 
  576. {   
  577.  
  578.       if(!is_open) { visible_error(30055,s); return FALSE; }
  579.  
  580.       FILE *fr=fopen(s,"r"); 
  581.       if(fr==NULL) { visible_error(30091,s); return FALSE; }
  582.   
  583.   
  584.       const MAX_NUM_FIELDS= 100;  //Increase this to allow more fields    
  585.       const MAX_FIELD_LEN = 500;  //Increase this to allow longer fields  
  586.  
  587.       int *finu;
  588.       finu=(int *)malloc(MAX_NUM_FIELDS*sizeof(int));
  589.       if(finu==NULL) { fclose(fr); visible_error(30092); return FALSE; }  
  590.  
  591.       char *fibu;    
  592.       fibu=(char *)malloc(MAX_FIELD_LEN);
  593.       if(fibu==NULL) 
  594.       {
  595.          fclose(fr); 
  596.          free(finu); 
  597.          visible_error(30092); 
  598.          return FALSE; 
  599.       }
  600.  
  601.       *fibu=0;  
  602.  
  603.       char *fipo=fibu+strlen("field:");  
  604.       char *cp; 
  605.       int  ifieldnr=0;    
  606.       int  ofieldnr; 
  607.  
  608.       int  RC=TRUE; 
  609.       int  InDef=TRUE; 
  610.  
  611.       memset(finu,0,MAX_NUM_FIELDS*sizeof(int));
  612.  
  613.       fgets(fibu,MAX_FIELD_LEN,fr); 
  614.       while(!strchr(fibu,12))  
  615.       {    
  616.         if(feof(fr))
  617.         { 
  618.            if(!InDef)   
  619.            visible_error(30093,s); 
  620.            RC=FALSE;
  621.            break; 
  622.         } 
  623.         pStrlwr(fibu);     //Converting to lower case.
  624.         notabs(fibu);      //Removing tabs.
  625.         trim_string(fibu); //Removing heading & trailing spaces.
  626.         if(!strchr(fibu,':') && *fibu) InDef=FALSE;   
  627.         if(strstr(fibu,"field:"))   
  628.         {  
  629.            ifieldnr++;  
  630.            trim_string(fipo);    
  631.            if((cp=strchr(fipo,' '))!=NULL) *cp=0;
  632.            if     (!strcmp(fipo,"name"))    ofieldnr=1;
  633.            else if(!strcmp(fipo,"data"))    ofieldnr=2;
  634.            else ofieldnr=0; 
  635.            finu[ifieldnr]=ofieldnr; 
  636.         }  
  637.         fgets(fibu,MAX_FIELD_LEN,fr);    
  638.       }    
  639.  
  640.  
  641.       if(RC) 
  642.       for(;;)   
  643.       {    
  644.         if(!strchr(fibu,12))   
  645.         {  
  646.            ifieldnr++; 
  647.            if(ifieldnr<MAX_NUM_FIELDS) 
  648.              switch(finu[ifieldnr])   
  649.              {  
  650.                 case 0:  break;
  651.                 case 1:
  652.                          fibu[DEMO_NAME_LENGTH]=0;
  653.                          name(fibu);
  654.                          break;
  655.                 case 2:
  656.                          fibu[DEMO_DATA_LENGTH]=0;
  657.                          data(fibu);
  658.                          break;
  659.              }  
  660.         }  
  661.         else    
  662.         {  
  663.            ifieldnr=0; 
  664.            append_blank();
  665.         }  
  666.         if(feof(fr)) break;    
  667.         fgets(fibu,MAX_FIELD_LEN,fr);    
  668.         cp=fibu+(pMax(1,strlen(fibu))-1); 
  669.         if(*cp=='\n') *cp=0;  //removing the line feed 
  670.       }    
  671.  
  672.  
  673.       fclose(fr); 
  674.       free(fibu); 
  675.       free(finu); 
  676.  
  677.       return RC; 
  678.  
  679. }
  680.  
  681. ///////////////////////////////// export to dBASE compatible file. ///////////
  682. int DEMO::to_DBASE(char *s) 
  683. {   
  684.  
  685.       if(!is_open) { visible_error(30056,s); return FALSE; }
  686.  
  687.       char bufje[12];
  688.  
  689.       write_rec(); 
  690.       FILE *fo=fopen(s,"wb"); 
  691.       if(fo==NULL) { visible_error(30095,s); return FALSE; }
  692.   
  693.       int i;
  694.   
  695.       csDATE d_upda;
  696.       d_upda.sem_jul(db.sj_updated());
  697.       fputc(03,fo);  
  698.       
  699.       fputc(d_upda.year()%100,fo);  
  700.       fputc(d_upda.month(),fo);  
  701.       fputc(d_upda.day(),fo);  
  702.  
  703.       long nr_record=numrec(); 
  704.       fwrite(&nr_record,sizeof(long),1,fo); 
  705.       WriteU16l(fo,98);        //Header length 
  706.       WriteU16l(fo,83);        //Length of data record 
  707.       for(i=0;i<20;i++) fputc(0,fo); // 20 dummy bytes 
  708.  
  709.  
  710. // Writing definition of field name to dbase file header.
  711.       memset(bufje,0,11);
  712.       strcpy(bufje,"NAME");
  713.       fwrite(bufje,11,1,fo);
  714.       fputc('C',fo); 
  715.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  716.       fputc(50,fo); 
  717.       fputc(0,fo); 
  718.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  719.  
  720. // Writing definition of field data to dbase file header.
  721.       memset(bufje,0,11);
  722.       strcpy(bufje,"DATA");
  723.       fwrite(bufje,11,1,fo);
  724.       fputc('C',fo); 
  725.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  726.       fputc(32,fo); 
  727.       fputc(0,fo); 
  728.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  729.  
  730.  
  731.       fputc(13,fo);  //Field terminator 
  732.       fputc(0,fo); 
  733.  
  734. // By now we have written the definition of the 
  735. // record structure to the file header. 
  736. // From here on we will export the records. 
  737.  
  738.      Record *rp;
  739.      U32 lmax=numrec();
  740.      U32 l;
  741.      for(l=1;l<=lmax;l++) 
  742.      {
  743.  
  744.         if(ferror(fo)) 
  745.         { 
  746.            fclose(fo); 
  747.            visible_error(30096,s); 
  748.            return FALSE; 
  749.         } 
  750.  
  751.         rp=(Record *)db.locate_rec(l);
  752.  
  753.         if(db.is_delet(l)) fputc(42,fo); 
  754.         else               fputc(32,fo); 
  755.  
  756. /////////////////////// writing field name /////////////
  757.         fprintf(fo,"%-50s",rp->_name);
  758. /////////////////////// writing field data /////////////
  759.         fprintf(fo,"%-32s",rp->_data);
  760.      }
  761.      fputc(26,fo);  //End of File 
  762.      fclose(fo); 
  763.  
  764.      if(ferror(fo)) 
  765.      { 
  766.         visible_error(30096,s); 
  767.         return FALSE; 
  768.      } 
  769.  
  770.      return TRUE; 
  771. }