home *** CD-ROM | disk | FTP | other *** search
/ World of A1200 / World_Of_A1200.iso / programs / database / isam / examples / test.c < prev   
C/C++ Source or Header  |  1995-02-27  |  28KB  |  1,003 lines
  1. ; /*  you can execute this file to compile it (if you're using lattice/SAS C )
  2. lc test
  3. blink from LIB:c.o test.o LIB LIB:lcm.lib LIB:lc.lib LIB:amiga.lib 
  4. quit
  5. */
  6.  
  7. #include <MYLIB:ISAMLibPROTO.h>
  8. #include <stdio.h>
  9.  
  10. struct Library *ISAMBase = NULL;
  11.  
  12. /* remove proto parm-names if your compiler can't handle them. */
  13. /* remove protos entirely, "   "      "       "     "     "    */
  14.  
  15. void FFlush ( void );
  16. void FlushScan ( char *fmt, void *ptr );
  17. void FillOut ( char *str, int strlen, int len );
  18. void HandlePrefix ( int keyno, void **ppprefix, int *pplen );
  19. void HandleKey ( int keyno, void **ppkey );
  20. void HandleRange ( int keyno, int itertype, void **ppfrom, void **ppto );
  21. int main ( int argc, char *(argv[]) );
  22.  
  23.   struct Employee {
  24.      /* 00 */  char  Class;
  25.      /* 01 */  char  LastName [15];
  26.      /* 16 */  char  FirstName[16];
  27.      /* 32 */  double Salary;
  28.      /* 40 */  ULONG EmpNo;
  29.      /* 44 */  char  SSN [9];
  30.   }; /* 53 */
  31.  
  32. #define MAXKEYNO 3 
  33.  
  34.   char str80[81];
  35.   int len, i, select, keyno;
  36.   long ErrorCode;
  37.   ULONG  RecNo, CountMax, Count;
  38.  
  39.   char c, from [17], to [17], key [17], prefix [17]; 
  40.   char KeyReturn [17];  /* enough for largest key, plus 1 */
  41.   void *KeyRet = &KeyReturn[0];
  42.  
  43.   void *pfrom, *pto, *pkey, *pprefix;
  44.   int itertype;
  45.   ULONG ISAMHandle, ulfrom, ulto, ulkey;
  46.   char SpecsFileName [] = "DATA:Employee.specs";
  47.   BOOL Lockk;
  48.   double dfrom, dto, dkey;
  49.   struct Employee Rec, tmpRec;
  50.  
  51.                              
  52. /*--------------------------------- FFlush -----------------------------------*/
  53. void FFlush ()
  54. /* if any string output is cut off because it's too long ( Ex: "%16s") */
  55. /* we don't want the overflow to count for part of the next scanf.     */
  56. {
  57.   char c;
  58.  
  59.   while ( (c=getchar ( )) != '\n' )
  60.     ;
  61.  
  62.   return;
  63. }
  64.  
  65.  
  66. /*------------------------------ FlushScan ----------------------------------*/
  67. void FlushScan ( fmt, ptr )
  68.  
  69. /* this function preforms a scan, and flushes anything past the first     */
  70. /* whitespace, so we don't start assigning extra input to the next scanf. */
  71.  
  72. char *fmt;
  73. void *ptr;
  74. {
  75.   scanf ( fmt, ptr );
  76.   FFlush ();
  77. }
  78.  
  79.  
  80. /*-------------------------------- FillOut ----------------------------------*/
  81. void FillOut ( str, strlen, len )
  82. char *str;
  83. int strlen, len;
  84. {
  85.   int i;
  86.  
  87.  
  88.   if ( ( str == NULL ) || ( len == 0 ) )
  89.     return;
  90.  
  91.   for ( i=strlen; i<len; i++ )
  92.     str[i] = ' ';
  93.  
  94.   return;
  95. }
  96.  
  97.  
  98. /*------------------------------ HandlePrefix -------------------------------*/
  99. void HandlePrefix ( keyno, ppprefix, plen )
  100. int keyno, *plen;
  101. void **ppprefix;
  102. {
  103.   switch ( keyno )
  104.   {
  105.     case 0 :
  106.          printf ( "\nprefix :" );
  107.          FlushScan  ( "%16s", &prefix );
  108.          len = strlen ( prefix );
  109.          *ppprefix = &prefix[0];
  110.          *plen = len;
  111.          printf ( "\n'%s'", prefix );
  112.          printf ( "\n" );
  113.          break;
  114.  
  115.     case 3 :
  116.          printf ( "\nprefix :" );
  117.          FlushScan  ( "%9s", &prefix );
  118.          len = strlen ( prefix );
  119.          *ppprefix = &prefix[0];
  120.          *plen = len;
  121.          printf ( "\n'%s'", prefix );
  122.          printf ( "\n" );
  123.          break;
  124.  
  125.     default:
  126.          break;
  127.   }
  128.  
  129.   return;
  130. }
  131.  
  132.  
  133. /*------------------------------ HandleKey -------------------------------*/
  134. void HandleKey ( keyno, ppkey )
  135. int keyno;
  136. void **ppkey;
  137. {
  138.   switch ( keyno )
  139.   {
  140.     case 0 :
  141.          printf ( "\nkey :" );
  142.          FlushScan  ( "%16s", &key );
  143.          FillOut ( key, strlen ( key ), 16 );
  144.          *ppkey = &key[0];
  145.          printf ( "\n'%16.16s'", key );
  146.          printf ( "\n" );
  147.          break;
  148.  
  149.     case 1 :
  150.          printf ( "\nkey :" );
  151.          FlushScan  ( "%lf", &dkey );
  152.          *ppkey = &dkey;
  153.          printf ( "\n%8.2lf", dkey );
  154.          printf ( "\n" );
  155.          break;
  156.  
  157.     case 2 :
  158.          printf ( "\nkey :" );
  159.          FlushScan  ( "%lu", &ulkey );
  160.          *ppkey = &ulkey;
  161.          printf ( "\n%lu", ulkey );
  162.          printf ( "\n" );
  163.          break;
  164.  
  165.     case 3 :
  166.          printf ( "\nkey :" );
  167.          FlushScan  ( "%9s", &key );
  168.          FillOut ( key, strlen ( key ), 9 );
  169.          *ppkey = &key[0];
  170.          printf ( "\n'%9.9s'", key );
  171.          printf ( "\n" );
  172.          break;
  173.  
  174.     default:
  175.          break;
  176.   }
  177.  
  178.   return;
  179. }
  180.  
  181.  
  182. /*----------------------------- HandleRange ------------------------------*/
  183. void HandleRange ( keyno, itertype, ppfrom, ppto )
  184. int keyno, itertype;
  185. void **ppfrom, **ppto;
  186. {
  187.   *ppfrom = NULL;
  188.   *ppto   = NULL;
  189.  
  190.   switch ( keyno )
  191.   {
  192.     case 0 :
  193.          if ( (itertype == 1) || ((itertype >=4) && (itertype <=9)) )
  194.            {
  195.              printf ( "\nfrom :" );
  196.              FlushScan  ( "%16s", &from );
  197.              FillOut ( from, strlen ( from ), 16 );
  198.              *ppfrom = &from[0];
  199.              printf ( "\n'%16.16s'", from );
  200.              printf ( "\n" );
  201.            }
  202.  
  203.          if ( (itertype >=2) && (itertype <=7) )
  204.            {
  205.              printf ( "\nto :" );
  206.              FlushScan  ( "%16s", &to );
  207.              FillOut ( to, strlen ( to ), 16 );
  208.              *ppto = &to[0];
  209.              printf ( "\n'%16.16s'", to );
  210.              printf ( "\n" );
  211.            }
  212.          break;
  213.  
  214.  
  215.     case 3 :
  216.          if ( (itertype == 1) || ((itertype >=4) && (itertype <=9)) )
  217.            {
  218.              printf ( "\nfrom :" );
  219.              FlushScan  ( "%9s", &from );
  220.              FillOut ( from, strlen ( from ), 9 );
  221.              *ppfrom = &from[0];
  222.              printf ( "\n'%9.9s'", from );
  223.              printf ( "\n" );
  224.            }
  225.  
  226.          if ( (itertype >=2) && (itertype <=7) )
  227.            {
  228.              printf ( "\nto :" );
  229.              FlushScan  ( "%9s", &to );
  230.              FillOut ( to, strlen ( to ), 9 );
  231.              *ppto = &to[0];
  232.              printf ( "\n'%9.9s'", to );
  233.              printf ( "\n" );
  234.            }
  235.          break;
  236.  
  237.  
  238.     case 1 :
  239.          if ( (itertype == 1) || ((itertype >=4) && (itertype <=9)) )
  240.            {
  241.              printf ( "\nfrom :" );
  242.              FlushScan  ( "%lf", &dfrom );
  243.              *ppfrom = &dfrom;
  244.              printf ( "\n%8.2lf", dfrom );
  245.              printf ( "\n" );
  246.            }
  247.  
  248.          if ( (itertype >=2) && (itertype <=7) )
  249.            {
  250.              printf ( "\nto :" );
  251.              FlushScan  ( "%lf", &dto );
  252.              *ppto = &dto;
  253.              printf ( "\n%8.2lf", dto );
  254.              printf ( "\n" );
  255.            }
  256.          break;
  257.  
  258.  
  259.     case 2 :
  260.          if ( (itertype == 1) || ((itertype >=4) && (itertype <=9)) )
  261.            {
  262.              printf ( "\nfrom :" );
  263.              FlushScan  ( "%lu", &ulfrom );
  264.              *ppfrom = &ulfrom;
  265.              printf ( "\n%lu", ulfrom );
  266.              printf ( "\n" );
  267.            }
  268.  
  269.          if ( (itertype >=2) && (itertype <=7) )
  270.            {
  271.              printf ( "\nto :" );
  272.              FlushScan  ( "%lu", &ulto );
  273.              *ppto = &ulto;
  274.              printf ( "\n%lu", ulto );
  275.              printf ( "\n" );
  276.            }
  277.          break;
  278.  
  279.  
  280.     default:
  281.          break;
  282.   }
  283.  
  284.   return;
  285. }
  286.  
  287.  
  288. /*
  289. ==================================== MAIN =================================
  290. */
  291.  
  292. main ( argc, argv )
  293. int argc;
  294. char *(argv[]);
  295. {
  296.   if ( (ISAMBase = OpenLibrary ( "isam.library", 0 )) == NULL )
  297.     {
  298.       printf ( "\nCouldn't open ISAM library.\n\n" );
  299.       exit ( 5 );
  300.     }
  301.  
  302.   for (;;)
  303.   {
  304.     printf ( "\n" );
  305.     printf ( "\n1  : OpenISAMFile             12 : ReadNextISAMKey" );
  306.     printf ( "\n2  : StoreISAMRecord          13 : DeleteISAMRecords" );
  307.     printf ( "\n3  : ModifyISAMRecord         14 : LockISAMFile" );
  308.     printf ( "\n4  : DeleteISAMRecord         15 : UnLockISAMFile" );
  309.     printf ( "\n5  : ReadISAMRecord           16 : LockISAMRecord" );
  310.     printf ( "\n6  : ReadUniqueISAMRecord     17 : UnLockISAMRecord" );
  311.     printf ( "\n7  : SetUpISAMIterationRange  18 : UnLockAllISAMRecords" );
  312.     printf ( "\n8  : SetUpISAMIterationKey    19 : CloseISAMFile" );
  313.     printf ( "\n9  : SetUpISAMIterationPrefix 20 : " );
  314.     printf ( "\n10 : CountISAMRecords         21 : " );
  315.     printf ( "\n11 : ReadNextISAMRecord       22 : " );
  316.     printf ( "\n\n0  : exit\n\nSELECT ?" );
  317.  
  318.     FlushScan ( "%d", &select );
  319.     printf ( "\n" );
  320.  
  321.  
  322.     if ( select == 0 )
  323.       break;
  324.  
  325.  
  326.  
  327.     switch ( select )
  328.     {
  329.       case 1 :
  330.          printf ( "\nLock ( 1: No,  2: Yes ) ?" );
  331.          FlushScan  ( "%d", &i );
  332.          printf ( "\n" );
  333.          if ( i == 1 )
  334.            Lockk = FALSE;
  335.           else if ( i == 2 )
  336.                  {
  337.                    Lockk = TRUE;
  338.                    printf ( "\nLockType ( W/R ) ?" );
  339.                    FlushScan ( "%1s", &c );  
  340.                    c = toupper ( c );
  341.                    if ( ( c != 'W' ) && ( c != 'R' ) )
  342.                      break;
  343.                  }
  344.                 else break;
  345.  
  346.          printf ( "\nEnter a number to OpenISAMFile: ");
  347.          FlushScan  ( "%d", &i );
  348.          printf ( "\n" );
  349.          if ( i == -1 )
  350.            break;
  351.        
  352.          if (( ErrorCode = OpenISAMFile ( SpecsFileName, Lockk, c, 
  353.                                           TRUE, &ISAMHandle )) != OK )
  354.            printf ( "\nError %ld.", ErrorCode );
  355.          break;
  356.  
  357.  
  358.       case 2 :
  359.          printf ( "\nEmployee Class ?" );
  360.          FlushScan  ( "%1s", str80 );  
  361.          Rec.Class = str80[0];
  362.  
  363.          printf ( "\nLast Name ?" );
  364.          FlushScan  ( "%15s", str80 );     
  365.          FillOut ( str80, strlen ( str80 ), 15 );
  366.          strncpy ( Rec.LastName, str80, 15 );
  367.  
  368.          printf ( "\nFirst Name ?" );
  369.          FlushScan  ( "%16s", str80 );  
  370.          FillOut ( str80, strlen ( str80 ), 16 ); 
  371.          strncpy ( Rec.FirstName, str80, 16 );
  372.  
  373.          printf ( "\nSalary ?" );
  374.          FlushScan  ( "%lf", &Rec.Salary );
  375.  
  376.          printf ( "\nEmployee Number ?" );
  377.          FlushScan  ( "%lu", &Rec.EmpNo );
  378.  
  379.          printf ( "\nSocial Security # ?" );
  380.          FlushScan  ( "%9s", str80 );  
  381.          FillOut ( str80, strlen ( str80 ), 9 ); 
  382.          strncpy ( Rec.SSN, str80, 9 );
  383.  
  384.          printf ( "\nLock ( 1: No,  2: Yes ) ?" );
  385.          FlushScan  ( "%d", &i );
  386.          printf ( "\n" );
  387.          if ( i == 1 )
  388.            Lockk = FALSE;
  389.           else if ( i == 2 )
  390.                  {
  391.                    Lockk = TRUE;
  392.                    printf ( "\nLockType ( W/R ) ?" );
  393.                    FlushScan ( "%1s", &c ); 
  394.                    c = toupper ( c );
  395.                    if ( ( c != 'W' ) && ( c != 'R' ) )
  396.                      break;
  397.                  }
  398.                 else break;
  399.  
  400.          printf ( "\nEnter a number to StoreISAMRecord: ");
  401.          FlushScan  ( "%d", &i );
  402.          printf ( "\n" );
  403.          if ( i == -1 )
  404.            break;
  405.        
  406.          ErrorCode = StoreISAMRecord ( ISAMHandle, &Rec, Lockk, c, &RecNo );
  407.          switch ( ErrorCode )
  408.          {
  409.            case ERROR_RECORD_EXISTS :
  410.              printf ( "\nAn Employee already exists with that EmpNo or SSN#.");
  411.              printf ( "\n(A Record exists with the same Unique key value.)" );
  412.              break;
  413.  
  414.            case OK :
  415.              printf ( "\nRecord# %lu", RecNo );
  416.              break;
  417.  
  418.            default :
  419.              printf ( "\nError %ld.", ErrorCode );
  420.              break;
  421.          }
  422.          break;
  423.  
  424.  
  425.       case 3 :
  426.          printf ( "\nRec# :" );
  427.          FlushScan  ( "%lu", &RecNo );
  428.          printf ( "\n" );
  429.  
  430.          ErrorCode = ReadISAMRecord ( ISAMHandle, RecNo, FALSE, ' ', &tmpRec );
  431.          switch ( ErrorCode )
  432.          {
  433.            case ERROR_DELETED_RECORD :
  434.              printf ( "\nThat record has been deleted." );
  435.              break;
  436.  
  437.            case ERROR_RECORD_TOO_HIGH :
  438.              printf ( "\nThat record number is too high." );
  439.              break;
  440.  
  441.            case OK :
  442.              break;
  443.  
  444.            default:
  445.              printf ( "\nError %ld.", ErrorCode );
  446.      }
  447.  
  448.          printf ( "\nEmployee Class ?\n" );
  449.          printf ( "%c\n", tmpRec.Class );
  450.          FlushScan  ( "%1s", str80 );  
  451.          Rec.Class = str80[0];
  452.          printf ( "\n" );
  453.  
  454.          printf ( "\nLast Name ?\n" );
  455.          printf ( "%15.15s\n", tmpRec.LastName );
  456.          FlushScan  ( "%15s", str80 );     
  457.          FillOut ( str80, strlen ( str80 ), 15 );
  458.          strncpy ( Rec.LastName, str80, 15 );
  459.  
  460.          printf ( "\n" );
  461.          printf ( "\nFirst Name ?\n" );
  462.          printf ( "%16.16s\n", tmpRec.FirstName );
  463.          FlushScan  ( "%16s", str80 );  
  464.          FillOut ( str80, strlen ( str80 ), 16 ); 
  465.          strncpy ( Rec.FirstName, str80, 16 );
  466.  
  467.          printf ( "\n" );
  468.          printf ( "\nSalary ?\n" );
  469.          printf ( "%8.2lf\n", tmpRec.Salary );
  470.          FlushScan  ( "%lf", &Rec.Salary );          
  471.          printf ( "\n" );
  472.  
  473.          printf ( "\nEmployee Number ?\n" );
  474.          printf ( "%9lu\n", tmpRec.EmpNo );
  475.          FlushScan  ( "%lu", &Rec.EmpNo );          
  476.          printf ( "\n" );
  477.  
  478.          printf ( "\nSocial Security # ?" );
  479.          printf ( "%9.9s\n", tmpRec.SSN );
  480.          FlushScan  ( "%9s", str80 );  
  481.          FillOut ( str80, strlen ( str80 ), 9 ); 
  482.          strncpy ( Rec.SSN, str80, 9 );
  483.  
  484.  
  485.          printf ( "\nEnter a number to ModifyISAMRecord: ");
  486.          FlushScan  ( "%d", &i );
  487.          printf ( "\n" );
  488.          if ( i == -1 )
  489.            break;
  490.        
  491.          ErrorCode = ModifyISAMRecord ( ISAMHandle, RecNo, &Rec );
  492.          switch ( ErrorCode )
  493.          {
  494.            case ERROR_RECORD_EXISTS :
  495.              printf ( "\nAn Employee already exists with that EmpNo or SSN#.");
  496.              printf ( "\n(A Record exists with the same Unique key value.)" );
  497.              break;
  498.  
  499.            case OK :
  500.              printf ( "\nRecord Modified." );
  501.              break;
  502.  
  503.            default :
  504.              printf ( "\nError %ld.", ErrorCode );
  505.              break;
  506.          }
  507.          break;
  508.  
  509.  
  510.       case 4 :
  511.          printf ( "\nRec# :" );
  512.          FlushScan  ( "%lu", &RecNo );
  513.          printf ( "\n" );
  514.  
  515.          printf ( "\nEnter a number to DeleteISAMRecord: ");
  516.          FlushScan  ( "%d", &i );
  517.          printf ( "\n" );
  518.          if ( i == -1 )
  519.            break;
  520.        
  521.          ErrorCode = DeleteISAMRecord ( ISAMHandle, RecNo );
  522.          switch ( ErrorCode )
  523.          {
  524.            case ERROR_DELETED_RECORD :
  525.              printf ( "\nThat record has been deleted." );
  526.              break;
  527.  
  528.            case ERROR_RECORD_TOO_HIGH :
  529.              printf ( "\nThat record number is too high." );
  530.              break;
  531.  
  532.            case OK :
  533.              printf ( "\nRecord deleted." );
  534.              break;
  535.  
  536.            default:
  537.              printf ( "\nError %ld.", ErrorCode );
  538.      }
  539.          break;
  540.  
  541.  
  542.       case 5 :
  543.          printf ( "\nRec# :" );
  544.          FlushScan  ( "%lu", &RecNo );
  545.          printf ( "\n" );
  546.  
  547.          printf ( "\nLock ( 1: No,  2: Yes ) ?" );
  548.          FlushScan  ( "%d", &i );
  549.          printf ( "\n" );
  550.          if ( i == 1 )
  551.            Lockk = FALSE;
  552.           else if ( i == 2 )
  553.                  {
  554.                    Lockk = TRUE;
  555.                    printf ( "\nLockType ( W/R ) ?" );
  556.                    FlushScan ( "%1s", &c ); 
  557.                    c = toupper ( c );
  558.                    if ( ( c != 'W' ) && ( c != 'R' ) )
  559.                      break;
  560.                  }
  561.                 else break;
  562.  
  563.          printf ( "\nEnter a number to ReadISAMRecord: ");
  564.          FlushScan  ( "%d", &i );
  565.          printf ( "\n" );
  566.          if ( i == -1 )
  567.            break;
  568.        
  569.          ErrorCode = ReadISAMRecord ( ISAMHandle, RecNo, Lockk, c, &Rec );
  570.          switch ( ErrorCode )
  571.          {
  572.            case ERROR_DELETED_RECORD :
  573.              printf ( "\nThat record has been deleted." );
  574.              break;
  575.  
  576.            case ERROR_RECORD_TOO_HIGH :
  577.              printf ( "\nThat record number is too high." );
  578.              break;
  579.  
  580.            case OK :
  581.              printf ( "\nClass      : '%c'",      Rec.Class );
  582.              printf ( "\nLast Name  : '%15.15s'", Rec.LastName );
  583.              printf ( "\nFirst Name : '%16.16s'", Rec.FirstName );
  584.              printf ( "\nSalary     : %8.2lf",    Rec.Salary );
  585.              printf ( "\nEmployee # : %9u",       Rec.EmpNo );
  586.              printf ( "\nSS #       : '%9.9s'",   Rec.SSN );
  587.              printf ( "\n" );
  588.              break;
  589.  
  590.            default:
  591.              printf ( "\nError %ld.", ErrorCode );
  592.      }
  593.          break;
  594.  
  595.  
  596.       case 6 : 
  597.          printf ( "\nkeyno (0-%d) :", MAXKEYNO );
  598.          FlushScan  ( "%d", &keyno );
  599.          printf ( "\nkeyno= '%d' ", keyno );
  600.          printf ( "\n" );
  601.          if ( keyno > MAXKEYNO )
  602.            break;
  603.          if ( keyno < 2 )
  604.            {
  605.              printf ( "\nKey not unique." );
  606.              break;
  607.        }
  608.  
  609.          switch ( keyno )
  610.          {
  611.            case 2 :
  612.              printf ( "\nkey :" );
  613.              FlushScan  ( "%lu", &ulkey );
  614.              pkey = &ulkey;
  615.              printf ( "\n%lu", ulkey );
  616.              printf ( "\n" );
  617.              break;
  618.  
  619.            case 3 :
  620.              printf ( "\nkey :" );
  621.              FlushScan  ( "%9s", &key );  
  622.              FillOut ( key, strlen ( key ), 9 );
  623.              pkey = &key[0];
  624.              printf ( "\n'%9.9s'", key );
  625.              printf ( "\n" );
  626.              break;
  627.  
  628.            default:
  629.              break;             
  630.      }
  631.  
  632.          printf ( "\nLock ( 1: No,  2: Yes ) ?" );
  633.          FlushScan  ( "%d", &i );
  634.          printf ( "\n" );
  635.          if ( i == 1 )
  636.            Lockk = FALSE;
  637.           else if ( i == 2 )
  638.                  {
  639.                    Lockk = TRUE;
  640.                    printf ( "\nLockType ( W/R ) ?" );
  641.                    FlushScan ( "%1s", str80 ); 
  642.                    c = toupper ( str80[0] );
  643.                    if ( ( c != 'W' ) && ( c != 'R' ) )
  644.                      break;
  645.                  }
  646.                 else break;
  647.  
  648.          printf ( "\nEnter a number to ReadUniqueISAMRecord: ");
  649.          FlushScan  ( "%d", &i );
  650.          printf ( "\n" );
  651.          if ( i == -1 )
  652.            break;
  653.        
  654.          ErrorCode = ReadUniqueISAMRecord ( ISAMHandle, keyno, pkey,
  655.                                             Lockk, c, &RecNo, &Rec );
  656.          switch ( ErrorCode )
  657.          {
  658.            case ERROR_NO_SUCH_RECORD :
  659.              printf ( "\nNo such record." );
  660.              break;
  661.  
  662.            case OK :
  663.              printf ( "\nClass      : '%c'",      Rec.Class );
  664.              printf ( "\nLast Name  : '%15.15s'", Rec.LastName );
  665.              printf ( "\nFirst Name : '%16.16s'", Rec.FirstName );
  666.              printf ( "\nSalary     : %8.2lf",    Rec.Salary );
  667.              printf ( "\nEmployee # : %9u",       Rec.EmpNo );
  668.              printf ( "\nSS #       : '%9.9s'",   Rec.SSN );
  669.              printf ( "\n" );
  670.  
  671.              break;
  672.            default :
  673.              printf ( "\nError %ld.", ErrorCode );
  674.              break;
  675.          }
  676.          break;
  677.  
  678.  
  679.       case 7 :
  680.          printf ( "\nkeyno (0-%d) :", MAXKEYNO );
  681.          FlushScan  ( "%d", &keyno );
  682.          printf ( "\nkeyno= '%d' ", keyno );
  683.          printf ( "\n" );
  684.          if ( keyno > MAXKEYNO )
  685.            break;
  686.  
  687.          printf ( "\nitertype (0-9) :" );
  688.          FlushScan  ( "%d", &itertype );
  689.          printf ( "\n" );
  690.          if ( itertype > 9 )
  691.            break;
  692.  
  693.          HandleRange ( keyno, itertype, &pfrom, &pto );
  694.  
  695.          printf ( "\nEnter a number to SetUpISAMIterationRange: ");
  696.          FlushScan  ( "%d", &i );
  697.          printf ( "\n" );
  698.          if ( i == -1 )
  699.            break;
  700.  
  701.          if (( ErrorCode = SetUpISAMIterationRange ( ISAMHandle, (UWORD) keyno,
  702.                                  (UBYTE) itertype, pfrom, pto )) != OK )
  703.            printf ( "\nError %ld.", ErrorCode );
  704.          break;
  705.  
  706.  
  707.       case 8 :
  708.          printf ( "\nkeyno (0-%d) :", MAXKEYNO );
  709.          FlushScan  ( "%d", &keyno );
  710.          printf ( "\n" );
  711.          if ( keyno > MAXKEYNO )
  712.            break;
  713.  
  714.          HandleKey ( keyno, &pkey );
  715.  
  716.          printf ( "\nEnter a number to SetUpISAMIterationKey: ");
  717.          FlushScan  ( "%d", &i );
  718.          printf ( "\n" );
  719.          if ( i == -1 )
  720.            break;
  721.  
  722.          if (( ErrorCode = SetUpISAMIterationKey ( ISAMHandle, (UWORD) keyno,
  723.                                                    pkey )) != OK )
  724.            printf ( "\nError %ld.", ErrorCode );
  725.          break;
  726.  
  727.  
  728.       case 9 :
  729.          printf ( "\nkeyno (0-%d) :", MAXKEYNO );
  730.          FlushScan  ( "%d", &keyno );
  731.          printf ( "\n" );
  732.          if ( keyno > MAXKEYNO )
  733.            break;
  734.          if ( (keyno == 1 ) || ( keyno == 2 ) )
  735.            break;
  736.  
  737.          HandlePrefix ( keyno, &pprefix, &len );
  738.  
  739.          printf ( "\nEnter a number to SetUpISAMIterationPrefix: ");
  740.          FlushScan  ( "%d", &i );
  741.          printf ( "\n" );
  742.          if ( i == -1 )
  743.            break;
  744.        
  745.          if (( ErrorCode = SetUpISAMIterationPrefix ( ISAMHandle, (UWORD) keyno,
  746.                                          pprefix, len )) != OK )
  747.            printf ( "\nError %ld.", ErrorCode );
  748.          break;
  749.  
  750.  
  751.       case 10 :
  752.          printf ( "\nkeyno (0-%d) :", MAXKEYNO );
  753.          FlushScan  ( "%d", &keyno );
  754.          printf ( "\n" );
  755.          if ( keyno > MAXKEYNO )
  756.            break;
  757.  
  758.          printf ( "\nStop Counting at how many records:" );
  759.          FlushScan  ( "%lu", &CountMax );
  760.          printf ( "\n" );
  761.  
  762.          printf ( "\nEnter a number to CountISAMRecords: ");
  763.          FlushScan  ( "%d", &i );
  764.          printf ( "\n" );
  765.          if ( i == -1 )
  766.            break;
  767.        
  768.          if (( ErrorCode = CountISAMRecords ( ISAMHandle, (UWORD) keyno,
  769.                                               CountMax, &Count )) != OK )
  770.            printf ( "\nError %ld.", ErrorCode );
  771.           else
  772.            printf ( "\n%lu Records.", Count );
  773.          break;
  774.  
  775.  
  776.       case 11 :
  777.          printf ( "\nkeyno (0-%d) :", MAXKEYNO );
  778.          FlushScan  ( "%d", &keyno );
  779.          printf ( "\n" );
  780.          if ( keyno > MAXKEYNO )
  781.            break;
  782.  
  783.          printf ( "\nLock ( 1: No,  2: Yes ) ?" );
  784.          FlushScan  ( "%d", &i );
  785.          printf ( "\n" );
  786.          if ( i == 1 )
  787.            Lockk = FALSE;
  788.           else if ( i == 2 )
  789.                  {
  790.                    Lockk = TRUE;
  791.                    printf ( "\nLockType ( W/R ) ?" );
  792.                    FlushScan ( "%1s", str80 ); 
  793.                    c = toupper ( str80[0] );
  794.                    if ( ( c != 'W' ) && ( c != 'R' ) )
  795.                      break;
  796.                  }
  797.                 else break;
  798.  
  799.          printf ( "\nEnter a number to ReadNextISAMRecord: ");
  800.          FlushScan  ( "%d", &i );
  801.          printf ( "\n" );
  802.          if ( i == -1 )
  803.            break;
  804.        
  805.          printf ( 
  806. "\n    RecNo C ---Last Name--- ---First Name--- -Salary- Employee# SocSecNum" );
  807.  
  808.          do
  809.            {
  810.              ErrorCode = ReadNextISAMRecord ( ISAMHandle, (UWORD) keyno,
  811.                                  Lockk, c, &RecNo, &Rec );
  812.              switch ( ErrorCode )
  813.              {
  814.                case OK :
  815.                  printf ( "\n    %5lu %c %15.15s %16.16s %8.2lf %9lu %9.9s",
  816.                           RecNo, Rec.Class, Rec.LastName, Rec.FirstName,
  817.                           Rec.Salary, Rec.EmpNo, Rec.SSN );
  818.                  break;
  819.  
  820.                case ERROR_NO_MORE_RECORDS :
  821.                  break;
  822.  
  823.                default :
  824.                  printf ( "\nError %ld.", ErrorCode );
  825.                  break;
  826.              }
  827.            }
  828.          while ( ErrorCode == OK );
  829.          break;
  830.  
  831.  
  832.       case 12 :
  833.          printf ( "\nkeyno (0-%d) :", MAXKEYNO );
  834.          FlushScan  ( "%d", &keyno );
  835.          printf ( "\n" );
  836.          if ( keyno > MAXKEYNO )
  837.            break;
  838.  
  839.          printf ( "\nEnter a number to ReadNextISAMKey: ");
  840.          FlushScan  ( "%d", &i );
  841.          printf ( "\n" );
  842.          if ( i == -1 )
  843.            break;
  844.        
  845.          do
  846.            {
  847.              ErrorCode = ReadNextISAMKey ( ISAMHandle, (UWORD) keyno,
  848.                                  &RecNo, KeyRet );
  849.              switch ( ErrorCode )
  850.              {
  851.                case OK :
  852.                  printf ( "\nRecord# %5lu : ", RecNo );
  853.                  switch ( keyno )
  854.                  {
  855.                    case 0 : printf ( "'%16.16s'", (char *) KeyRet );  break;
  856.                    case 1 : printf ( "%8.2lf", *((double *) KeyRet) );break;
  857.                    case 2 : printf ( "%9lu", *((ULONG *) KeyRet) );   break;
  858.                    case 3 : printf ( "'%9.9s'",   (char *) KeyRet );  break;
  859.  
  860.                    default: break;
  861.                  }
  862.                  break;
  863.  
  864.                case ERROR_NO_MORE_RECORDS :
  865.                  printf ( "\n" );
  866.                  break;
  867.  
  868.                default :
  869.                  printf ( "\nError %ld.", ErrorCode );
  870.                  break;
  871.              }
  872.            }
  873.          while ( ErrorCode == OK );
  874.          break;
  875.  
  876.  
  877.       case 13 :
  878.          printf ( "\nkeyno (0-%d) :", MAXKEYNO );
  879.          FlushScan  ( "%d", &keyno );
  880.          printf ( "\n" );
  881.          if ( keyno > MAXKEYNO )
  882.            break;
  883.  
  884.          printf ( "\nEnter a number to DeleteISAMRecords: ");
  885.          FlushScan  ( "%d", &i );
  886.          printf ( "\n" );
  887.          if ( i == -1 )
  888.            break;
  889.        
  890.          if (( ErrorCode = DeleteISAMRecords ( ISAMHandle, (UWORD) keyno,
  891.                                                &Count )) != OK )
  892.            printf ( "\nError %ld", ErrorCode );
  893.           else
  894.            printf ( "\n%lu Records Deleted.", Count );
  895.          break;
  896.  
  897.  
  898.       case 14 :
  899.          printf ( "\nLockType ( W/R ) ?" );
  900.          FlushScan ( "%1s", str80 ); 
  901.          c = toupper ( str80[0] );
  902.          if ( ( c != 'W' ) && ( c != 'R' ) )
  903.            break;
  904.  
  905.          printf ( "\nEnter a number to LockISAMFile: ");
  906.          FlushScan  ( "%d", &i );
  907.          printf ( "\n" );
  908.          if ( i == -1 )
  909.            break;
  910.        
  911.          if (( ErrorCode = LockISAMFile ( ISAMHandle, c )) != OK )
  912.            printf ( "\nError %ld.", ErrorCode );
  913.          break;
  914.  
  915.  
  916.       case 15 :
  917.          printf ( "\nEnter a number to UnLockISAMFile: ");
  918.          FlushScan  ( "%d", &i );
  919.          printf ( "\n" );
  920.          if ( i == -1 )
  921.            break;
  922.        
  923.          if (( ErrorCode = UnLockISAMFile ( ISAMHandle )) != OK )
  924.            printf ( "\nError %ld.", ErrorCode );
  925.          break;
  926.  
  927.  
  928.       case 16 :
  929.          printf ( "\nRec# :" );
  930.          FlushScan  ( "%lu", &RecNo );
  931.          printf ( "\n" );
  932.  
  933.          printf ( "\nLockType ( W/R ) ?" );
  934.          FlushScan ( "%1s", str80 ); 
  935.          c = toupper ( str80[0] );
  936.          if ( ( c != 'W' ) && ( c != 'R' ) )
  937.            break;
  938.  
  939.          printf ( "\nEnter a number to LockISAMRecord: ");
  940.          FlushScan  ( "%d", &i );
  941.          printf ( "\n" );
  942.          if ( i == -1 )
  943.            break;
  944.        
  945.          if (( ErrorCode = LockISAMRecord ( ISAMHandle, RecNo, c )) != OK )
  946.            printf ( "\nError %ld.", ErrorCode );
  947.          break;
  948.  
  949.  
  950.       case 17 :
  951.          printf ( "\nRec# :" );
  952.          FlushScan  ( "%lu", &RecNo );
  953.          printf ( "\n" );
  954.  
  955.          printf ( "\nEnter a number to UnLockISAMRecord: ");
  956.          FlushScan  ( "%d", &i );
  957.          printf ( "\n" );
  958.          if ( i == -1 )
  959.            break;
  960.        
  961.          if (( ErrorCode = UnLockISAMRecord ( ISAMHandle, RecNo )) != OK )
  962.            printf ( "\nError %ld.", ErrorCode );
  963.          break;
  964.  
  965.  
  966.       case 18 :
  967.          printf ( "\nEnter a number to UnLockAllISAMRecords: ");
  968.          FlushScan  ( "%d", &i );
  969.          printf ( "\n" );
  970.          if ( i == -1 )
  971.            break;
  972.        
  973.          if (( ErrorCode = UnLockAllISAMRecords ( ISAMHandle )) != OK )
  974.            printf ( "\nError %ld.", ErrorCode );
  975.          break;
  976.  
  977.  
  978.       case 19 :
  979.          printf ( "\nEnter a number to CloseISAMFile: ");
  980.          FlushScan  ( "%d", &i );
  981.          printf ( "\n" );
  982.          if ( i == -1 )
  983.            break;
  984.        
  985.          if (( ErrorCode = CloseISAMFile ( ISAMHandle )) != OK )
  986.            printf ( "\nError %ld.", ErrorCode );
  987.          break;
  988.  
  989.  
  990.       default :
  991.          break;
  992.     }
  993.  
  994.   }  /* for */
  995.  
  996.  
  997.   CloseLibrary ( ISAMBase );
  998.  
  999.   printf ( "\n\n" );
  1000.  
  1001.   return;
  1002. }
  1003.