Short-Record Data Compression and Decompression System

1. Field of the Invention

The invention relates to data compression and decompression particularly with respect to processing short records.

2. Description of the Prior Art

The prior art is exemplified by U.S. Pat. No. 4,464,650; issued Aug. 7,1984; entitled "Apparatus And Method For Compressing Data Signals And Restoring The Compressed Data Signals"; by Eastman et al. and by U.S. Pat. 4,558,302; issued Dec. 10, 1985; entitled "High Speed Data Compression And Decompression Apparatus And Method"; by Welch. Said U.S. Pat. Nos. 4,464,650 and 4,558,302 are incorporated herein by reference in their entirety. The systems of said U.S. Pat. Nos. 4,464,650 and 4,558,302 are practical implementations of Lempel-Ziv data compression and represent the state of the art in this technology.

The data compression and decompression systems of said U.S. Pat. Nos. 4,464,650 and, 5,558,302 have a disadvantage which limits the usefulness thereof in certain applications. In order to decompress any section of compressed data, it is necessary first to decompress any and all data which precedes the desired section of data in the original input file. This process can be slow and cumbersome in applications where frequent access to individual records of a file is required. Heretofore it has not been possible to retrieve and decompress individual records from a file without having to decompress preceding records in the file. Additionally, the prior art did not provide the capability of decompressing an individual record, altering the record and recompressing the altered record without having to decompress and recompress the preceding records in the file.

The present invention overcomes the above-described limitation of the prior art while retaining the advantages of the systems of said U.S. Pat. Nos. 4,464,650 and 4,558,302. In the present invention, a file preprocessor constructs a searchtree database utilizing a sample of the data. Once the preprocessed searchtree is formed, it is maintained fixed. A short record encoder utilizes the preprocessed searchtree to compress individual data records and to generate an encoded-record directory to denote stored locations of the compressed individual records. A short record decoder utilizes the preprocessed searchtree to decompress compressed records which are accessed utilizing the encoded-record directory. Individual decompressed records can be changed and recompressed by the short-record encoder utilizing the preprocessed searchtree and restored in compressed file storage. The encoded-record directory maintains cognizance of the locations of altered and recompressed records.

FIG. 1 is a schematic block diagram of the short-record data compression and decompression system of the present invention.

FIG. 2 is a flow chart depicting the operation of the File Preprocessor of the present invention.

FIG. 3 is a flow chart depicting the operation of the Short-Record Encoder of the present invention.

FIG. 4 is a flow chart depicting the operation of the Short-Record Decoder of the present invention.

FIG. 5 is a schematic block diagram of an embodiment of the File Preprocessor of the present invention.

FIGS. 5a, which consists of FIGS. 5aa and 5ab taken together is a schematic block diagram illustrating details of the searchtree database of the preprocessor of FIG. 5.

FIG. 5b is a schematic block diagram illustrating details of the pointer counter of the searchtree database of FIG. 5a.

FIG. 5c is a schematic block diagram illustrating details of the address generator of the preprocessor of FIG. 5.

FIG. 5d is a schematic block diagram illustrating details of the threshold calculator of the preprocessor of FIG. 5.

FIG. 6 is a schematic block diagram of an embodiment of the short-record encoder of the present invention.

FIG. 6a is a schematic block diagram illustrating details of the searchtree database of the encoder of FIG. 6.

FIG. 6b is a schematic block diagram illustrating details of the address generator of the encoder of FIG. 6.

FIG. 6c is a schematic block diagram illustrating details of the pointer generator of the encoder of FIG. 6.

FIG. 6d is a schematic block diagram illustrating details of the economy encoder of the encoder of FIG. 6.

FIG. 7 is a schematic block diagram of an embodiment of the short-record decoder of the present invention.

FIGS. 7a and b are schematic block diagrams illustrating details of the economy decoders of the decoder of FIG. 7.

FIG. 7c is a schematic block diagram illustrating details of the searchtree database of the decoder of FIG. 7.

FIG. 7d is a schematic block diagram illustrating details of the label generator of the decoder of FIG. 7.

FIG. 7e is a schematic block diagram illustrating detail of the position extractor of the decoder of FIG. 7;.

FIG. 7f is a schematic block diagram illustrating detail of the push-down stack of the decoder of FIG. 7.

The present invention compresses digital data contained in a file, record by record, in such a manner that individual records can be accessed and decompressed, changed if necessary, recompressed and restored to the compressed file in compressed form. This is achieved at a small additional cost in hardware and a small amount of preprocessing of the input data. The invention provides the capability of retrieving and decompressing individual records from a file without having to decompress any other records of the file. Additionally, changes can be made in individual records and the records can be recompressed without having to recompress any other records of the file.

The invention is a modification of the system disclosed in said U.S. Pat. No. 4,464,650 retaining all of the advantages and properties of the system as described in the patent. Many of the algorithms and hardware components of the present system are the same as those described in said U.S. Pat. No. 4,464,650.

Referring to FIG. 1, the system of the present invention is comprised of a file preprocessor 10, a searchtree database 11, an electronic storage unit 12, a short-record encoder 13, an encoded-record directory 14 and a short-record decoder 15.

The file processor 10 operates on a modest-sized sample of the input data to produce the searchtree database 11 used by the encoder 13 and decoder 15. The searchtree database 11 produced by the preprocessor 10 is stored in the electronic storage unit 12. Once built, it is fixed and unchanging and, unlike its counterpart in said U.S. Pat. No. 4,464,650, will not adapt to subsequent changes in the input data. The electronic storage unit 12 holds the searchtree database 11 produced by the preprocessor 10, and the encoded records and encoded-record directory 14 produced by the short-record encoder 13. The short-record encoder 13 uses the searchtree database 11 produced by the preprocessor 10 to compress, and after changes to records by a record modifier 16, to recompress individual data records. It produces both the compressed records and the encoded-record directory 14, both of which are stored in the electronic storage unit 12. The encoded-record directory 14 contains the starting location for each compressed record in the compressed file, and is consulted whenever it is desired to retrieve and decompress an individual compressed record. The short-record decoder 15 decompresses an individual record whenever requested or needed in its original form.

The file preprocessor 10 utilizes those portions of the encoder of said U.S. Pat. No. 4,464,650 used for constructing the searchtree database and eliminates those components utilized to construct and transmit the compressed code therefrom. The file preprocessor 10 also inverts the tables constructed in generating the forward searchtree utilized by the short-record encoder to provide the backward searchtree tables utilized by the short-record decoder. The short-record encoder 13 utilizes those portions of the encoder of said U.S. Pat. No. 4,464,650 used in tracing a path through the forward searchtree and in encoding the leaf pointers for generation of the compressed code. In addition, the short-record encoder 13 builds the encoded-record directory. The short-record encoder 13 eliminates the portions of the encoder of said U.S. Pat. No. 4,464,650 utilized for updating the searchtree.

In a similar manner, the short-record decoder 15 utilizes the portions of the decoder of said Pat. No. 4,464,650 that traced a backward path through the searchtree and retrieved and reversed the symbol strings. The short-record decoder 15 eliminates from the decoder of said U.S. Pat. No. 4,464,650 those portions that updated the searchtree.

The short-record parsing procedure will now be described. The parsing procedure comprises the rules for parsing the input data into segments. The parsing procedure for the system of said Pat. No. 4,464,650 is described therein and the short-record parsing procedure used by the short-record encoder 13 is a modification thereof. The short-record parsing procedure uses the searchtree constructed by the preprocessor 10, but does not effect any further changes or additions thereto. Let K denote the final number of internal nodes present in the incrementally grown searchtree constructed by the file preprocessor 10 in accordance with said U.S. Pat. No. 4,464,650. The short-record parsing procedure is as follows:

Initially, set step k=1, and n.sub.0 =0.

At step k, find i<K such that X.sub.i is the longest segment which is a prefix of x(n.sub.k-1 +1,L(x)). Set n.sub.k =n.sub.k-1 +L(X.sub.i).

The following property of the short-record parsing procedure is observed: Since X.sub.k =X.sub.ik, where i.sub.k .ltoreq.K is the value of i in the k.sup.th iteration of the short-record parsing procedure, it follows that it is possible to determine X.sub.k recursively if the database provided by the searchtree constructed by the file preprocessor 10 in accordance with the process described in said U.S. Pat. No. 4,464,650 has been retained.

The searchtree database is the key to implementation of the parsing procedure described above and to the encoding and decoding of parsed segments. The searchtree database is constructed by the file preprocessor 10. The searchtree is utilized by the encoder 13 both for parsing the input data into segments and for encoding the parsed segments. The searchtree database is utilized by the decoder 15 for decoding the encoded segments. As described in said U.S. Pat. No. 4,464,650, and in a manner to be further described below, the searchtree database is actually stored as a set of tables or lists, which in effect define the searchtree over a finite alphabet. For an understanding of the searchtree database, reference is made to the definitions in said U.S. Pat. No. 4,464,650, column 9, line 19, through column 10, line 21.

The growth of (T.sub.k, B.sub.k) by the file preprocessor 10 terminates with a tree (T.sub.K, B.sub.K) containing K internal nodes whenever either the storage allotted for the tree is completely used or the portion of the input file to be scanned for building the tree has been completely parsed. The growth of (T.sub.k, BB.sub.k) is described in said U.S. Pat. No. 4,464,650 with respect to the encoder thereof. The searchtree is then stored in the electronic storage unit 12 for subsequent use in encoding and decoding of individual records of the file. There are seven tables or lists which comprise the database: the label table (forward tree) (encoder); the address table (backward tree) (decoder); the last-descendant list (decoder); the symbol-position table (encoder); the position-symbol table (decoder); the unseen-rank table (encoder), and the rank-unseen table (decoder).

All but the last-descendant list have been described in detail in said U.S. Pat. No. 4,464,650. The last-descendant list is utilized, when required, when translating the encoded pointer back into a virtual address. If the last symbol in a parsed segment was also the first symbol encountered in the file, the address obtained is not that of a leaf, but that of an interior node. For each virtual address, the last-descendant list provides the length d of a path composed entirely of rightmost arcs, which path connects the interior node to a leaf. The decoder 15 can then begin decoding at the interior node, knowing that d repetitions of the first file-symbol are to be attached to the end of the decoded segment.

Briefly, with respect to the other tables and lists, the label table array is utilized to encode when traversing the searchtree in the forward direction. For any labeled node k and arc label, the address of the appropriate son node is computed by a shift-and-add operation. The label of the son node is then obtained from the label table. The address table is utilized to decode by traversing the searchtree in the backward direction. For any virtual address, the node label of the appropriate father node is computed by a shift-and-add operation. The virtual address of the father is then obtained from the address table. The symbol-position table provides the arc position assigned to each symbol encountered in the file by the preprocessor 10. The rightmost (highest) position is assigned to the first symbol encountered, the second rightmost (second highest) to the second symbol, etc. The position-symbol table, which is the inverse of the symbol-position table, provides for each arc position the symbol which has been assigned to that position. The unseen-rank table provides for each potential symbol never encountered previously, the symbol's rank among all the unseen symbols. It is more efficient to encode the rank of any new symbol encountered by the encoder 13, rather than to encode the symbol itself. The rank-unseen table assigns an unseen but potential symbol to each rank up to the number of unseen symbols. The rank-unseen table is the inverse of the unseen-rank table utilized by the encoder 13.

The searchtree database is used by the short-record encoder 13 for encoding, as well as for parsing individual data records. The number of possible joint events (comma, innovation) is identical to the number of leaves in the tree (T.sub.K, B.sub.K). Thus, if the leaves are numbered consecutively by the integers from 0 to K(.vertline.B.sub.K .vertline.-1), then these numbers, denoted as leaf pointers, provide an efficient encoding of the parsed segment X.sub.k. An efficient binary encoding of the leaf pointer is then provided by the economy binary tree described in said U.S. Pat. No. 4,464,650 and described below. The decoding process utilizes the same searchtree built by the preprocessor 10. Given the (T.sub.K, B.sub.K), current encoded segment (Y.sub.k), can be decoded to identify v.sub.k. By tracing the backward path from v.sub.k to the root, in the manner described in said U.S. Pat. No. 4,464,650, the arc labels and associated symbols are obtained. Thus, the searchtree generated by the preprocessor 10 provides for parsing the input data, encoding the parsed segments, and decoding the compressed records.

The preferred embodiments of the invention described herein comprise software and hardware embodiments. The software embodiment comprises Fortran V programs for the file preprocessing, the short-record encoding and the short-record decoding. The Fortran V versions of the programs are provided in the Appendix hereto. It is appreciated, that other embodiments of the invention can be realized by, for example, microprogrammed or hardwired electronic devices such as those described herein with respect to the hardware embodiment. A discussion of the preprocessing, encoding and decoding programs now follows.

The file preprocessing program constructs the searchtree described above. The encoder and decoder programs utilize the searchtree, tracing paths through the tree to encode and decode segments of data. Forward (encoding) and backward (decoding) path tracing through the searchtree is described in detail in said U.S. Pat. No. 4,464,650 with respect to the incrementally growing searchtree (T.sub.k, B.sub.k). In the present invention, the detailed operations described in said U.S. Pat. No. 4,464,650 are considered with respect to the fixed searchtree (T.sub.k, B.sub.k) constructed by the file preprocessor 10. Node labels are stored in the label table (array F) built by the preprocessor 10 either directly or by hashing, as described in said U.S. Pat. No. 4,464,650. Virtual addresses of father nodes are obtained from an array G (address table) which is the inverse of F and also constructed by the preprocessor 10.

Said U.S. Pat. No. 4,464,650 describes utilizing a label table in backward path tracing. Although this approach can be utilized in the present invention, a last-descendant list technique is described. Initially, before the backward trace is started, the last-descendant list is consulted to determine how many (if any) repetitions of the initial symbol x.sub.1 to append to the decoded string.

The preprocessor 10 also constructs the symbol-position table and the position-symbol table, which are inverses of each other, in the manner described in said U.S. Pat. No. 4,464,650 and maintains the unseen-symbol rank table, updating the table each time the preprocessor 10 encounters a new symbol. This table is subsequently inverted by the encoder 13 to provide the decoder with the rank-unseen table. Both tables are required if re-encoding of records is performed.

The encoding and decoding of the leaf pointers are described in detail in said U.S. Pat. No. 4,464,650, at column 16, line 29 through column 18, line 64. It is appreciated, however, that the present invention utilizes the fixed searchtree (T.sub.K, B.sub.K) rather than the incrementally growing searchtree (T.sub.k, B.sub.k) described in said U.S. Pat. No. 4,464,650. Thus, although all references to the encoded output segment Y.sub.k and the symbols X.sub.k are applicable herein, all other references in the denoted section of said U.S. Pat. No. 4,464,650 to "k" are utilized herein as "K" so as to refer to the fixed searchtree. It is also appreciated that the threshold TB is provided herein by the preprocessor 10 in a manner to be described. Additionally, the last-descendant list is utilized to complete the leaf pointer decoding translation, rather than a forward tree label table as described in said U.S. Pat. No. 4,464,650. To complete the decoding translation of the leaf pointer, the last-descendant list is referenced to determine whether the virtual address referred to in column 18, line 26 of said U.S. Pat. No. 4,464,650 is the address of a leaf or an internal node. If the address is that of a leaf, the backward decoding trace begins therefrom. If the virtual address is that of an internal node, the decoded segment begins with a string of XL symbols all equal to x.sub.1, where XL is the extension length returned from the last-descendant list. The backward decoding trace then begins from the internal node whose address is the referred to virtual address.

The encoding and decoding of new symbols are performed herein in the manner described in said U.S. Pat. No. 4,464,650 (see column 19, line 33 through column 21, line 5, and elsewhere), except that the thresholds TA and TB are provided by the preprocessor 10 and the unseen-rank and rank-unseen tables stored as the list DR are maintained by the preprocessor 10.

The software embodiment of the invention will now be described with reference to the flow charts of FIGS. 2-4 and the Fortran V program appended hereto. With respect to FIGS. 2-4, the program flow is designated by the YES and NO arrows denoted by the legends. The line numbers referred to below, refer to the lines of code referenced to the section of the software being discussed. It is appreciated, that present day computer systems with which the invention may be utilized usually provide appropriate subroutines in their software libraries suitable for calling by the appended programs. Comments are provided with the appended preprocessor, encoder and decoder programs to explain the functions thereof.

Referring to FIG. 2 and the associated file preprocessor program in the appendix, the program for the file preprocessor is divided into seven sections: initialization, last-descendant list update, symbol-table update, searchtree update, input testing, path tracing, and termination.

The initialization section of the program defines initial values for a number of program variables, sets up the unseen-rank table DR, and partitions the available storage for the searchtree between direct and hashed parts. Initialization is concluded by a jump to section 4 to define the initial two-node searchtree.

Section 2 completes the updating of the last-descendant list. The length of the extension to the last descendant is stored in an array GE at line 16. To conclude the second section a jump is made to section 3 or section 4 according as the last symbol processed is or is not a new symbol.

Section 3 updates the symbol tables. The unseen-rank table DR is updated by the DO loop at lines 2-3 The count of unseen symbols is decremented at the fourth line, and, if any remain, a new green leaf is created for every internal node of the searchtree.

Section 4 of the program performs the updating of the incrementally growing searchtree. The count K of internal nodes is incremented and the internal node label K is stored at the appropriate address in the array F. The count H of green leaves is augmented by BSYM, the number of symbols B , and if necessary, the value of (H), called B in the program, is corrected. The definition of (H) is given in said U.S. Pat. No. 4,464,650 as the least integer not less than log.sub.2 H. At the last line of the section, a jump is made to the termination section 7 if the storage allotted for the searchtree has been completely filled.

In section 5 the virtual address C of the current node is reset to 1, the leaves-only pointer value D is reset to zero, and the extension length XL is reset to 1 in preparation for the next search. A test is then made to determine whether additional input is needed and available. If not available, an exit is made to the program termination section 7. Otherwise, if input is needed, it is obtained from the source thereof.

Section 6 is the parsing procedure of said U.S. Pat. No. 4,464,650: Input symbols are traced along a forward path of the incrementally growing searchtree from the root to a leaf. Separate coding is executed in accordance with whether the current node C belongs to the direct or hashed portion of the tree. The next input symbol is first read and replaced by its arc position, given by the symbol-position table SYM. At line 24 the virtual address for the new son is calculated and replaces C. The extension length XL, which keeps track of the number of repetitions of the symbol x.sub.1, is incremented at line 25, but is reset to 1 at line 27 if the current symbol is not x.sub.1. The leaves-only pointer is updated at line 28 as D=C-E-1 unless the current symbol is x.sub.1. Next, the internal node label E for the node C is sought from the label table F. The tracing continues until no node label is returned from F for the node with address C. A leaf has now been reached, and an exit is made to section 2.

In the termination section 7 the searchtree database is stored in the electronic storage unit, and the program run is terminated.

Referring to FIG. 3 and the associated short-record encoder program in the Appendix, the program for the short-record encoder is divided into six sections: initialization, pointer encoding, symbol encoding, input testing, path tracing, and termination.

The initialization section of the program defines initial values for a number of program variables and obtains the symbol-position table SYM and the unseen-rank table DR from the electronic storage unit. In the lines following label 10, the searchtree pointer is reset to the root of the tree to begin processing of the next record to be compressed. This section is concluded by an unconditional jump to section 4.

Section 2 completes parts 2 and 3 of the encoding of the leaf pointer as described in said U.S. Pat. No. 4,464,650 and below with respect to the hardware embodiment. The second line of code in the section converts the leaves-only value of the pointer into the green-leaves value. The fifth line tests the pointer against the threshold and modifies the pointer when necessary. The encoded pointer is then stored (lines 6-18) in an output array Z which, when full, is emptied into the electronic storage unit. To conclude section 2 a jump is made to section 3 or section 4 according as the last symbol processed is or is not a new symbol.

Section 3 encodes the new symbol rank. At line 4 the rank is modified if the threshold is exceeded. Lines 5-17 are concerned with storing the encoded symbol in the output array Z.

At line 2 of section 4 the leaves-only pointer value D is reset to zero in preparation for the next search. Next, a test is made to determine whether additional input is needed and available. If not available, an exit is made to section 6. Otherwise, if input is needed, it is obtained from the source thereof and read into the input buffer array R. The virtual address C of the current node is reset to 1 to begin a new search from the root in section 5.

Section 5 is the short-record parsing procedure: input symbols are traced along a forward path of the searchtree from the root to a leaf. Separate coding is executed in accordance with whether the current node C belongs to the direct or hashed portion of the tree. The next input symbol is first read and replaced by its arc position, using the symbol-position table SYM (lines 9-22). At line 23 the virtual address for the new son is calculated and replaces C. The leaves-only pointer is updated at line 24 as D=C-E-1 unless the current symbol is x.sub.1. Next, the internal node label E for the node C is sought from the label table F. The tracing continues until no node label is returned from F for the node with address C. A leaf has now been reached, and an exit is made to section 2.

When section 6 is reached, processing of the current record has been completed. A pointer to the encoded record is stored in the array OP (lines 6-8), and a test is made at line 11 to determine whether there are more records to be compressed. If there remain records to compress, then a return is made to section 1 to reset the searchtree pointer to the root to begin processing of the next record. Otherwise, the array OP is stored as the encoded record directory, any remaining encoded output in the array Z is stored in the electronic storage unit, and the program run is terminated.

Referring to FIG. 4 and the associated short-record decoder program in the Appendix, the program for the short-record decoder is divided into eight sections: initialization, store decoded segment, fetch pointer, convert pointer to address, backward trace, fetch new symbol, store decoded symbol, and termination.

The initialization section is similar to that for the encoder, but also includes obtaining the position-symbol and rank-unseen tables, the searchtree, the encoded-record directory, and the encoded record. It is concluded by a jump to section 3.

At the start of section 2 the array L (Pushdown Stack) contains the symbols of the decoded segment X.sub.k, but in reverse order. In section 2 the order of the symbols is reversed, and X.sub.k is stored in the output buffer R. At the conclusion of the section a jump is made to the termination section 8 if the record has been completely decoded.

In section 3 the encoded pointer Y.sub.k is extracted from the input data stream and converted to its green-leaves value, as described in said U.S. Pat. No. 4,464,650 and below with respect to the hardware embodiment.

At line 1 of section 4 the green-leaves value of the pointer is replaced by the leaves-only value. At line 2 the leaves-only value is converted to the virtual address of a node of the searchtree. The extension length XL to the last descendant is obtained at line 18. If XL is not zero, then the decoded string L is started with XL repetitions of the initial symbol x.sub.1 (lines 22-26).

In section 5 one step is made along the backward path to the root. At line 6 the internal node label of the father of the current node C is derived, and at line 7, C is replaced by the virtual address of the father, obtained from the address table G. At line the position of the arc from son to father is obtained. Section 5 is completed by a jump to section 7 if the position-symbol table SYM returns a nonzero value. Otherwise, section 6 is executed next to read the new symbol.

In section 6 a new symbol rank is extracted from the input compressed data stream. The encoded rank is decoded (lines 2-14), and the correct symbol is obtained by reference to the rank-unseen table DR (line 15).

In section 7 the symbol associated with the arc traversed in section 5 is stored in the Pushdown Stack L. Since the path to the root encounters the symbols of the segment X.sub.k in reverse order, the string of symbols formed in L must be reversed (in section 2) before they can be stored in the output buffer R. At the end of section 7 a test is made to determine whether the root has been reached. If it has, then a jump is made back to section 2 to reverse and store the decoded segment; if not, then a return is made to section 5 of the program to traverse the next arc in the backward path and obtain the next (earlier) symbol of X.sub.k.

In the termination section 8 the decoded record is printed, and the program is terminated.

The encoded-record directory built by the encoder contains the starting location for each compressed record in the compressed file. The encoded record directory is consulted whenever retrieval and decompression of an individual record from the compressed file is desired. The length of the compressed version, if required, is obtained by additionally using the directory to yield the start position of the ensuing record. This procedure for obtaining the length may require modification if the system alters and recompresses retrieved records since the recompressed record may require more space than the original and thus require repositioning elsewhere in the compressed file. In this situation, if the length of the compressed version is desired, it may be necessary to store end points as well as start locations for each record.

It is often the case that the records comprising the original input file are all of fixed known length. In this situation it will not be necessary to include the end points in the directory, since the decoder knows in advance when to stop decoding, even if it does not know in advance where the encoded record ends. In the herein described software embodiment of the invention, the directory contains the start location for each encoded record. The directory itself is stored in a disk file which is loaded into memory at the start of execution of the decoder program. The decoder program obtains the start locations for both the record to be decoded and its successor in the compressed file. Thus, the decoder can calculate the length of the compressed input to be decoded. In the fixed length input case the decoder further knows the length of the output in advance, and therefore can halt processing either when the decoder input is exhausted or when it has decoded an entire record.

The hardware embodiment of the invention is now described with reference to FIGS. 5, 5a-5d, 6, 6a-6d, 7 and 7a-7f. The functions performed by the preprocessing, encoding and decoding programs described above are now performed by electronic subsystems denoted as the File Preprocessor, the Short-Record Encoder and the Short-Record Decoder. The components of these subsystems are illustrated in the drawings and described hereinbelow. In these drawings, solid lines denote data paths while dashed lines represent control signal paths. With respect to the labeled blocks of the drawings described below, additional descriptive material is found in said U.S. Pat. No. 4,464,650 with respect to identically labeled blocks of the drawings thereof.

Referring to FIGS. 5 and 5a-5d, the basic components of the File Preprocessor are an Input Buffer 42, a Searchtree Database 40, an Address Generator 45, and a Threshold Calculator 48. An overview of the Preprocessor organization is illustrated in FIG. 5, with three of the four components shown in greater detail in FIGS. 5a-5d. The Input Buffer 42 consists of storage elements which hold a portion of the input data stream which is currently undergoing processing. It supplies the current input symbol to the Searchtree Database 40 via a lead 43 when called for by an enable pulse transmitted on a lead 44.

The Searchtree Database 40 is used by the Preprocessor to parse the input data. Subsequently, the database values obtained by the Preprocessor will be used by the Encoder for parsing and encoding data and by the Decoder for decoding compressed data. Therefore, the Searchtree Database 40 (FIG. 5a) contains collections of storage elements capable of storing the three tables required by the Preprocessor to parse and by the Encoder to parse and encode the input data: the label table 57, the symbol-position table 52, and the unseen-rank table 62 described above and in said U.S. Pat. No. 4,464,650; storage elements capable of storing the four tables required by the Decoder to decode: the address table 58, the last-descendant table 72, the position-symbol table 61, and the rank-unseen table 63; four comparators: the label comparator 51, the position comparator 56, the KM comparator 64, and the first-position comparator 67; four simple counters: the position counter 60, the symbol counter 59, the node counter 54, and the extension-length counter 66; one complex counter: the pointer counter 55; and several gates (53,65,68,69). The storage elements comprising the label table 57 are capable of being accessed under control of an address supplied on a lead 41 by the Address Generator 45 so as to return a successor label. The resulting sequences of labels can be viewed as paths through the tree which serve to record all segments previously encountered during the encoding. The last element in such a sequence is distinguished as a leaf when the label zero is returned by the label table for the current address The label table initially contains a 1 in the label column for address 1 (the root), and zeros for all other addresses. The tree is updated by storing the next available label at the current address, in effect creating .vertline.B.sub.k .vertline. new leaves, one for each symbol which has been seen, and one for the alpha branch to represent all unseen symbols.

The storage elements comprising the address table 58 are potentially capable of being addressed under control of a label so as to return a new address. The resulting sequences of addresses can be viewed as backward paths through the tree which serve to record the decoded segments in reverse order. The last element in such a sequence is distinguished as the root when the address one is returned by the address table for the current label. The address table is not actually used by the File Preprocessor, but, along with the last-descendant table 72, the position-symbol table 61, and the rank-unseen table 63, is constructed, or loaded, by the File Preprocessor for later use by the Decoder. The address table initially contains a 1 in the address column for the label 1 (the root), and zeros for all other labels. At the end of each parsing cycle, the tree is updated by storing the virtual address of the leaf where forward tracing ends at the next available slot in the address table. This is the slot K at the cycle where internal node K is created.

The sequence of events occurring during a single parsing cycle, as viewed by the Searchtree Database 40, is as follows. At the start of a cycle the address 1 is applied to the label table 57, which, upon receiving an address, sends the corresponding node label to the label comparator 51. The label comparator 51 compares the label with zero. Whenever the label is not zero, it is passed on via lead 47 to the Address Generator 45 (FIG. 5c). At the same time, an enable pulse is sent along lead 44 to the Input Buffer 42, which then releases the next input symbol. The new input symbol is applied to the symbol-position table 52, which sends the position assigned to the symbol on to the position comparator 56, where it is compared with zero. If not zero, the position is sent along via the or-gate 69 and lead 46 to the Address Generator 45, which, when it has received both a new label and a new position from the Database, generates a new address which is returned to the label table 57 via lead 41 to continue the cycle.

Whenever the new symbol position is zero, however, the position comparator 56 generates an enable signal which is sent via lead 76 to the position counter 60, the symbol counter 59, the pointer counter 55, the gate 68, which passes the new position NSYM obtained from the position counter 60 along to the Address Generator 45 via the or-gate 69 and the lead 46, and to the gate 53 preceding the unseen-rank table 62. The enable pulse sent to the gate 53 allows the input symbol on lead 43 to be applied via lead 74 to the unseen-rank table 62 as well as to the rank-unseen table 63 and to the position-symbol table 61. The unseen-rank table 62 initially contains the ranks 1 to .vertline.A.vertline. in the slots opposite to the symbols 0 to .vertline.A.vertline.-1, respectively, while the rank-unseen table 63, its inverse, initially contains the symbols 0 to .vertline.A.vertline.-1 in the slots opposite to the ranks 1 to .vertline.A.vertline., respectively. The unseen-rank and rank-unseen tables are updated by removing the, new symbol, in effect, decrementing the rank of each symbol appearing later in the tables. The position-symbol table 61 initially contains zeros in the slots opposite to the positions 1 to .vertline.A.vertline., while the symbol-position table initially contains zeros in the slots opposite to the symbols 0 to .vertline.A.vertline.-1. The position-symbol table 61 is updated by storing the new input symbol on lead 74 in the slot opposite to the position NSYM obtained from the position counter 60. The symbol-position table 52 is also updated at this time by storing the position NSYM obtained from the position counter 60 in the slot opposite to the new symbol which has just been obtained from the Input Buffer 42 on lead 43. Following this update, the position counter contents are decremented. If the contents are reduced to 1, the inhibit lead 75 is activated, preventing further incrementation of the symbol counter 59 and also inhibiting further increases in the pointer count by the node count K, as discussed below.

The symbol counter 59 counts BSYM, the number of distinct input symbols which have been seen. Each time it receives an enable pulse on lead 76 from the position comparator 56 it increments the count, unless the inhibit lead 75 is active. The count BSYM is sent via lead 79 to the pointer counter 55, where it is used to augment the pointer count H each time a new internal node is created. When all but one symbol have been seen, however, the alpha branch is no longer needed, so that the count should be augmented by BSYM-1 rather than BSYM. For this reason, the final incrementation of BSYM is inhibited by activation of the lead 75 whenever the position counter 60 contains the count one.

The position counter 60 is initially loaded with the alphabet size .vertline.A.vertline.. It keeps track at all times of NSYM, the number of potential, but as yet unseen, symbols. Whenever it receives an enable pulse on lead 76 from the position comparator 56, it sends the current count NSYM along the lead 78 to the symbol-position table 52 to be stored in the slot opposite to the new input symbol, and to the position-symbol table 61, which is updated by storing the new symbol in the slot opposite to the count NSYM. The count NSYM is also sent via lead 78 to the gate 68, which, when activated by a pulse on lead 76 from the position comparator 56, passes the new symbol position NSYM to the or-gate 69. The count NSYM is then decremented. When, however, the count reaches one, an inhibit pulse is sent on the lead 75 to the symbol counter 59, as discussed above, and to the pointer counter 55, as will be discussed below. At the end of the preprocessing run an enable pulse on lead 77 from the KM comparator 64 causes the final NSYM count to be released on lead 49 by the position counter 60 for use by the Threshold Calculator 48 (FIG. 5d) in calculating the rank threshold TA for the Encoder and Decoder in a manner to be discussed below.

The or-gate 69 receives either the nonzero position from the position comparator 56 or the new position NSYM from the position counter 60 via lead 78 and gate 68, and passes it on as the current position to the Address Generator 45 and a first-position comparator 67, using the lead 46. The first-position comparator 67 compares the position received on lead 46 with the first position, namely, the alphabet size .vertline.A.vertline.. If the two positions agree, an enable pulse is sent via lead 80 to the extension-length counter 66, causing incrementation of its contents, the extension length XL. If, however, the two positions disagree, then a reset pulse is sent via lead 81 to the extension-length counter 66, causing its contents XL to be reset to 1. The contents XL of the extension-length counter 66 are passed to a gate 65, which is enabled by a pulse on lead 73 from the label comparator 51 whenever a leaf is attained. The extension length XL is then passed through the gate 65 to the last-descendant table 72, which is updated by storing the length XL in the slot opposite to the current address, obtained on lead 41 from the Address Generator 45. Upon completion of the update, the table 72 sends a reset signal to the extension-length counter 66, causing its contents XL to be reset to 1. Initially, the last-descendant table 72 contains zeros for all addresses. Note that the address received on lead 41 may be a hashed address.

When the new node label obtained from the label table 57 is zero, a leaf has been reached. The label comparator 51 sends an enable signal on the lead 73 to the node counter 54, the pointer counter 55, and the gate 65. The pointer counter 55 is discussed below. The enable pulse sent to the gate 65 allows the updating of the last-descendant table 72 by permitting the extension length XL to pass from the extension-length counter 66. Upon receipt of the enable pulse on lead 73 the node counter 54 sends the node count K via the lead 70 to the pointer counter 55, to the label table 57 where it is stored in the slot opposite to the current address, to the address table 58 which is updated by storing the virtual address returned by the Address Generator 45 in the slot of the table opposite to the node count K, and to the KM comparator 64. If the count K equals the maximum tree size KM, the comparator 64 sends an inhibit pulse on lead 71 to the Input Buffer 42 to stop all further processing of input, and an enable pulse on lead 77 to the position counter 60, the pointer counter 55, and the Threshold Calculator 48 to initiate calculation of the rank and pointer thresholds. After sending out the node count K on lead 70, the node counter is incremented, and a reset signal is sent to the label table 57 to initiate the next parsing cycle.

The pointer counter 55 (FIG. 5b) is a more complex arithmetic circuit than the other four counters. It consists of an accumulator 87, two input gates 85 and 86, and an output gate 90. It receives the node count K on lead 70 from the node counter 54 and the symbol count BSYM on lead 79 from the symbol counter 59 and computes the pointer count H, the number of green-leaves in the tree. Whenever a new node is defined, an enable pulse sent on lead 73 to gate 86 by the label comparator 51 causes the count to be increased by BSYM, or by BSYM-1 if all potential symbols have been seen. Whenever a new symbol is encountered, an enable pulse sent on lead 76 to gate 85 by the position comparator 56 causes the pointer count to be increased by the node count K. However, this increase does not occur if all .vertline.A.vertline. potential symbols have been seen. This is prevented by an inhibit pulse sent on lead 75 to gate 85 by the position counter 60 whenever it contains the count one. The same inhibit pulse inhibits incrementation of the symbol counter 59, which as a result will not count beyond .vertline.A.vertline.-1. The pointer count H is not used by the File Preprocessor until the end of the preprocessing run. At this time an enable pulse on lead 77 to the gate 90 from the KM comparator 64 causes the final pointer count H to be released on lead 50 to the Threshold Calculator 48 for use in the calculation of the pointer threshold TB.

The Address Generator 45 (FIG. 5c) contains a shift-and-add address calculator 83, an address comparator 84, an or-gate 88, and a standard hashing circuit 89. It receives the current input symbol position p on the lead 46 from the or-gate 69 of the Searchtree Database 40 and the current node label i on the lead 47 from the label comparator 51 of the Searchtree Database. It calculates a new virtual address for the next node to be visited, using the formula

with the multiplication by .vertline.A.vertline. accomplished by shifting the label i to the left by M places, where M is the symbol size in bits. This virtual address is returned via lead 82 to the address table 58, where it is stored in the slot opposite to the node count K, thus updating the backward tree for the Decoder. It is also sent to the address comparator 84, where it is compared with the limit established for the size of direct storage in the label table. If greater than the limit, then the address is sent on to the hashing circuit 89 to be hashed; otherwise it is sent directly without change to the or-gate 88. The resulting calculated address, hashed or unhashed as the case may be, is selected by the or-gate 88 and returned via lead 41 to the label table 57 of the Searchtree Database for the next label-table lookup and to the last-descendant table 72.

The Threshold Calculator 48 (FIG. 5d) is activated only at the end of a preprocessing run, after the KM comparator 64 has found equality. At this time, the comparator 64 sends an inhibit pulse on the lead 71 to the Input Buffer 42 to stop further processing of input data, and an enable pulse on lead 77 to the position counter 60, the pointer counter 55, and the Threshold Calculator 48. The Threshold Calculator 48 consists of two identical parts, one which calculates the rank threshold TA, and one which calculates the pointer threshold TB. Each part consists of a storage register 141 (142) for the initial value 1 of the parameter KA (KB), a comparator 143 (144), a doubler 147 (148), and an adder 145 (146). The rank threshold calculator will now be described, the operation of the pointer threshold calculator being essentially the same.

The rank threshold calculator is activated by the enable pulse on lead 77 from the KM comparator 64, causing the initial value 1 for KA to be fed to the comparator 143. The comparator 143 compares the current value of KA with the value of NSYM on the lead 49 from the position counter 60 of the Searchtree Database 40. If NSYM exceeds KA, then KA is passed to the doubler 147, which doubles its value by shifting one place to the left. The doubled value is returned to the comparator 143 on the lead 149 to continue the cycle. When NSYM no longer exceeds the value of KA, KA is passed to the adder 145, which calculates the rank threshold TA by the formula TA=2*NSYM-KA. The value TA obtained for the rank threshold is saved for future use by the Encoder and Decoder.

In addition to the four basic components shown in FIG. 5, the File Preprocessor also contains a Clock, connected to all components, and Sequence Control Units, which control the sequencing of operations by the components. These are not shown in FIG. 5.

Referring to FIGS. 6 and 6a-6d, the basic components of the Short-Record Encoder are an Input Buffer 92, a Searchtree Database 91, an Address Generator 95, a Pointer Generator 96, an Economy Encoder 100, and an Output Buffer 105. An overview of the Encoder organization is illustrated in FIG. 6, with four of the six components shown inn greater detail in FIGS. 6a-6d. The input records to be compressed are processed one at a time by the Encoder. The Input Buffer 92 consists of storage elements which hold the input record which is currently undergoing processing. It supplies the current input symbol on a lead 93 to the searchtree Database 91 when called for by an enable pulse from the Database sent on a lead 94. The Output Buffer 105 consists of storage elements which receive and store temporarily, until completion of compression of the current input record, the encoded outputs sent by the Economy Encoder 100 via a lead 104. When the entire record has been processed, the Output Buffer stores the compressed version of the record in the Electronic Storage Unit (FIG. 1) and stores the start location for the next record to be compressed in the Encoded-Record Directory.

The Searchtree Database 91 (FIG. 6a) contains collections of storage elements capable of storing the three tables required by the Encoder to parse and encode the input data: the label table 110, the symbol-position table 112, and the unseen-rank table 114. These tables are loaded with the values obtained for the corresponding tables of the File Preprocessor during the preprocessing run. These values are never changed during processing by the Encoder. The Searchtree Database also contains three comparators: the label comparator 111, the position comparator 116, and the first-position comparator 119; three gates 107, 108, and 115; and a register 120 to hold NSYM, the count of unseen symbols. The value of NSYM is obtained from the position counter 60 of the File Preprocessor after the preprocessing run and is never changed by the Encoder. NSYM is passed by the gate 108 to the or-gate 107 for use as the symbol position whenever an unseen symbol is encountered in the input data. NSYM is also transmitted on the lead 113 to the green-leaves converter 128 of the Pointer Generator 96 (FIG. 6c).

The sequence of events occurring during a single parsing and encoding cycle, as viewed by the Searchtree Database 91, is as follows. At the start of a cycle the address 1 is applied to the label table 110, which, upon receiving an address, sends the corresponding node label to the label comparator 111. The label comparator 111 compares the label with zero. Whenever the label is not zero, it is passed on via lead 98 to the Address Generator 95 (FIG. 6b). At the same time, an enable pulse is sent along lead 94 to the Input Buffer 92, which then releases the next input symbol. The new input symbol, as in the case of the File Preprocessor, is applied via lead 93 to the gate 115 and to the symbol-position table 112, which sends the position assigned to the symbol on to the position comparator 16, where it is compared with zero. If not zero, the position is sent along via the or-gate 107 and lead 99 to the first-position comparator 119 and to the Address Generator 95, which, when it has received both a new label and a new position from the Database, generates a new address which is returned via lead 97 to the label table to continue the cycle. The first-position comparator 119 compares the position with the initial position, the alphabet size .vertline.A.vertline.. If the two positions agree (that is, the current input symbol is the initial input symbol x.sub.1 seen by the File Preprocessor), then the pointer should not be updated, and the comparator 119 sends an inhibit pulse on the lead 117 to the Pointer Generator (FIG. 6c) to prevent the update. Whenever the new symbol position is zero, the position comparator 116 generates an enable signal which is sent via lead 118 to the NSYM register 120 and to the gates 115 and 108. Upon receipt of the enable pulse, the NSYM register 120 releases the NSYM value to the gate 108, which passes it through the or-gate 107. The or-gate 107 sends it on to the Address Generator 95 via lead 99 as the current symbol position, and to the first-position comparator 119. The enable signal on lead 118 also activates the gate 115, which allows the input symbol on lead 93 to be applied to the unseen-rank table 114. This table then sends the rank of the new symbol on to the Economy Encoder 100 (FIG. 6d) via the lead 102. Gate 115 does not operate, however, until there is also an enable pulse on the lead 106 from the Output Buffer 105, indicating that the last encoded pointer has been received and stored. This prevents the transmission of the rank by the unseen-rank table 114 until the Economy Encoder 100 is ready to receive it. Each time that a symbol which had not been seen by the Preprocessor is encountered it must be encoded and included in the encoded output for the record. There is no updating of either the symbol-position table or the unseen-rank table.

When the new node label obtained from the label table 110 is zero, a leaf has been reached. The label comparator 111 then sends an enable signal on lead 103 to the Pointer Generator 96. The parsing-encoding cycle is completed when the label table 110 receives an acknowledge signal from the Output Buffer 105 on the lead 106. The address 1 is then applied to the table to initiate a new cycle. The acknowledge signal on lead 106 also opens the gate 115 if there is an active enable signal on lead 118, allowing encoding of the new symbol rank to take place.

The Address Generator 95 (FIG. 6b) contains a shift-and-add address calculator 121, an address comparator 122, an or-gate 123, and a standard hashing circuit 124, identical to the circuit 89 of FIG. 5c. The Address Generator 95 differs only slightly from its counterpart in the File Preprocessor (FIG. 5c). As before, it receives the current input symbol position p on the lead 99 from the or-gate 107 of the Searchtree Database 91 and the current node label i on the lead 98 from the label comparator 111 of the Searchtree Database. It calculates a new virtual address for the next node to be visited, using the formula

with the multiplication by .vertline.A.vertline. accomplished by shifting the label i to the left by M places, where M is the symbol size in bits. The calculated virtual address is sent on lead 109 to the Pointer Generator 96 for use in updating the leaves-only pointer and to the address comparator 122, where it is compared with the limit established for the size of direct storage in the label table. If greater than the limit, then the address is sent on to the hashing circuit 124 to be hashed; otherwise it is sent unaltered directly to the or-gate 123. The resulting calculated address, hashed or unhashed as the case may be, is then returned by the or-gate 123 to the label table 110 of the Searchtree Database 91 via the lead 97 for the next label-table lookup.

The Pointer Generator 96 (FIG. 6c) is comprised of two arithmetic circuits: a leaves-only converter 126, a green-leaves converter 128, and a gate 127. The green-leaves converter 126 receives the node label E of the father from the label comparator 111 of the Searchtree Database 91 on the lead 98, and the virtual address C of the son on the lead 109 from the address calculator 121 of the Address Generator 95. It converts the address into the leaves-only value of the pointer by the formula

where D is the leaves-only pointer. This conversion does not take place, however, if there is an inhibit pulse on the lead 117 from the first-position comparator 119. As discussed above, the comparator 119 sends an inhibit pulse whenever the current symbol position equals the first position .vertline.A.vertline.. Upon receipt of an enable pulse on the lead 103 from the label comparator 111 of the Searchtree Database 91, the gate 127 passes the leaves-only pointer D on to the green-leaves converter 128, which transforms it into the green-leaves pointer D.sub.g by carrying out the calculation

where all arithmetic is integer, and NSYM, the number of unseen symbols, is obtained from the NSYM register 120 of the Searchtree Database 91 via the lead 113. The green-leaves value D.sub.g is then transmitted to the Economy Encoder 100 via the lead 101.

The Economy Encoder (FIG. 6d) is a mechanized version of the economy binary tree. It is used to calculate the Economy Code for the parsed input segment (new symbol rank). It consists of two threshold registers 130 and 135, two threshold comparators 131 and 136, two output converters 132 and 137, three gates 133, 134, and 138, and a delay 139. The rank threshold register 135 is loaded initially with the rank threshold TA computed by the adder 145 of the Threshold Calculator 48 (FIG. 5d) of the File Preprocessor at the end of the preprocessing run. The pointer threshold register 130 is loaded initially with the pointer threshold TB computed by the adder 146 of the Threshold Calculator 48 (FIG. 5d) of the File Preprocessor at the end of the preprocessing run. The rank threshold comparator 136 receives the threshold TA from the rank threshold register 135 and the symbol rank R on the lead 102 from the unseen rank table 114. The two inputs are compared, and if the threshold TA is not the smaller, the unchanged rank R is sent to the or-gate 138 as the Economy Code for the new symbol rank. If the rank R exceeds the threshold TA, then R is first sent to the rank output converter 137, where it is changed to (2R-TA)/2 by shift-and-add circuitry. The output from the converter 137 is then sent to the or-gate 138 as the Economy Code for the new symbol rank.

The pointer threshold comparator 131 receives the threshold TB from the pointer threshold register 130 and the green-leaves pointer D.sub.g on the lead 101 from the green-leaves converter 128 of the Pointer Generator 96 (FIG. 6c). The two inputs are compared, and if the threshold TB is not the smaller, the unchanged pointer D.sub.g is sent to the or-gate 133 as the Economy Code for the green-leaves pointer D.sub.g. If the green-leaves pointer D.sub.g exceeds the threshold TB, then D.sub.g is first sent to the pointer output converter 132, where it is changed to (2D.sub.g -TB)/2 by shift-and-add circuitry. The output from the converter 132 is then sent to the or-gate 133 as the Economy Code for the green-leaves pointer. The or-gates 133 and 138 transmit the selected Economy Codes to the Output Buffer 105 via the gate 134 and the lead 104. The delay 139 delays the encoded symbol rank until after the transmittal of the encoded pointer. The Output Buffer 105 completes the parsing-encoding cycle by sending a reset signal on lead 106 to the Searchtree Database 91 after receiving the Economy Code or Codes.

In addition to the six basic components shown in FIG. 6, the Short-Record Encoder also contains a Clock, connected to all components, and Sequence Control Units, which control the sequencing of operations by the components. These are not shown in FIG. 6.

Referring to FIGS. 7 and 7a-7f, the basic components of the Short-Record Decoder are an Input Buffer 156, a Searchtree Database 150, and an Output Buffer 154, similar to their counterparts in the Short-Record Encoder, plus an Economy Decoder 158, a Label Generator 165, a Position Extractor 166, and a Pushdown Stack 151. An overview of the Decoder organization is illustrated in FIG. 7, with five of the seven components shown in greater detail in FIGS. 7a-7f. The Decoder inverts the compressed code by means of a retrieval tree constructed by the File Preprocessor and identical to that used by the Encoder.

The Input Buffer 156 is comprised of storage elements which hold the compressed data record which is currently undergoing processing. The Input Buffer 156 supplies the current encoded symbol rank on the lead 162 to the Economy Decoder 158 when called for by an enable pulse from the Searchtree Database 150 sent on a lead 160. The Input Buffer 156 supplies the current encoded pointer on a lead 159 to the Economy Decoder 158 whenever it receives an acknowledge signal on a lead 157 from the Pushdown Stack 151. Processing of a record is initiated by a request from outside, and the Encoded-Record Directory is consulted for a given record, say J. The Encoded-Record Directory supplies the starting location at which the encoded version of record J is to be found in storage. The encoded record J is then read from the Electronic Storage Unit 12 (FIG. 1) into the Input Buffer 156, and decompression of the record can commence.

The Economy Decoder 158 is comprised of two parts: the rank decoder (FIG. 7a) and the pointer decoder (FIG. 7b). The rank decoder is comprised of a rank threshold register 180, loaded initially with the value TA computed by the Threshold Calculator 48 of the File Preprocessor at the end of the preprocessing run, a rank threshold comparator 181, a rank code converter 182, and two gates 183 and 184. When the Input Buffer 156 receives a symbol request pulse on the lead 160 from the symbol comparator 188 of the Searchtree Database 150 (FIG. 7c), it sends the economy code R for the new symbol rank to the rank threshold comparator 181 on the lead 162. The comparator 181 compares the rank R with the threshold TA obtained from the rank threshold register 180. If the rank does not exceed the threshold, it is passed directly without change to the or-gate 183; if, however, the rank R exceeds the threshold TA, it is passed to the rank code converter 182, where it is converted by the integer equation

and then on to the Or-gate 183. Additionally, if R>TA the comparator 181 sends a signal via lead 181' to the Input Buffer 156 to inform the Input Buffer 156 where the encoded rank ended (i.e. to move back 1 bit). The or-gate 183 passes the appropriate R value on to the rank-unseen table 185 of the Searchtree Database 150 (FIG. 7c) via the gate 184, which is only open when an enable pulse is active on lead 160 from the symbol comparator 188 of the Searchtree Database 150, and via the lead 163.

The pointer decoder (FIG. 7b) is comprised of a pointer threshold register 190, loaded initially with the pointer threshold TB computed by the Threshold Calculator 48 of the File Preprocessor at the end of the preprocessing run, a pointer threshold comparator 191, a pointer code converter 192, a pointer comparator 195, a leaves-only converter 198, an address converter 196, two registers 173 and 174, and three gates 193, 194, and 197. The threshold comparator 191 receives the pointer threshold TB from the threshold register 190 and the Economy Code Y.sub.k from the Input Buffer 156 on the lead 159. If the Economy Code Y.sub.k exceeds the threshold TB, it is sent to the pointer code converter 192 to be transformed into the green-leaves pointer D.sub.g by the integer equation

and passed to the or-gate 193. Additionally, if Y.sub.k >TB, the comparator 191 sends a signal via lead 191' to the Input Buffer 156 to inform the Input Buffer 156 to move the pointer back 1 bit. If the threshold is not exceeded, then the Economy Code Y.sub.k is passed directly without alteration to the or-gate 193 as the green-leaves pointer. The green-leaves pointer is passed by the or-gate 193 to the pointer comparator 195 by way of the gate 194, which is normally open, but is closed if there is an active enable pulse (symbol request) on the lead 160 from the symbol comparator 188. The pointer comparator 195 compares the pointer with zero: if zero, it is passed directly to the or-gate 197 as the leaves-only pointer D; if not zero, it must first go to the leaves-only converter 198 to be converted to the leaves-only pointer D by the integer equation

where CSYM and BSYM are obtained from the CSYM register 173 and the BSYM register 174, respectively. The CSYM register 173 is loaded initially with the value CSYM, which is taken to be NSYM-1 if NSYM>0, and 0 otherwise. NSYM is provided by the contents of the position counter 60 (FIG. 5a) at the end of the preprocessing run. The BSYM register 174 is loaded with BSYM, the contents of the symbol counter 59 (FIG. 5a) at the end of the preprocessing run. Finally, the leaves-only pointer D is converted into a virtual address by the address converter 196, which implements the integer equation

This computed virtual address is then sent back via lead 161 to the gate 176 and to the limit comparator 125 of the Searchtree Database 150 (FIG. 7c).

The Searchtree Database 150 is comprised of collections of storage elements capable of storing the four tables required by the Decoder: the address table 178, the last-descendant table 186, the position-symbol table 187, and the rank-unseen table 185 described above; three comparators: the address comparator 189, the symbol comparator 188, and the limit comparator 125; a standard hashing circuit 129, identical to the circuit 89 of the Address Generator 45 of the File Preprocessor (FIG. 5c); and four gates 171, 172, 176, and 179. The four tables are loaded initially with the values obtained by the File Preprocessor during the preprocessing run. These values are never changed or updated by the Decoder. The storage elements comprising the address table 178 are capable of being accessed under control of a label supplied by the Label Generator 165 so as to return a new address. The resulting sequences of addresses can be viewed as backward paths through the tree which serve to record the decoded segments in reverse order. The last element in such a sequence is distinguished as the root when the address one is returned by the address table 178 for the current label.

The address which is sent back to the Searchtree Database by the Economy Decoder 158 may be the address, not of a leaf, but of an internal node, since in computing leaves-only values, the pointer value of the father is passed on to its x.sub.1 -son, where x.sub.1 is the first symbol encountered by the File Preprocessor during the preprocessing run. Before beginning the traceback, the Decoder determines whether this address is the address of a leaf or an internal node. The Decoder employs the last-descendant table 186 of the Searchtree Database for this purpose The virtual address returned by the pointer decoder on the lead 161 is tested by the limit comparator 125 against the limit established for the size of direct storage. If greater than the limit, then the address is sent on to the hashing circuit 129 to be hashed; otherwise it is sent directly without change to the or-gate 171. The resulting calculated address, hashed or unhashed as the case may be, is selected by the or-gate 171 and applied to the last-descendant table 186. The decoded segment begins with a string of XL symbols, all equal to x.sub.1, where XL is the extension length returned by the last-descendant table 186 in response to the applied address. These XL repetitions of x.sub.1 are applied to the Pushdown Stack 151 (FIG. 7f), in a manner to be discussed below. When this has been completed, the Pushdown Stack returns an enable pulse on the lead 177 which opens the gate 176, allowing the virtual address on lead 161 from the address converter 196 of the pointer decoder to be passed, via the or-gate 179 and lead 167, to the Label Generator 165 (FIG. 7d). The backward decoding trace is then ready to commence.

At each cycle of the backward trace, the current node label is supplied on lead 168 to the address table 178, which returns the virtual address of the node. This address is sent to the address comparator 189, where it is compared with one. If not equal to one, the new address is sent via the or-gate 179 and lead 167 to the Position Extractor 166, which then computes the position of the arc being traversed. The new address on lead 167 is also sent to the Label Generator 165, which then computes the label of the father to be visited next. This label is sent on lead 168 both to the Position Extractor 166 and back to the address table 178 to continue the traceback. When the address comparator 189 finally receives the address one, the root of the tree has been reached, and the traceback ends. The comparator 189 then sends an enable pulse on lead 153 to the Pushdown Stack 151 (FIG. 7f), which can then send its contents on to the Output Buffer 154.

The Label Generator 165 (FIG. 7d) is a shift-and-add circuit which computes the label of the father node from the virtual address of the son. It receives the address C from the address table 178 via the address comparator 189, the or-gate 179, and lead 167 of the Searchtree Database and returns the label C1 of the father to the address table 178 and to the Position Extractor 166 via the lead 168. (The first address in each decoding cycle comes directly from the address converter 196 of the Economy Decoder 158 via lead 161 and the gates 176 and 179 of the Searchtree Database, instead of from the address table.) The label is calculated by shift-and-add using the equation

where C1 is the label of the father, C is the address of the son, .vertline.A.vertline. is the alphabet size, and integer arithmetic is used.

The Position Extractor 166 (FIG. 7e) is a shift-and-add circuit that receives the node label C1 of the father on the lead 168 from the Label Generator 165 and the virtual address C of the son on the lead 167 from the address table 178 via the address comparator 189 and the or-gate 179 of the Searchtree Database. (Again, the first address in each decoding cycle comes directly from the Economy Decoder 158 via the gates 176 and 179 of the Searchtree Database, instead of from the address table.) It computes the position p of the arc joining the son to the father and returns this position via the lead 169 to the position-symbol table 187 of the Searchtree Database. The position p is calculated by shift-and-add, using the integer equation

The position p returned by the Position Extractor 166 is applied to the position-symbol table 187 of the Searchtree Database (FIG. 7c). This table then sends the symbol assigned to position p to the symbol comparator 188, where it is compared to zero. If not zero, it is sent on to the or-gate 172, which passes it on via lead 152 to the Pushdown Stack 151 for temporary storage until the traceback is completed. Whenever the symbol value is zero, however, it is known that a new symbol has been encountered. The comparator 188 then sends an enable pulse (symbol request) via the lead 160 to both the rank decoder (FIG. 7a) and the pointer decoder (FIG. 7b) of the Economy Decoder 158 and to the Input Buffer 156. The enable pulse sent to the pointer decoder inhibits operation of that unit during the rank decoding by closing the gate 194 (FIG. 7b). The Input Buffer 156, upon receiving the enable pulse on lead 160, sends the encoded symbol rank via lead 162 to the rank decoder for decoding. The decoded symbol rank is then sent by the rank decoder (FIG. 7a) via the lead 163 to the rank-unseen table 185 of the Searchtree Database. This table then supplies the new symbol value, which is sent to the Pushdown Stack 151 via the or-gate 172 and lead 152.

The Pushdown Stack (FIG. 7f) consists of a last in-first out (LIFO) stack 200, a register 202 loaded with x.sub.1, the first input symbol seen by the File Preprocessor during the preprocessing run, a countdown counter 199, and two gates 201 and 203. At the beginning of a traceback cycle, the pointer decoder (FIG. 7b) sends the decoded virtual address to the last-descendant table 186 of the Searchtree Database 150 (FIG. 7). The last-descendant table then sends XL, the extension length to a leaf via x.sub.1 arcs, to the countdown counter 199 on the lead 164. Whenever the countdown counter 199 contains a positive integer, it emits an enable signal on lead 175 to the gate 203, opening the gate and allowing the symbol x.sub.1 to be passed from the register 202 to the stack 200, where it is stored in the lowest empty slot. The counter 199 is then decremented, and the process is repeated until the counter is empty. When the count goes from 1 to 0, an enable signal is emitted on the lead 177, which opens the gate 176 of the Searchtree Database, initiating the traceback cycle by passing the first node address to the or-gate 179 (FIG. 7c).

During the traceback the LIFO stack 200 receives the decoded symbols one at a time on the lead 152 from the or-gate 172 of the Searchtree Database. After storing the received symbol in the lowest empty slot, the stack sends an acknowledge signal on lead 170 to the address table 178 of the Searchtree Database to continue the backward decoding trace. When the root of the tree is finally reached, the address comparator 189 of the Searchtree Database sends an enable signal on lead 153 to open the gate 201. The contents of the LIFO stack 200 are emptied into the Output Buffer 154 in the reverse order to which they were acquired by the stack. This completes the decoding of the current parsed segment. When the stack 200 is finally empty, it sends the Input Buffer 156 an acknowledge signal on the lead 157, telling it to send the next encoded pointer to the Economy Decoder for decoding.

In addition to the seven basic components shown in FIG. 7, the Short-Record Decoder also contains a Clock, connected to all components, and Sequence Control Units, which control the sequencing of operations by the components. These are not shown in FIG. 7.

In operation, a request for a particular record, say J, is received from the outside and the short-record decoder 15 (FIG. 1) by conventional circuitry (not shown) calls for the encoded record J using the encoded-record directory 14 and places this record into the decoder input buffer 156. The record is decoded as described above, and from the Output Buffer 154 is altered if desired by the record modifier 16 (FIG. 1). The altered record is applied to the encoder 13 (FIG. 1), recompressed and stored back to the electronic storage unit 12. As described above, the altered record may or may not be stored back in the previous location. If not, the encoded-record directory 14 is accordingly modified as described above. It will be further appreciated from the foregoing, that if all of the symbols of the alphabet has not been encountered when the searchtree database is fixed, the encoder and decoder will process each as yet unseen symbol as a newly encountered symbol irrespective of the number of times it continues to appear.

While the invention has been described in its preferred embodiment, it is to be understood that the words which have been used are words of description rather than limitation and that changes may be made within the purview of the appended claims without departing from the true scope and spirit of the invention in its broader aspects.