home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c004 / 1.ddi / CTEXMG.C < prev    next >
Encoding:
C/C++ Source or Header  |  1989-04-18  |  12.7 KB  |  601 lines
  1. /*
  2.  * public domain example 
  3.  *
  4.  * ISAM Parameter File named ctexam.p
  5.  *
  6.  */
  7.  
  8. #include "ctstdr.h"
  9.                 /* automatically includes necessary
  10.                  * header files (including compiler's
  11.                  * "stdio.h")
  12.                  */
  13. #include "ctoptn.h"
  14. #include "ctstrc.h"
  15.  
  16. #ifdef CTSERVER
  17. #include "ctcomm.h"
  18. extern UCOUNT  cts_apxsiz;            /* message size */
  19. #endif
  20.  
  21. COUNT OPNISAM(),CLISAM(),ADDREC(),GTEREC(),NXTREC(),PRVREC(),RWTREC();
  22. COUNT LKISAM(),DELREC(),RRDREC();
  23. TEXT *TFRMKEY();
  24.                 
  25. EXTERN COUNT   isam_err,isam_fil;    /* ISAM error code variables */
  26. EXTERN COUNT   uerr_cod;
  27. EXTERN CTFILE *ct_key;
  28.  
  29. #define    CUSTDAT    4        /* customer data file        */
  30. #define    NAMEKEY 1        /* name ct_key            */
  31. #define    NUMBKEY    2        /* customer number ct_key        */
  32. #define    ZIPCKEY    3        /* zip code ct_key            */
  33.  
  34. #define NO_FLD    7        /* number of data record fields */
  35. #define INTFLD    '\1'        /* integer field designator     */
  36. #define CHRFLD    '\0'        /* character field designator    */
  37.  
  38. #define NEW    0        /* new versus old record image    */
  39. #define OLD    1
  40.  
  41. #define NEXT    2        /* scan direction indicators    */
  42. #define PREV    3
  43. #define RWRT    4        /* rewrite flag            */
  44. #define DELT    5        /* delete flag            */
  45.  
  46.  
  47. TEXT *fldnam[NO_FLD];        /* field descriptions        */
  48. TEXT  fldtyp[NO_FLD];        /* field type: INTFLD or CHRFLD    */
  49. COUNT fldlen[NO_FLD];        /* field length            */
  50. TEXT *fldptr[NO_FLD];        /* new image field pointer    */
  51. TEXT *oldptr[NO_FLD];        /* old image field pointer    */
  52. TEXT  inpbuf[128];        /* general purpose input buffer */
  53.  
  54.  
  55. #define CNUML    4        /* field lengths in bytes    */
  56. #define LNAML    24
  57. #define FNAML    24
  58. #define ADRSL    32
  59. #define CITYL    24
  60. #define STATL    2
  61. #define ZIPCL    9
  62.  
  63. LONG  numtar;            /* input variable for integer key value */
  64. TEXT  namtar[LNAML + 1];    /* input variable for character ct_key    */
  65.  
  66. struct CUSTOMER {        /* data record format            */
  67.     COUNT    delete_flag;    /* delete flag byte            */
  68.     LONG    cnum;        /* customer number            */
  69.     TEXT    lnam[LNAML];    /* last name                */
  70.     TEXT    fnam[FNAML];    /* first name                */
  71.     TEXT    adrs[ADRSL];    /* street address            */
  72.     TEXT    city[CITYL];    /* city                    */
  73.     TEXT    stat[STATL];    /* state abreviation            */
  74.     TEXT    zipc[ZIPCL];    /* zip code                */
  75.     TEXT    padding[7];    /* unused padding            */
  76.     } cust,old_cust,chk_cust;
  77.                 /* old_cust is the record buffer for
  78.                  * existing data. cust is the record buffer
  79.                  * for new and/or updated data. chk_cust
  80.                  * is used for multi-user updates.
  81.                  */
  82. /*
  83.  * IF YOUR SYSTEM FORCES DOUBLE WORD ALIGNMENT OF LONG INTEGERS, THEN THE 
  84.  * SEGMENT OFFSETS IN ctexam.p MUST BE CHANGED TO REFLECT ANY HOLES WHICH 
  85.  * ARISE IN CUSTOMER AS A RESULT OF THE ALIGNMENT OF THE CNUM MEMBER.
  86.  */
  87.  
  88. /* ************************************************************************* */
  89. /* ************************************************************************* */
  90.  
  91. main () {
  92.     VOID database();
  93.  
  94. #ifdef CTSERVER
  95.     cts_apxsiz = CTS_MAXSMSG;
  96. #endif
  97.     printf("\nc-tree(R) V4.3 Release C\n\nDatabase Example\n\n");
  98.  
  99.     if (OPNISAM("ctexam.p")) {
  100.         printf("\n\nParameter file (ctexam.p) error code %d (%d).\n",
  101.             isam_err,isam_fil);
  102.         STPUSR();
  103.         exit(0);
  104.     }
  105. /*
  106.  * assign field characteristics
  107.  */
  108.  
  109.     fldnam[0] = "Number";
  110.     fldtyp[0] = INTFLD;
  111.     fldlen[0] = CNUML;
  112.     fldptr[0] = (TEXT *) &cust.cnum;
  113.     oldptr[0] = (TEXT *) &old_cust.cnum;
  114.  
  115.     fldnam[1] = "Last Name";
  116.     fldtyp[1] = CHRFLD;
  117.     fldlen[1] = LNAML;
  118.     fldptr[1] = cust.lnam;
  119.     oldptr[1] = old_cust.lnam;
  120.     
  121.     fldnam[2] = "First Name";
  122.     fldtyp[2] = CHRFLD;
  123.     fldlen[2] = FNAML;
  124.     fldptr[2] = cust.fnam;
  125.     oldptr[2] = old_cust.fnam;
  126.  
  127.     fldnam[3] = "Address";
  128.     fldtyp[3] = CHRFLD;
  129.     fldlen[3] = ADRSL;
  130.     fldptr[3] = cust.adrs;
  131.     oldptr[3] = old_cust.adrs;
  132.  
  133.     fldnam[4] = "City";
  134.     fldtyp[4] = CHRFLD;
  135.     fldlen[4] = CITYL;
  136.     fldptr[4] = cust.city;
  137.     oldptr[4] = old_cust.city;
  138.  
  139.     fldnam[5] = "State Abrev";
  140.     fldtyp[5] = CHRFLD;
  141.     fldlen[5] = STATL;
  142.     fldptr[5] = cust.stat;
  143.     oldptr[5] = old_cust.stat;
  144.  
  145.     fldnam[6] = "Zip Code";
  146.     fldtyp[6] = CHRFLD;
  147.     fldlen[6] = ZIPCL;
  148.     fldptr[6] = cust.zipc;
  149.     oldptr[6] = old_cust.zipc;
  150.  
  151. /*
  152.  * clear the delete flag
  153.  */
  154.  
  155.     cust.delete_flag = 0;
  156.  
  157. /*
  158.  * call the main database routine
  159.  */
  160.  
  161.     database();
  162.  
  163. /*
  164.  * close the ISAM files
  165.  */
  166.  
  167.     if (CLISAM())
  168.         printf("\n\nCould not close isam. Error codes %d %d",
  169.             isam_err,isam_fil);
  170.     exit(0);
  171. }
  172.  
  173. /* ************************************************************************* */
  174. /* ************************************************************************* */
  175.  
  176. /*
  177.  * main data base routine
  178.  */
  179.         
  180. VOID database()
  181.  
  182. {
  183.     TEXT choice[2];
  184.  
  185.     VOID datadd(),datscan();
  186.  
  187.     choice[0] = '\0';
  188.  
  189.     while (choice[0] != 'q' && choice[0] != 'Q') {
  190.     printf("\n\nA)dd  U)pdate  Q)uit:");
  191.     gets(inpbuf);
  192.     choice[0] = inpbuf[0];
  193.     switch (choice[0]) {
  194.  
  195. case 'A':
  196. case 'a':
  197.         datadd();    /* add new entry to customer data base */
  198.         break;
  199.  
  200. case 'U':
  201. case 'u':
  202.         datscan();    /* scan/update existing entries */
  203.         break;
  204.  
  205. default:
  206.         break;
  207.     }
  208.     }
  209. }
  210.  
  211. /* ************************************************************************* */
  212. /* ************************************************************************* */
  213.  
  214. /*
  215.  * routine to add new customer
  216.  */
  217.  
  218. VOID datadd()
  219.  
  220. {
  221.     COUNT i;
  222.  
  223.     VOID getfld();
  224.  
  225.     printf("\nADD NEW DATA\n\n");
  226.  
  227. /*
  228.  * enter data for each field
  229.  */
  230.  
  231.     for (i = 0; i < NO_FLD; i++)
  232.         getfld(i,NEW);            
  233.  
  234. /*
  235.  * enable ct_locks and add data
  236.  */
  237.  
  238.     if (TRANSACTION(BEGTRAN) || LKISAM(ENABLE) || ADDREC(CUSTDAT,&cust)) {
  239.         printf("\n\nError during addition. Codes %d %d",isam_err,
  240.             isam_fil);
  241.         TRANSACTION(ABRTRAN);
  242.     } else {
  243.         if (TRANSACTION(ENDTRAN))
  244.             printf("\nCould not commit transaction (%d)\n",
  245.                 uerr_cod);
  246.         else
  247.             printf("\nSuccessful Addition.");
  248.     }
  249.     LKISAM(FREE);
  250. }
  251.  
  252.  
  253. /* ************************************************************************* */
  254. /* ************************************************************************* */
  255.  
  256. /*
  257.  * print field name and get field input
  258.  */
  259.  
  260. VOID getfld(fldno,typ)
  261.  
  262. COUNT fldno,typ;
  263.  
  264. {
  265.     COUNT i;
  266.  
  267.     VOID inpfld(),putfld();
  268.  
  269.     i = fldno + 1;
  270.     if (typ == OLD) {
  271.         printf("\n\nCurrent value for %-15s: ",fldnam[fldno]);
  272.         putfld(fldno);
  273.         printf("\nEnter new value   %-15s: ","");
  274.         inpfld(fldno);
  275.     } else {
  276.         printf("\n%d. %-15s :",i,fldnam[fldno]);
  277.         inpfld(fldno);
  278.     }
  279. }
  280.  
  281.  
  282. /* ************************************************************************* */
  283. /* ************************************************************************* */
  284.  
  285. LONG getnum(tp)
  286. TEXT *tp;
  287. {
  288.     LONG retval;
  289.  
  290.     retval = 0L;
  291.     do {
  292.         if (*tp >= '0' && *tp <= '9') {
  293.             retval *= 10;
  294.             retval += (*tp - '0');
  295.         }
  296.     } while (*tp++);
  297.     return(retval);
  298. }
  299.  
  300. /*
  301.  * field input routine handles character and (long) integer fields
  302.  */
  303.  
  304. VOID inpfld(fldno)
  305.  
  306. COUNT fldno;
  307.  
  308. {
  309.     LONG *intdat;
  310.  
  311.     VOID cpychr();
  312.  
  313.     if (fldtyp[fldno] == INTFLD) {
  314.         intdat = (LONG *) fldptr[fldno];
  315.         gets(inpbuf);
  316.         *intdat = getnum(inpbuf);
  317.     } else {
  318.         gets(inpbuf);
  319.         cpychr(fldptr[fldno],inpbuf,fldlen[fldno]);
  320.     }
  321. }
  322.  
  323. /* ************************************************************************* */
  324. /* ************************************************************************* */
  325.  
  326. /*
  327.  * routine to scan existing customers
  328.  */
  329.  
  330. VOID datscan()
  331. {
  332.     COUNT update();
  333.  
  334.     COUNT i,action,filno,fldno;
  335.     TEXT *tarval;        /* pointer to target key value    */
  336.     TEXT  choice[2];
  337.  
  338.     printf("\nSCAN DATA\n");
  339.     filno = -1;
  340.  
  341. /*
  342.  * select which ct_key to order scan by  and  starting key value
  343.  */
  344.  
  345.     while (filno == -1) {
  346.         printf(
  347. "\nScan by  N)ame  #(number)  Z)ip Code  P)hysical Order    or Q)uit>> ");
  348.         gets(inpbuf);
  349.         choice[0] = inpbuf[0];
  350.         switch (choice[0]) {
  351. case 'n':
  352. case 'N':
  353.             filno = NAMEKEY;
  354.             fldno = 1;
  355.             break;
  356. case '#':
  357.             filno = NUMBKEY;
  358.             fldno = 0;
  359.             break;
  360. case 'z':
  361. case 'Z':
  362.             filno = ZIPCKEY;
  363.             fldno = 6;
  364.             break;
  365. case 'p':
  366. case 'P':
  367.             filno = CUSTDAT;
  368.             break;
  369.  
  370. case 'q':
  371. case 'Q':
  372.             return;
  373. default:
  374.             printf("\nImproper selection (%.1s). Try again.\n",
  375.                 choice);
  376.         }
  377.     }
  378.  
  379.     if (filno != CUSTDAT) {
  380.         printf("\nEnter %s: ",fldnam[fldno]);
  381.         for (i = 0; i < 128; i++)
  382.             inpbuf[i] = '\0';
  383.         gets(inpbuf);
  384.         if (filno != NUMBKEY) {
  385.             tarval = inpbuf;
  386.         } else {
  387.             numtar = getnum(inpbuf);
  388.             tarval = (TEXT *) &numtar;
  389.         }
  390.         GTEREC(filno,TFRMKEY(filno,tarval),&old_cust);
  391.     } else
  392.         FRSREC(filno,&old_cust);
  393.  
  394.     action = 0;
  395.     while (action > -1 && !isam_err) {
  396.         action = update();    /* update data and/or determine 
  397.                      * direction of scan
  398.                      */
  399.         if (action == NEXT)
  400.             NXTREC(filno,&old_cust);
  401.         else if (action == PREV)
  402.             PRVREC(filno,&old_cust);
  403.     }
  404.     if (isam_err)
  405.         printf("\n\nScan ending (code %d  file %d).",isam_err,
  406.             isam_fil);
  407. }
  408.  
  409. /* ************************************************************************* */
  410. /* ************************************************************************* */
  411.  
  412. /*
  413.  * routine to update customer records. note that the scan routine reads the
  414.  * customer records into the "old_cust" buffer and this routine creates
  415.  * an updated version in the "cust" buffer.
  416.  */
  417.  
  418. COUNT update()
  419.  
  420. {
  421.     COUNT i,update_flag,change();
  422.     TEXT  choice[2];
  423.  
  424.     VOID getfld(),putfld();
  425.  
  426.     cpybuf(&cust,&old_cust,(ct_key + CUSTDAT)->reclen);
  427.     for (i = 0; i < NO_FLD; i++) {
  428.         printf("\n%d. %-15s: ",i + 1,fldnam[i]);
  429.         putfld(i);
  430.     }
  431.     update_flag = NO;
  432.  
  433.     for(;;) {
  434.         printf(
  435. "\n\nEnter field # to change data or N)ext, P)revious D)elete U)ndo or E)nd scan>> ");
  436.         gets(inpbuf);
  437.         choice[0] = inpbuf[0];
  438.         switch (choice[0]) {
  439.  
  440. case 'u':
  441. case 'U':
  442.             update_flag = NO;
  443.             break;
  444. case 'n':
  445. case 'N':
  446.             if (update_flag && change(RWRT))
  447.                 return(-1);
  448.             else
  449.                 return(NEXT);
  450.             
  451. case 'p':
  452. case 'P':
  453.             if (update_flag && change(RWRT))
  454.                 return(-1);
  455.             else
  456.                 return(PREV);
  457.  
  458. case 'e':
  459. case 'E':
  460.             if (update_flag)
  461.                 change(RWRT);
  462.             return(-1);
  463. case 'd':
  464. case 'D':
  465.             change(DELT);
  466.             return(NEXT);
  467.  
  468. case '1':
  469. case '2':
  470. case '3':
  471. case '4':
  472. case '5':
  473. case '6':
  474. case '7':
  475.             update_flag = YES;
  476.             getfld((choice[0] - '1'),OLD);
  477.             break;
  478. default:
  479.             printf("\nImproper selection (%.1s). Try again.\n",
  480.                 choice);
  481.         }
  482.     }
  483. }
  484.  
  485. /* ************************************************************************* */
  486. /* ************************************************************************* */
  487.  
  488. /*
  489.  * routine to output customer field
  490.  */
  491.  
  492. VOID putfld(fldno)
  493.  
  494. COUNT fldno;
  495.  
  496. {
  497.     LONG      *intdat;
  498.     FAST COUNT i;
  499.     FAST TEXT *tp;
  500.  
  501.     if (fldtyp[fldno] == INTFLD) {
  502.         intdat = (LONG *) fldptr[fldno];
  503.         printf("%ld",*intdat);
  504.     } else
  505.         for (i = 0, tp = fldptr[fldno]; i++ < fldlen[fldno];)
  506.             printf("%c",*tp++);
  507. }
  508.  
  509. /* ************************************************************************* */
  510. /* ************************************************************************* */
  511.  
  512. /*
  513.  * routine to copy character data, padding with blanks
  514.  * if the data does not fill the field
  515.  */
  516.  
  517. VOID cpychr(dp,sp,len)
  518.  
  519. PFAST TEXT *dp,*sp;
  520. PFAST COUNT len;
  521.  
  522. {
  523.     while (*sp && len-- > 0 )    /* loop terminates either when 
  524.                      * complete field filled in, or
  525.                      * when a null termination byte
  526.                      * encountered
  527.                      */
  528.         *dp++ = *sp++;
  529.  
  530.     while (len-- > 0)        /* if field not filled in, pad
  531.                      * with blanks
  532.                      */
  533.         *dp++ = ' ';
  534. }
  535.  
  536. /* ************************************************************************* */
  537. /* ************************************************************************* */
  538.  
  539. COUNT change(mode)
  540. COUNT         mode;
  541. {
  542.     COUNT       i;
  543.  
  544. #ifdef MUSTFRCE
  545.     FAST TEXT *cp,*kp;
  546.  
  547.     if (TRANSACTION(BEGTRAN) || LKISAM(ENABLE) || RRDREC(CUSTDAT,&chk_cust)) {
  548.         printf("\nCould not reread record (%d)\n",isam_err);
  549.         TRANSACTION(ABRTRAN);
  550.         LKISAM(FREE);
  551.         return(-1);
  552.     }
  553.     i  = (ct_key + CUSTDAT)->reclen;
  554.     cp = (TEXT *) &old_cust;
  555.     kp = (TEXT *) &chk_cust;
  556.     while (i-- > 0)
  557.         if (*cp++ != *kp++) {
  558.             printf("\nRecord already updated.\n");
  559.             TRANSACTION(ABRTRAN);
  560.             LKISAM(FREE);
  561.             return(-1);
  562.         }
  563.     if (mode == RWRT) {
  564.         if (i = RWTREC(CUSTDAT,&cust)) {
  565.             TRANSACTION(ABRTRAN);
  566.             printf("\nCould not rewrite record (%d)\n",i);
  567.         }
  568.     } else {
  569.         if (i = DELREC(CUSTDAT)) {
  570.             TRANSACTION(ABRTRAN);
  571.             printf("\nCould not delete record (%d)\n",i);
  572.         }
  573.     }
  574.     if (i == 0)
  575.         if (i = TRANSACTION(ENDTRAN))
  576.         printf("\nCould not end transaction (%d)\n",i);
  577.     LKISAM(FREE);
  578.     return(i);
  579. #else
  580.     if (i = TRANSACTION(BEGTRAN))
  581.         printf("\nCould not begin transaction (%d)\n",i);
  582.     else if (mode == RWRT) {
  583.         if (i = RWTREC(CUSTDAT,&cust)) {
  584.             TRANSACTION(ABRTRAN);
  585.             printf("\nCould not rewrite record (%d)\n",i);
  586.         }
  587.     } else {
  588.         if (i = DELREC(CUSTDAT)) {
  589.             TRANSACTION(ABRTRAN);
  590.             printf("\nCould not delete record (%d)\n",i);
  591.         }
  592.     }
  593.     if (i == 0)
  594.         if (i = TRANSACTION(ENDTRAN))
  595.         printf("\nCould not end transaction (%d)\n",i);
  596.     return(i);
  597. #endif
  598. }
  599.  
  600. /* end of ctexmg.c */
  601.