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