home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / cslio205.zip / EXAMPLES / 3 / CSADDIO.CPP < prev    next >
C/C++ Source or Header  |  1997-01-06  |  30KB  |  1,083 lines
  1. /////////////////////////////////////////////////////////
  2. //     Implementation file of database class: NAMio.
  3. //                                                          
  4. //     Source generated by: CSDBGEN version 1.6.c.
  5. //     Date of generation:  Monday, 6 January 1997.
  6. //     Time of generation:  09:51:27.
  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: NAMio
  16. record: record
  17. file: csadr.dbf
  18. field: name s 40 T
  19. field: adre s 32
  20. field: city s 23 Y
  21. field: count s 32
  22. field: zip s 9
  23. field: tel s 17
  24. field: update d MDY2
  25. field: birth d DMY4 Y
  26. field: relation s 10 Y
  27. field: info s 70
  28. */
  29. /////////////// End of .def file //////////////////////////////////////////////
  30. /*
  31.  
  32.  
  33.  
  34.  
  35.                  █████     █                       █        
  36.                 ██   ██   ██                      ██        
  37.                 ███      ████     ███   ██ ███   ████       
  38.                   ███     ██        ██   ███ ██   ██        
  39.                     ███   ██     █████   ██       ██        
  40.                 ██   ██   ██ █  ██  ██   ██       ██ █      
  41.                  █████     ██    ███ ██  ██        ██       
  42.                                                             
  43.                                                             
  44.              ████     ████  ██  ██  ██ ███   █████   ████   
  45.             ██       ██  ██ ██  ██   ███ ██ ██   █  ██  ██  
  46.              ████    ██  ██ ██  ██   ██     ██      ██████  
  47.                 ██   ██  ██ ██  ██   ██     ██   █  ██      
  48.              ████     ████   ███ ██  ██      █████   █████  
  49.                                                             
  50.  
  51.  
  52.  
  53. */
  54. //////////////////////////////////////////////////////////////////////////////
  55.  
  56.  
  57. #include "csmess.h"
  58. #include "csendian.h"
  59. #include "csaddio.h"
  60.  
  61. #ifdef _CP_010
  62. extern unsigned _stklen=7000;   // Under DOS, a large stack is needed.
  63. #endif
  64.  
  65.  
  66. #define TD_NAME "\t(),- "     // Token delimiters for field 'name'.
  67. #define TL_NAME 4             // Minimal Token length for field 'name'.
  68.  
  69.  
  70. record *record_p; 
  71.  
  72.  
  73. ///////////////////////////////// Constructor ////////////////////////////////
  74. NAMio::NAMio(void) 
  75. { 
  76.     static_rec=(record *)malloc(sizeof(record));
  77.     if(!static_rec) { csmess_p(" Out of memory "); exit(12); } 
  78.     is_open=FALSE; 
  79.     current=1; 
  80.     NeedSync=TRUE; 
  81.     errnr=0;;
  82.     e_name="NAMio-class";
  83.     _update.format(MDY2); 
  84.     _birth.format(DMY4); 
  85.     use_lock_file(TRUE); 
  86. }
  87.  
  88. ///////////////////////////////// Destructor /////////////////////////////////
  89. NAMio::~NAMio(void) 
  90. { 
  91.     close();
  92.     free(static_rec);
  93. }
  94.  
  95. ///////////////////////////////// Errors /////////////////////////////////////
  96. int NAMio::error_nr(void) 
  97. {
  98.  
  99.     int RC=0;
  100.     int RCT;
  101.  
  102.     RCT=in1.error_nr(); if(RCT) RC=RCT;
  103.     RCT=in2.error_nr(); if(RCT) RC=RCT;
  104.     RCT=in3.error_nr(); if(RCT) RC=RCT;
  105.     RCT=in4.error_nr(); if(RCT) RC=RCT;
  106.  
  107.     RCT=db.error_nr();  if(RCT) RC=RCT;
  108.  
  109.     if(errnr) { RC=errnr; errnr=0; }
  110.  
  111.     return RC; 
  112. }
  113.  
  114. ///////////////////////////////// Display Error //////////////////////////////
  115. U16 NAMio::display_error(void) 
  116. {
  117.  
  118.     int RC;
  119.  
  120.     RC=db.display_error(); 
  121.  
  122.     if(!RC) RC=in1.display_error(); 
  123.     if(!RC) RC=in2.display_error(); 
  124.     if(!RC) RC=in3.display_error(); 
  125.     if(!RC) RC=in4.display_error(); 
  126.  
  127.  
  128.     if(!RC && errnr) { RC=errnr; csmess_p(RC,e_name); }
  129.  
  130.     error_nr();  // Just to reset all error variables.
  131.  
  132.     return RC; 
  133. }
  134.  
  135.  
  136. ///////////////////////////////// Messages ///////////////////////////////////
  137. void NAMio::visible_error(int ErrorNr,char *Parm) 
  138. { 
  139.     csmess_p(ErrorNr,e_name,Parm);
  140.     error_nr(ErrorNr);
  141. }
  142.  
  143. ///////////////////////////////// Test for Empty DB //////////////////////////
  144. void NAMio::te(void) 
  145. { 
  146.     if(numrec()) return;
  147.     visible_error(30010);
  148.     close(); 
  149.     exit(8); 
  150. }
  151.  
  152. ///////////////////////////////// test Begin Of File /////////////////////////
  153. int NAMio::tBOF(void) 
  154. {
  155.     if(!numrec()) return TRUE;  
  156.     if(NeedSync) synch_index();
  157.     return (this->*bof_fun)(); 
  158. }
  159.  
  160. ///////////////////////////////// test End Of File /////////////////////////
  161. int NAMio::tEOF(void) 
  162. {
  163.     if(!numrec()) return TRUE;  
  164.     if(NeedSync) synch_index();
  165.     return (this->*eof_fun)(); 
  166. }
  167.  
  168. ///////////////////////////////// Read Only //////////////////////////////////
  169. int NAMio::read_only(int ToF) 
  170. {
  171.     if(already_open()) { visible_error(30063); return FALSE; }
  172.  
  173.     db.read_only(ToF);
  174.  
  175.     in1.read_only(ToF); 
  176.     in2.read_only(ToF); 
  177.     in3.read_only(ToF); 
  178.     in4.read_only(ToF); 
  179.  
  180.     return TRUE; 
  181. }
  182.  
  183. ///////////////////////////////// Use lock files /////////////////////////////
  184. int NAMio::use_lock_file(int ToF) 
  185. {
  186.  
  187.     db.use_lock_file(ToF);
  188.  
  189.     in1.use_lock_file(FALSE); 
  190.     in2.use_lock_file(FALSE); 
  191.     in3.use_lock_file(FALSE); 
  192.     in4.use_lock_file(FALSE); 
  193.  
  194.     return TRUE; 
  195. }
  196.  
  197. ///////////////////////////////// Lock file exist/////////////////////////////
  198. int NAMio::lock_file_exist(void) 
  199. {
  200.  
  201.     if(db.lock_file_exist("csadr.dbf")) return TRUE; 
  202.  
  203.     return FALSE; 
  204. }
  205.  
  206. ///////////////////////////////// remove lock file ///////////////////////////
  207. int NAMio::remove_lock_file(void) 
  208. {
  209.  
  210.     db.remove_lock_file("csadr.dbf"); 
  211.  
  212.     return TRUE;  
  213. }
  214.  
  215. ///////////////////////////////// Sync Index /////////////////////////////////
  216. void NAMio::synch_index(void) 
  217. {
  218.  
  219.      switch(order())
  220.      {
  221.          case UNSORTED:
  222.                   break; 
  223.          case NAMIO_NAME_INDEX:
  224.                  tokenize(TRUE,static_rec->_name,TD_NAME,TL_NAME,&NAMio::find1); 
  225.                  break; 
  226.          case NAMIO_CITY_INDEX:
  227.                  find2(static_rec->_city); 
  228.                  break; 
  229.          case NAMIO_BIRTH_INDEX:
  230.                  static_rec->__birth=_birth.sem_jul();
  231.                  find3(&static_rec->__birth); 
  232.                  break; 
  233.          case NAMIO_RELATION_INDEX:
  234.                  find4(static_rec->_relation); 
  235.                  break; 
  236.      }
  237.      NeedSync=FALSE; 
  238. }
  239.  
  240. ///////////////////////////////// reindex ////////////////////////////////////
  241. int NAMio::reindex(void) 
  242. {
  243.     if(!already_open()) { visible_error(30051); return FALSE; }
  244.  
  245.     write_rec();
  246.  
  247.     U32 l=current;  
  248.     record *rp;  
  249.  
  250.     in1.empty(); 
  251.     in2.empty(); 
  252.     in3.empty(); 
  253.     in4.empty(); 
  254.     for(current=numrec(); current>0; current--)  
  255.     {                          
  256.        rp=locate_curr(); 
  257.        tokenize(FALSE,rp->_name,TD_NAME,TL_NAME,&NAMio::in1_ins_tok); 
  258.        in2.insert(rp->_city,¤t); 
  259.        in3.insert(&rp->__birth,¤t); 
  260.        in4.insert(rp->_relation,¤t); 
  261.     }                          
  262.     current=l;                 
  263.     NeedSync=TRUE;             
  264.  
  265.     return TRUE;               
  266. }
  267.  
  268. ///////////////////////////////// skip ///////////////////////////////////////
  269. int  NAMio::skip0(int delta) 
  270. {
  271.      long old_current=current; 
  272.      current=pMax(pMin(current+delta,db.numrec()),1); 
  273.      return (int)(current-old_current); 
  274. }
  275.  
  276. int  NAMio::skip(int delta) 
  277. {
  278.      int rc; 
  279.  
  280.      if(numrec()==0) return 0; 
  281.  
  282.      if(NeedSync) synch_index();
  283.  
  284.      write_rec(); 
  285.      rc=(this->*skip_fun)(delta); 
  286.      read_rec(); 
  287.  
  288.      return rc; 
  289. }
  290. /////////////// go_to ////////////////////////////////////////////
  291. int NAMio::go_to(long n) 
  292. {
  293.     if(n<1 || n>numrec()) return FALSE; 
  294.  
  295.     write_rec(); 
  296.     current=n; 
  297.     read_rec(); 
  298.  
  299.     NeedSync=(order()!=UNSORTED);
  300.  
  301.     return TRUE;
  302. }
  303.  
  304. /////////////// bottom() /////////////////////////////////////////
  305. int NAMio::bottom(void ) 
  306. {
  307.     if(numrec()==0) return FALSE; 
  308.  
  309.     write_rec(); 
  310.     (this->*bottom_fun)();
  311.     read_rec(); 
  312.  
  313.     NeedSync=FALSE;
  314.  
  315.     return TRUE;
  316. }
  317.  
  318. /////////////// top() ////////////////////////////////////////////
  319. int NAMio::top(void ) 
  320. {
  321.     if(numrec()==0) return FALSE; 
  322.  
  323.     write_rec(); 
  324.     (this->*top_fun)();
  325.     read_rec(); 
  326.  
  327.     NeedSync=FALSE;
  328.  
  329.     return TRUE;
  330. }
  331.  
  332. /////////////// search() /////////////////////////////////////////
  333. int NAMio::search(void *k) 
  334. {
  335.     if(numrec()==0) return FALSE; 
  336.  
  337.     int RC;      
  338.     write_rec(); 
  339.     if(0==(RC=(this->*search_fun)(k))) bottom(); 
  340.     read_rec(); 
  341.  
  342.     NeedSync=FALSE;
  343.  
  344.     return RC;
  345. }
  346.  
  347. /////////////// append blank//////////////////////////////////////
  348. void NAMio::append_blank(void) 
  349. {
  350.     append();
  351.     tokenize(FALSE,static_rec->_name,TD_NAME,TL_NAME,&NAMio::in1_ins_tok); 
  352.     in2.insert(static_rec->_city,¤t); 
  353.     in3.insert(&static_rec->__birth,¤t); 
  354.     in4.insert(static_rec->_relation,¤t); 
  355.     NeedSync=FALSE;
  356. }
  357.  
  358. ///////////////////////////////// append /////////////////////////////////////
  359. // This function doesn't update the indexes, which can save some 
  360. // disk I/O because you are likely to alter the fields 
  361. // immediately after you have appended the record.
  362. // However, if you have an index on a field you don't update, this 
  363. // record will NOT appear in that particular index! 
  364. // The 'append_blank' function does update all indexes, which 
  365. // makes it a safer, but slower option. 
  366. //  
  367. void NAMio::append(void) 
  368. {
  369.     write_rec();
  370.     memset(static_rec,0,sizeof(record)); 
  371.     current=db.append_rec(static_rec); 
  372.     dirty=TRUE;    
  373.     _update.sem_jul((S32)0);
  374.     _birth.sem_jul((S32)0);
  375.     NeedSync=TRUE;
  376. }
  377.  
  378. ///////////////////////////////// open ///////////////////////////////////////
  379. int NAMio::open(int kBbuf) 
  380. {
  381.      if(already_open()) { visible_error(30061); return FALSE; } 
  382.  
  383.      int   needs_reindex=FALSE;        
  384.      char *iname;        
  385.  
  386.      dirty=FALSE;     
  387.      current=1;       
  388.  
  389.      int fre=kBbuf/9; //kBbuf default = 100 Kb.  
  390.  
  391.      if(!db.open("csadr.dbf",fre)) 
  392.      {
  393.          visible_error(30020,"csadr.dbf");
  394.          error_nr(db.error_nr());
  395.          return FALSE;
  396.      }
  397.      if(db.lengthrec()!=sizeof(record)) 
  398.      {
  399.          visible_error(30030);
  400.          db.close(); 
  401.          exit(1); 
  402.      }
  403.  
  404.      iname="csadr01.idx";
  405.  
  406.      if(!file_exist(iname))
  407.      { 
  408.        in1.multiple_keys(TRUE);
  409.        in1.define(iname,NAMio_NAME_TOK_LENGTH,sizeof(long));
  410.        needs_reindex=TRUE; 
  411.      } 
  412.      if(!in1.open(iname,fre*2))
  413.      { 
  414.          visible_error(30040,iname);
  415.          error_nr(in1.error_nr());
  416.          goto OnOpenError;
  417.      } 
  418.   
  419.  
  420.      iname="csadr02.idx";
  421.  
  422.      if(!file_exist(iname))
  423.      { 
  424.        in2.multiple_keys(TRUE);
  425.        in2.define(iname,NAMio_CITY_LENGTH+1,sizeof(long));
  426.        needs_reindex=TRUE; 
  427.      } 
  428.      if(!in2.open(iname,fre*2))
  429.      { 
  430.          visible_error(30040,iname);
  431.          error_nr(in2.error_nr());
  432.          goto OnOpenError;
  433.      } 
  434.   
  435.  
  436.      iname="csadr03.idx";
  437.  
  438.      if(!file_exist(iname))
  439.      { 
  440.        in3.multiple_keys(TRUE);
  441.        in3.define(iname,sizeof(long),sizeof(long));
  442.        needs_reindex=TRUE; 
  443.      } 
  444.      if(!in3.open(iname,fre*2))
  445.      { 
  446.          visible_error(30040,iname);
  447.          error_nr(in3.error_nr());
  448.          goto OnOpenError;
  449.      } 
  450.   
  451.  
  452.      iname="csadr04.idx";
  453.  
  454.      if(!file_exist(iname))
  455.      { 
  456.        in4.multiple_keys(TRUE);
  457.        in4.define(iname,NAMio_RELATION_LENGTH+1,sizeof(long));
  458.        needs_reindex=TRUE; 
  459.      } 
  460.      if(!in4.open(iname,fre*2))
  461.      { 
  462.          visible_error(30040,iname);
  463.          error_nr(in4.error_nr());
  464.          goto OnOpenError;
  465.      } 
  466.   
  467.      is_open=TRUE; 
  468.      if(needs_reindex) reindex(); 
  469.      read_rec(); 
  470.   
  471.      order(UNSORTED);  
  472.  
  473.      return TRUE;    
  474.   
  475.   
  476.   
  477. OnOpenError: 
  478.  
  479.      close2();
  480.  
  481.      return FALSE;    
  482.  
  483. }
  484.  
  485. ///////////////////////////////// close //////////////////////////////////////
  486. int NAMio::close2(void) 
  487. {
  488.  
  489.      db.close(); 
  490.      in1.close();
  491.      in2.close();
  492.      in3.close();
  493.      in4.close();
  494.  
  495.      return TRUE;   
  496. }
  497.  
  498.  
  499.  
  500. int NAMio::close(void) 
  501. {
  502.      if(!already_open()) return TRUE; 
  503.  
  504.      int RC=close2(); 
  505.  
  506.      is_open=FALSE; 
  507.  
  508.      return RC;   
  509. }
  510.  
  511. ///////////////////////////////// define /////////////////////////////////////
  512. int  NAMio::define(void) 
  513. {
  514.      if(already_open()) { visible_error(30062); return FALSE; }
  515.  
  516.      int RC;
  517.  
  518.      RC=db.define("csadr.dbf",sizeof(record)); 
  519.  
  520.      in1.multiple_keys(TRUE);
  521.      RC&=in1.define("csadr01.idx",NAMio_NAME_TOK_LENGTH,sizeof(long));
  522.      in2.multiple_keys(TRUE);
  523.      RC&=in2.define("csadr02.idx",NAMio_CITY_LENGTH+1,sizeof(long));
  524.      in3.multiple_keys(TRUE);
  525.      RC&=in3.define("csadr03.idx",sizeof(long),sizeof(long));
  526.      in4.multiple_keys(TRUE);
  527.      RC&=in4.define("csadr04.idx",NAMio_RELATION_LENGTH+1,sizeof(long));
  528.  
  529.      if(!RC) visible_error(30070); 
  530.  
  531.      return RC; 
  532. }
  533.  
  534. ///////////////////////////////// pack ///////////////////////////////////////
  535. int NAMio::pack(void) 
  536. {
  537.      if(!is_open) { visible_error(30052); return FALSE; }
  538.  
  539.      write_rec(); 
  540.      db.pack();
  541.      reindex();
  542.      top();
  543.  
  544.      return TRUE;
  545. }
  546.  
  547. ///////////////////////////////// order //////////////////////////////////////
  548. int NAMio::order(int nr) 
  549. {
  550.      if(!is_open) { visible_error(30053); return FALSE; }
  551.  
  552.      switch(nr)
  553.      {
  554.          case UNSORTED:        //Unsorted 
  555.                   bof_fun   =&NAMio::bof0;
  556.                   eof_fun   =&NAMio::eof0;
  557.                   skip_fun  =&NAMio::skip0;
  558.                   top_fun   =&NAMio::top0;
  559.                   bottom_fun=&NAMio::bottom0;
  560.                   search_fun=&NAMio::search0;
  561.                   NeedSync=FALSE;
  562.                   break; 
  563.          case NAMIO_NAME_INDEX:    //Index on field name
  564.                   bof_fun   =&NAMio::bof1;
  565.                   eof_fun   =&NAMio::eof1;
  566.                   skip_fun  =&NAMio::skip1;
  567.                   top_fun   =&NAMio::top1;
  568.                   bottom_fun=&NAMio::bottom1;
  569.                   search_fun=&NAMio::search1;
  570.                   NeedSync=TRUE;
  571.                   break; 
  572.          case NAMIO_CITY_INDEX:    //Index on field city
  573.                   bof_fun   =&NAMio::bof2;
  574.                   eof_fun   =&NAMio::eof2;
  575.                   skip_fun  =&NAMio::skip2;
  576.                   top_fun   =&NAMio::top2;
  577.                   bottom_fun=&NAMio::bottom2;
  578.                   search_fun=&NAMio::search2;
  579.                   NeedSync=TRUE;
  580.                   break; 
  581.          case NAMIO_BIRTH_INDEX:    //Index on field birth
  582.                   bof_fun   =&NAMio::bof3;
  583.                   eof_fun   =&NAMio::eof3;
  584.                   skip_fun  =&NAMio::skip3;
  585.                   top_fun   =&NAMio::top3;
  586.                   bottom_fun=&NAMio::bottom3;
  587.                   search_fun=&NAMio::search3;
  588.                   NeedSync=TRUE;
  589.                   break; 
  590.          case NAMIO_RELATION_INDEX:    //Index on field relation
  591.                   bof_fun   =&NAMio::bof4;
  592.                   eof_fun   =&NAMio::eof4;
  593.                   skip_fun  =&NAMio::skip4;
  594.                   top_fun   =&NAMio::top4;
  595.                   bottom_fun=&NAMio::bottom4;
  596.                   search_fun=&NAMio::search4;
  597.                   NeedSync=TRUE;
  598.                   break; 
  599.          default: { visible_error(30080); return FALSE; }
  600.      }
  601.      iOrder=nr;
  602.  
  603.      return TRUE;
  604. }
  605. /////////////////////////////reading record  ///////////////////////////////
  606. void NAMio::read_rec(void) 
  607. {
  608.     if(numrec()==0) return; 
  609.     *static_rec=*locate_curr(); 
  610.     _update.sem_jul(static_rec->__update); 
  611.     _birth.sem_jul(static_rec->__birth); 
  612. }
  613. /////////////////////////////writing record  ///////////////////////////////
  614. void NAMio::write_rec2(void) 
  615. {
  616.     record *recp=locate_curr(); 
  617.     if(strcmp(recp->_name,static_rec->_name)) 
  618.     { 
  619.       tokenize(FALSE,recp->_name,TD_NAME,TL_NAME,&NAMio::in1_del_tok); 
  620.       tokenize(FALSE,static_rec->_name,TD_NAME,TL_NAME,&NAMio::in1_ins_tok); 
  621.     } 
  622.     if(strcmp(recp->_city,static_rec->_city)) 
  623.     { 
  624.       in2.delet(recp->_city,¤t); 
  625.       in2.insert(static_rec->_city,¤t); 
  626.     } 
  627.     static_rec->__update=_update.sem_jul(); 
  628.     static_rec->__birth=_birth.sem_jul(); 
  629.     if(recp->__birth!=static_rec->__birth) 
  630.     { 
  631.       in3.delet(&recp->__birth,¤t); 
  632.       in3.insert(&static_rec->__birth,¤t); 
  633.     } 
  634.     if(strcmp(recp->_relation,static_rec->_relation)) 
  635.     { 
  636.       in4.delet(recp->_relation,¤t); 
  637.       in4.insert(static_rec->_relation,¤t); 
  638.     } 
  639.     db.write_rec(current,static_rec); 
  640.     dirty=FALSE;   
  641. }
  642.  
  643. ///////////////////////////////// export /////////////////////////////////////
  644. int  NAMio::export(char *s) 
  645. {
  646.      if(!is_open) { visible_error(30054,s); return FALSE; }
  647.  
  648.      write_rec();
  649.  
  650.      FILE *fo=fopen(s,"w"); 
  651.      if(fo==NULL) { visible_error(30071,s); return FALSE; }
  652.  
  653.      fprintf(fo,"class:  NAMio");
  654.      fprintf(fo,"\nrecord: record");
  655.      fprintf(fo,"\nfile:   csadr.dbf");
  656.      fprintf(fo,"\nfield:  name s 40 T   ");
  657.      fprintf(fo,"\nfield:  adre s 32   ");
  658.      fprintf(fo,"\nfield:  city s 23 Y   ");
  659.      fprintf(fo,"\nfield:  count s 32   ");
  660.      fprintf(fo,"\nfield:  zip s 9   ");
  661.      fprintf(fo,"\nfield:  tel s 17   ");
  662.      fprintf(fo,"\nfield:  update d MDY2   ");
  663.      fprintf(fo,"\nfield:  birth d DMY4 Y   ");
  664.      fprintf(fo,"\nfield:  relation s 10 Y   ");
  665.      fprintf(fo,"\nfield:  info s 70   ");
  666.  
  667.      if(ferror(fo)) { fclose(fo); visible_error(30072,s); return FALSE; } 
  668.  
  669.      record *rp;
  670.      csDATE conv;
  671.      conv.format(Y4MD);
  672.      U32 lmax=numrec();
  673.      U32 l;
  674.      for(l=1;l<=lmax;l++) 
  675.      {
  676.         rp=( record * )db.locate_rec(l);
  677.         fprintf(fo,"\n%c",12);
  678.         fprintf(fo,"\n%s",rp->_name);
  679.         fprintf(fo,"\n%s",rp->_adre);
  680.         fprintf(fo,"\n%s",rp->_city);
  681.         fprintf(fo,"\n%s",rp->_count);
  682.         fprintf(fo,"\n%s",rp->_zip);
  683.         fprintf(fo,"\n%s",rp->_tel);
  684.         conv.sem_jul(rp->__update);
  685.         fprintf(fo,"\n%s",(char *)conv);
  686.         conv.sem_jul(rp->__birth);
  687.         fprintf(fo,"\n%s",(char *)conv);
  688.         fprintf(fo,"\n%s",rp->_relation);
  689.         fprintf(fo,"\n%s",rp->_info);
  690.         fprintf(fo,"\n"); //Additional linefeed
  691.  
  692.         if(ferror(fo)) { fclose(fo); visible_error(30072,s); return FALSE; } 
  693.      }
  694.  
  695.      if(fclose(fo)) { visible_error(30072,s); return FALSE; }
  696.  
  697.      return TRUE;  
  698. }
  699.  
  700. ///////////////////////////////// import /////////////////////////////////////
  701. int NAMio::import(char *s) 
  702. {   
  703.  
  704.       if(!is_open) { visible_error(30055,s); return FALSE; }
  705.  
  706.       FILE *fr=fopen(s,"r"); 
  707.       if(fr==NULL) { visible_error(30091,s); return FALSE; }
  708.   
  709.   
  710.       const MAX_NUM_FIELDS= 100;  //Increase this to allow more fields    
  711.       const MAX_FIELD_LEN = 500;  //Increase this to allow longer fields  
  712.  
  713.       int *finu;
  714.       finu=(int *)malloc(MAX_NUM_FIELDS*sizeof(int));
  715.       if(finu==NULL) { fclose(fr); visible_error(30092); return FALSE; }  
  716.  
  717.       char *fibu;    
  718.       fibu=(char *)malloc(MAX_FIELD_LEN);
  719.       if(fibu==NULL) 
  720.       {
  721.          fclose(fr); 
  722.          free(finu); 
  723.          visible_error(30092); 
  724.          return FALSE; 
  725.       }
  726.  
  727.       *fibu=0;  
  728.  
  729.       char *fipo=fibu+strlen("field:");  
  730.       char *cp; 
  731.       int  ifieldnr=0;    
  732.       int  ofieldnr; 
  733.  
  734.       int  RC=TRUE; 
  735.       int  InDef=TRUE; 
  736.       csDATE conv;
  737.       conv.format(Y4MD);
  738.  
  739.       memset(finu,0,MAX_NUM_FIELDS*sizeof(int));
  740.  
  741.       fgets(fibu,MAX_FIELD_LEN,fr); 
  742.       while(!strchr(fibu,12))  
  743.       {    
  744.         if(feof(fr))
  745.         { 
  746.            if(!InDef)   
  747.            visible_error(30093,s); 
  748.            RC=FALSE;
  749.            break; 
  750.         } 
  751.         pStrlwr(fibu);     //Converting to lower case.
  752.         notabs(fibu);      //Removing tabs.
  753.         trim_string(fibu); //Removing heading & trailing spaces.
  754.         if(!strchr(fibu,':') && *fibu) InDef=FALSE;   
  755.         if(strstr(fibu,"field:"))   
  756.         {  
  757.            ifieldnr++;  
  758.            trim_string(fipo);    
  759.            if((cp=strchr(fipo,' '))!=NULL) *cp=0;
  760.            if     (!strcmp(fipo,"name"))    ofieldnr=1;
  761.            else if(!strcmp(fipo,"adre"))    ofieldnr=2;
  762.            else if(!strcmp(fipo,"city"))    ofieldnr=3;
  763.            else if(!strcmp(fipo,"count"))    ofieldnr=4;
  764.            else if(!strcmp(fipo,"zip"))    ofieldnr=5;
  765.            else if(!strcmp(fipo,"tel"))    ofieldnr=6;
  766.            else if(!strcmp(fipo,"update"))    ofieldnr=7;
  767.            else if(!strcmp(fipo,"birth"))    ofieldnr=8;
  768.            else if(!strcmp(fipo,"relation"))    ofieldnr=9;
  769.            else if(!strcmp(fipo,"info"))    ofieldnr=10;
  770.            else ofieldnr=0; 
  771.            finu[ifieldnr]=ofieldnr; 
  772.         }  
  773.         fgets(fibu,MAX_FIELD_LEN,fr);    
  774.       }    
  775.  
  776.  
  777.       if(RC) 
  778.       for(;;)   
  779.       {    
  780.         if(!strchr(fibu,12))   
  781.         {  
  782.            ifieldnr++; 
  783.            if(ifieldnr<MAX_NUM_FIELDS) 
  784.              switch(finu[ifieldnr])   
  785.              {  
  786.                 case 0:  break;
  787.                 case 1:
  788.                          fibu[NAMio_NAME_LENGTH]=0;
  789.                          name(fibu);
  790.                          break;
  791.                 case 2:
  792.                          fibu[NAMio_ADRE_LENGTH]=0;
  793.                          adre(fibu);
  794.                          break;
  795.                 case 3:
  796.                          fibu[NAMio_CITY_LENGTH]=0;
  797.                          city(fibu);
  798.                          break;
  799.                 case 4:
  800.                          fibu[NAMio_COUNT_LENGTH]=0;
  801.                          count(fibu);
  802.                          break;
  803.                 case 5:
  804.                          fibu[NAMio_ZIP_LENGTH]=0;
  805.                          zip(fibu);
  806.                          break;
  807.                 case 6:
  808.                          fibu[NAMio_TEL_LENGTH]=0;
  809.                          tel(fibu);
  810.                          break;
  811.                 case 7:
  812.                          conv=fibu;
  813.                          _update.sem_jul(conv.sem_jul());
  814.                          break;
  815.                 case 8:
  816.                          conv=fibu;
  817.                          _birth.sem_jul(conv.sem_jul());
  818.                          break;
  819.                 case 9:
  820.                          fibu[NAMio_RELATION_LENGTH]=0;
  821.                          relation(fibu);
  822.                          break;
  823.                 case 10:
  824.                          fibu[NAMio_INFO_LENGTH]=0;
  825.                          info(fibu);
  826.                          break;
  827.              }  
  828.         }  
  829.         else    
  830.         {  
  831.            ifieldnr=0; 
  832.            append_blank();
  833.         }  
  834.         if(feof(fr)) break;    
  835.         fgets(fibu,MAX_FIELD_LEN,fr);    
  836.         cp=fibu+(pMax(1,strlen(fibu))-1); 
  837.         if(*cp=='\n') *cp=0;  //removing the line feed 
  838.       }    
  839.  
  840.  
  841.       fclose(fr); 
  842.       free(fibu); 
  843.       free(finu); 
  844.  
  845.       return RC; 
  846.  
  847. }
  848.  
  849. ///////////////////////////////// export to dBASE compatible file. ///////////
  850. int NAMio::to_DBASE(char *s) 
  851. {   
  852.  
  853.       if(!is_open) { visible_error(30056,s); return FALSE; }
  854.  
  855.       char bufje[12];
  856.  
  857.       write_rec(); 
  858.       FILE *fo=fopen(s,"wb"); 
  859.       if(fo==NULL) { visible_error(30095,s); return FALSE; }
  860.   
  861.       int i;
  862.   
  863.       csDATE d_upda;
  864.       d_upda.sem_jul(db.sj_updated());
  865.       fputc(03,fo);  
  866.       
  867.       fputc(d_upda.year()%100,fo);  
  868.       fputc(d_upda.month(),fo);  
  869.       fputc(d_upda.day(),fo);  
  870.  
  871.       long nr_record=numrec(); 
  872.       fwrite(&nr_record,sizeof(long),1,fo); 
  873.       WriteU16l(fo,354);        //Header length 
  874.       WriteU16l(fo,250);        //Length of data record 
  875.       for(i=0;i<20;i++) fputc(0,fo); // 20 dummy bytes 
  876.  
  877.  
  878. // Writing definition of field name to dbase file header.
  879.       memset(bufje,0,11);
  880.       strcpy(bufje,"NAME");
  881.       fwrite(bufje,11,1,fo);
  882.       fputc('C',fo); 
  883.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  884.       fputc(40,fo); 
  885.       fputc(0,fo); 
  886.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  887.  
  888. // Writing definition of field adre to dbase file header.
  889.       memset(bufje,0,11);
  890.       strcpy(bufje,"ADRE");
  891.       fwrite(bufje,11,1,fo);
  892.       fputc('C',fo); 
  893.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  894.       fputc(32,fo); 
  895.       fputc(0,fo); 
  896.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  897.  
  898. // Writing definition of field city to dbase file header.
  899.       memset(bufje,0,11);
  900.       strcpy(bufje,"CITY");
  901.       fwrite(bufje,11,1,fo);
  902.       fputc('C',fo); 
  903.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  904.       fputc(23,fo); 
  905.       fputc(0,fo); 
  906.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  907.  
  908. // Writing definition of field count to dbase file header.
  909.       memset(bufje,0,11);
  910.       strcpy(bufje,"COUNT");
  911.       fwrite(bufje,11,1,fo);
  912.       fputc('C',fo); 
  913.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  914.       fputc(32,fo); 
  915.       fputc(0,fo); 
  916.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  917.  
  918. // Writing definition of field zip to dbase file header.
  919.       memset(bufje,0,11);
  920.       strcpy(bufje,"ZIP");
  921.       fwrite(bufje,11,1,fo);
  922.       fputc('C',fo); 
  923.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  924.       fputc(9,fo); 
  925.       fputc(0,fo); 
  926.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  927.  
  928. // Writing definition of field tel to dbase file header.
  929.       memset(bufje,0,11);
  930.       strcpy(bufje,"TEL");
  931.       fwrite(bufje,11,1,fo);
  932.       fputc('C',fo); 
  933.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  934.       fputc(17,fo); 
  935.       fputc(0,fo); 
  936.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  937.  
  938. // Writing definition of field update to dbase file header.
  939.       memset(bufje,0,11);
  940.       strcpy(bufje,"UPDATE");
  941.       fwrite(bufje,11,1,fo);
  942.       fputc('D',fo); 
  943.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  944.       fputc(8,fo); 
  945.       fputc(0,fo); 
  946.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  947.  
  948. // Writing definition of field birth to dbase file header.
  949.       memset(bufje,0,11);
  950.       strcpy(bufje,"BIRTH");
  951.       fwrite(bufje,11,1,fo);
  952.       fputc('D',fo); 
  953.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  954.       fputc(8,fo); 
  955.       fputc(0,fo); 
  956.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  957.  
  958. // Writing definition of field relation to dbase file header.
  959.       memset(bufje,0,11);
  960.       strcpy(bufje,"RELATION");
  961.       fwrite(bufje,11,1,fo);
  962.       fputc('C',fo); 
  963.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  964.       fputc(10,fo); 
  965.       fputc(0,fo); 
  966.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  967.  
  968. // Writing definition of field info to dbase file header.
  969.       memset(bufje,0,11);
  970.       strcpy(bufje,"INFO");
  971.       fwrite(bufje,11,1,fo);
  972.       fputc('C',fo); 
  973.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  974.       fputc(70,fo); 
  975.       fputc(0,fo); 
  976.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  977.  
  978.  
  979.       fputc(13,fo);  //Field terminator 
  980.       fputc(0,fo); 
  981.  
  982. // By now we have written the definition of the 
  983. // record structure to the file header. 
  984. // From here on we will export the records. 
  985.  
  986.      record *rp;
  987.      U32 lmax=numrec();
  988.      U32 l;
  989.      for(l=1;l<=lmax;l++) 
  990.      {
  991.  
  992.         if(ferror(fo)) 
  993.         { 
  994.            fclose(fo); 
  995.            visible_error(30096,s); 
  996.            return FALSE; 
  997.         } 
  998.  
  999.         rp=(record *)db.locate_rec(l);
  1000.  
  1001.         if(db.is_delet(l)) fputc(42,fo); 
  1002.         else               fputc(32,fo); 
  1003.  
  1004. /////////////////////// writing field name /////////////
  1005.         fprintf(fo,"%-40s",rp->_name);
  1006. /////////////////////// writing field adre /////////////
  1007.         fprintf(fo,"%-32s",rp->_adre);
  1008. /////////////////////// writing field city /////////////
  1009.         fprintf(fo,"%-23s",rp->_city);
  1010. /////////////////////// writing field count /////////////
  1011.         fprintf(fo,"%-32s",rp->_count);
  1012. /////////////////////// writing field zip /////////////
  1013.         fprintf(fo,"%-9s",rp->_zip);
  1014. /////////////////////// writing field tel /////////////
  1015.         fprintf(fo,"%-17s",rp->_tel);
  1016. /////////////////////// writing field update /////////////
  1017.         if(rp->__update)
  1018.         { 
  1019.           d_upda.sem_jul(rp->__update);
  1020.           fprintf(fo,"%4d",d_upda.year4());
  1021.           fprintf(fo,"%02d",d_upda.month());
  1022.           fprintf(fo,"%02d",d_upda.day());
  1023.         } 
  1024.         else 
  1025.         { 
  1026.           fprintf(fo,"        "); 
  1027.         } 
  1028. /////////////////////// writing field birth /////////////
  1029.         if(rp->__birth)
  1030.         { 
  1031.           d_upda.sem_jul(rp->__birth);
  1032.           fprintf(fo,"%4d",d_upda.year4());
  1033.           fprintf(fo,"%02d",d_upda.month());
  1034.           fprintf(fo,"%02d",d_upda.day());
  1035.         } 
  1036.         else 
  1037.         { 
  1038.           fprintf(fo,"        "); 
  1039.         } 
  1040. /////////////////////// writing field relation /////////////
  1041.         fprintf(fo,"%-10s",rp->_relation);
  1042. /////////////////////// writing field info /////////////
  1043.         fprintf(fo,"%-70s",rp->_info);
  1044.      }
  1045.      fputc(26,fo);  //End of File 
  1046.      fclose(fo); 
  1047.  
  1048.      if(ferror(fo)) 
  1049.      { 
  1050.         visible_error(30096,s); 
  1051.         return FALSE; 
  1052.      } 
  1053.  
  1054.      return TRUE; 
  1055. }
  1056. ///////////////////////////////// tokenize field ///////////////////////
  1057. void NAMio::tokenize(int once,char *s,const char *delim,int min_len,void(NAMio::*fun)(void *))
  1058. {
  1059.  
  1060.      char *p,*q;
  1061.      char c;
  1062.      int  insert=FALSE;
  1063.  
  1064.      q=p=s;
  1065.  
  1066.      for(;;)
  1067.      {
  1068.        while(*p && !strchr(delim,*p)) p++;
  1069.        if(p-q>=min_len)
  1070.        {
  1071.           c=*p; *p=0;
  1072.           (this->*fun)(q);
  1073.           *p=c;
  1074.           if(once) return;
  1075.           insert=TRUE;
  1076.        }
  1077.        if(!*p) break;
  1078.        q=++p;
  1079.      }
  1080.  
  1081.      if(!insert) (this->*fun)(s);
  1082.  
  1083. }