home *** CD-ROM | disk | FTP | other *** search
/ World of Shareware - Software Farm 2 / wosw_2.zip / wosw_2 / CPROG / SKPR115C.ZIP / SKPR.TXT < prev   
Text File  |  1992-03-31  |  28KB  |  946 lines
  1.  
  2.  
  3.  
  4.  
  5.  
  6.  
  7.  
  8.  
  9.  
  10.  
  11.  
  12.  
  13.  
  14.  
  15.                                 CAM Technical Systems
  16.                                     CTS 1991-1992
  17.                                      Presents :
  18.  
  19.                                 SKIPPER version 1.15c
  20.                                Flat File Database API
  21.                                        for C++
  22.  
  23.                                    DOS/Windows DLL
  24.  
  25.  
  26.  
  27.  
  28.  
  29.  
  30.  
  31.  
  32.  
  33.  
  34.  
  35.  
  36.  
  37.  
  38.  
  39.  
  40.  
  41.  
  42.  
  43.                                                  Borland C++ version 3.0
  44.                                                is a registered trademark
  45.                                                 of Borland International
  46.  
  47.                                      Skipper is copyrighted intellectual
  48.                                  Property of CTS - CAM Technical Systems
  49.                             and Cannot be reproduced,reverse engineered,
  50.                          or used in any manner that is inconsistent with
  51.                        the limited license that is granted to registered
  52.                       users with out the express written consent of CTS.
  53.  
  54.  
  55.  
  56.  
  57.  
  58.  
  59.             Table of Contents:
  60.  
  61.             Introductions ................................2
  62.             Librarys and Data Integrity ..................2
  63.  
  64.             System Design and Implementation .............3
  65.  
  66.             Registration .................................4
  67.  
  68.             Features and Functions:
  69.                       Master Contrutctor .................5
  70.                       OpenDB .............................5
  71.  
  72.                       Master Destructor ..................6
  73.                       CloseDB ............................6
  74.  
  75.                       Insert .............................7
  76.  
  77.                       LookUp .............................8
  78.                       Extract ............................8
  79.  
  80.                       CheckInserts .......................9
  81.  
  82.                       Remove .............................10
  83.  
  84.                       Delete .............................11
  85.  
  86.                       GetNext ............................12
  87.                       GetPrev ............................12
  88.                       StepNext ...........................12
  89.                       StepPrev ...........................12
  90.  
  91.                       Align ..............................13
  92.                       PackDB .............................13
  93.  
  94.                       State ..............................14
  95.                       ClearState .........................14
  96.  
  97.                       Switch Functions :
  98.                            NoDuplicates
  99.                            Duplicates
  100.                            PackOff
  101.                            PackOn
  102.                            AlignOff
  103.                            AlignOn .......................15
  104.  
  105.                       Version ............................16
  106.                       VERROR .............................16
  107.  
  108.                       Disclaimer and Help ................17
  109.  
  110.                       Error Codes ........................18
  111.  
  112.  
  113.  
  114.  
  115.  
  116.             Introduction :
  117.  
  118.                  The SKIPPER system is a C++ implementation of a flat
  119.             file database manager for the individual who needs an easy
  120.             to use versatile Platform to build a C++ application that
  121.             requires access to a database.  SKIPPER is a powerful OOP
  122.             model that allows the programmer to create or use pre-
  123.             existing files as database platforms.  The only requirement
  124.             for an existing file to be used as a SKIPPER file is.
  125.  
  126.  
  127.                  1] The file must be in a flat format and contain only
  128.                      Records of a consistent length.
  129.  
  130.                  2] The file must contain a key field and the file must
  131.                      be in ascending sequential order by that key field.
  132.  
  133.  
  134.                  If the file is to be created by SKIPPER these details
  135.             can be overlooked as SKIPPER will handle the sequencing of
  136.             the keys.
  137.  
  138.  
  139.  
  140.             Libraries :
  141.  
  142.  
  143.                  SKIPPER is comprised of a series of libraries SKIPPER[s
  144.             c m l h] relating to the memory model of the application
  145.             that is being designed.  To use the SKIPPER libraries
  146.             include in any source modules that will access the skipper
  147.             system the include file :
  148.  
  149.                                      "SKIPPER.H"
  150.  
  151.                  If using the IDE and a project file include the correct
  152.             SKIPPER library file for the memory model being used in the
  153.             application.  If using the command line compiler include the
  154.             library file for the correct memory model in the link step.
  155.  
  156.  
  157.             Data Integrity :
  158.  
  159.  
  160.                  It is important to understand that with the flat file
  161.             model used in skipper the integrity of the database is only
  162.             as good as the programmer that writes a SKIPPER application.
  163.                  The functionality and Integrity of the data in a
  164.             SKIPPER database are controlled by the original
  165.             specifications of the data contained in the file(s) used by
  166.             skipper.  If an application program creates a database that
  167.             doesn't allow duplicate key values and the same file is used
  168.             in another application that does and a Duplicate key gets
  169.             inserted into the data stream.
  170.  
  171.  
  172.  
  173.  
  174.  
  175.  
  176.                  The integrity of the original database application has
  177.             been violated.  As long as the SKIPPER API rules for
  178.             creation and use of a data file are followed and a database
  179.             is closed correctly after each use the integrity of the data
  180.             will be maintained by SKIPPER.  If the Integrity of a
  181.             SKIPPER database is violated the resulting violation can
  182.             cause missed extractions and other related data retrieval
  183.             errors.  Future versions of SKIPPER will control the
  184.             integrity of the database more closely with the addition of
  185.             external file definition records and the like.
  186.  
  187.                  NOTE: Version 2.0 will improve on integrity with DBMS
  188.             control files and other security measures.
  189.  
  190.             Supported Compilers :
  191.  
  192.                  SKIPPER version 1.15c was engineered, written and
  193.             tested on the Borland C++ version 3 compiler and has not
  194.             been tested in any other environments(due to the cost of
  195.             obtaining various vendors compilers).  The source code for
  196.             SKIPPER was written to be as compatible as possible with
  197.             other vendors products based on the authors experience with
  198.             the other vendors products.  SKIPPER does have dependance on
  199.             certain 'C'  and 'C++' library functions contained in the
  200.             Borland C++ package the functions are as listed.
  201.  
  202.  
  203.                  - memcpy(void *source,void *dest,size).
  204.                  - memcmp(void *source1,void *source2,size).
  205.                  - fstream and related stream functions.
  206.  
  207.  
  208.                  Any problems that arise with the use of the SKIPPER
  209.             system or suggestions for future releases or any other
  210.             contructive criticism can be directed as follows.
  211.  
  212.                       BUFFALO CREEK BBS
  213.                       message to : Craig McNiel
  214.                       515-225-8496 (8-N-1)
  215.  
  216.                       or
  217.  
  218.                       CAM Technical Systems
  219.                       Route #1 Box #3
  220.                       Batavia, IA 52533-9701
  221.                       Phone: (515)662-2507
  222.  
  223.  
  224.             NOTICE : SKIPPER can not be interfaced with 'C' source due
  225.             to C++  name mangling. A registered user could create a 'C'
  226.             version with a little effort but , a 'C' version is not
  227.             currently planned.
  228.  
  229.  
  230.  
  231.  
  232.  
  233.  
  234.  
  235.  
  236.  
  237.  
  238.  
  239.  
  240.  
  241.  
  242.  
  243.  
  244.  
  245.             Registration :  SKIPPER system is copyrighted software and
  246.             is distributed  under the SHAREWARE concept.  If you find
  247.             the SKIPPER database manager useful or use the SKIPPER
  248.             system in an application or for anything other than
  249.             evaluation purposes please register your copy.  With your
  250.             registration you will receive the following.
  251.  
  252.                  1. The most recent version of the SKIPPER system.
  253.                  2. FREE unlimited technical support (not that it
  254.                      won't be provided during the trial period).
  255.                  3. The chance to voice your opinion and an suggestions
  256.                      you would like to see in the next revision.
  257.                      (Unregistered users have NO say).
  258.                  4. FREE minor upgrades and LOW COST major upgrades.
  259.  
  260.                  5. All memory models and DLL's and any other existing
  261.                      SKIPPER support material.
  262.  
  263.             Support the shareware concept and register by filling out
  264.             the registration form REGISTER.DOC by typing :
  265.  
  266.                  TYPE REGISTER.DOC >PRN
  267.  
  268.             at the command line and then mail the completed form with
  269.             the registration fee of $35.00 in U.S. funds (NO CASH
  270.             PLEASE!!) to :
  271.  
  272.                       CAM Technical Systems
  273.                       Route #1 Box #3
  274.                       Batavia, IA 52533-9701.
  275.  
  276.             Thank you for your support.
  277.  
  278.  
  279.  
  280.  
  281.  
  282.  
  283.  
  284.             SKIPPER FEATURES ,FUNCTIONS and SPECIFICATIONS :
  285.  
  286.                  The current version of SKIPPER version 1.15c consists
  287.             of 25 different functions excluding the constructor and
  288.             destructor for SKIPPER.  The class name for all of the
  289.             SKIPPER functions that are user callable is "Master".  The
  290.             SKIPPER system also has provisions for a verbose error
  291.             message system that aids in debugging Applications using the
  292.             SKIPPER system.
  293.  
  294.                  Currently SKIPPER requires the following for operation.
  295.  
  296.                  * DOS 2.1 or Higher.
  297.                  * Free Disk space equal to the largest Database.
  298.                  * Borland C++ or compatible compiler.
  299.  
  300.  
  301.  
  302.             SKIPPER FUNCTIONS :
  303.  
  304.             Master::OpenDB(char *filename,int RecordSize,
  305.                            int KeyOffset,int KeyLength)
  306.             and
  307.             Master::Master(char *filename,int RecordSize,
  308.                            int KeyOffset,int KeyLength)
  309.  
  310.             Purpose :
  311.  
  312.                  To create a Master object and open a SKIPPER file or to
  313.             open a SKIPPER file for a pre-created Master object.
  314.  
  315.             Parameters:
  316.  
  317.                  char *filename - Pointer to valid DOS filename of the
  318.                                    SKIPPER database.
  319.                  int RecordSize - Unsigned length of the entire record.
  320.                  int KeyOffset  - Unsigned 0 based offset from the
  321.                                    beginning of each record.
  322.                  int KeyLength  - Length of the records key in bytes.
  323.  
  324.             Specifications :
  325.  
  326.                  Currently the SKIPPER systems include file that the
  327.             system itself is compliled with contains define statements
  328.             that must match certain parameters of the functions.  These
  329.             parameters are the RECORDSIZE,and KEYLENGTH. If the
  330.             parameters don't match the system will report an error and
  331.             halt execution of the application.
  332.  
  333.             Note : The SHAREWARE version is configured for 80 byte
  334.             records.  These limitations can easily be over come by
  335.             registering.
  336.  
  337.  
  338.  
  339.  
  340.  
  341.  
  342.  
  343.  
  344.  
  345.  
  346.  
  347.  
  348.  
  349.  
  350.  
  351.  
  352.  
  353.             Master::CloseDB(void)
  354.             and
  355.             Master::~Master()
  356.  
  357.             Purpose :
  358.  
  359.                  These functions systematically shut down the SKIPPER
  360.             system and maintain the integrity of the database.  If a
  361.             user wants to Open another Database a quick call the
  362.             CloseDB() function will allow another database to be opened
  363.             by the Master Object as long as it falls within the
  364.             parameters the Object was created under  . (Key length,
  365.             Record size) using smaller values will not endanger data
  366.             integrity when passing parameters on opening the database.
  367.  
  368.  
  369.             Parameters :
  370.  
  371.                  None.
  372.  
  373.             Specifications :
  374.  
  375.                  The Libraries that are the SKIPPER system were and can
  376.             be compiled  using different MAXIMUM parameters.  These
  377.             parameters can not be exceeded when opening a database but
  378.             they can be smaller values.  The only define statement that
  379.             cannot be altered at runtime is the MAXINSERTIONS which
  380.             controls the number of consecutive insertions that are
  381.             allowed before the queue is full and the database must be
  382.             "ALIGNED" or placed in ascending sequential key order.  All
  383.             other parameters can be overridden upon opening or calling
  384.             the SKIPPER constructor.
  385.  
  386.  
  387.  
  388.  
  389.  
  390.  
  391.  
  392.  
  393.  
  394.  
  395.  
  396.  
  397.  
  398.  
  399.  
  400.  
  401.             Master::Insert(void *Record)
  402.  
  403.             Purpose :
  404.  
  405.                  Insert is used to add another record to a database.
  406.             Insert is a queued operation and is very fast.  When an
  407.             insert operation passes beyond the maximum number of
  408.             insertions allowed the database is "ALIGNED" which involves
  409.             making the database into one contiguous file that has the
  410.             key fields in ascending sequential order.  If the
  411.             NoDuplicates function has been called the Insert function
  412.             first checks to see if the records key exists before
  413.             insertion.  If the key does exist the function returns an
  414.             error and the insertion is aborted.
  415.  
  416.             Parameters :
  417.  
  418.                  void *Record - A pointer to the area in storage that
  419.                                  the record is stored.  The Key is
  420.                                  extracted from the Record.
  421.  
  422.             Specifications :
  423.  
  424.                  The insert function places a record at the end of the
  425.             database until the database is ALIGNED.  The database is
  426.             aligned automatically when a record is retrieved or when the
  427.             database passes the maximum number of insertions.
  428.  
  429.                  The key that is used in the insert function is grabbed
  430.             out of the record that is pointed to by void *Record.
  431.             Depending on if Duplicated keys are allowed or not the
  432.             insert function will check for a duplicate prior to
  433.             insertion and fail if a duplicate is found.
  434.  
  435.  
  436.  
  437.  
  438.  
  439.  
  440.  
  441.  
  442.  
  443.  
  444.  
  445.  
  446.  
  447.             Master::LookUp(char *key,void *Record)
  448.             and
  449.             Master::Extract(char *key,void *Record)
  450.  
  451.  
  452.             Purpose:
  453.  
  454.                  These two functions are used to retrieve records from
  455.             the database.  The only difference is the method used to
  456.             search for the record.  The LookUp function uses a linear
  457.             search from the front to the back. and Extract uses a Binary
  458.             search from the middle out.  The main different is speed.
  459.             LookUp is slower the longer the database is and the further
  460.             to the end the record is contained.  The advantage is that a
  461.             LookUp doesn't require the overhead of an alignment to
  462.             extract a record.  Extract on the other hand is very fast
  463.             but the records must be aligned.  If an insertion or
  464.             deletion has occurred prior to calling Extract the database
  465.             will be aligned and/or packed prior to the search beginning.
  466.  
  467.             Parameters :
  468.  
  469.                       char *key   - Pointer to a field containing the
  470.                                       key value of the record to be
  471.                                       returned.
  472.  
  473.                       void *Record - A pointer to an area in storage for
  474.                                     the record to be returned to.
  475.  
  476.             Specifications :
  477.  
  478.                  Depending on the size of the database and the number of
  479.             records involved which function that is called is dependant
  480.             on the number of insertions that occur between record seeks.
  481.             If the size of the database is small and the number of
  482.             inserts between records being returned is great a call to
  483.             LookUp() may yield better results.  Where as if a database
  484.             is large and the inserts are few and far between an
  485.             Extract() will certainly get the record first.
  486.  
  487.  
  488.  
  489.  
  490.  
  491.  
  492.  
  493.  
  494.  
  495.  
  496.  
  497.  
  498.  
  499.  
  500.  
  501.  
  502.  
  503.             Master::CheckInserts(char *key,void *Rec)
  504.  
  505.             Purpose :
  506.  
  507.                  This function can be used to check the recently
  508.             inserted records that haven't been aligned for a specific
  509.             key.  The purpose is to offset the overhead of an automatic
  510.             call to align by Extract if inserted records are present.
  511.  
  512.             Parameters :
  513.  
  514.                       char *key - Pointer to a field containing the
  515.                                     key of the record to be returned.
  516.  
  517.                       void *Rec - Pointer to an area in which the
  518.                                     record will be placed if found.
  519.  
  520.             Specifications :
  521.  
  522.                  The Automatic calls to align can be averted with the
  523.             NoAlign() function.  This will allow the use of the Extract
  524.             function without the overhead of and align.  If the record
  525.             is not found in the main database then a call the
  526.             CheckInserts() can be made to sequentially search the queue
  527.             of recent unaligned inserts for a particular key value.  The
  528.             use of the NoAlign() function is not recommended for
  529.             unexperienced database programmers as it can endanger the
  530.             integrity of the database.  It's use should be restricted to
  531.             experts only.  NoAlign() circumvents ALL of the database
  532.             automatic alignment calls.
  533.  
  534.  
  535.  
  536.  
  537.  
  538.  
  539.  
  540.  
  541.  
  542.  
  543.  
  544.  
  545.  
  546.  
  547.  
  548.  
  549.  
  550.  
  551.  
  552.  
  553.  
  554.             Master::Remove(void)
  555.  
  556.             Purpose :
  557.  
  558.                  Remove is the function that deletes the last record
  559.             that was read from a particular database file.  Remove
  560.             cannot be called unless the last function called prior to
  561.             remove() was a record read function (ie. Getxxx Stepxxx
  562.             ect..).
  563.  
  564.             Parameters :
  565.  
  566.                  None.
  567.  
  568.             Specifications :
  569.  
  570.                  Remove physically deletes a record from the database
  571.             structure by overwriting the record with a NULL value.  The
  572.             record is not stored anywhere and is not retrievable after
  573.             being removed.  A physical record get must be the last
  574.             SKIPPER function called prior to Remove or the function will
  575.             fail.
  576.  
  577.  
  578.  
  579.  
  580.  
  581.  
  582.  
  583.  
  584.  
  585.  
  586.  
  587.  
  588.  
  589.  
  590.  
  591.  
  592.  
  593.  
  594.  
  595.  
  596.  
  597.  
  598.             Master::Delete(char *key)
  599.  
  600.  
  601.             Purpose :
  602.  
  603.                  Delete physically removes a record from the database
  604.             structure by overwriting the record with a NULL value.  The
  605.             record is not stored and cannot be retrieved later.
  606.  
  607.             Parameters :
  608.  
  609.                  char *key - A pointer to the key value of the record to
  610.                               be deleted.
  611.  
  612.             Specifications :
  613.  
  614.                  Delete unlike Remove is called with a pointer to the
  615.             value of the key that is to be deleted.  In multiple key
  616.             databases the first key is the one to be deleted and if a
  617.             key with duplicates is to be deleted Remove is recommended.
  618.  
  619.  
  620.  
  621.  
  622.  
  623.  
  624.  
  625.  
  626.  
  627.  
  628.  
  629.  
  630.  
  631.  
  632.  
  633.  
  634.  
  635.  
  636.             Master::GetNext(void *Record) - GetPrev(void *Record)
  637.             and
  638.             Master::StepNext(void *Record) - StepPrev(void *Record)
  639.  
  640.             Purpose :
  641.  
  642.                  All of these functions step forward and backward
  643.             through the database in the direction specified by the
  644.             function name (Next - Forward;Prev - Backward).  The main
  645.             difference between the Getxxxx and Stepxxxx functions lies
  646.             in that the Get functions stay within that key value of the
  647.             Extract() or LookUp() function called before the function is
  648.             called.  The Stepxxxx functions are independent of key value
  649.             and will step between key values.
  650.  
  651.             Parameters :
  652.  
  653.                  void *Record - Pointer to where to place the record on
  654.                                  success.
  655.  
  656.             Specifications :
  657.  
  658.                  Each of the Getxxxx and Stepxxxx functions require that
  659.             the programmer make a call to a LookUp() or Extract()
  660.             function prior to calling.  Each of the Get functions will
  661.             step forward or backward within the same key value.  Hence
  662.             is not very useful in databases without duplicate keys. The
  663.             Stepxxxx functions will go from the very first physical
  664.             record to the very last physical record regardless of key
  665.             value.
  666.  
  667.  
  668.  
  669.  
  670.  
  671.  
  672.  
  673.  
  674.  
  675.  
  676.  
  677.  
  678.  
  679.  
  680.  
  681.  
  682.  
  683.  
  684.             Master::Align(void)
  685.             and
  686.             Master::PackDB(void)
  687.  
  688.             Purpose :
  689.  
  690.                  These two functions are automatically called during
  691.             certain operations on the database if certain conditions
  692.             have been met.  Align() is the function that insures that
  693.             all inserted records are placed in the correct sequence of
  694.             keys in the database.  Align() is called automatically after
  695.             MAXINSERTIONS is exceeded.
  696.                  PackDB() is the function that compresses the database
  697.             and removes all of the NULL records that result from
  698.             deletions. PackDB() is called Automatically on Extractions
  699.             from the database.
  700.  
  701.             Parameters :
  702.  
  703.                  None.
  704.  
  705.             Specifications :
  706.  
  707.                  Usually these two functions should never need to be
  708.             called unless they have been overridden by the functions
  709.             (PackOff() and AlignOff() ) for some advanced operations.
  710.             This should only be done by experienced programmers who know
  711.             how to maintain the integrity of the database on their own.
  712.  
  713.  
  714.  
  715.  
  716.  
  717.  
  718.  
  719.  
  720.  
  721.  
  722.  
  723.  
  724.  
  725.  
  726.  
  727.  
  728.  
  729.  
  730.  
  731.             Master::State(void)
  732.             and
  733.             Master::ClearState(void)
  734.  
  735.             Purpose :
  736.  
  737.                  State returns the Error status of the last call to the
  738.             SKIPPER DBMS.  The value returned is maintained until
  739.             another call to the SKIPPER DBMS is made.  All Skipper
  740.             functions except the constructor and destructor return the
  741.             same value as State() returns.
  742.                  ClearState() is used to return the state of SKIPPER to
  743.             "OK" in the event that program logic requires or for
  744.             functions that require state to be "OK" to function
  745.             properly.  Such as the Stepxxxx and Getxxxx functions which
  746.             require that SKIPPER's State() be "OK".
  747.  
  748.             Parameters :
  749.  
  750.                  None.
  751.  
  752.             Specifications :
  753.  
  754.                  State is an internal variable that is private and
  755.             maintained by all SKIPPER functions to insure that the
  756.             status of a function is retained automatically between calls
  757.             to the DBMS.
  758.  
  759.  
  760.  
  761.  
  762.  
  763.  
  764.  
  765.  
  766.  
  767.  
  768.  
  769.  
  770.  
  771.             Switch Functions :
  772.  
  773.             Master::Duplicates() *
  774.             Master::NoDuplicates()
  775.             Master::PackOn() *
  776.             Master::PackOff()
  777.             Master::AlignOn() *
  778.             Master::AlignOff()
  779.  
  780.             * denotes the default behavior
  781.  
  782.             Purpose:
  783.  
  784.                  Each of the switch functions toggle an attribute of the
  785.             database or of the DBMS.
  786.  
  787.             Parameters :
  788.  
  789.                  None.
  790.  
  791.             Specifications :
  792.  
  793.                  The Duplicates() and NoDuplicates() determine the
  794.             behavior of the DBMS in relation to duplicate key values.
  795.             If Duplicates are NOT allowed the DBMS looks for the key
  796.             value in the database prior to insertion and if found the
  797.             insertion fails.  Once a database is specified as
  798.             NoDuplicates() it should always be accessed as such or the
  799.             integrity of the database could be damaged.
  800.  
  801.                  The PackOff() and PackOn() functions control if
  802.             automatic calls to the PackDB() function are made to remove
  803.             deleted (NULL) records.
  804.  
  805.                  The AlignOn() and AlignOff() functions control if
  806.             automatic calls to the Align() function are made to
  807.             correctly insert the newly inserted record into the
  808.             database.
  809.  
  810.  
  811.  
  812.  
  813.  
  814.  
  815.  
  816.  
  817.  
  818.  
  819.  
  820.  
  821.  
  822.  
  823.  
  824.             Master::Version(void)
  825.  
  826.             Purpose :
  827.  
  828.                  To be able to check the SKIPPER version number and
  829.             release information.
  830.  
  831.             Parameters :
  832.  
  833.                  None.
  834.  
  835.             Specifications :
  836.  
  837.                  Version returns a char* to a string with the value of
  838.             "Skipper Version 1.15c\n"
  839.  
  840.  
  841.  
  842.             Master::VERROR()
  843.  
  844.             Purpose :
  845.  
  846.                  To enable verbose error reporting of the DBMS status.
  847.  
  848.             Parameters :
  849.  
  850.                  None.
  851.  
  852.             Specifications :
  853.  
  854.                  When the SKIPPER DBMS is compiled with the #define
  855.             DEBUG switch this function is enabled and will return a
  856.             char* to a verbose error string describing the status of the
  857.             last SKIPPER function call.
  858.  
  859.  
  860.  
  861.  
  862.  
  863.  
  864.  
  865.  
  866.  
  867.  
  868.  
  869.  
  870.  
  871.  
  872.  
  873.  
  874.  
  875.             DISCLAIMER :
  876.  
  877.                  This software is presented to the public in an "AS IS"
  878.             format and the author claims no responsibility for any
  879.             damages ensued from the use of this software and any related
  880.             products.
  881.  
  882.             In Case Of Trouble :
  883.  
  884.  
  885.                  If SKIPPER doesn't work correctly for you or you find
  886.             an error in the software.  Registered or not please report
  887.             the error so that it can be fixed or incorporated into the
  888.             next release of SKIPPER.  Any errors in the software that
  889.             cause SKIPPER to function other than intended by the author
  890.             will qualify for a patch or a minor revision release.  Such
  891.             revisions will qualify for a FREE minor upgrade to all
  892.             registered users.  To report a problem :
  893.  
  894.                  Write:
  895.  
  896.                       CAM Technical Systems
  897.                       Route #1 Box #3
  898.                       Batavia, IA 52533-9701
  899.                       Phone: (515)662-2507
  900.  
  901.                  or
  902.  
  903.                       Dial (515)225-8496
  904.                       Buffalo Creek BBS (the Authors Favorite BBS!)
  905.                       and leave a message addressed to Craig McNiel.
  906.  
  907.  
  908.  
  909.  
  910.  
  911.  
  912.  
  913.  
  914.  
  915.  
  916.  
  917.  
  918.  
  919.  
  920.  
  921.  
  922.  
  923.  
  924.  
  925.  
  926.  
  927.  
  928.  
  929.             Error Codes Returned by SKIPPER :
  930.  
  931.             0 .......................Ok.
  932.             1 .......................Not found.
  933.             2 .......................EOF.
  934.             3 .......................No records inserted since aligned.
  935.             4 .......................Memory allocation error.
  936.             5 .......................File creation error (TMP).
  937.             6 .......................File operation error (TMP).
  938.             7 .......................File creation error (MASTER).
  939.             8 .......................Definitions and file don't match.
  940.             9 .......................No records in the file.
  941.             10 ......................Duplicate record is not allowed.
  942.             11 ......................File operation error (MASTER).
  943.             12 ......................Operation out of sequence.
  944.             13 ......................File already packed.
  945.             14 ......................Catastrophic file system failure.
  946.             15 ......................Previous operation un-successful.