home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c004 / 1.ddi / CTIXMG.C < prev    next >
Encoding:
C/C++ Source or Header  |  1989-04-18  |  16.7 KB  |  796 lines
  1. /*
  2.  * public domain example Ver 4.3 Release C
  3.  *
  4.  * variable record length example    
  5.  *
  6.  * incremental isam example (based on ctvxmg.c)
  7.  *
  8.  */
  9.  
  10. #include "ctstdr.h"
  11.                 /* automatically includes necessary
  12.                  * header files (including compiler's
  13.                  * "stdio.h")
  14.                  */
  15. #include "ctoptn.h"
  16. #include "ctstrc.h"
  17. #include "ctisam.h"
  18. #include "ctifil.h"
  19. #include "cterrc.h"
  20. #ifdef CTSERVER
  21. #include "ctcomm.h"
  22. extern UCOUNT  cts_apxsiz;            /* message size */
  23. #endif
  24.  
  25. #ifdef MUSTFRCE
  26. #define MULTIUSER
  27. #endif
  28.  
  29. COUNT CLISAM(),ADDVREC(),GTEREC(),NXTREC(),PRVREC(),RWTVREC();
  30. COUNT DELVREC(),REDVREC(),FRSSET(),NXTSET(),PRVSET(),LKISAM(),frmkey();
  31. COUNT OPNIFIL(),CLIFIL(),CREIFIL(),RBLIFIL(),INTISAM();
  32. TEXT *TFRMKEY();
  33.                 
  34. EXTERN COUNT   isam_err,isam_fil;    /* ISAM error code variables */
  35. EXTERN CTFILE *ct_key;
  36.  
  37. #define CUSTLOK 0        /* dummy file for systems with    */
  38.                 /* only exclusive rec ct_locks:    */
  39.                 /* e.g., DOS 3.1        */
  40. #define    CUSTDAT    1        /* customer data file        */
  41. #define    NAMEKEY 2        /* name ct_key            */
  42. #define    NUMBKEY    3        /* customer number ct_key        */
  43. #define    ZIPCKEY    4        /* zip code ct_key            */
  44.  
  45. #define NO_FLD    7        /* number of data record fields */
  46. #define VARFLD  '\2'        /* variable length field    */
  47. #define INTFLD    '\1'        /* integer field designator     */
  48. #define CHRFLD    '\0'        /* character field designator    */
  49.  
  50. #define NEW    0        /* new versus old record image    */
  51. #define OLD    1
  52.  
  53. #define NEXT    2        /* scan direction indicators    */
  54. #define PREV    3
  55.  
  56. IFIL dummylock = {
  57.     "vcustilk",
  58.     0,    /* file #     */
  59.     128,    /* record length */
  60.     0,    /* xtdsiz     */
  61.     3,    /* file mode     */
  62.     0    /* # of indices     */
  63.     };
  64. ISEG segments[] = {
  65.     {0,15,5},
  66.     {4,5,2},
  67.     {0,4,1},
  68.     {4,9,2},
  69.     {0,9,5}
  70.     };
  71. IIDX indices[] = {
  72.     {24, 4,1,1,32,2, segments},    /* customer name    */
  73.     { 4, 0,0,0, 0,1,&segments[2]},    /* customer number    */
  74.     {22,12,1,1,32,2,&segments[3]}    /* customer zipcode    */
  75.     };
  76. IFIL vcustomer = {
  77.     "vcusti",
  78.     1,
  79.     15,
  80.     4096,
  81.     5,
  82.     3,
  83.     4096,
  84.     1,
  85.     indices
  86.     };
  87.     
  88. TEXT *fldnam[NO_FLD];        /* field descriptions        */
  89. TEXT  fldtyp[NO_FLD];        /* field type: INTFLD, CHRFLD,    *
  90.                  * or VARFLD            */
  91. COUNT fldord[NO_FLD];        /* screen i/o order        */
  92. COUNT fldlen[NO_FLD];        /* (max) field length        */
  93. TEXT *fldptr[NO_FLD];        /* new image field pointer    */
  94. TEXT *oldptr[NO_FLD];        /* old image field pointer    */
  95. TEXT  inpbuf[128];        /* input buffer            */
  96.  
  97. #define CNUML    4        /* field lengths in bytes    */
  98. #define LNAML    36
  99. #define FNAML    36
  100. #define ADRSL    48
  101. #define CITYL    36
  102. #define STATL    2
  103. #define ZIPCL    9
  104.  
  105. LONG  numtar;            /* input variable for integer key value */
  106. TEXT  namtar[LNAML + 1];    /* input variable for character ct_key    */
  107.  
  108. struct CUST_IMAGE {        /* data record format            */
  109.     LONG    cnum;        /* customer number            */
  110.     TEXT    zipc[ZIPCL];    /* zip code                */
  111.     TEXT    stat[STATL];    /* state abreviation            */
  112.     TEXT    lnam[LNAML+1];    /* last name                */
  113.     TEXT    fnam[FNAML+1];    /* first name                */
  114.     TEXT    adrs[ADRSL+1];    /* street address            */
  115.     TEXT    city[CITYL+1];    /* city                    */
  116.     } image,
  117.       old_image,
  118.       key_target;        /* contains the record image with fields */
  119.                 /* at max lengths & known locations    */
  120.  
  121. #define MAX_CUST sizeof(struct CUST_IMAGE)
  122.  
  123. TEXT  cust[MAX_CUST],old_cust[MAX_CUST];
  124.  
  125.                 /* old_cust is the record buffer for
  126.                  * existing data. cust is the record buffer
  127.                  * for new and/or updated data
  128.                  */
  129.  
  130. /* ************************************************************************* */
  131. /* ************************************************************************* */
  132.  
  133. main () {
  134.     VOID database();
  135.  
  136. #ifdef CTSERVER
  137.     cts_apxsiz = CTS_MAXSMSG;
  138. #endif
  139.  
  140.     printf(
  141.         "\nc-tree(R) V4.3 Release C\n\nIncremental ISAM Example\n");
  142.  
  143.  
  144.     if (INTISAM(10,5,4)) {
  145.         printf("\nCould not initialize c-tree (%d)\n",isam_err);
  146.         STPUSR();
  147.         exit(2);
  148.     }
  149.  
  150. #ifndef CTSERVER
  151. #ifdef FPUTFGET
  152.     if (OPNIFIL(&dummylock) && CREIFIL(&dummylock)) {
  153.         printf("\n\nLock file problems. Error codes %d %d",
  154.             isam_err,isam_fil);
  155.         STPUSR();
  156.         exit(2);
  157.     }
  158. #endif
  159. #endif
  160.  
  161.     if (OPNIFIL(&vcustomer)) {
  162.             printf("\nCould not open %s with Error #%d.",
  163.             vcustomer.pfilnam,isam_err);
  164.         if (isam_err == FNOP_ERR) {
  165.             printf(" Attempting to create.\n");
  166.             if (CREIFIL(&vcustomer))
  167.                 printf(
  168. "\nCould not create file with error %d (on file %d).\n",isam_err,isam_fil);
  169.             else {
  170.                 CLIFIL(&vcustomer);
  171.                 OPNIFIL(&vcustomer);
  172.             }
  173.         }
  174.  
  175. #ifndef MUSTFRCE
  176.         /* MUSTFRCE is defined when c-tree is in multi-user mode */
  177.         if (isam_err == DOPN_ERR || isam_err == FCRP_ERR ||
  178.             isam_err == FCMP_ERR) {
  179.             printf(" Attempting a rebuild.\n");
  180.             if (RBLIFIL(&vcustomer)) {
  181.                 printf("Rebuild failed with Error #%d\n",
  182.                     isam_err);
  183.                 STPUSR();
  184.                 exit(2);
  185.             } else {
  186.                 printf("\nRebuild succeeded.\n");
  187.                 if (OPNIFIL(&vcustomer)) {
  188.                   printf("\nUNEXPECTED ERROR ON REOPEN #%d\n",
  189.                     isam_err);
  190.                   STPUSR();
  191.                   exit(2);
  192.                 }
  193.             }
  194.         } else if (isam_err) {
  195.             STPUSR();
  196.             exit(2);
  197.         }
  198. #else
  199.         if (isam_err) {
  200.             STPUSR();
  201.             exit(2);
  202.         }
  203. #endif
  204.     }
  205.  
  206. /*
  207.  * assign field characteristics
  208.  */
  209.     fldord[0] = 0;
  210.     fldord[1] = 3;
  211.     fldord[2] = 4;
  212.     fldord[3] = 5;
  213.     fldord[4] = 6;
  214.     fldord[5] = 2;
  215.     fldord[6] = 1;
  216.  
  217.     fldnam[0] = "Number";
  218.     fldtyp[0] = INTFLD;
  219.     fldlen[0] = CNUML;
  220.     fldptr[0] = (TEXT *) &image.cnum;
  221.     oldptr[0] = (TEXT *) &old_image.cnum;
  222.  
  223.     fldnam[1] = "Zip Code";
  224.     fldtyp[1] = CHRFLD;
  225.     fldlen[1] = ZIPCL;
  226.     fldptr[1] = image.zipc;
  227.     oldptr[1] = old_image.zipc;
  228.  
  229.     fldnam[2] = "State Abrev";
  230.     fldtyp[2] = CHRFLD;
  231.     fldlen[2] = STATL;
  232.     fldptr[2] = image.stat;
  233.     oldptr[2] = old_image.stat;
  234.  
  235.     fldnam[3] = "Last Name";
  236.     fldtyp[3] = VARFLD;
  237.     fldlen[3] = LNAML;
  238.     fldptr[3] = image.lnam;
  239.     oldptr[3] = old_image.lnam;
  240.     
  241.     fldnam[4] = "First Name";
  242.     fldtyp[4] = VARFLD;
  243.     fldlen[4] = FNAML;
  244.     fldptr[4] = image.fnam;
  245.     oldptr[4] = old_image.fnam;
  246.  
  247.     fldnam[5] = "Address";
  248.     fldtyp[5] = VARFLD;
  249.     fldlen[5] = ADRSL;
  250.     fldptr[5] = image.adrs;
  251.     oldptr[5] = old_image.adrs;
  252.  
  253.     fldnam[6] = "City";
  254.     fldtyp[6] = VARFLD;
  255.     fldlen[6] = CITYL;
  256.     fldptr[6] = image.city;
  257.     oldptr[6] = old_image.city;
  258.  
  259. /*
  260.  * call the main database routine
  261.  */
  262.  
  263.     database();
  264.  
  265. /*
  266.  * close the ISAM files
  267.  */
  268.  
  269.     if (CLISAM())
  270.         printf("\n\nCould not close isam. Error codes %d %d",
  271.             isam_err,isam_fil);
  272.     exit(0);
  273. }
  274.  
  275. /* ************************************************************************* */
  276. /* ************************************************************************* */
  277.  
  278.  
  279. /*
  280.  * routine to convert string to long integer
  281.  */
  282.  
  283. LONG getnum(tp)
  284. TEXT *tp;
  285. {
  286.     LONG retval;
  287.  
  288.     retval = 0L;
  289.     do {
  290.         if (*tp >= '0' && *tp <= '9') {
  291.             retval *= 10;
  292.             retval += (*tp - '0');
  293.         }
  294.     } while (*tp++);
  295.     return(retval);
  296. }
  297.  
  298. /*
  299.  * routines to pack and unpack variable length records
  300.  */
  301.  
  302. UCOUNT putimage()     /* puts image into cust and returns length */
  303. {
  304.     COUNT  i,len;
  305.     UCOUNT tlen;
  306.     TEXT  *dp,*sp;
  307.  
  308.     dp     = cust;
  309.     tlen   = 0;
  310.     for (i = 0; i < NO_FLD; i++) {
  311.         len = fldlen[i];
  312.         sp  = fldptr[i];
  313.         if (fldtyp[i] != VARFLD) {
  314.             tlen += len;
  315.             while (len-- > 0)
  316.                 *dp++ = *sp++;
  317.         } else
  318.             while (++tlen && (*dp++ = *sp++))
  319.                 ;
  320.     }
  321.     return(tlen);
  322. }
  323.  
  324. VOID getimage()        /* fills old image from old_cust */
  325. {
  326.     COUNT i,len;
  327.     TEXT *dp,*sp; 
  328.  
  329.     sp     = old_cust;
  330.     for (i = 0; i < NO_FLD; i++) {
  331.         len = fldlen[i];
  332.         dp  = oldptr[i];
  333.         if (fldtyp[i] != VARFLD)
  334.             while (len-- > 0)
  335.                 *dp++ = *sp++;
  336.         else {
  337.             while (*dp++ = *sp++)
  338.                 len--;
  339.             while (--len > 0)
  340.                 *dp++ = '\0';
  341.         }
  342.     }
  343. }
  344.  
  345. /* ************************************************************************* */
  346. /* ************************************************************************* */
  347.  
  348. /*
  349.  * main data base routine
  350.  */
  351.         
  352. VOID database()
  353.  
  354. {
  355.     TEXT choice[2];
  356.  
  357.     VOID datadd(),datscan(),seqscan();
  358.  
  359.     choice[0] = '\0';
  360.  
  361.     while (choice[0] != 'q' && choice[0] != 'Q') {
  362.     printf("\n\nA)dd   U)pdate   S)equence Set   Q)uit:");
  363.     gets(inpbuf);
  364.     choice[0] = inpbuf[0];
  365.     switch (choice[0]) {
  366.  
  367. case 'A':
  368. case 'a':
  369.         datadd();    /* add new entry to customer data base */
  370.         break;
  371.  
  372. case 'U':
  373. case 'u':
  374.         datscan();    /* scan/update existing entries */
  375.         break;
  376.  
  377. case 'S':
  378. case 's':
  379.         seqscan();    /* scan/update sequence set */
  380.         break;
  381.  
  382. default:
  383.         break;
  384.     }
  385.     }
  386. }
  387.  
  388. /* ************************************************************************* */
  389. /* ************************************************************************* */
  390.  
  391. /*
  392.  * routine to add new customer
  393.  */
  394.  
  395. VOID datadd()
  396. {
  397.     COUNT  i;
  398.     UCOUNT varlen;
  399.  
  400.     VOID getfld();
  401.  
  402.     printf("\nADD NEW DATA\n\n");
  403.  
  404. /*
  405.  * enter data for each field
  406.  */
  407.  
  408.     for (i = 0; i < NO_FLD; i++)
  409.         getfld(i,NEW);            
  410.  
  411. /*
  412.  * enable locks and add data
  413.  */
  414.  
  415.     varlen = putimage(); 
  416.     if (LKISAM(ENABLE) || ADDVREC(CUSTDAT,cust,varlen))
  417.         printf("\n\nError during addition. Codes %d %d",isam_err,
  418.             isam_fil);
  419.     else
  420.         printf("\nSuccessful Addition.");
  421.     LKISAM(FREE);
  422. }
  423.  
  424.  
  425. /* ************************************************************************* */
  426. /* ************************************************************************* */
  427.  
  428. /*
  429.  * print field name and get field input
  430.  */
  431.  
  432. VOID getfld(pos,typ)
  433. COUNT pos,typ;
  434. {
  435.     COUNT fldno;
  436.  
  437.     VOID inpfld(),putfld();
  438.  
  439.     fldno = fldord[pos++];
  440.     if (typ == OLD) {
  441.         printf("\n\nCurrent value for %-15s: ",fldnam[fldno]);
  442.         putfld(fldno);
  443.         printf("\nEnter new value   %-15s: ","");
  444.         inpfld(fldno);
  445.     } else {
  446.         printf("\n%d. %-15s :",pos,fldnam[fldno]);
  447.         inpfld(fldno);
  448.     }
  449. }
  450.  
  451. /* ************************************************************************* */
  452. /* ************************************************************************* */
  453.  
  454. /*
  455.  * field input routine handles character and (long) integer fields
  456.  */
  457.  
  458. VOID inpfld(fldno)
  459. COUNT fldno;
  460. {
  461.     LONG *intdat;
  462.  
  463.     VOID cpychr(),cpyvar();
  464.  
  465.     if (fldtyp[fldno] == INTFLD) {
  466.         intdat = (LONG *) fldptr[fldno];
  467.         gets(inpbuf);
  468.         *intdat = getnum(inpbuf);
  469.     } else {
  470.         gets(inpbuf);
  471.         if (fldtyp[fldno] == CHRFLD)
  472.             cpychr(fldptr[fldno],inpbuf,fldlen[fldno]);
  473.         else
  474.             cpyvar(fldptr[fldno],inpbuf,fldlen[fldno]);
  475.     }
  476. }
  477.  
  478. /* ************************************************************************* */
  479. /* ************************************************************************* */
  480.  
  481. /*
  482.  * routine to scan existing customers
  483.  */
  484.  
  485. VOID datscan()
  486. {
  487.     COUNT update();
  488.     VOID  cpychr();
  489.  
  490.     COUNT fldno,action,keyno;
  491.     TEXT *tarval;        /* pointer to target key value    */
  492.     TEXT  choice[2];
  493.  
  494.     printf("\nSCAN DATA\n");
  495.     keyno = -1;
  496.  
  497. /*
  498.  * select which ct_key to order scan by  and  starting key value
  499.  */
  500.  
  501.     while (keyno < NAMEKEY || keyno > ZIPCKEY) {
  502.         printf("\nScan by  N)ame  #(number)  Z)ip Code   or Q)uit>> ");
  503.         gets(inpbuf);
  504.         choice[0] = inpbuf[0];
  505.         switch (choice[0]) {
  506. case 'n':
  507. case 'N':
  508.             keyno = NAMEKEY;
  509.             fldno = 3;
  510.             break;
  511. case '#':
  512.             keyno = NUMBKEY;
  513.             fldno = 0;
  514.             break;
  515.  
  516. case 'z':
  517. case 'Z':
  518.             keyno = ZIPCKEY;
  519.             fldno = 1;
  520.             break;
  521.  
  522. case 'q':
  523. case 'Q':
  524.             return;
  525. default:
  526.             printf("\nImproper selection (%.1s). Try again.\n",
  527.                 choice);
  528.         }
  529.     }
  530.  
  531.     printf("\nEnter %s: ",fldnam[fldno]);
  532.     gets(inpbuf);
  533.     if (keyno == NAMEKEY) {
  534.         cpychr(key_target.lnam,inpbuf,LNAML);
  535.         key_target.zipc[0] = '\0';
  536.     } else if (keyno == ZIPCKEY) {
  537.         cpychr(key_target.zipc,inpbuf,ZIPCL);
  538.         key_target.lnam[0] = '\0';
  539.     }
  540.     if (keyno != NUMBKEY) {
  541.         /* Ordinarily we would use TFRMKEY. frmkey() used for example */
  542.         frmkey(keyno,&key_target,inpbuf,0L);
  543.         tarval = inpbuf;
  544.     } else {
  545.         numtar = getnum(inpbuf);
  546.         tarval = TFRMKEY(keyno,&numtar);
  547.     }
  548.  
  549.  
  550. /*
  551.  * scan data acquiring a lock on each record and then freeing lock before
  552.  * going on to next record
  553.  */
  554.         
  555.     action = 0;
  556.     if (LKISAM(ENABLE) || GTEREC(keyno,tarval,old_cust) ||
  557.         REDVREC(CUSTDAT,old_cust,MAX_CUST)) {
  558.         printf("\n\nSCAN failed at start with codes %d %d",isam_err,
  559.             isam_fil);
  560.         LKISAM(FREE);
  561.         return;
  562.     }
  563.     while (action > -1 && !isam_err) {
  564.         action = update();    /* update data and determine 
  565.                      * direction of scan
  566.                      */
  567.         LKISAM(RESET);
  568.         if (action == NEXT)
  569.             NXTREC(keyno,old_cust);
  570.         else if (action == PREV)
  571.             PRVREC(keyno,old_cust);
  572.         if (!isam_err && (action == NEXT || action == PREV))
  573.             REDVREC(CUSTDAT,old_cust,MAX_CUST);
  574.     }
  575.     if (isam_err)
  576.         printf("\n\nScan ending (code %d  file %d).",isam_err,
  577.             isam_fil);
  578.     LKISAM(FREE);
  579. }
  580.  
  581.  
  582. VOID seqscan()
  583. {
  584.     COUNT update();
  585.  
  586.     COUNT i,fldno,action,keyno;
  587.     TEXT *tarval;        /* pointer to target key value    */
  588.     TEXT  choice[2];
  589.  
  590.     printf("\nSCAN SEQUENCE SET\n");
  591.     keyno = -1;
  592.  
  593. /*
  594.  * select which ct_key to order scan by  and  starting key value
  595.  */
  596.  
  597.     while (keyno < NAMEKEY || keyno > ZIPCKEY) {
  598.         printf("\nScan by  N)ame  Z)ip Code   or Q)uit>> ");
  599.         gets(inpbuf);
  600.         choice[0] = inpbuf[0];
  601.         switch (choice[0]) {
  602. case 'n':
  603. case 'N':
  604.             keyno = NAMEKEY;
  605.             fldno = 3;
  606.             break;
  607. case 'z':
  608. case 'Z':
  609.             keyno = ZIPCKEY;
  610.             fldno = 1;
  611.             break;
  612.  
  613. case 'q':
  614. case 'Q':
  615.             return;
  616. default:
  617.             printf("\nImproper selection (%.1s). Try again.\n",
  618.                 choice);
  619.         }
  620.     }
  621.  
  622.     printf("\nEnter %s: ",fldnam[fldno]);
  623.     gets(inpbuf);
  624.     tarval = TFRMKEY(keyno,inpbuf);
  625.  
  626. /*
  627.  * scan data acquiring a lock on each record and then freeing lock before
  628.  * going on to next record
  629.  */
  630.         
  631.     action = 0;
  632.     if (LKISAM(ENABLE) || FRSSET(keyno,tarval,old_cust,strlen(tarval)) ||
  633.         REDVREC(CUSTDAT,old_cust,MAX_CUST)) {
  634.         printf("\n\nSCAN failed at start with codes %d %d",isam_err,
  635.             isam_fil);
  636.         LKISAM(FREE);
  637.         return;
  638.     }
  639.     while (action > -1 && (isam_err == 0 || isam_err == INOT_ERR)) {
  640.         action = update();    /* update data and determine 
  641.                      * direction of scan
  642.                      */
  643.         LKISAM(RESET);
  644.         if (action == NEXT)
  645.             NXTSET(keyno,old_cust);
  646.         else if (action == PREV)
  647.             PRVSET(keyno,old_cust);
  648.         if (!isam_err && (action == NEXT || action == PREV))
  649.             REDVREC(CUSTDAT,old_cust,MAX_CUST);
  650.     }
  651.     if (isam_err)
  652.         printf("\n\nScan ending (code %d  file %d).",isam_err,
  653.             isam_fil);
  654.     LKISAM(FREE);
  655. }
  656.  
  657. /* ************************************************************************* */
  658. /* ************************************************************************* */
  659.  
  660. /*
  661.  * routine to update customer records. note that the scan routine reads the
  662.  * customer records into the "old_cust" buffer and this routine creates
  663.  * an updated version in the "cust" buffer.
  664.  */
  665.  
  666. COUNT update()
  667. {
  668.     COUNT   i,fldno;
  669.     TEXT    choice[2];
  670.     POINTER curb;
  671.     TEXT   *curi;
  672.  
  673.     VOID getfld(),getimage(),putfld();
  674.  
  675.     getimage();
  676.     for (i = 0; i < NO_FLD; i++) {
  677.         fldno = fldord[i];
  678.         cpybuf(fldptr[fldno],oldptr[fldno],fldlen[fldno]);
  679.         printf("\n%d. %-15s: ",i + 1,fldnam[fldno]);
  680.         putfld(fldno);
  681.     }
  682.  
  683.     for(;;) {
  684.         printf(
  685. "\n\nEnter field # to change data or N)ext, P)revious D)elete or E)nd scan>> ");
  686.         gets(inpbuf);
  687.         choice[0] = inpbuf[0];
  688.         switch (choice[0]) {
  689.  
  690. case 'n':
  691. case 'N':
  692. case 'p':
  693. case 'P':
  694. case 'e':
  695. case 'E':
  696.             curi = cur_image[CUSTDAT];    /* save cur ISAM */
  697.             curb = cur_recno[CUSTDAT];
  698.             if (RWTVREC(CUSTDAT,cust,putimage()))
  699.                 return(-1);
  700.             cur_image[CUSTDAT] = curi;    /* reset cur ISAM */
  701.             cur_recno[CUSTDAT] = curb;
  702.             switch (choice[0]) {
  703.     case 'n':
  704.     case 'N':
  705.                 return(NEXT);
  706.             
  707.     case 'p':
  708.     case 'P':
  709.                 return(PREV);
  710.  
  711.     case 'e':
  712.     case 'E':
  713.                 return(-1);
  714.             }
  715. case 'd':
  716. case 'D':
  717.             if(!DELVREC(CUSTDAT))
  718.                 printf("\nSuccessful Deletion.\n");
  719.             return(NEXT);
  720.  
  721. case '1':
  722. case '2':
  723. case '3':
  724. case '4':
  725. case '5':
  726. case '6':
  727. case '7':
  728.             getfld((choice[0] - '1'),OLD);
  729.             break;
  730. default:
  731.             printf("\nImproper selection (%.1s). Try again.\n",
  732.                 choice);
  733.         }
  734.     }
  735. }
  736.  
  737. /* ************************************************************************* */
  738. /* ************************************************************************* */
  739.  
  740. /*
  741.  * routine to output customer field
  742.  */
  743.  
  744. VOID putfld(fldno)
  745. COUNT fldno;
  746. {
  747.     LONG      *intdat;
  748.     FAST COUNT i;
  749.     FAST TEXT *tp;
  750.  
  751.     if (fldtyp[fldno] == INTFLD) {
  752.         intdat = (LONG *) fldptr[fldno];
  753.         printf("%ld",*intdat);
  754.     } else
  755.         for (i = 0, tp = fldptr[fldno]; i++ < fldlen[fldno];)
  756.             printf("%c",*tp++);
  757. }
  758.  
  759. /* ************************************************************************* */
  760. /* ************************************************************************* */
  761.  
  762. /*
  763.  * routine to copy character data, padding with blanks
  764.  * if the data does not fill the field
  765.  */
  766.  
  767. VOID cpychr(dp,sp,len)
  768. PFAST TEXT *dp,*sp;
  769. PFAST COUNT len;
  770. {
  771.     while (*sp && len-- > 0 )    /* loop terminates either when 
  772.                      * complete field filled in, or
  773.                      * when a null termination byte
  774.                      * encountered
  775.                      */
  776.         *dp++ = *sp++;
  777.  
  778.     while (len-- > 0)        /* if field not filled in, pad
  779.                      * with blanks
  780.                      */
  781.         *dp++ = ' ';
  782. }
  783.  
  784. VOID cpyvar(dp,sp,len)
  785. PFAST TEXT *dp,*sp;
  786. COUNT       len;
  787. {
  788.     while (*sp && len-- > 0)
  789.         *dp++ = *sp++;
  790.     while (len-- > 0)
  791.         *dp++ = '\0';
  792.     *dp = '\0';
  793. }
  794.  
  795. /* end of ctixmg.c */
  796.