home *** CD-ROM | disk | FTP | other *** search
Text File | 1994-02-15 | 67.8 KB | 2,646 lines |
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- KEYED FILE SYSTEM - User's Guide
-
- Version 2.0 (DOS and OS/2 1.x)
-
-
- (c) 1993 APT Computer Solutions, Inc.
-
-
-
-
-
-
-
-
-
-
-
- Table of Contents
-
- Introduction 1
-
- System Components and Requirements 2
- System Requirements 2
- Keyed File System Components 2
- Keyed File System Restrictions 2
-
- Including KFS Routines in Your Program 4
-
- What Are Keyed Files 5
-
- Keyed File System Functions 7
-
- The File Information Structure 8
-
- Parameters to Keyed File System Functions 10
-
- Keyed File System Functions 11
- KFS_Add 11
- KFS_Close 13
- KFS_Create 14
- KFS_Delete 16
- KFS_Open 18
- KFS_Read 19
- KFS_ReadFirst 20
- KFS_ReadGen 21
- KFS_ReadGenNumeric 23
- KFS_ReadNext 25
- KFS_Replace 27
- Interdependencies of the KFS operations 29
-
- Special Processing 30
- KFS_Small_PTR 30
- KFS_Numeric_Key 30
- KFS_Ignore_Case 31
-
- Programming Hints and Tips 32
-
- Data Recovery 34
-
- Appendix A - Keyed File System Return Codes 35
-
- Appendix B - File Recovery Example 37
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- 3
-
-
-
-
-
-
-
-
-
-
- Introduction
-
- The Keyed File System is a set of routines that allow you to
- write programs in C to build and maintain databases on a PC that
- are logically organized by a user defined key. Records can be
- read or written directly using an alphabetic or numeric key. An
- alphabetic key can be a string consisting of any combination of
- ASCII characters up to 32,767 characters in length. You may also
- have 4 byte signed numeric keys contained in the normal Intel
- 80x86 long integer format. Note that a database may have alpha-
- betic keys or numeric keys but not both (however, see
- "Programming Hints & Tips" for hints about combining keys).
-
- The Keyed File System uses normal DOS and OS/2 functions to
- create and maintain its databases. Therefore, records may be of
- any length supported by the DOS or OS/2 operating systems and
- can be created using the FAT or HPFS (OS/2 only) file systems.
- Files may be created on floppy or hard disks, although, as might
- be expected, hard disk files will provide better performance.
- KFS databases may be moved or copied using normal DOS or OS/2
- commands (such as COPY) as long as both file components are
- moved together (see "Copying Files"). Additionally, databases
- built using the KFS functions on one operating system are com-
- patible with databases built using the KFS functions on the
- other operating system. Thus, databases built by programs run-
- ning under DOS may be subsequently used by programs running
- under OS/2.
-
- The Keyed File System supports most operations normally associ-
- ated with keyed files:
-
- * Direct reading and writing of records by key.
-
- * Sequential reading of records in key sequence.
-
- * Deleting of records by key.
-
- * Reading records using a partial key.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- 4
-
-
-
-
-
-
-
-
-
-
- System Components and Requirements
-
- System Requirements
-
- The minimum system required to run programs that use the
- Keyed File System are:
-
- * OS/2 1.2 or higher, or DOS 3.3 or higher.
-
- * Approx. 180K of disk space including sample programs and
- utilities.
-
- * Microsoft C compiler and libraries, version 6.0 (OS/2 and
- DOS) or 7.0 (DOS only).
-
-
- Keyed File System Components
-
- KFS.H - The header file for use in C programs that
- want to use KFS functions.
-
- KFSMSC6O.LIB - A lib used at linkedit time to include the
- KFS functions when building OS/2 programs
- written in Microsoft C Version 6.0.
-
- KFSMSC6D.LIB - A lib used at linkedit time to include the
- KFS functions when building DOS programs
- written in Microsoft C Version 6.0.
-
- KFSMSC7.LIB - A lib used at linkedit time to include the
- KFS functions when building DOS programs
- written in Microsoft C Version 7.0.
-
- KFSSAMP.C - A sample program that builds a KFS database
- from a sequential file and then uses most of
- the functions available in KFS.
-
- KFSSAMP.DAT - The sequential input file to the KFSSAMP
- program.
-
- KFSSAMP.MAK - A sample make file for KFSSAMP.C.
-
-
- Keyed File System Restrictions
-
- The following restrictions apply to KFS databases:
-
- * Databases must contain fixed length records.
-
- * Each record must be at least 5 bytes in length.
-
- * Numeric keys must be 4 bytes in length but alphabetic keys
- may be up to 32767 characters in length.
-
- * Duplicate keys are not allowed (see "Programming Tips and
- Techniques").
-
- * The path and file name specified during KFS_Create or
- KFS_Open for a KFS database cannot be longer than 63 bytes.
-
- 5
-
-
-
-
-
-
-
-
-
-
- * Files cannot be created using KFS_Open, you must use
- KFS_Create to create a new file and KFS_Open after a file
- exists.
-
- * Two databases with the same "base" name cannot exist in the
- same directory even if the file extensions are different.
- That is KFS databases with the base names of MYFILE.001 and
- MYFILE.002 cannot exist in the same directory, but the
- names MYFILE1.XXX and MYFILE2.XXX are OK. This is explained
- further in the section "What Are Keyed Files".
-
- * You cannot name a KFS database using the extension of .PTR.
- Thus MYFILE.PTR is invalid. This is also explained in the
- "What Are Keyed Files" section.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- 6
-
-
-
-
-
-
-
-
-
-
- Including KFS Routines in Your Program
-
- To include the KFS routines in your C program requires three
- steps:
-
- 1. Include the KFS.H header file at the beginning of your
- program source. For example:
- #include <KFS.H>
-
- 2. Define any keyed files using the KFS_FILEINFO typedef. For
- example:
- KFS_FILEINFO keyedfile;
-
- 3. Include the appropriate KFS---.LIB file when linking your
- program. For example, to link a DOS program compiled with
- MS/C version 6.0 would be:
- LINK myprog,,,KFSMSC6D;
-
- For a complete example of a program using some KFS functions,
- look at the KFSSAMP.C file included with this package.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- 7
-
-
-
-
-
-
-
-
-
-
- What Are Keyed Files
-
- Keyed File System databases are actually composed of two files,
- an index file and a data file. These two files work together to
- provide you with direct access of a record by key while keeping
- the records in a logical keyed sequence. The name of the data
- file is the same as the name of the database and is specified by
- the programmer when the KFS database is created (using the
- KFS_Create function). This may be any valid DOS or OS/2 file
- name. The index file is automatically given the same base name
- you specified for the database but with an extension of .PTR.
- For example, specifying a name of CUSTOMER.DAT for a database
- automatically causes the creation of an index file with the name
- of CUSTOMER.PTR. This leads to two restrictions in the Keyed
- File System:
-
- 1) You cannot name a database using an extension of .PTR.
-
- 2) You cannot have two databases in the same directory with
- the same base name since this would result in an attempt by
- KFS to create duplicate .PTR files. For example, MYFILE.001
- and MYFILE.002 would both result in KFS attempting to cre-
- ate an index file named MYFILE.PTR.
-
- Because these two files work together they must remain physi-
- cally in the same directory. Therefore, if the Keyed File System
- database is moved, both the data and index files must be moved
- together.
-
- The format and content of the index file is determined by the
- Keyed File System, while the format and content of the data file
- is determined by you when the database is created. When you
- create a Keyed File System database you must tell the Keyed File
- System how large each record in the database will be
- (KFS_recsize), where the key begins in the record (KFS_keypos),
- and how long the key is (KFS_keylen). Note that the Keyed File
- System only supports fixed length records (ie. each record in
- the database is the same length).
-
- The Keyed File System requires that databases are either created
- or opened before they are used, and that they are closed before
- the program terminates. With any file system, if a program ter-
- minates abnormally without closing files (such as a system crash
- because of a power failure) and file buffering is being used
- (such as is available with HPFS or DOS lazy writing), data that
- has been "written" by the program but waiting in an output
- buffer to be physically written to disk may be lost. The Keyed
- File System makes every attempt to minimize the impact of such a
- system failure, but since it does utilize two files working
- together, there are rare times this loss of data may result in
- the database becoming unusable. Thus special care should be
- taken by your application user to properly back up the data and
- index files making up each KFS database. Also, see the section
- on "Data Recovery" for an example of how to recover a damaged
- KFS database.
-
-
-
-
-
- 8
-
-
-
-
-
-
-
-
-
-
- Keyed File System Functions
-
- The Keyed File System is a set of 11 routines that provide you
- with the basic functions required for keyed record access on the
- PC. These functions are:
-
- KFS_Add
- Adds a new record to a KFS database. The key of the record
- being added must not already exist in the database.
-
- KFS_Close
- Close an open KFS database.
-
- KFS_Create
- Create and open a new KFS database. The database must not
- already exist.
-
- KFS_Delete
- Deletes the record from a KFS database that has the key
- specified.
-
- KFS_Open
- Open an existing KFS database.
-
- KFS_Read
- Read a record from an open KFS database by key.
-
- KFS_ReadFirst
- Reads the first logical record in a KFS database.
-
- KFS_ReadGen
- For databases with alphabetic keys only. Read a record from
- an open KFS database using a partial key. If no records
- match the partial key, the next record in sequence after
- the key requested is returned in the user area and a code
- of KFS_Key_Not_Found is returned in KFS_rc.
-
- KFS_ReadGenNumeric
- For databases with numeric keys only. Read a record from an
- open KFS database. If the requested key is not found, the
- next record in sequence after the key requested is returned
- in the user area and a return code of KFS_Key_Not_Found is
- returned in KFS_rc.
-
- KFS_ReadNext
- Reads the record in a KFS database that is the next record
- after the key specified.
-
- KFS_Replace
- Replaces the record in a KFS database that has the same key
- as the one specified. A record with this key must exist in
- the database.
-
-
-
-
-
-
-
-
- 9
-
-
-
-
-
-
-
-
-
-
- The File Information Structure
-
- In order to use the Keyed File System routines, you must provide
- the KFS functions with a File Information Structure for each
- database you are going to use in your program. This is a control
- structure (similar to the C "FILE" typedef) that includes such
- information about the database as the database name, key length,
- location of the key within the record, and a return code field
- for checking the result of KFS operations, as well as control
- fields used by the KFS functions themselves. Once the database
- is opened, this structure should not be modified by the appli-
- cation since this may damage the control information used by the
- KFS functions and the integrity of the database may be compro-
- mised. There is a C typedef named KFS_FILEINFO for this
- structure defined in the KFS.H header file provided with the
- system. Also present in this header file are the C prototypes
- for the KFS functions and the definitions of the KFS return
- codes.
-
- To create a KFS database (using the KFS_Create operation), you
- must provide several important pieces of information about the
- database. This is done by placing the appropriate values in the
- following fields in the File Information Structure defined for
- the file:
-
- KFS_filename
- Required for KFS_Create or KFS_Open, this field must
- contain the name of the database being created or
- opened. This is a DOS or OS/2 file specification that
- includes drive, path, and database name. As mentioned
- before the Keyed File System actually creates (or
- opens) two files for any KFS database and if these
- files are moved, both must be move to the same loca-
- tion (ie. subdirectory or floppy disk). The first file
- will have the name you specify here, while the second
- file will have the same base name as the database you
- specified but a qualifier of .PTR.
-
- KFS_keypos
- KFS_Create only. This is the position of the key
- within the record. This position is relative to 0.
- That is, if the key begins in the first position of
- the record, 0 is placed here by the programmer. If the
- key begins in the 5th position of the record, 4 is put
- here.
-
- KFS_keylen
- KFS_Create only. This is the length of the key in the
- record. For example, if the key went from position 5
- through position 10 (ie. 6 characters long) in the
- data record, 6 would be placed here. For numeric keys,
- this field is ignored.
-
-
-
-
-
-
-
- 10
-
-
-
-
-
-
-
-
-
-
- KFS_recsize
- KFS_Create only. Place the total size of each data
- record, including the key in this field.
-
- KFS_flags
- KFS_Create only. These flags specify any special pro-
- cessing required for the database. The options
- available to you are normal pointer file, small
- pointer file, numeric keys, and ignore case. These
- options are discussed further in the section "Special
- Processing".
-
- Once a KFS database is created, it may be subsequently used by
- simply specifying the name of the database in the KFS_filename
- field of the File Information structure and using KFS_Open to
- open the database. The remaining information about the database
- (ie. KFS_keypos, KFS_keylen, KFS_recsize, and KFS_flags) is
- stored with the database when it is created.
-
- Upon the completion of a KFS operation, the success or failure
- of the operation is determined by checking the return code pro-
- vided in the database's KFS_FILEINFO field KFS_rc. The valid
- return codes are defined in the KFS.H header file and are docu-
- mented in Appendix A of this User's Guide.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- 11
-
-
-
-
-
-
-
-
-
-
- Parameters to Keyed File System Functions
-
- The are 11 application interfaces that can be called to perform
- operations on databases with the Keyed File System. These
- operations require 1, 2, or 3 parameters depending on the func-
- tion desired.
-
- The first parameter to all of the KFS functions is always the
- address of the KFS File Information structure (KFS_FILEINFO) for
- the desired database. As mentioned before, once a database is
- created or opened this structure should not be changed by the
- programmer since it is used by the database system to keep track
- of current information about the database. It is also used to
- provide feedback to the programmer about the requested opera-
- tion.
-
- The second parameter is necessary for the functions that will be
- reading data from or writing data to a KFS database. This
- parameter is the address of an area large enough to contain a
- record from the database (that is, at least KFS_recsize in
- length). When a key is required by a specific KFS operation, the
- system expects the key to be in this area at the same relative
- position, and with the same length, as the key in a record in
- the database. For example, to read a record with the key "ABCDE"
- for a database whose KFS_keypos = 3, KFS_keylen = 5, and
- KFS_recsize = 80 means that the second parameter would be the
- address of an area at least 80 bytes in length that contains
- "ABCDE" in the 4th, 5th, 6th, 7th, and 8th bytes (ie.
- ...ABCDE..).
-
- The third parameter is only required on the KFS_ReadGen function
- and is the length of the portion of the key provided. This
- parameter is discussed further in the discussion of KFS_ReadGen.
- The following program segment illustrates how the above param-
- eters would be specified for a typical KFS function call:
-
- #include <kfs.h>
- KFS_FILEINFO file1;
- char recarea[100];
-
- strcpy(file1.KFS_filename, "C:\\MYDIR\\MYFILE.DAT");
- KFS_Open(&file1);
- if (file1.KFS_rc != KFS_OK)
- printf("Error opening file1\n");
- strcpy(&recarea[file1.KFS_keypos], "A k");
- KFS_ReadGen(&file1, (void *)recarea, 3);
-
- For further examples, see the description of the individual KFS
- functions and the KFSSAMP.C program provided as part of this
- package.
-
-
-
-
-
-
-
-
-
-
- 12
-
-
-
-
-
-
-
-
-
-
- Keyed File System Functions
-
- In the description of the following functions the KFS_File_Error
- is a general error caused by an "unknown error" returned from
- the operating system and is possible for all functions.
-
- KFS_Add(fs, area)
- Add a data record to a database.
-
- Parameters
- KFS_FILEINFO *fs
- A pointer to a KFS file structure.
-
- void *area
- A pointer to a data area containing the record to be
- added. The key to be added must be at KFS_keypos of
- this area before the operation is issued.
-
-
-
- Description
- Add a record to the database. Another record with this key
- must not already exist in the database.
-
-
- Required Fields
- KFS_filename
- Contains the name of an open database where the record
- is to be added.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- 13
-
-
-
-
-
-
-
-
-
-
- Example
- /* Add a record to a KFS file */
- #include <kfs.h>
- KFS_FILEINFO file1;
- typedef struct m {
- int f1;
- int f2;
- char mykey[7];
- char filler[89];
- } MYSTRUCT;
- MYSTRUCT inarea;
-
- strcpy(file1.KFS_filename, "C:\\MYDIR\\NUMFILE.DAT");
- KFS_Open(&file1);
- if (file1.KFS_rc != KFS_OK)
- printf("Error opening file1\n");
- strcpy(&inarea.mykey, "Newkey");
- inarea.f1 = 0; /* Just some data in record */
- inarea.f2 = 15; /* Just some data in record */
- KFS_Add(&file1, (void *)&inarea);
- switch (file1.KFS_rc) {
- case KFS_Key_Already_Exists :
- printf("Key already in file");
- case KFS_OK:
- break;
- default:
- printf("Error adding record");
- }
-
-
- Possible KFS_rc Values
- KFS_OK
- The record was added successfully.
-
- KFS_Key_Already_Exists
- A record with the same key as the record being added
- already exists in the database. The operation is
- ignored.
-
- KFS_File_Error
- An unknown error occurred when attempting to add a
- record to a KFS database.
-
- KFS_No_Space_On_Disk
- There was not enough space on the disk containing the
- KFS file to contain another data and pointer record.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- 14
-
-
-
-
-
-
-
-
-
-
- KFS_Close(fs)
- Close a database.
-
-
- Parameters
- KFS_FILEINFO *fs
- A pointer to a KFS file structure.
-
-
- Description
- Close a database. The database must then be opened before
- further processing can occur.
-
-
- Required Fields
- KFS_filename
- Contains the name of an opened database.
-
-
- Example
- /* Close a KFS file */
- #include <kfs.h>
- KFS_FILEINFO file1;
- .
- .
- KFS_Close(&file1);
-
-
- Possible KFS_rc Values
- KFS_OK
- The database was closed successfully.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- 15
-
-
-
-
-
-
-
-
-
-
- KFS_Create(fs)
- Create a new, empty database and open it.
-
- Parameters
- KFS_FILEINFO *fs
- A pointer to a KFS file structure.
-
-
- Description
- Create an empty database from the information supplied in
- the KFS_FILEINFO structure. At the conclusion of a suc-
- cessful operation the database is opened and may be used
- without the need to call the KFS_Open function. If a data-
- base already exists with this name, an error is returned.
-
-
- Required Fields
- KFS_keypos
- Contains the position of the key in the records of the
- new database. This position is relative to 0.
-
- KFS_keylen
- Contains the length of the key.
-
- KFS_recsize
- Contains the size of each of the keyed records to be
- built.
-
- KFS_filename
- Contains the name of the database to be created. If
- the name has a qualifier, it cannot be PTR. Also, the
- base portion of the name cannot be the same as any
- other database even if the qualifiers are unique.
-
- KFS_flags
- Specifies some additional information about the data-
- base (See the "Special Processing" section for more
- discussion of these options). The valid settings for
- this field are:
-
- KFS_Normal_PTR
- The normal pointer file organization is
- used. This results in the initial allocation
- of the .PTR file of about 8K but results in
- good performance for large databases.
-
- KFS_Small_PTR
- The organization of the pointer file will be
- changed to save space on the initial allo-
- cation of the database. This option should
- be specified only when the database will be
- a small one since larger databases having
- this option are slower than for databases
- created with KFS_Normal_PTR.
-
- KFS_Numeric_Keys
- The keys in the database will be numeric
- keys stored in the Intel long integer for-
- mat. This option also implies a small
- pointer file.
- 16
-
-
-
-
-
-
-
-
-
-
-
- KFS_Ignore_Case
- The case of the keys in the database is
- ignored. That is, a key of "ABCDE" and "ab-
- cde" will be treated as the same key.
-
- Example
- /* Create and open a KFS file with alphabetic keys starting */
- /* in the 5th position of the record and 7 bytes long */
- #include <kfs.h>
- KFS_FILEINFO file1;
- char recarea[100];
-
- file1.KFS_flags = KFS_Normal_PTR;
- file1.KFS_keypos = 4;
- file1.KFS_keylen = 7;
- file1.KFS_recsize = 100;
- strcpy(file1.KFS_filename, "C:\\MYDIR\\MYFILE.DAT");
- KFS_Create(&file1);
- if (file1.KFS_rc != KFS_OK)
- printf("Error creating file1\n");
-
-
- Possible KFS_rc Values
- KFS_OK
- The database was created successfully.
-
- KFS_Keyed_File_Already_Exists
- A database with this name already exists.
-
- KFS_Invalid_File_Name
- The file name and associated path name is longer than
- 63 characters.
-
- KFS_PTR_File_Open_Error
- An unknown error occurred while attempting to open the
- PTR file associated with the database. This error can
- occur if there is not enough space on the disk to
- allocate the pointer file or if a .PTR file by this
- name already exists.
-
- KFS_Data_File_Open_Error
- An unknown error occurred while attempting to open the
- data file associated with the database.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- 17
-
-
-
-
-
-
-
-
-
-
- KFS_Delete(fs, area)
- Delete a record from the database.
-
-
- Parameters
- KFS_FILEINFO *fs
- A pointer to a KFS file structure.
-
- void *area
- A pointer to a data area containing the key of the
- record to be deleted. This key must be placed at
- KFS_keypos of this area before the operation is
- issued.
-
- Description
- Delete a record from the database.
-
-
- Required Fields
- KFS_filename
- Contains the name of an opened database.
-
- area
- The data area pointed to must contain the key of the
- record being deleted beginning in KFS_keypos of the
- area.
-
-
- Example
- /* Add a record to a KFS file */
- #include <kfs.h>
- KFS_FILEINFO file1;
- typedef struct m {
- int f1;
- int f2;
- char mykey[7];
- char filler[89];
- } MYSTRUCT;
- MYSTRUCT inarea;
-
- strcpy(file1.KFS_filename, "C:\\MYDIR\\NUMFILE.DAT");
- KFS_Open(&file1);
- memset(&inarea.mykey, ' ', sizeof(inarea.mykey));
- strcpy(&inarea.mykey, "Dkey");
- KFS_Delete(&file1, (char *)&inarea);
- switch (file1.KFS_rc) {
- case KFS_OK:
- break;
- case KFS_No_Space_On_Disk:
- printf("Not enough space on disk to add record\n");
- break;
- default:
- printf("Error adding record\n");
-
- }
-
- Possible KFS_rc Values -
- KFS_OK
- The record was deleted successfully.
-
- 18
-
-
-
-
-
-
-
-
-
-
- KFS_Key_Not_Found
- A record with the key specified was not found. The
- operation is ignored.
-
- KFS_No_Space_On_Disk
- There is not enough space on the disk containing the
- KFS database to add a record.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- 19
-
-
-
-
-
-
-
-
-
-
- KFS_Open(fs)
- Open an existing database.
-
- Parameters
- KFS_FILEINFO *fs
- A pointer to a KFS file structure.
-
-
- Description
- Open an existing database for processing. All databases
- must be opened before any processing may be done on those
- databases.
-
-
- Required Fields
- KFS_filename
- Contains the name of an existing database to be
- opened.
-
-
- Example
- /* Open a KFS file */
- #include <kfs.h>
- KFS_FILEINFO file1;
- char recarea[100];
-
- strcpy(file1.KFS_filename, "C:\\MYDIR\\MYFILE.DAT");
- KFS_Open(&file1);
- if (file1.KFS_rc != KFS_OK)
- printf("Error opening file1\n");
-
-
- Possible KFS_rc Values
- KFS_OK
- The database was opened successfully.
-
- KFS_Keyed_File_Does_Not_Exist
- The database does not exist.
-
- KFS_Invalid_File_Name
- The database name and associated path name is longer
- than 63 characters.
-
- KFS_PTR_File_Open_Error
- An unknown error occurred while attempting to open the
- PTR file associated with the database.
-
- KFS_Data_File_Open_Error
- An unknown error occurred while attempting to open the
- data file associated with the database.
-
-
-
-
-
-
-
-
-
- 20
-
-
-
-
-
-
-
-
-
-
- KFS_Read(fs, area)
- Read a record by key from the database.
-
-
- Parameters
- KFS_FILEINFO *fs
- A pointer to a KFS file structure.
-
- void *area
- A pointer to a data area where the requested record
- will be read. The key to be read must be placed at
- KFS_keypos of this area before the operation is
- issued.
-
-
- Description
- Read a record by key from a database.
-
-
- Required Fields
- KFS_filename
- Contains the name of an open database.
-
- area
- The data area pointed to must contain the key of the
- record being read beginning at position KFS_keypos.
-
-
- Example
- /* Read a KFS file by key (keypos=4, keylen=7) */
- #include <kfs.h>
- KFS_FILEINFO file1;
- char recarea[100];
-
- strcpy(file1.KFS_filename, "C:\\MYDIR\\MYFILE.DAT");
- KFS_Open(&file1);
- if (file1.KFS_rc != KFS_OK)
- printf("Error opening file1\n");
- memset(recarea, ' ', sizeof(recarea));
- /* Note - we kept the terminating NULL as part of the key */
- strcpy(&recarea[file1.KFS_keypos], "A key");
- KFS_Read(&file1, (void *)recarea);
- if (file1.KFS_rc != KFS_OK)
- printf("Error reading keyed record from file1\n");
-
-
- Possible KFS_rc Values
- KFS_OK
- The record was read successfully.
-
- KFS_Key_Not_Found
- A record with the key specified was not found. The
- operation is ignored.
-
-
-
-
-
-
-
- 21
-
-
-
-
-
-
-
-
-
-
- KFS_ReadFirst(fs, area)
- Read the first record in keyed sequence in the database.
-
-
- Parameters
- KFS_FILEINFO *fs
- A pointer to a KFS file structure.
-
- void *area
- A pointer to a data area where the first record in the
- KFS database will be read.
-
-
- Description
- Read the first record from a database. The record with the
- lowest key will be read and placed in the data area.
-
-
- Required Fields
- KFS_filename
- Contains the name of an open database.
-
-
- Example
- /* Read the all of the records sequentially from a file */
- #include <kfs.h>
- KFS_FILEINFO file1;
- char recarea[100];
-
- strcpy(file1.KFS_filename, "C:\\MYDIR\\NUMFILE.DAT");
- KFS_Open(&file1);
- if (file1.KFS_rc != KFS_OK)
- printf("Error opening file1\n");
- KFS_ReadFirst(&file1, recarea);
- if (file1.KFS_rc != KFS_OK) printf("Error");
-
-
- Possible KFS_rc Values -
- KFS_OK
- The record was read successfully.
-
- KFS_Keyed_File_Empty
- No records were found in the database. The operation
- is ignored.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- 22
-
-
-
-
-
-
-
-
-
-
- KFS_ReadGen(fs, area, length)
- Read a record using a partial key.
-
- Parameters
- KFS_FILEINFO *fs
- A pointer to a KFS file structure.
-
- void *area
- A pointer to a data area where the requested record
- will be read. The partial key to be used must be
- placed at KFS_keypos of this area before the operation
- is issued.
-
- int length
- The length of the partial key at KFS_keypos. If the
- length specified is 0, the first record in the data-
- base is read.This length must be less than or equal to
- KFS_keylen.
-
- Description
- Read the first record in the database whose first portion
- matches that of the partial key supplied. If no record
- matches the partial key, the next logical record in the
- database is returned.
-
-
- Required Fields
- KFS_filename
- Must contain the name of an open database.
-
- area
- The data area pointed to must contain the key of the
- record being read.
-
-
- Example
- /* Read a KFS file by partial key (keypos=4, keylen=7) */
- #include <kfs.h>
- KFS_FILEINFO file1;
- char recarea[100];
-
- strcpy(file1.KFS_filename, "C:\\MYDIR\\MYFILE.DAT");
- KFS_Open(&file1);
- if (file1.KFS_rc != KFS_OK)
- printf("Error opening file1\n");
- strcpy(&recarea[file1.KFS_keypos], "A k");
- KFS_ReadGen(&file1, (void *)recarea, 3);
- if (file1.KFS_rc == KFS_Key_Not_Found)
- printf("We had no key match but got the next key\n");
- else
- if (file1.KFS_rc == KFS_OK)
- printf("We got a record with a key starting with 'A
- k'");
-
- Possible KFS_rc Values -
- KFS_OK
- The partial key matched an existing record and this
- record was read successfully.
-
- KFS_Key_Not_Found
- 23
-
-
-
-
-
-
-
-
-
-
- No record with a key that matched the partial key
- specified was found. The next logical record in the
- database is returned.
-
- KFS_EOF
- The partial key requested could not be found and the
- next position in the database was end of file.
-
- KFS_Key_Length_Invalid
- A length greater than KFS_keylen was supplied in the
- parameter list.
-
- KFS_Invalid_Request
- A KFS_ReadGen operation was attempted on a database
- with numeric keys.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- 24
-
-
-
-
-
-
-
-
-
-
- KFS_ReadGenNumeric(fs, area)
- Read a numeric record, return the next record if not found.
-
-
- Parameters -
- KFS_FILEINFO *fs
- A pointer to a KFS file structure.
-
- void *area
- A pointer to a data area where the requested record
- will be read. A numeric key must be placed in
- KFS_keypos of this area prior to performing the
- operation.
-
-
- Description
- If a record in the database matches the key specified it is
- read and placed in the data area. KFS_OK is then returned.
- If no record matches the numeric key, then the next record
- in the database is returned with a return code of
- KFS_Key_Not_Found.
-
-
- Required Fields
- KFS_filename
- Contains the name of an open database.
-
- area
- The data area pointed to must contain a numeric key at
- KFS_keypos.
-
-
- Example
- /* Read a KFS file by numeric key (keypos=4) */
- #include <kfs.h>
- KFS_FILEINFO file1;
- typedef struct m {
- int f1;
- int f2;
- long mykey;
- char filler[92];
- } MYSTRUCT;
- MYSTRUCT inarea;
-
- strcpy(file1.KFS_filename, "C:\\MYDIR\\NUMFILE.DAT");
- KFS_Open(&file1);
- if (file1.KFS_rc != KFS_OK)
- printf("Error opening file1\n");
- inarea.mykey = 1000;
- KFS_ReadGenNumeric(&file1, (void *)inarea);
- if (file1.KFS_rc == KFS_Key_Not_Found)
- printf("There was no key 1000 but got the next key\n");
-
- else
- if (file1.KFS_rc == KFS_OK)
- printf("We got the record with key 1000");
-
- Possible KFS_rc Values
- KFS_OK
- The record was read successfully.
- 25
-
-
-
-
-
-
-
-
-
-
-
- KFS_Key_Not_Found
- No record with a key that matched the key specified
- was found. The next logical record in the database is
- returned.
-
- KFS_EOF
- The partial key requested could not be found and the
- next position in the database was at end of file.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- 26
-
-
-
-
-
-
-
-
-
-
- KFS_ReadNext(fs, area)
- Read the next record in keyed sequence in the database.
-
-
- Parameters
- KFS_FILEINFO *fs
- A pointer to a KFS file structure.
-
- void *area
- A pointer to a data area where the requested record
- will be read. The key placed at KFS_keypos of this
- area must be the key of the record before the record
- desired.
-
-
- Description
- Read the next logical record from a database. The record
- with the next highest key after the key specified in the
- data area will be read. The user must provide the key of
- the previous record in KFS_keypos of area. This allows the
- user to read all records in a database with a succession of
- KFS_ReadNext functions.
-
-
- Required Fields
- KFS_filename
- Contains the name of an open database.
-
- area
- Contains the key of the record previous to the one to
- be read.
-
-
- Example
- /* Read the all of the records sequentially from a file */
- #include <kfs.h>
- KFS_FILEINFO file1;
- typedef struct m {
- int f1;
- int f2;
- char mykey[7];
- char filler[89];
- } MYSTRUCT;
- MYSTRUCT inarea;
-
- strcpy(file1.KFS_filename, "C:\\MYDIR\\NUMFILE.DAT");
- KFS_Open(&file1);
- if (file1.KFS_rc != KFS_OK)
- printf("Error opening file1\n");
- KFS_ReadFirst(&file1, (void *)&inarea);
- while (file1.KFS_rc != KFS_EOF) {
- KFS_ReadNext(&file1, (void *)&inarea);
-
- if (file1.KFS_rc != KFS_OK) printf("Error");
- }
- KFS_Close(&file1);
-
- Possible KFS_rc Values
- KFS_OK
- The record was read successfully.
- 27
-
-
-
-
-
-
-
-
-
-
-
- KFS_EOF
- There are no more records in the dataset.
-
- KFS_Key_Not_Found
- A record with the specified key did not exist in the
- database and no record is returned. (i.e. the previous
- record must be found before the "next" record can be
- returned)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- 28
-
-
-
-
-
-
-
-
-
-
- KFS_Replace(fs, area)
- Replace the record with the specified key.
-
-
- Parameters
- KFS_FILEINFO *fs
- A pointer to a KFS file structure.
-
- void *area
- A pointer to a data area containing the record that
- will replace the record with the specified key in the
- database.
-
-
- Description
- Replace the record with the corresponding key in the data-
- base with the record in area. If the record does not exist
- in the database, the operation is ignored and a
- KFS_Key_Not_found is returned. No prior read of the record
- being replaced must be done.
-
-
- Required Fields
- KFS_filename
- Contains the name of an open database.
-
- area
- Contains the record that will replace the one in the
- database.
-
-
- Example
- /* Replace a record in a KFS file */
- #include <kfs.h>
- KFS_FILEINFO file1;
- typedef struct m {
- int f1;
- int f2;
- char mykey[7];
- char filler[89];
- } MYSTRUCT;
- MYSTRUCT inarea;
-
- strcpy(file1.KFS_filename, "C:\\MYDIR\\NUMFILE.DAT");
- KFS_Open(&file1);
- strcpy(&inarea.mykey, "Oldkey");
- /* Note - we would not have to read to replace */
- KFS_Read(&file1, (void *)&inarea);
- inarea.f2 = 77;
- KFS_Replace(&file1, (void *)&inarea);
- switch (file1.KFS_rc) {
- case KFS_Key_Not_Found :
-
- printf("Record was not in file");
- case KFS_OK:
- break;
- default:
- printf("Error replacing record");
- }
-
- 29
-
-
-
-
-
-
-
-
-
-
- Possible KFS_rc Values -
- KFS_OK
- The record was read successfully.
-
- KFS_Key_Not_Found
- A record with the key specified was not found. The
- operation is ignored.
-
- KFS_File_Error
- An unknown error occurred when attempting to replace
- the requested record.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- 30
-
-
-
-
-
-
-
-
-
-
- Interdependencies of the KFS operations
-
- Except for the requirements for opening databases first and
- closing databases last, there is no specific dependencies
- between KFS operations. That is, there is no requirement to call
- a specific function before another function can be called. For
- example, it is not necessary to read a specific record before
- replacing it with KFS_Replace. The same is true if you want to
- delete a record, it is not necessary to read it first. Simi-
- larly, you can issue a KFS_ReadNext after any other operation,
- as long as the key of an existing record is present in the data
- area so that KFS_ReadNext can read the record with the next
- highest key.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- 31
-
-
-
-
-
-
-
-
-
-
- Special Processing
-
- There are a few special options that may be chosen when creating
- a database with the Keyed File System that allow for special
- uses of databases. These options are enabled by setting certain
- bits in the KFS_flags field of the File Information Structure.
- If none of the options are desired, the flags field should be
- set to KFS_Normal_PTR. Normally, databases are relatively large
- databases (such as customer record databases) with keys that
- contain primarily letters (people's names, for example) and the
- Keyed File System was designed to handle these databases most
- efficiently. Some assumptions are made about the number and type
- of keys that will exist in the database when it is created and
- results in creating an initial .PTR file of about 8K bytes.
- Because of this initial allocation, the .PTR file is normally
- slow to grow. However, for some applications, the assumptions
- made by the Keyed File System may not be correct. Three options
- are provided to enable the programmer to select a more efficient
- initial .PTR allocation or to utilize various types of keys.
-
-
- KFS_Small_PTR
-
- For applications that need relatively small databases (up to a
- few hundred records), the KFS_Small_PTR option provides a way to
- greatly reduce the initial size of the .PTR file from 8K to a
- few hundred bytes. However, using this option will result in
- slower execution speed if the database does grow large. Note
- that this does not prohibit the database from becoming large,
- just that performance is slower should it do so.
-
- The option is enabled by setting the KFS_flags field to
- KFS_Small_PTR. In C this could be done by the following code :
-
- #include <kfs.h>
- KFS_FILEINFO file1;
- file1.KFS_flags = KFS_Small_PTR;
-
-
- KFS_Numeric_Key
-
- For applications whose keys are all numbers, it would be more
- efficient of these numbers could be stored in the normal way
- that the Intel 80x86 stores numbers. That is, in byte reversed
- binary form (ie. short, int, or long in C terminology). The
- Keyed File System provides the KFS_Numeric_Key option that
- allows the key to be stored in the 4 byte Intel integer format
- (ie. C's "long int"). Using this option will cause the system to
- assume that KFS_keypos indicates the beginning of a 4 byte key
- that is a number stored in integer form. KFS_keylen is ignored
- when this option is specified.
-
-
- The option is enabled by setting the KFS_flags field to
- KFS_Numeric_Key. In C this could be done by the following code :
-
- #include <kfs.h>
- KFS_FILEINFO file1;
- file1.KFS_flags = KFS_Numeric_Key;
-
- 32
-
-
-
-
-
-
-
-
-
-
-
- KFS_Ignore_Case
-
- Normally, databases created with alphabetic keys are sensitive
- to the case of the keys. That is, keys "ABCDE" and "abcde"
- indicate the keys of two different records. However, setting
- this option allows case to be ignored for databases that have
- alphabetic keys. Then a database created with this option would
- treat the keys "ABCDE" and "abcde" as the key to the same
- record.
-
- The option can be combined with the KFS_Normal_PTR or
- KFS_Small_PTR options and is enabled by setting the KFS_flags
- field to KFS_Ignore_Case. In C this could be done by the fol-
- lowing code :
-
- #include <kfs.h>
- KFS_FILEINFO file1;
- file1.KFS_flags = KFS_Normal_PTR | KFS_Ignore_Case;
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- 33
-
-
-
-
-
-
-
-
-
-
- Programming Hints and Tips
-
- In this section we will try to provide some hints, examples,
- and, hopefully, the answers to some questions to help an appli-
- cation developer in using the Keyed File System. As part of the
- KFS package we have included the source to the sample and util-
- ity programs we have provided. These programs will provide some
- concrete coding examples of how to use the functions we have
- described. Use them to reinforce some of the examples we use in
- this section.
-
- * Ensure that when creating a database that the KFS_flags
- field is properly set to one of the valid options.
-
- * When specifying a key in the data area for an operation
- that requires a key, make sure that all bytes in the key
- field are set to a known value. Remember, the Keyed File
- System always assumes the key is KFS_keylen bytes long,
- irrespective of any NULLS in the key field. A common mis-
- take is not to "clear" the key field before moving in a key
- that may be shorter than keylen. For example, STRCPY only
- moves data until a '00'X is detected in the source. Thus,
- if what is being moved in is shorter than KFS_keylen, the
- remaining bytes of the key field will remain unchanged (ie.
- may contain garbage). Additionally, consider that STRCPY
- also moves the terminating NULL character and that will
- become part of the key. This may be OK, just realize that
- the NULL is there. A good habit to get into when using KFS
- functions is illustrated by the following code:
-
- #include <kfs.h>
- KFS_FILEINFO file1;
- char area[80];
- memset(&area[file1.KFS_keypos], ' ', file1.KFS_keylen);
- strcpy(&area[file1.KFS_keypos, newkey);
-
- This code sequence initially sets the key field of "area"
- to blanks and then copies in the desired key from the
- "newkey" variable.
-
- * You will notice that the Keyed File System does not allow
- for duplicate keys. However, with a little thought, the
- KFS_ReadGen and KFS_ReadNext functions can be used to pro-
- vide a similar capability. For example, if you wanted to
- have a database whose key was a name field, duplicate names
- could be avoided by making the key field the name AND
- account number. You could still issue a KFS_ReadGen for
- only the name and then use KFS_ReadNext to read the rest of
- the records having the same name.
-
- * If KFS_ReadNext tries to read the next record after the
- last logical record in the database (ie. the record with
- the highest key) a KFS_EOF is returned. If another
- KFS_ReadNext is issued, KFS_EOF will again be returned.
- However, other operations (such as KFS_Read) are still
- allowed on the database and will result in KFS_rc to be set
- to another value (such as KFS_OK if the read is success-
- ful). Further KFS_ReadNext operations may be performed from
- that spot in the database.
-
- 34
-
-
-
-
-
-
-
-
-
-
- * We mentioned earlier that numeric and alphabetic keys can-
- not be combined. However, if you keep in mind that shorts
- and longs are stored in byte reversed format, you can form
- keys that mix data types. The following code segment com-
- bines an alphabetic customer name and a numeric (i.e. long)
- customer number into a single key. The customers names
- would be in the database in alphabetic sequence, but cus-
- tomers with the same name would not necessarily be in
- sequence by customer number (customer number 256, stored as
- '00010000'x, would be before customer number 255, stored as
- 'FF000000'x, for example).
-
- #include <kfs.h>
- struct DA {
- char custname[40];
- long custnum;
- char morestuff[40];
- } myarea;
- KFS_FILEINFO myfile;
- :
- myfile.KFS_keypos = 0;
- myfile.KFS_keylen = 44;
- :
- KFS_Create(&myfile);
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- 35
-
-
-
-
-
-
-
-
-
-
- Data Recovery
-
- Most programmers are familiar with damaged data files caused by
- unusual system problems (power failures or system crashes) while
- a file is being written to disk. While these problems are rare,
- they do occur. The Keyed File System contains code that attempts
- to minimize the impact of such a system failure, but this impact
- cannot be eliminated completely. Since the Keyed File System
- uses two related DOS files (an index file and a data file) to
- manage a database, damage to one of these files can cause the
- database to become unusable. With a little planning, however, a
- programmer can frequently recover a damaged KFS database with
- little or no loss of data. To do this requires a little knowl-
- edge of the internals of KFS.
-
- The data file that makes up a KFS database is a normal DOS
- binary file. That is, each "logical" record is KFS_recsize bytes
- long and does not contain a CR/LF at the end of each record.
- Thus, these records can be read using operating system or C
- language functions just like any other binary file. Addition-
- ally, when KFS deletes a record, it is not physically removed
- from the data file but only from the .PTR file. However, it is
- marked for reuse and a hex 'FF' is placed in the last byte of
- the data record when a record is deleted. This hex 'FF' has no
- consequence to KFS since deleted records are tracked another way
- internally, but can be useful for a programmer wanting to
- recover a damaged KFS database by using only the data file. If,
- when writing an application, a programmer using the Keyed File
- System ensures that the last byte of each data record cannot
- normally be hex 'FF', then recovering a KFS database can be
- relatively simple. A database recovery program can be written
- that simply reads the data portion of the damaged KFS database
- as fixed length binary records, checks to ensure the last byte
- of each record is not hex 'FF' (remember, hex 'FF' means the
- record has been deleted), and uses the KFS_Add operation to add
- the record to a new KFS database. At the conclusion of such a
- recovery program, the new KFS database would contain all of the
- undamaged records that existed in the original KFS database. A
- simple example of this technique appears in Appendix B.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- 36
-
-
-
-
-
-
-
-
-
-
- Appendix A - Keyed File System Return Codes
-
- The following is a list of return codes generated by the Keyed
- File System. These definitions are found in the supplied header
- file (KFS.H).
-
- KFS_OK (0)
- The operation completed successfully.
-
- KFS_Data_File_Open_Error (3)
- A bad return code was return from the system when trying to
- open the data file of the database.
-
- KFS_EOF (-1)
- End of file was reached on the data database during a
- KFS_ReadNext. The database remains open and subsequent
- keyed operations are allowed.
-
- KFS_File_Error (8)
- An unknown error was returned by the operating system.
-
- KFS_File_Already_Exists (9)
- You are trying to create a database that already exists in
- this directory.
-
- KFS_Invalid_File_Name (1)
- The database name requested in KFS_filename is longer than
- the 63 characters allowed by the Keyed File System.
-
- KFS_Invalid_Request (11)
- You are attempting to do a KFS_ReadGen on a database with
- numeric keys. Use a KFS_ReadGenNumeric function instead.
-
- KFS_Key_Already_Exists (4)
- A record with the key specified already exists in the
- database.
-
- KFS_Key_Length_Invalid (12)
- The length of the partial key specified for a KFS_ReadGen
- was either 0 or greater than the key length for this data-
- base.
-
- KFS_Key_Not_Found (5)
- A record with the key specified does not exist in the
- database.
-
- KFS_Keyed_File_Empty (7)
- When attempting to execute a KFS_ReadFirst operation it was
- discovered that the database had no records.
-
-
-
-
- KFS_No_Space_On_Disk (13)
- There is no space on the disk containing the KFS database
- to add a new record.
-
- KFS_Prior_Key_Not_Found (6)
- The key specified as the prior key in a KFS_ReadNext was
- not found in the database.
- 37
-
-
-
-
-
-
-
-
-
-
-
- KFS_PTR_File_Open_Error (2)
- A bad return code was return from the system when trying to
- open the pointer file of the database.
-
- KFS_Recordsize_Too_Short (10)
- The amount specified in KFS_recsize is smaller than
- KFS_keypos + KFS_keylen.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- 38
-
-
-
-
-
-
-
-
-
-
- Appendix B - File Recovery Example
-
- The following is an example of a C program that could be used to
- recover a KFS database. Assume the damaged database had the
- following characteristics:
-
- KFS_filename = C:\DATA\MYFILE.DAT
- KFS_recsize = 100
- KFS_keypos = 0
- KFS_keylen = 15
-
- The C program to recover this database could look like this:
-
- main()
- {
- /* Example of how to recover a KFS file if .PTR is damaged */
- FILE *old;
- KFS_FILEINFO new;
- char dataarea[100];
-
- old = fopen("C:\\DATA\\MYFILE.DAT", "rb");
- new.KFS_recsize = 100;
- new.KFS_keylen = 15;
- new.KFS_keypos = 0;
- new.KFS_flags = KFS_Normal_PTR;
- strcpy(new.KFS_filename, "C:\\WORK\\MYFILE.DAT");
- KFS_Create(&new);
- fread(&dataarea, sizeof(dataarea), 1, old);
- while(!feof(old))
- {
- if (dataarea[new.KFS_recsize - 1] != 0xff)
- KFS_Add(&new, &dataarea);
- fread(&dataarea, sizeof(dataarea), 1, old);
- }
- fclose(old);
- KFS_Close(&new);
- }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- 39
-
-
-
-