JPH06236250A - Device and method for encoding - Google Patents

Abstract

PURPOSE:To provide the method and device for efficiently converting the text expression of a nested procedure into a birnary format. CONSTITUTION:In a grammer analysis step 4, a clear text SPDL file 2 is decomposed to a basic unit and in a binary encoding step 6, this is converted to, the binary format. In the case of this binary encoding, a temporary storage buffer is generated by the first procedure among the nested procedures, memory location for storing a procedure length is secured in the buffer, and next, the procedure is binary encoded and continuously stored in the same memory location. Concerning each procedure nested inside the first procedure, the memory location for storing the length is secured in the buffer as well and when each procedure is completed, the length is calculated and stored in the memory location. The temporary storage buffer is composed of a single memory buffer or logically continued plural small buffers regarded as the single memory buffer.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to compression / encoding of information sent to a printer and control of the printer. Here, the printer means not only an ordinary computer printer, but also a remote fax printer and other types of displays or presentation devices. More particularly, the present invention relates to computer language binary encoding, and more particularly to an apparatus and method for efficient binary encoding of nested procedures that includes a field for procedure length in the binary representation. .

[0002]

BACKGROUND OF THE INVENTION A huge amount of information is sent to printers every day in the world. In today's busy office environment,
Often, information is required to be printed and available more quickly.

Conventionally, a data compression method is known in which a stream of digital data is encoded into a compressed digital code signal, and the compressed digital code signal is decoded again into original data. The purpose of data compression schemes is to reduce the amount of memory or time required to store or transmit a fixed amount of digital information. Compression leads to cost savings by reducing the required memory for data storage or data transmission time. When using tapes or disks to store data files, fewer tapes or disks are needed to store the compressed files. In the case of transmitting digital information using a telephone line or satellite line, compressing the data prior to transmission shortens the required transmission time, resulting in cost reduction.

For example, suppose that the contents of daily newspaper or weekly newsletter are to be sent to a remote place for printing via a satellite line or a telephone line. With a suitable device, the contents of the newspaper or newsletter are converted into a character data stream and transmitted via the communication line. If the symbols that compose the contents of the newspaper or the current newsletter are compressed and then transmitted and reproduced by the receiver, the transmission time can be greatly reduced.

Another example will be given. When storing a huge document group such as a word processing data file on a network file server of a large company, the entire symbol signal that composes the document is compressed and then stored, and the compressed file is then used. If it were more stretched, the storage space would be significantly reduced.

The basic requirement for compression of digital data is that the compression scheme must be lossless. That is, the compressed data must be able to be decompressed or decoded again in its original form without changing or losing information. The decrypted data and the original data must be exactly the same.

The best known and most widely used general purpose data compression procedure is US Pat.
The method other than Lempel and Ziv disclosed in U.S. Pat. No. 4,650, hereinafter referred to as "LZ" method. This LZ method is a lossless dynamic online method for text data. In the LZ method, a string of frequently appearing characters is stored in a memory. When a new string of characters that matches the stored character string appears in the input string, a pointer to the stored character string is transmitted instead of the entire string. When a string of characters that matches the stored string of characters and that consists of one or more characters appears in the input stream, the pointer for the matched string is the first character of the new character string. Although transmitted together, the leading character is transmitted in uncompressed form.

However, the problem with the LZ data compression method is that
This method usually requires a large amount of computer memory and processing time. Moreover, once the memory that stores the frequently repeated character strings is full, the LZ scheme has difficulty dynamically changing the frequent character strings.

Store, US Pat. No. 4,876,54
No. 1 discloses a data compression method that solves the problems of the above-mentioned Lempel patent and enables updating of a frequent character string to be compressed. This St
In the ore data compression scheme, both the encoder and the decoder have dictionaries for storing frequent character strings. Each string is identified by a unique pointer. The input data string is parsed and matched against a string in the encoder's dictionary using a matching algorithm. Then, a pointer for the matched string is transmitted to a remote location for storage or decoding. Then, using an update algorithm, the encoder dictionary is updated to include new data based on the matched data string.

Another data compression scheme was disclosed by Friedman et al. In US Pat. No. 5,027,376,
It was transferred to Microcom System. Friedman's compression method is MNP (Micr
om Networking Protocol) Used for modems. In the Friedman scheme, a compression modem receives an input data stream and each character in the data stream is reorganized with a compressed character code, the code length of which depends on the frequency of the character in the data stream. . The provision of the frequency table allows the compression modem to recognize changes in the relative frequency of the characters in the data stream, and correspondingly replaces the compressed characters representing such characters. The decompression modem is connected to the compression modem via a communication line, but processes the compressed character code in the reverse order of the code processing method of the compression modem. The decompression modem also has a relative frequency table, and when the relative frequency of various characters changes, the actual character represented by the compression code must also be changed. While each of the data compression schemes described above would be very efficient at compressing data for transmission or storage, it does have some drawbacks. First, the compressed file is stored in a format that cannot be read directly. That is, the file must be decompressed before it can be used for any purpose. Only by spending processor time on this information expansion can the compressed information be restored to its original form.

Secondly, when compressing data, an enormous memory is often required to store a frequently used character string stored as a code in a compressed file.

The data compression routines are particularly useful for word processing files. One way to store a data processing file is to use a page description language consisting of file text information and formatting commands. Page Description Language (PDL) is currently used to control computer printers and is ideal for printing documents that contain both text and graphics.

As an example of PDL, PostScript (PostScript, registered trademark) from Adobe and Xe
There is an interpress (registered trademark) of Rox.

The present invention is described in the standard page description language (SPD).
It will be described in relation to L). This SPDL is Inter
national Standard Organiz
ation (“ISO”) section, ISO /
The draft is currently being drafted as IEC DIS 10180 and is located in American Nat, New York.
Ional Standards Institute
(“ANSI”).

The SPDL document is the final form of the document. That is, this document has been created, edited, and the composition, formatting, and placement for that document have all been determined. The SPDL document can be presented by a printer or a presentation device such as a computer monitor that displays the final form of the document. The SPDL document can also be transmitted to another computer or a facsimile machine via a communication line.

An SPDL document has two basic parts: structure and content. The structure of a document does not depend on its content, but establishes an interpretation environment (context) for the content. For example, when boldface is available, the interpretation environment indicates that the boldface is among the available resources, but the text itself is content.

Examples of structural elements are documents, pictures, dictionary generators and token sequences, as described in pending US patent application Ser. No. 07 / 876,601. A token sequence is a special structural element that contains document content.

SPDL is ISO 8824: 1990 and ISO 8 which are hereby incorporated by reference.
825: 1990 Abstract Syntax Notation 1 (Abstract Synth)
tax Notification1; ANS. 1) is used, which defines the token sequence as an octet string which is a sequence of 8-bit bytes for binary structure encoding. Standard Generalized Markup Language (Standard) defined in ISO 8897: 1986
d Generalized Markup Lang
age; "SGML") is used for clear text structure encoding.

SPDL documents can be represented in two formats: clear text format and binary format. The clear text format represents a document in a human readable format and is readable by those who are familiar with the SPDL page description language. Binary SPDL format, on the other hand, represents a document in a computer-readable binary format.

The drawback of binary encoding is that it is not visible to human reading. Therefore, even if there is an error in the binary code of the SPDL file, the error cannot be easily corrected. For example, if a document was transmitted to another system but cannot be printed, the user of the system that received the document would not be able to correct the binary form of the document.

The clear text SPDL file is
It can be read by either computer, but it requires a large amount of storage space, is slow in transmission over communication lines, and requires a long processing time to print. But,
Clear text SPDL files and binary SPDL files are fully equivalent. That is, a function that can be expressed on the one hand can be expressed on the other by syntactic conversion.

The SPDL file uses a different encoding method from Interpress and Postscript. Interpress can only handle binary encoded files, and these files are not equivalent to binary SPDL files.
Initially, Postscript could only use clear text representation, but now it supports both clear text and binary encoding. However, PostScript clear text and binary encoding is SPDL
Is different from that.

The clear text SPDL document is "{"
And a procedure represented by the information between "}". When the procedure is represented in binary format, the start of the procedure is, for example, 67
It is represented by H, followed by 2 bytes representing the number of bytes required to represent the procedure, for example 00H 08H representing that the procedure is 8 bytes long, followed by the binary representation of the procedure.

During the conversion of the clear text procedure to a binary representation, each clear text operand or instruction is written to a storage buffer while being converted to binary. When the entire text routine is converted to binary and stored in the storage buffer, 67H is returned to the binary SP.
It is written to a DL file, followed by a 2-byte field of the number of bytes needed to represent the routine, followed by the content of the storage buffer containing the binary representation of the cleartext routine. . Therefore, in order to rewrite a clear text procedure into a binary representation, it is necessary to know the number of bytes in the binary representation of the procedure in advance.

The main problem is that each procedure needs a buffer to store the binary representation of the procedure, and many nested procedures require many buffers, which is a memory management concern. It is a problem. Clear text nested procedure "{1 add {2 add {3
The following describes how "add}}}" is converted into a binary representation by a simple method. The above procedure is intended to briefly explain the operation and problems of the conventional method.

When "{1 add" is encountered, "1
A single buffer is created to hold the binary representation of "add". When the second "{" is encountered, there is one nested procedure, so the second one holding the binary representation of "2 add". The third buffer is created which holds the binary representation of "3 add" when the third "{" is encountered.

When the first "}" is encountered, "3 ad
The third procedure, whose contents are d ", ends. At that time, 67H, 2 bytes representing the length of the third buffer, and the contents of the third buffer are added to the second buffer in this order.

When the second "}" is encountered, the second nested routine converted to binary format ends. At this time, the number of 2 bytes representing the length of 67H, the second routine (for example, the length of the 2-byte representation of "2 add" and the length of the third routine), and the contents of the second buffer are They are sequentially added to the first buffer. The same procedure is performed for the third "}",
An encoded version of the nested procedure is written to a file or other storage location.

Such a conventional method has a low memory usage efficiency in that it requires a large number of buffers with space.
In addition, if you have multiple nested procedures,
Special management of these numerous buffers is required.

[0030]

SUMMARY OF THE INVENTION Accordingly, one object of the present invention is to enable clear text SPDL files to be stored in less storage space, transmitted in less time, and faster. It is to provide a method for representing a clear text SPDL file that can be compressed into a binary file for printing.

Another object of the invention is to provide an efficient apparatus for binary encoding a nested procedure, where the binary representation of the procedure contains a length field.

Another object of the present invention is to provide an efficient method and apparatus capable of encoding a nested procedure in binary format using a minimum of temporary storage buffers.

[0033]

The main feature of the encoding method and the encoding apparatus provided by the present invention is that one logically continuous memory buffer is used as a buffer for temporary storage of a procedure after encoding. Is to be done.

According to the first aspect of the present invention, a single memory buffer is used as the temporary storage buffer. According to the second and third aspects of the present invention, the temporary storage buffer is used. As such, buffers are allocated when needed so that a plurality of buffers are logically continuous.

According to the second aspect of the present invention, a plurality of buffers are managed using the pointer array. Third of the present invention
According to this aspect, a plurality of buffers are managed using the doubly linked list data structure. This doubly linked list data structure has a pointer to the previous doubly linked list data structure and a pointer to the next linked list data structure.

[0036]

According to the first aspect of the present invention, since a single memory buffer is literally used for temporary storage of a procedure after encoding, the overhead for memory management is greater than that when a plurality of buffers are used. Is reduced and efficient encoding is possible. In addition, it is possible to avoid the problem that the memory is subdivided as in the case of using a plurality of buffers and the memory usage efficiency is deteriorated.

According to the second and third aspects of the present invention, the plurality of buffers are allocated so as to be logically continuous. Logically contiguous means that each buffer follows the logical end of the previous buffer and that memory locations do not have to be physically adjacent. A plurality of such logically consecutive buffers can be regarded as a single buffer as a whole. And, even if multiple buffers are used, instead of having one small buffer for each procedure as in the past, when a certain buffer becomes full, the logical end of this buffer becomes the next buffer. Is added. Since it is not necessary to consider the overflow of each buffer, the size of each buffer can be made sufficiently smaller than before. Therefore, there are many free buffers with a relatively large size, as in the past.
The problem of unnecessarily occupying memory is solved, and memory can be used efficiently.

[0038]

BEST MODE FOR CARRYING OUT THE INVENTION The present invention will be described below with reference to three preferred embodiments. First, an outline of each embodiment will be described.

According to the method and apparatus provided by the first embodiment of the present invention, only one buffer is used for temporary storage of the nested procedure after encoding,
Encoding of nested procedures in clear text format can be performed efficiently.

When the procedure is encoded from clear text to binary format, at the beginning of the first procedure, a storage buffer is created into which 67H 00H 00H is written. This 67H means the beginning of the procedure, and 00H 00H reserves space for the length of the binary representation of the procedure to be written later. The binary representation of the procedure is 67
It is written into the buffer following H00H00H.
67H 00H 00H at the end of the buffer if there is a second or subsequent procedure after the first
Is written, followed by the binary representation of the procedure. Similar processing occurs at the beginning of each subsequent procedure.

When "}" is encountered, which means the end of one procedure, the length of the last procedure being processed is calculated and the 0 reserved for that procedure.
Overwritten with 0H 00H. Similar processing occurs at the end of each subsequent procedure. The second and third embodiments of the present invention operate in much the same way as the first embodiment, but do not allocate as much memory for temporary storage buffers as the first embodiment.

In the second and third embodiments, additional storage buffers are allocated as needed to store additional information when the storage buffers are full. But the second
The method of using the plurality of storage buffers in the embodiment and the third embodiment is different from the method of using the plurality of buffers in the above-mentioned conventional technique because the plurality of temporary storage buffers are logically continuous. That is, the information stored at the beginning of the next one storage buffer does not match the previous storage buffer. Therefore, even if multiple buffers are used, they should be viewed as one logically contiguous storage buffer.

In the second embodiment of the present invention, array indexes are assigned to a plurality of storage buffers, and these are used to manage the plurality of buffers.

The third embodiment of the present invention uses a doubly linked list data structure to manage multiple storage buffers. This doubly linked list data structure has a pointer to the previous data structure and a pointer to the next data structure.

Hereinafter, description will be given with reference to the drawings, and the same reference numerals in the drawings indicate the same or corresponding portions.

First, referring to FIG. Although the clear text SPDL file 2 is converted to a binary SPDL file 8 in the binary encoding process shown in FIG. 1, the clear text SPDL file 2 is typically produced by, for example, a word processor or graphics program.

Converting a clear text SPDL file into a binary format compresses the file to about 30% or more of its original size, thus reducing the space required to store the file by about 30% or more. According to the present invention, it has been found that the size of a clear text file having a smaller amount of content than the amount of structure can be reduced by 90% when converted to binary. The time required to transfer a file to a printer or network via a communication line is also 30%.
Or more shortened. In addition, the binary SPDL
Files can be printed much faster than clear text files. The reason why the binary SPDL file is printed at high speed is that, for example, the clear text command is converted into an equivalent binary OP code (opcode), but this OP code can be processed much faster than the clear text command. is there. Also,
This is because there is no need to check the procedure end command in the binary SPDL file because the procedure length is described at the beginning of each procedure.

The present invention is not limited to the conversion of a clear text SPDL file into a binary SPDL file, but can be applied to the direct generation of a binary SPDL file by an application program such as a word processing program or a page description file generation program. . Therefore, the processing program does not have to first generate the clear text SPDL file, but the application program may directly encode the file into the binary SPDL format. Furthermore, any kind of data to be encoded can be written to the memory by repeated generation of the procedure, which is then encoded. This data is, for example, data read from a pre-generated file, eg a clear text SPDL file previously generated to be converted into a binary SPDL file.

The single buffer of the first embodiment of the present invention can manage memory using less resources as compared with the method of multiple buffers. Moreover, when there is only one storage buffer, multiple buffers are used. It does not cause the problem of memory fragmentation that occurs when used.

Although the processes and examples described herein describe encoding to a binary representation, a feature of the invention is the physical transformation performed by the invention. The physical representation of clear text data in memory is greater than the physical representation of equivalent information in binary format. When data is represented in a memory such as a disk, the data is stored as a 0 and 1 magnetic modulation on the disk. Thus, translating the file representation requires less magnetic material on the disk to represent the same information. On the other hand, when storing data in RAM, the data is not magnetic
It is stored electrically. Therefore, the binary representation requires less electrical signals and is stored in fewer memory locations.

The first processing step shown in FIG. 1 is a grammar parsing step 4. This grammar analysis step decomposes the components of the cleartext SPDL file into basic units such as structural elements and content that can be converted into machine instructions by the binary encoding step 6. Since general grammar analysis is easily realized by either software or hardware, its details are omitted for simplification of description.

Next, the basic unit analyzed in step 6 is encoded in the binary format in step 6 and stored in the binary SPDL file 8.
This binary encoding process is a target step of the present invention, and therefore its details will be described, but prior to that, the hardware used for carrying out the process of the present invention will be described. As mentioned above, it is also possible to encode the file into a binary representation without first encoding the file into the clear text format.

FIG. 2 shows a block diagram of an apparatus constructed according to the present invention. The clear text SPDL file 2 provided from the storage device 18 such as a hard disk is sent to the CPU 12 in the processing system 10. CPU 12
Grammar analysis routine 14 and binary encoding routine 16
Grammar analysis step 4 of the process shown in FIG.
And by performing the binary encoding step 6,
Encode the clear text SPDL file into a binary SPDL file 8. This binary SPDL file 8 can be returned to storage device 18 if desired, or sent to printer 20 or other device in network 22.

FIG. 3 is a detailed view of the processing device 10 shown in FIG. 2 and peripheral devices connected thereto. The storage device 18 stores the clear text SPDL file 2, which is sent to the RAM 40 using the disk controller 26 and the system bus 36. CPU 12
Grammar analysis routine 14 stored in the hard disk 18
And the binary encoding routine 16 using the RAM 40
Used for grammar parsing and encoding of clear text SPDL files stored in. Further, the grammar analysis routine and / or the binary encoding routine can be stored in the ROM 38. The encoded binary file may be stored on the storage device 18 (eg, hard disk) as the binary SPDL file 8, on the floppy drive 28 connected to the disk controller 26, or on the SCSI.
It can also be stored in another hard disk 48 connected to the I / O controller 46 via the bus. Further, this file is printed by the printer 20 connected to the I / O controller 46 using, for example, the RS232C line, or the network 22 such as a general Ethernet (registered trademark) network using the communication controller 24. Sent to.
CR the information sent from the display controller 42
Can be displayed at T44. The processing device 10 is controlled by the user via a keyboard or a mouse that can be connected to the input controller 34, for example. ROM 38 is a CPU
It is used to store the various routines that 12 needs.

FIG. 4 shows various routines in the binary encoding routine 16. At the start of the cleartext SPDL file encoding, the main binary encoding routine 1
00 is executed. This May binary encoding routine 1
00 determines whether content or structure is being encoded and calls the main content binary encoding routine 104 or the structure binary encoding routine 112. The Structure Binary Encoding Routine 112 looks up the type of structure to be encoded into a binary format so that a suitable content interpretation environment can be achieved. SPD
Various structures are used in the L language, examples of which include pictures, prologues, and dictionary generators. The structure defines the various available components, such as initial state variables and dictionaries used when interpreting content.

A more detailed description of the various structures is not necessary to an understanding of the invention, but is pending 199.
U.S. Patent Application No. 07 / 778,57 dated October 17, 1
No. 8, US Patent Application No. 07/8, dated April 30, 1992.
76,251, U.S. patent application Ser. No. 07 / 876,601 dated April 30, 1992, U.S. patent application Ser. No. 07 / 931,808 dated August 11,1992.

Once the structure is determined by the Structure Binary Encoding Routine 112, the Content Binary Encoding Routine 102 can convert the clear text representation of various tokens from a text format to a binary format. When a procedure is encoded into this binary format, the length of the procedure (ie the number of bytes) must be described at the beginning of the procedure. A token sequence is a special structural element that contains content and can contain one or more procedures and can contain one or more nested procedures within a procedure. That is, a procedure can have one or more other procedures inside. It can also have a token sequence, but the token sequence does not contain any nested procedures. The token sequence can contain, for example, only one operation.

The procedure start routine 106 and the procedure end routine 108 manage the start and end of the procedure in the token sequence and the nesting of the procedure. The other encoding routine 110 handles encoding of the content of the token sequence. Main content binary encoding routine 1
04 determines whether there is a start, content, or end of the procedure, and calls the procedure start routine 106, other encoding routine 110, or procedure end routine 108 depending on what kind of content appears.

Although each routine in FIG. 4 is shown in a separate form, this is for simplification and it is also possible to combine two or more routines into one routine. For example, the main binary encoding routine 100
The binary coding routine 110 can be combined into one routine. The grammar parsing function may be performed by the main binary encoding routine 100 or the structure encoding routine 112. A simple embodiment of the present invention uses all binary encoding routines in the CPU.
However, in order to increase the execution speed, the structure processor for the structure binary encoding routine 112 and the content processor for the content binary encoding routine 102 may be separately provided.

The procedure start routine shown in FIG. 5 and the procedure end routine shown in FIG. 6 perform the binary encoding of the content according to the first embodiment of the present invention. One buffer PROC_BUFFER to manage,
One stack POSITION_STACK, variable P
Use ROC_FLAG and set the variable NEXT to PRO
Used to manage position in C_BUFFER.

PROC_BUFFER is, for example, one physically contiguous memory buffer (ie, occupies physically adjacent locations in memory), or
Alternatively, it is a memory buffer with sequential addresses (ie, the address of each location in the buffer sequentially follows the address of the previous location).
This memory buffer can also be a logically continuous memory buffer having a plurality of memory buffers. These multiple memory buffers are managed using an index or linked list data structure,
This will be described in detail later in connection with the second and third embodiments of the present invention.

The procedure start routine 106 shown in the flowchart of FIG. 5 is called by the main content binary encoding routine 104 when the beginning of the procedure represented by the character "{" is detected, for example. The first step 202 of the procedure start routine determines if the variable PROC_FLAG is zero. If PROC_FLAG is 0, this routine is the first routine to be encoded, not inside another procedure. Process flow proceeds along line 204 to step 206, where 2 ¹⁶ +2 bytes of memory are allocated for PROC_BUFFER.
Next, at step 208, the variable NEXT for managing the position in PRO_BUFFER is initialized to 0.

In step 202, PROC_FLA
If G is non-zero then this is a nested procedure and PROC_BUFFER already exists. The process flow proceeds along line 210 to step 212, where the value of NEXT is examined to determine if PROC_BUFFER is available for more than 3 bytes for the procedure by checking if NEXT is greater than 2 ¹⁶ -1. . When 3 bytes or more cannot be used, the processing flow proceeds to step 214 and error code 1 is returned. This error code means that there is not enough space left in PROC_BUFFER to encode the current routine. As will be described later in detail, in the third embodiment,
Instead of ending the processing here, PROC_BUFFER is managed using a doubly linked list, and PROC_BU is used using an array index in the second embodiment.
Manage FFER. In each of these embodiments, a new buffer is allocated and the variables are adjusted accordingly. If there is sufficient space, then process flow proceeds to step 216.

In step 216, NEXT is incremented by one, and in step 226, PROC--BUF.
Load 00H to FER (NEXT). Next, at step 222, the value of NEXT is POSITION_STA.
Pushed to CK. NEXT value to POSITION
PROC where the length of the nested procedure is finally written by pushing to _STACK
The position in _BUFFER is stored.

In step 224, NEXT is incremented by one, and in step 226, PROC--BUF.
Load 00H to FER (NEXT). PROC_
Loading 00H into BUFFER ensures the space where the procedure length is finally written.
"00H 00H" is written to the buffer to reserve 2 bytes for the length of the procedure. This allows up to 64 Kbytes in length for one procedure and procedures nested within it. If necessary, more than 2 bytes can be used, and 2 bytes is only an example. In step 228, NEXT is incremented by 1 so that the information written to PROC_BUFFER will be written to the empty position. In step 230, PROC_FLAG is incremented by 1, which means that the nesting level is increased by 1. Then, the process flow returns to the main content binary encoding routine 104.

When the procedure start routine 106 is finished and the content of the information is being processed by the other encoding routine 110, the binary representation of the content is written to PROC_BUFFER and PROC_B.
NEXT is incremented by 1 each time one byte is written in UFFER. When the content of the current procedure is being processed by other encoding routines,
Nest one procedure in this procedure,
Alternatively, the procedure can be terminated. When the start of another procedure is detected, the procedure start routine 106 shown in FIG. 5 is called again. When the end of the procedure is detected, the procedure end routine 108 of FIG. 6 is called by the main content binary encoding routine 104.

In the first step 302 of the procedure termination routine 108 shown in the process of FIG.
Determine whether ROC_FLAG is greater than 0. PROC
If _FLAG is not greater than 0, it means that the end of the procedure has been detected without the beginning of the procedure, so an error has occurred. Therefore, the process flow proceeds to step 304, where error code 2 is returned. If PROC_FLAG is greater than 0, then process flow proceeds to step 306, where N
Determine if a buffer overflow has occurred by examining the value of EXT. If NEXT is larger than the buffer size, this routine returns error code 1 in step 308 and returns. If the buffer has not overflowed, the process flow proceeds to step 310, where the top value of POSITION_STACK is popped and temporarily stored in the variable P. In step 312, the value at the next position in the buffer, or NEXT
To determine the length of the procedure just finished by subtracting from it the number P in the stack representing the starting position of the current routine, and because there are two characters in PROC_BUFFER to store the length of the position. , 2 is subtracted from the obtained value. In steps 314 and 316, the procedure length is set to PROC_F.
Put in LAG length field. Step 314 is
It operates to remove the least significant 2 bytes from the value of LEN and write the most significant 2 bytes to the P position of PROC_BUFFER. Step 316 sets the two least significant bytes to P
Write to the P + 1 position of ROC_BUFFER. next,
Now there is less than one nested procedure, so
In step 318, PROC_FLAG is decremented by 1. If PROC_FLAG is determined to be 0 in step 320, there are no more nested procedures, so in step 320 PROC
_BUFFER contents to TOKENSEQUENCE_
Can be added to BUFFER. TOKENSE
QUENCE_BUFFER is a buffer that holds the binary code of the token sequence structure element that is the content part of SPDL. PROC_BUFFE holds the binary coded procedure
Since these are only the first NEXT bytes of R, we only need to add these bytes to TOKENSEQUENCE_BUFFER. An example of pseudo code to make this addition is TOKENSEQUENCE_BUFFER = PROC_BUFFER [i], i = 0
It is to NEXT-1. TOKENSEQUENCE_BUFFER may be any type of memory, such as random access memory or disk. The procedure termination memory is terminated and processing returns to the main content binary encoding routine 104 at step 324.

An example of converting a clear text representation of a token sequence into a binary representation will be described below. FIG. 7 shows a clear text representation of the token sequence 1 1 ADD {1 ADD {1 ADD}}. Although the token sequence shown here contains only simple mathematical formulas for simplicity, the invention is applicable to more complex nested routines. In addition, the procedure does not need to be first encoded in the clear text format, but the procedure can be directly encoded in the binary encoding format by the page description generation device or the application program. As shown in step A of FIG. 8 (A), in step A of binary encoding, "1 1 ADD" is converted into a binary format, and TOKENSEQUENCE is converted.
It is put in _BUFFER. TOKENSEQUEN
CE_BUFFER holds the output of the content binary encoding routine 102 and can be part of the binary SPDL file 8 of FIGS. 1, 2 and 3.

Since the first "{" indicates the beginning of the procedure, the main content encoding routine 104 is shown in FIG.
The procedure start routine 106 shown in FIG. When the procedure start routine is called, PROC_FLAG is 0 because this is the first routine.
, The memory for PROC_BUFFER is allocated, and NEXT is set to 0. And
67H is put in position 0 of PROC_BUFFER,
00H is put in position 1 and position 2. The first length field reserved as 00H is PROC_BUFF.
Position 1 of ER, so 1 is POSITION_ST
It has been pushed to ACK. Therefore, step B
At the end of the, PROC_FLAG is 1 since the first routine is processing, and NEXT in PROC_BUFFER will be written with data.
NEXT is 3 because position is 3.

When the character "1 ADD" is encountered and the other binary encoding routine 110 is called, the other binary encoding routine is "1 ADD".
To PROC_BUFFER position 3, position 4, position 5
To 90H 01H 31H. P
Since 3 positions in ROC_BUFFER have been written, NEXT is incremented by 3 and becomes 6
become. Since the procedure has not started or ended, PROC_FLAG and POSITION_STAC
K does not change as shown in step C of FIG.

The second "{" calls the procedure start routine of FIG. 5, which is 67H.
00H 00H is the 6th and 7th of PROC_BUFFER
And push to the 8th position and return, NEXT =
9, PROC_FLAG = 2, and as shown in step D of FIG. 8B, POSITION_STACK holds 7 as the top entry and 1 as the bottom entry.

Next, "1 ADD" is encoded using the other encoding routine 110, and this routine executes 90H 01H 31 as shown in step E of FIG. 8B.
Write H to PROC_BUFFER at position 9, position 10, position 11 and NEXT is incremented to 12.

Since the first "}" indicates the end of one routine, the procedure end routine 108 shown in FIG.
Is called. 7 is popped from the top of POSITION_STACK, and LEN is 12-7-2 =
Calculated as 3. The procedure termination routine writes 00H and 03H to PROC_BUFFER at positions 7 and 8. Also, because one procedure is completed, P
ROC_FLAG is decremented from 2 to 1. P
Since no character has been written to ROC_BUFFER, NEXT remains 12. These variables are shown in step F of FIG.

The next "}" again calls the procedure termination routine of FIG. 6, which is POSITION
Pop 1 from _STACK and PR 00H and 09H
Push OC_BUFFER to position 1 and position 2.
This parenthesis meant the end of the first procedure, so there are no more nested procedures, PROC_F
LAG is decremented to 0. These values are shown in Figure 8.
This is shown in step G of (B). Next, FIG. 8 (B)
As shown in step G of step 1, the NEXT byte of PROC_BUFFER is TOKESEQUENCE_BUFF.
It is added to the ER and the process ends.

In the above description, one buffer PROC_BU is provided for temporary storage of the encoded binary routine.
One stack POSITION_STACK is used to store the position where the length information is written, and a variable NE is used to store the next empty position of PROC_BUFFER and the number of nested routines, respectively.
XT and PROC_FLAG were used. However,
The present invention can be implemented using a table of buffers or a multi-link list of buffers.

The process of the present invention is applicable to printer drivers in operating environments or application software. For example, a device driver implementing the process of the present invention is a Microsoft Win.
It can be used as part of a printer driver for an operating environment such as dows (registered trademark). A device driver that implements the present invention is a WordPerfect.
It can also be directly attached to application software such as (registered trademark). In either case, when the driver needs to generate SPDL binary output, the present invention can speed up processing of nested procedures and reduce the required storage space for files. Furthermore, when printing a file over a network, the transmission time of the file over the network is reduced, and if the file must be buffered before printing, the size of that buffer is also reduced.

The main advantage of the present invention over conventional methods of encoding nested text procedures is that one buffer is reserved for temporary storage of the binary representation of the procedure.
It is to use only one. Using one buffer reduces the overhead for managing the buffer. When many procedures are nested, the prior art may require large overhead due to the system having to manage many discontinuous storage buffers. Further, when a plurality of buffers are used, the memory usage efficiency is deteriorated because the memory must be allocated for the plurality of buffers and the memory is subdivided. For example, a certain amount of memory must be secured for each buffer used. If you have a very large number of non-contiguous buffers, you must allocate enough memory for each buffer so that the buffer does not overflow even if there is no buffer that is likely to fill up with data. However, the second and third embodiments of the present invention
The embodiment does not allocate the next buffer until the previous one is full. Therefore, there is no problem with having a large number of free buffers in any of the embodiments of the present invention.

Furthermore, even if multiple discontinuous buffers are used and one buffer between the two buffers is no longer needed because the procedure was converted, the memory allocated to that buffer is Not always available. Releasing the memory for this buffer subdivides the memory so that the newly released memory will not be immediately available because it will be too small to store the required information. Although it is possible to perform a garbage collection procedure to free the fragmented memory, this procedure is time consuming and may not provide contiguous space. Therefore, the present invention makes more efficient use of memory and processor time by eliminating the overhead of managing multiple buffers and by not wasting memory due to memory fragmentation associated with multiple buffers. The first embodiment of the present invention provides a very efficient method and apparatus for encoding nested routines. However, a drawback of the process of the first embodiment is that although one large buffer (for example, a 64K size buffer) must be allocated, the entire buffer is rarely full. Therefore, if the memory of the computer system encoding the nested routines in binary is relatively small, then one would not want to allocate 64K of memory to PROC_BUFFER.

One solution to the problem of using one large PROC_BUFFER is to allocate and use a large number of small buffers when needed.
The use of multiple small buffers is approximately the same as using one large storage buffer if the multiple small buffers are assigned to be logically contiguous. Allocating multiple small buffers logically contiguously means that when one of the small buffers is full, another small buffer is added to the logical end of that buffer. . Although using multiple buffers, rather than having one buffer for each procedure, multiple procedures are encoded and stored in a buffer until it is full. After that buffer is full, another buffer is added to the logical end of the previous buffer. Each buffer need not be physically contiguous in memory locations, but may be considered to follow the logical end of the previous buffer.

FIG. 9 shows a memory structure used in the second embodiment of the present invention. One array B_Pointe
There is r_Array, which is used to manage multiple logically contiguous buffers. B_Point
The first entry in er_Array points to the first buffer, buffer ₀ . When buffer ₀ is full, the second entry of B_Pointer_Array is written, which is the second buffer buf.
Indicates fer ₁ . In this way, buffers are allocated as needed. The length of each buffer is, for example, 512 bytes or 1 Kbyte.

In the present embodiment, as in the first embodiment, it is useful to manage where in the buffer the position information should be written. Therefore, instead of managing one variable in POSITION_STACK as done in the first embodiment, two variables for the start of each procedure, namely an array index (ARRAY INDEX) that indicates which buffer to write to. ,
A buffer index (BUFFER INDEX) indicating the position where the length information should be written is stored.
Such information can be obtained by using the POSITION_
It is managed by STACK.

FIG. 11 shows the procedure start routine used by the process of the second embodiment of the present invention. 1
When one procedure is started, the process of FIG. 11 is called, and in step 400 the variable PR
It is checked whether OC_FLAG is 0. PROC_FLAG in this embodiment has the same purpose as in the first embodiment and is used for managing the nesting level of the routine. The process of FIG. 11 is called when the document is first encoded. Therefore, PROG_FLAG is 0 because no procedure has been processed yet.
Is. The process flow proceeds to step 402, where an index i_b indicating which buffer should be used.
And both the index j_b indicating the position in the buffer are set to 0.

Step 404 calls the buffer allocation routine. The buffer allocation routine allocates one new buffer having a length of 512 bytes or 1 Kbyte, for example, and assigns a pointer to this buffer to B_P.
Write to the i_b position of the pointer_Array. After the buffer is allocated in step 404, step 406 determines if the buffer to be used is the array pointer B_Po.
Indicates that it is the buffer pointed to by inter_Array (i_b).

Step 408 sets the j_b position of the buffer to 67H, indicating the beginning of the routine. Step 410 increments j_b and step 412 writes 00H to BUFFER (j_b). As described with respect to the first embodiment of the present invention, 00
H is the first byte of the length information, and the length information of the routine is finally written therein. The position reserved for this length information is written after that, so step 414.
Will push you to POSITION_STACK,
You don't have to remember it. This is because scanning processes and other methods can be used to find out where the location information was stored. Both the array pointer and the buffer index are pushed onto the stack.

Step 416 increments the counter j_b and writes 00H to j_b position of the buffer in step 418 to reserve space for the second byte of routine length information. And step 4
20 increments the counter j_b. Next, the process flow advances to step 442, where the variable PROC_
FLAG is incremented by 1 to indicate that one procedure is currently in process.

In step 400, PROC_FLAG is set to 0.
If not, the current procedure is not the first in-process procedure and the process proceeds to step 422. In step 422, routine A shown in FIG. 12 is called to see if there is more than one byte available for additional information in the current buffer being used.

When the memory check routine A shown in FIG. 12 is entered, it is determined in step 450 whether the index j_b is L or more. Here, L is the length of the buffer, which is, for example, 512 bytes or 1 Kbyte. If the index j_b is greater than or equal to L, then the end of the buffer has been reached and a new buffer must be allocated. Step 452 calls the buffer allocation routine. This buffer allocation routine allocates memory for the buffer to be added and writes a pointer to this buffer in B_Pointer_Array.
An example of this is shown in FIG. Then, step 454
Sets the buffer index j_b to 0 and increments the index i_b indicating the buffer to be used by 1. Next, step 456 sets the pointer to the allocated memory buffer to B_Pointe.
Store in the i_b position of r_Array. Finally, step 458 indicates that the buffer to use is a newly allocated buffer. The process is step 45.
Return from 8 to the step where the memory check routine is called.

Returning to FIG. 11, step 424 sets the j_b position of the buffer to 67H. Step 426
Increments the index j_b by 1. Another entry in the buffer is about to be written, so we have to check if the end of the buffer has been reached. Then, in step 428, the routine A, that is, the memory check routine is called again. When the process returns from the memory check routine to the process of FIG. 11,
Step 430 writes 00H to the j_b position of the active buffer. Since this position is the place where the length information is finally written, indexes j_b and i_b
Value is pushed into POSITION_STACK.

Next, in step 434, the index j_
The buffer is checked to increment b, and to make sure that the buffer has enough memory for additional information, the memory check routine A of FIG. 12 is called again. When processing returns from FIG. 12, step 438 writes 00H to the j_b position of the buffer to reserve a second byte for position information of the length of the routine. Then, in step 440, the index j_b is incremented. Step 441 calls the memory check routine A. However, if the routine for encoding the file calls the memory check routine before writing to the buffer, the memory check routine A need not be called in step 441. At step 442, PROC_FLAG is incremented by 1 to indicate that there is another nested procedure.

After processing returns from the procedure start routine, the routine is encoded in binary. Before each byte encoded in one of the buffers used for storing the routine is written, the memory check routine shown in FIG. 12 is called to make sure the buffer to be written is not full. If the buffer is full, the memory check routine allocates one additional buffer and the encoded bytes are written to this buffer. If the beginning of a new procedure is encountered while processing the routine, the procedure start routine of FIG. 11 is called. When encountered at the end of the procedure, the procedure termination routine of the process of the second embodiment of the present invention shown in FIG. 13 is called.

In FIG. 13, in step 500, PRO
Error checking is done by checking if C_FLAG is greater than zero. If PROC_FLAG is not greater than 0, then the end of the routine was encountered but the corresponding beginning was not encountered. Therefore, step 502 returns error code 2
To display the procedure end without the corresponding procedure start.

If PROC_FLAG is greater than 0, then flow proceeds to step 504 where the top entry is the position stack POSITION_STA.
Popped from CK, array index is written to Si_b and array position is written to Sj_b. The length of the encoded routine is calculated at step 506. Step 508 makes the buffer holding the position where the first byte of the length information of the routine is to be written the active buffer. Next, step 510 writes the first byte of length information to the Sj_b position of this buffer. Step 512 increments the buffer position index by 1 so that the second byte of length information can be written to the buffer. Step 514 is
The position of the buffer is checked to determine whether the value obtained by adding 1 to the buffer index is larger than the actual length of the buffer. If the buffer index exceeds the length of the buffer, processing proceeds to step 516 where the buffer in use is incremented by 1 and at step 518 the position in the next buffer is set to 0.

In step 520, the second byte of the length information is written in the Sj_b position of the current buffer. Next, step 522 increments PROC_FLAG by 1 to indicate that there are no more nested procedures.

In step 524, PROC_FLAG is 0.
Check if If it is 0, there are no more nested procedures, so in step 526, the buffer i_b
* L + j_b bytes to TOKENSEQUENCE_B
Should be added to UFFER. Step 526 is bu
The contents of ffer ₀ are set to TOKENSEQUENCE_B
If there are buffers added to UFFER and following buffer ₀ , they are also TOKENSEQU
Append to ENCE_BUFFER. TOK the buffer
The following is an example of pseudo code that performs the function of appending to ENSEQUENCE_BUFFER.

Append B_Pointer_Array
[I], i = 0. ． ． (I_b-1) buffer = B_Pointer_Array [i_
b] append buffer [j], j = 0. ． ． (J
_B-1) The first line of the above pseudo code is to TOK all the full buffers.
Append to ENSEQUENCE_BUFFER. Second
The line sets the last buffer that is not full as the current buffer. The third line TOKs the contents of the last buffer that is not full
Append to ENSEQUENCE_BUFFER (but not after the last byte of the buffer).

In step 524, PROC_FLAG is set to 0.
Otherwise, the level of the first nested routine has not been reached and the information must continue to be written to the buffer. Step 528 sets the current buffer equal to the last buffer, as previously modified in step 508 to change the active buffer to allow writing procedure length information. The procedure termination routine then returns to the main binary encoding routine that called it.

The second embodiment of the present invention shown in FIGS. 9 to 13 is the most efficient embodiment for utilizing a plurality of memory buffers which are logically continuous, as far as the present inventor knows. . However, there is a third embodiment of the invention,
This also uses a logically contiguous memory buffer,
A doubly linked list data structure is used instead of the pointer array to manage the logically contiguous memory buffers used in the second embodiment of FIGS.

FIG. 14 shows a doubly linked list data structure used by the third embodiment of the invention to manage a plurality of logically contiguous buffers for holding nested routines. This doubly linked list data structure has as its first entry a pointer (PREVIOUS) pointing to the previous doubly linked list data structure.
Have. PREVIOUS pointer is NULL if the doubly linked list data structure is the first.
Refers to. The second entry of the doubly linked list data structure is a pointer (NEXT) that points to the next doubly linked list data structure that contains a buffer that is logically contiguous with the buffer of that data structure. Here, a plurality of logically consecutive buffers can be regarded as one buffer, and one end thereof is followed by another buffer. It means that the information that does not fit in the end is stored in the head of another buffer. When the current buffer is not yet full, there is no subsequent buffer, so NEX
The T pointer points to null. The role of the "LEVEL" entry of the doubly linked list data structure is to indicate the number of the linked list data structure. The first data structure level is 0, and the subsequent data structure levels are 1 in order.
It increases in steps. The last entry in the doubly linked list data structure is a buffer to hold the procedure being encoded. This buffer has a length of L, which is, for example, 512 bytes or 1 Kbyte. The index j is used to indicate the designated buffer.

Each time a nested procedure is encountered, it is useful to store location information where the length of that procedure is written. In order to manage where the location information should be written, the POSITI shown in FIG.
ON_STACK is used. This POSITION
_STACK has two entries for each nested routine. There is an entry j corresponding to the position in the buffer where the length information is written, and an entry LEVEL which indicates in which buffer the information should be written.

FIG. 16 shows an example of the data structure generated when the procedure being encoded requires three buffers. The first doubly linked list data structure has level 0, and the PREVIOUS pointer points to null because there is no previous doubly linked list data structure.
The XT pointer points to the underlying doubly linked list data structure. The level 1 doubly linked list data structure is pointed to by the NEXT pointer of the level 0 doubly linked list data structure. The PREVIOUS pointer of the level 1 linked list data structure points to the level 0 data structure, and the NEXT pointer points to the level 2 data structure. The third data structure is level 2 and points to the level 1 data structure by its PREVIOUS pointer, and its NEXT pointer points to null since there is no next doubly linked list data structure.

The procedure start routine of the third embodiment of the present invention is shown in FIG. 17, which is used when the beginning of the procedure is encountered. The procedure start routine of the third embodiment of the present invention is used with a doubly linked list data structure, but for the array / index method managing the plurality of logically contiguous buffers used in the second embodiment. It is similar to the procedure start routine shown in FIG. 11 utilized.

When this procedure start routine is called, for example by the main binary encoding routine, step 600 checks if PROC--RLAG is zero. When PROC_FLAG is 0, the process proceeds to step 602, where variables LEVEL, j are both set to 0. Step 604 calls the linked list allocation routine, which creates the initial doubly linked list data structure. This data structure is PREVIO
Both the US and NEXT pointers point to null,
LEVEL is 0, the buffer is empty and the buffer position index j is 0. Step 606 is LEVLE
Set the buffer allocated in L to the buffer that should be used, but LEVE when one buffer is used
L is 0. Step 608 writes 67H to the first position in the buffer. Step 610 increments the buffer position index j by one. Step 6
12 sets the j position of the buffer to 00H to reserve memory where the first byte of the routine length information is later written. Step 614 pushes the values of j and LEVEL into POSITION_STACK, which stores the location information where the length information is finally written. Step 616 is buffer index j
Is incremented by 1 and step 618 reserves another byte in the buffer for the second byte of length information. Step 620 increments index j by 1, and the process proceeds to step 642, where PR
OC_FLAG is incremented by 1 to indicate that the next nested routine exists.

In step 600, PROC_FLAG is 0.
If not, step 622 calls the memory check routine B shown in FIG. The memory check routine of FIG. 18 checks to see if there is at least one free byte in its buffer so that information can be written to the active register. Step 65
When it is determined that j is smaller than the buffer length L at 0,
Since there is at least one byte in the buffer, processing flow proceeds to step 652 and then to the process that called the memory check routine. The buffer length L is, for example, 512 bytes or 1 Kbyte. If the index j is greater than or equal to L at step 650, then the end of the buffer has been reached, so
A new dual linked data structure needs to be created. Step 654 sets the buffer index j to 0 and increments the buffer level by 1.
Step 656 then calls the link list allocation routine, which creates the next doubly linked list data structure. The newly created linked list data structure is one level above the level of the previous doubly linked list data structure, the NEXT entry points to null, and the PREVIOUS entry points to the previous doubly linked list data structure. The NEXT entry of the previous doubly linked list data structure, which was pointing to null, is modified to point to the newly created doubly linked list data structure. Next, step 658 sets the buffer for the newly allocated linked list to the current buffer and then processing returns to the procedure that called the memory check routine.

When the processing returns to the flowchart of FIG. 17,
Step 624 sets 67H in the j position of the buffer. Step 626 increments j. Step 628 calls the memory check routine again,
Check for free bytes in the buffer and if not, allocate a new doubly linked list data structure. Then step 630 writes 00H to the j position of the buffer to reserve memory for the first length byte of the procedure. Next, step 632 writes buffer location j and LEVEL to the location stack. Thus, when the length information is written later, the position in the buffer where the information is written is stored. In this example, 2 bytes are used for the length information, so step 6
At 34, j is incremented by 1. Then, in step 634, the memory check routine is called again to confirm that one or more bytes remain in the buffer. Step 638 writes 00H to the buffer as the second length byte and step 640 increments the buffer index j by one. Next, the process flow proceeds to step 642, where PROC_FLAG
Is incremented by 1 to show that the procedure is nested one more.

After the procedure start routine is executed, during encoding of the procedure into binary, the memory check routine B is checked to ensure that there is one or more free bytes in the buffer prior to writing each byte to the buffer. Have to call. If there is no more than one free byte in the buffer, a new buffer and doubly linked list data structure is allocated.

When the end of the routine is detected, the procedure termination routine shown in FIG. 19 for the third embodiment of the present invention is called. Step 700 performs an error check to make sure that there is a beginning that corresponds to the end of the procedure. If PROC_FLAG is not greater than 0, then the number of beginnings and endings of the procedure do not match, so step 702 returns error code 2 to indicate that the start and end do not match. PRO
When C_FLAG is greater than 0, the process flow proceeds to step 704, where the information indicating where in the buffer the position information should be written is POSITION_S.
Popped from TACK. S_j holds the position index in the buffer, and S_LEVEL specifies the buffer in which the position information should be written.

Next, in step 706, the length of the procedure is calculated and the length is written in the variable LEN. Step 708 sets the buffer of the level popped in step 704 as the active buffer. Step 71
0 writes the first byte of length information, then the popped buffer index is incremented in step 712. Step 714 examines the buffer index after being popped and incremented by 1 to determine if this index is greater than the length of the current buffer. If so, the very beginning of the next buffer must be used, so processing proceeds to step 716 and the buffer level is incremented. Next, step 718 sets the buffer index to zero. Step 7
20 writes the second byte of length information. Step 72
2 decrements PROC_FLAG, indicating that there is no other routine nested.

Step 724 checks if any nested routines remain. If not, step 7
At 26, the (LEVEL * L + j) bytes of the contents of the buffer are added to TOKENSEQUENCE_BUFFER. As in the second embodiment of the invention, only the buffer containing the encoded routine is TOKEN.
It is added to SEQUENCE_BUFFER. TOK
ENSEQUENCE_BUFFER may be, for example, random access memory or a disk file. Such an adding operation is performed by the same method as in the second embodiment. In step 724, PROC_FLAG is 0.
If it is larger, and thus there are still nested routines, step 728 returns the buffer to the level it was in before the procedure exit routine encountered. Then, the process returns to the main encoding routine that called the procedure termination routine.

The present invention is not limited to the above-described embodiment itself, but can be modified or modified in various ways.

[0110]

As will be understood from the above detailed description, according to the present invention defined in each of claims 1 to 40, a text representation of a nested procedure such as a clear text SPDL file can be obtained. An efficient method and apparatus for converting to a binary format can be provided, and a storage space such as a clear text SPDL file, a time required for transmission to a printer or a network via a communication line, and a time required for printing. It can save a lot of time.

According to the present invention, by using a single memory buffer, or a plurality of memory buffers that can be regarded as substantially one logically contiguous memory buffer, for temporary storage of the procedure after encoding. , Efficient coding is possible even when many procedures are nested.

According to the invention that literally uses a single memory buffer as a temporary storage buffer for a procedure after binary encoding, as defined in claim 3, compared with the conventional method using a plurality of buffers, the memory management Therefore, it is possible to significantly reduce the overhead for the above, greatly improve the efficiency of encoding, and solve the problem of the subdivision of the memory and the deterioration of the memory use efficiency due to the subdivision.

According to the invention defined in claim 4, claim 6, claim 11, claim 13 or the like, a plurality of buffers are managed using a pointer array or a doubly linked list data structure. As a result, a plurality of buffers are allocated so as to be logically continuous as a temporary storage buffer for the procedure after binary encoding. Logically contiguous means that each buffer follows the logical end of the previous buffer and that memory locations do not have to be physically adjacent. A plurality of such logically consecutive buffers can be regarded as a single buffer as a whole. And, even if multiple buffers are used, instead of having one small buffer for each procedure as in the past, when a certain buffer becomes full, the logical end of this buffer becomes the next buffer. Is added. Since it is not necessary to consider the overflow of each buffer, the size of each buffer can be made sufficiently smaller than before. Therefore, even when a large number of procedures are nested, it is possible to significantly improve the memory usage efficiency without having to occupy the memory unnecessarily with a large number of relatively large free buffers as in the conventional case.

[Brief description of drawings]

Figure 1: Clear text SPDL file in binary S
7 is a schematic flowchart of a process of encoding a PDL file.

FIG. 2 is a block diagram of a system implementing the present invention.

3 is a detailed block diagram of the system of FIG.

FIG. 4 is a block diagram of a binary encoding routine used in the present invention.

FIG. 5 is a flow chart illustrating processing of a procedure start routine used in the first embodiment of the present invention.

FIG. 6 is a flowchart illustrating a procedure of a procedure end routine used in the first embodiment of the present invention.

FIG. 7 is an example of a simple token sequence in clear text format.

8A and 8B show variables used to encode the clear text representation shown in FIG. 7 into a binary format according to the first embodiment of the present invention.

FIG. 9 shows a plurality of buffers and array indexes used in the second embodiment of the present invention.

FIG. 10 shows a stack structure for managing a length information position secured in a buffer according to a second embodiment of the present invention.

FIG. 11 is a flowchart illustrating a procedure end routine used in the second embodiment of the present invention.

FIG. 12 is an explanatory diagram of a memory check routine called by a procedure start routine according to the second embodiment of this invention.

FIG. 13 is a flowchart illustrating a procedure end routine used in the second embodiment of the present invention.

FIG. 14 is an explanatory diagram of a doubly linked list data structure used in the third embodiment of the present invention.

FIG. 15 is an explanatory diagram of a stack used for managing a secured position in the third embodiment of the present invention.

FIG. 16 is an explanatory diagram of a plurality of doubly linked list data structures used in the third embodiment of the present invention.

FIG. 17 is a flowchart illustrating a procedure start routine used in the third embodiment of the present invention.

FIG. 18 is a memory check routine used by the procedure start routine of the third embodiment of the present invention.

FIG. 19 is a flowchart illustrating a procedure end routine used in the third embodiment of the present invention.

[Explanation of symbols]

 2 clear text SPDL file 4 grammar analysis step 6 binary encoding step 8 binary SPDL file 10 processing system 12 CPU 14 grammar analysis routine 16 binary encoding routine 18 storage device 20 printer 22 network 26 disk controller 28 floppy drive 30 keyboard 32 mouse 34 Input Controller 36 System Bus 38 ROM 40 RAM 42 Display Controller 44 CRT 46 I / O Controller 48 Hard Disk 100 Main Binary Encoding Routine 102 Content Binary Encoding Routine 104 Main Content Binary Encoding Routine 106 Procedure Start Routine 108 Procedure End Routine 110 Other Encoding routine 112 structure Binary encoding routine

Claims (40)

[Claims] 1. Generating means for generating a main procedure having at least one nested procedure, means for coupling the generated procedure to a binary format, and means coupled to the generating means, the procedure being binary. One logically contiguous memory buffer, coupled with means for converting to a format, the length of the binary representation of the main procedure and the at least one nested procedure into the logically contiguous memory buffer Means for combining with the logically contiguous memory buffer, and memory locations for storing the length of the binary representation of the main procedure and the at least one nested procedure in the logically contiguous manner. To secure in the memory buffer, An encoder for encoding a nested procedure into a binary representation, comprising means associated with the logically contiguous memory buffer. 2. A first memory means for storing the location of the reserved memory location, coupled to the means for securing the memory location, and a next memory means in the logically contiguous memory buffer. 2. An encoding device according to claim 1, further comprising: a second memory means coupled with the logically contiguous memory buffer for storing position information regarding empty positions. 3. The logically contiguous memory buffer comprises a single memory buffer.
Encoding device described. 4. The logically contiguous memory buffer is
The first memory means comprises a plurality of memory buffers each having one array index, and the first memory means for storing the position of the reserved memory location includes one array index and one buffer position for each reserved location. The encoding device according to claim 2, wherein the index is stored. 5. The logically contiguous memory buffer is
The first memory means for linking a plurality of memory buffers by a linked list data structure and for storing the location of the reserved memory location includes a buffer level of the reserved memory location and a buffer in the buffer. The encoding device according to claim 2, wherein the position is stored. 6. The encoding of claim 5, wherein the linked list data structure comprises a dual linked list data structure having a pointer to a previous data structure and a pointer to a next data structure. apparatus. 7. The generating means generates the main procedure with at least one nested procedure in a clear text format and the generated clear text procedure until it is encoded into a binary format. The encoding apparatus according to claim 2, further comprising a storage unit that stores the information. 8. Generating means for generating a main procedure having at least one nested procedure, means for coupling the generated procedure to a binary format, and means coupled to the generating means, the procedure being binary. One logically contiguous memory buffer, coupled to the means for encoding into a format, the length of the binary representation of the main procedure and the at least one nested procedure into the logically contiguous memory buffer Means in the logically contiguous memory buffer for writing, a means associated with the memory buffer, a memory location for storing a length of a binary representation of the main procedure and the at least one nested procedure. For the logically continuous A memory buffer and means for transmitting the binary encoded procedure from the logically contiguous memory buffer to the printer means, the printer means being coupled to the logically contiguous memory buffer. An encoding device for receiving the transmitted binary encoded procedure, encoding the nested procedure into a binary representation and controlling the printer, which is controlled by the received binary encoded procedure. 9. A first memory means associated with the logically contiguous memory buffer for storing a reserved memory location location, and a next free location in the logically contiguous memory buffer. 9. Coding apparatus according to claim 8, further comprising second memory means associated with the logically contiguous memory buffer for storing position information for determining. 10. A logically contiguous memory buffer for storing the contents of said logically contiguous memory buffer until it is transmitted by said means for said transmission to said printer means. The encoding apparatus according to claim 9, further comprising third memory means. 11. The logically contiguous memory buffer comprises a plurality of memory buffers, each having one array index, and the first memory means for storing a reserved memory location location comprises: 1 array index and 1 for each reserved location
Coding device according to claim 9, characterized in that it stores one buffer position index. 12. The logically contiguous memory buffer comprises a plurality of memory buffers linked by at least one linked list data structure, and the first for storing locations of reserved memory locations.
Coding device according to claim 9, characterized in that the memory means stores a buffer level of the reserved memory location and a position in the buffer. 13. The at least one linked list data structure comprises at least one doubly linked list data structure having a pointer to a previous data structure and a pointer to a next data structure. Claim 12
Encoding device described. 14. The generating means generates the main procedure with at least one nested procedure in a clear text format and the generated clear text procedure until it is encoded into a binary format. The encoding device according to claim 9, further comprising a storage unit that stores the data. 15. Generating means for generating a main procedure having at least one nested procedure, means for coupling the generated procedure to a binary format, coupled with the generating means, binary of the procedure. At least one memory buffer in combination with means for encoding into a format, a buffer index for each of said at least one memory buffer, an additional memory buffer when said at least one memory buffer is full Means for allocating, means for generating a buffer index for the allocated additional memory buffer, and memory locations for storing the lengths of the binary representations of the main procedure and the at least one nested procedure, Comprising means for securing to the rebuffered, coding apparatus for coding nested procedures to binary representation. 16. A means for reserving the memory location for storing the location of the reserved memory location by storing an array index and a buffer position index for each reserved memory location. 16. The encoding device according to claim 15, further comprising a first memory means coupled to the first memory means and a second memory means for storing position information regarding a next vacant position in the memory buffer. 17. The encoding device according to claim 16, wherein said first memory means comprises a stack for storing an array index and a buffer position index for each reserved memory location. 18. Generating means for generating a main procedure having at least one nested procedure, means for coupling the generated procedure to a binary format, coupled with the generating means, binary of the procedure. At least one memory buffer, coupled with means for encoding into a format, allocating an additional memory buffer when the at least one memory buffer is full, and a linked list for each additional memory buffer allocated Means for generating, and means for reserving a memory location in the at least one memory buffer for storing a length of a binary representation of the main procedure and the at least one nested procedure. , Nested procedure An encoding device that encodes a coder into a binary representation. 19. A first memory means for storing the location of a reserved memory location, coupled with a means for reserving the memory location, and a next free location in the at least one memory buffer. The encoding device according to claim 18, further comprising a second memory means for storing the position information. 20. Double linked list data having a first pointer to a linked list data structure of a previous memory buffer and a next pointer to a linked list data structure of a next memory buffer. The encoding device according to claim 19, wherein the encoding device comprises a structure. 21. Encoding a main procedure with at least one nested procedure into a binary format, allocating a memory location in a storage buffer for the length information of the main procedure after binary encoding, Writing the main procedure after binary encoding into the storage buffer, encoding the at least one nested procedure of the main procedure into a binary format, length information of the nested procedure after binary encoding A memory location in the storage buffer for storing the binary-coded nested procedure in the storage buffer; Writing to a memory location reserved for the length information of the lossier, and writing the length of the main procedure after binary encoding to a memory location reserved for the length information of the main procedure. , An encoding method for encoding a main procedure with at least one nested procedure into a binary representation. 22. After the step of reserving the memory location for the length information of the main procedure after binary encoding, the position of the memory location reserved for the length information of the main procedure after binary encoding is determined. Memory reserved for the length information of the nested procedure after binary encoding after the steps of storing and reserving memory locations for the length information of the nested procedure after binary encoding 22. The encoding method of claim 21, further comprising the step of storing the location of the location, encoding the textual representation of the nested procedure into a binary representation. 23. The step of storing the position information of the nested procedure after the binary encoding and the step of storing the position information of the nested procedure are characterized in that each position information is stored in one stack. The encoding method according to claim 22. 24. Storing location information regarding the next available location of the storage buffer when a memory location is reserved in the storage buffer, and at least the main procedure and the nested procedure after binary encoding. 23. The encoding method of claim 22, further comprising the step of storing position information regarding a next available position of the storage buffer when one is written to the storage buffer. 25. The method further comprising the step of checking whether the storage buffer is full before each write and each allocation of the storage buffer and allocating an additional memory buffer when the buffer is determined to be full. 22. The encoding method according to claim 21. 26. The encoding method according to claim 25, further comprising the step of generating one array index for each additional memory buffer allocated. 27. The encoding method of claim 25, further comprising the step of generating one linked list data structure for each allocated memory buffer. 28. Creating a doubly linked list data structure having a pointer to a previous linked list data structure and a pointer to a next linked list data structure during the step of generating a linked list data structure. The encoding method according to claim 27. 29. The method further comprises first expressing the main procedure and the at least one nested procedure in a clear text format, and storing the clear text format until the procedure is binary encoded. 22. The encoding method according to claim 21, wherein: 30. Reserving a memory location in a memory buffer for length information of a main procedure, storing location information of the reserved memory location of the main procedure, binary text representation of the main procedure. Encoding into a representation and writing the binary representation into the memory buffer; reserving a memory location in the memory buffer for length information of a nested procedure in the main procedure; Storing the location information of the reserved memory location, converting the textual representation of the nested procedure to a binary representation and writing the binary representation of the nested procedure to the memory buffer; Writing the length of the procedure to a location in the memory buffer corresponding to the stored location information of the nested procedure, and the length of the main procedure to the stored location information of the main procedure. An encoding method for encoding a textual representation of a nested procedure into a binary representation, comprising the step of writing to a corresponding location in the memory buffer. 31. At least one of a main procedure and a nested procedure after binary encoding, storing the next available location of the memory buffer when a memory location is reserved in the memory buffer. 31. The encoding method of claim 30, further comprising storing the next available location of the memory buffer when written to the memory buffer. 32. When there are a plurality of nested procedures in the main procedure, a step of allocating a memory location for each of the nested procedures in the main procedure, and a text representation of the procedure to a binary representation. Repeating the steps of converting and storing, and for each nested procedure, repeating the step of writing the length of the nested procedure if there are multiple nested procedures in the main procedure. 31. The encoding method according to claim 30. 33. Encoding the main procedure into a binary format, securing a memory location in a storage buffer for the length information of the main procedure after the binary encoding, the main after the binary encoding Writing the main procedure after the binary encoding to the storage buffer after confirming that a memory location available for the procedure exists in the storage buffer, and for the main procedure after the binary encoding. If an available memory location does not exist in the storage buffer, then create an additional memory buffer with an index in which the part of the main procedure after the binary encoding that does not fit into the storage buffer is filled. Writing step, the main procedure Encoding the at least one nested procedure of a binary coder into a binary format, the length information of the nested procedure after the binary encoding when there is an available memory location in the storage buffer. Allocating a memory location for the storage buffer in the storage buffer and allocating an additional storage buffer with an index when there is no available memory location in the storage buffer. Write the binary-coded nested procedure to the storage buffer and to store the binary code in the storage buffer when available memory locations exist for the binary-coded nested procedure. For nested procedures after conversion Allocating an additional storage buffer with an index and writing to it part of the binary-coded nested procedure when no possible memory locations exist, the binary-coded nested Writing the length of the nested procedure after the binary encoding to a memory location reserved for the length information of the procedure, and reserving for the length information of the main procedure after the binary encoding A coding method for coding a main procedure having at least one nested procedure into a binary representation, the method having the step of writing the length of the main procedure after the binary coding in a stored memory location. 34. Generating means for generating a main procedure having at least one nested procedure; Means coupled with the generating means for encoding the generated procedure into a binary SPDL format; A logically contiguous memory buffer, combined with means for conversion to a binary format, the length of a binary representation of the main procedure and the at least one nested procedure, the logically contiguous memory buffer Means for writing to the logically contiguous memory buffer and memory locations for storing the length of the binary representation of the main procedure and the at least one nested procedure. Secured in the specified memory buffer For encoding a nested procedure into a binary representation, comprising means associated with the logically contiguous memory buffer for. 35. First memory means for storing the location of the reserved memory location, coupled with the means for reserving the memory location, and the next free space in the logically contiguous memory buffer. 35. The encoding device of claim 34, further comprising second memory means associated with the logically contiguous memory buffer for storing position information regarding a position. 36. Encoding the main procedure into an SPDL binary format token sequence, allocating a memory location in a storage buffer for the length information of the main procedure after the binary encoding, after the binary encoding A main procedure of the main procedure into the storage buffer, encoding at least one nested procedure of the main procedure into a binary format, and a memory location for length information of the nested procedure after the binary encoding. In the storage buffer, writing the nested procedure after the binary encoding into the storage buffer, and a method reserved for the length information of the nested procedure after the binary encoding. Writing the length of the nested procedure after the binary encoding to a memory location, and the memory location reserved for the length information of the main procedure after the binary encoding, to the memory location after the binary encoding. Encoding method for encoding a main procedure with at least one nested procedure into a binary representation, comprising the step of writing the length of the main procedure. 37. A memory location reserved for the length information of the main procedure after the binary encoding after the step of reserving a memory location for the length information of the main procedure after the binary encoding. Of the length information of the nested procedure after the binary encoding, and the step of reserving a memory location for the length information of the nested procedure after the binary encoding. 4. The method further comprising storing the location of a reserved memory location for encoding the test representation of the nested procedure into a binary representation.
6. The encoding method according to item 6. 38. Generating means for generating a main procedure having zero or more nested procedures, means for coupling the generated procedure to a binary format, and means for coupling with the generating means, the procedure comprising: One logically contiguous memory buffer, coupled to the means for encoding into a binary format, the logically contiguous memory buffer for writing the length of the binary representation of the procedure into the logically contiguous memory buffer Means for associating with a contiguous memory buffer, and said logically contiguous memory buffer for reserving a memory location in the logically contiguous memory buffer for storing the length of the binary representation of the procedure; An encoding device for encoding a procedure into a binary representation, comprising means for combining. 39. First memory means for storing the location of the reserved memory location, coupled to the means for reserving the memory location, and a next memory means in the logically contiguous memory buffer. 39. The encoding apparatus of claim 38, further comprising second memory means coupled to the logically contiguous memory buffer for storing position information regarding empty positions. 40. Encoding the procedure into a binary format, allocating a memory location in a storage buffer for length information of the encoded procedure, storing the encoded procedure in the storage buffer An encoding method for encoding a procedure into a binary representation, comprising the steps of writing and writing the length of the procedure after the binary encoding to a memory location reserved for the length information.