JPS6081638A - Method for comparing character string in japanese word processor - Google Patents

Abstract

PURPOSE:To separate correctly and easily a command superposed on a data string mixing one-byte characters with two-byte characters by comparing characters on the positions specified by two pointers advanced by prescribed bytes. CONSTITUTION:When a command is one byte, the shifting attribute of an old character string located on a position in which a code ''C'' indicating the command is inputted is checked. When the shift attribute is KS shift, characters before and after the old character strings are Japanese characters, so that null close writing is not generated. Therefore, pointers for the new and old character strings are advanced every two characters respectively and characters on the positions specified by two pointers are compared. When the shift attribute is A shift, whether the 2nd byte of the old character string is the KS shift or not is checked, if it is not the KS shift, the character is a one-byte character and the comparison of the character strings is continued. In case of the KS shift, a null code is removed from the 3rd byte of the new character string, the pointer for the old character string is advanced by 4 bytes and the pointer for the new character is advanced by 2 bytes. The contents indicating that the old shifting atribute on the position is the KS shift is set up and the succeeding character comparison is executed.

Description

[Detailed Description of the Invention] ta) Technical Field of the Invention The present invention relates to a character string comparison method in a Japanese language processing device, and particularly to a method for detecting NIILL padding in compressed data sent from a terminal device to a host computer and extracting a command. Regarding the method.

(bl Prior Art and Problems In electronic computer systems, different codes are usually used for Japanese and alphanumeric characters. That is, alphanumeric characters are E
It is displayed in 1 byte using a code called BCDIG, and Japanese characters such as hiragana and kanji are displayed in 2 bytes using a code different from EBCDIG.

For this reason, Japanese characters displayed in 2 bytes on the display device [see Figure 1 + al] 2 For example, alphanumeric characters displayed in 1 byte over the character "A" [see Figure 1 (see bl)] 2 For example, if you overtype the character “A,” the first half of the area occupied by the character “A” will be replaced by the character “A.”
A is displayed, a NULL code is inserted in the latter half, and the display becomes blank.

When such data is sent from the terminal device to the host computer, the NULL code inserted on the display is removed and the data is compressed. In this way 11iBcDIc
If data with new characters such as commands is sent on a string containing a mixture of Japanese and Japanese codes, it is impossible for the host computer to grasp the first position of the string to be cut out by simple comparison. However, this operation was not always easy.

(C1 Purpose of the Invention The purpose of the present invention is to accurately grasp the position of a newly typed character on a data string in which EBCDIC and Japanese are mixed in the Japanese display device as described above, and to correctly and easily issue commands. The objective is to provide a string comparison method that can be used to extract strings.

(d) Structure of the Invention The feature of the present invention is that the 1-hide character and the 2-hide character that are overwritten on the old cross character string that is displayed on the display device screen of the terminal device connected to the host computer are mixed. When recognizing a command consisting of one or more hide characters, the pointers for the double character string and the command string are advanced by a predetermined number of bytes, respectively, according to the shift attribute of the double character string and the number of hide characters of the input command. The purpose is to compare the characters at the positions indicated by the two pointers.

+e) Embodiment of the invention FIG. 2 is a diagram showing an example of the screen display and corresponding data when a 1-byte character is overprinted on a Japanese character string displayed on a Japanese display device of a terminal device. .

The kanji for "..." displayed on the terminal screen
The data in the host computer [(b) in the same figure] for the character string [(a) in the same figure] is composed of a 2-byte code each. However, in the figure, for convenience of explanation, characters corresponding to the above codes are shown. Now, “Han”
If you type the English letter “A゛” over the letter “A゛”,
The character "A" is displayed in the front half of the position where the character "Kan゛" was, and a NULL code is inserted in the back half [see figure (C)].The data for this is shown in the figure (d).
Immediately before the 1 Hyde character appears as seen in l, 1
An A code indicating that it is a Hyde character is inserted, and a KS code indicating that it is a Japanese character is inserted immediately before a Japanese character appears.

If this data is sent as is to the host computer, the host computer will compare it point by point with the original data shown in the same figure (bl) (during the comparison, the shift code is used to know the attribute, and the characters are skipped. ), it is possible to accurately detect areas that have changed from before.

However, when sending this data to the host computer,
As described above, the operation of deleting the NULL code and compressing the data is performed [FIG. 2(f)], so the data location is also different from the original data [FIG. 12(b)]. Therefore, even if you simply compare this with the original data, you will not be able to detect any changes.

A command usually consists of a symbol indicating that it is a command, such as "ko", followed by a predetermined English character string, that is, a character string of one hide character.

Therefore, when a command is overwritten on a Japanese character string, the above-mentioned problem inevitably occurs.

When a command consists of one or two hide characters, the 8 characters shown in Figures 3 and 4 are displayed in relation to the structure of the double character string that was displayed before the command was entered.
There are two cases.

FIG. 3 is a diagram showing an example in which a 1-byte command is overwritten on an old intersecting string. First, the example shown in the same figure (al is 2) is typed over the ＼ite character ``kan''. In this case, the first half of the character 'kan° is a symbol indicating that it is a command, and the second half is a command. It's crowded.

In the example shown in the figure (bl is typed over two 1-hide characters, the symbol indicating the command is typed in the first byte, and the command is typed in the second byte). (C) is an example in which one 1-hide character and the following 2-hide character are typed, and the command symbol is on the first byte, the command is on the first half of the second byte, and the command is on the second half. N [ILL code is stored.

When data with such a configuration is sent to the host computer side, the NULL code is deleted and the data is compressed as shown in (di to (fl) in the same figure. (There is no problem in the case of el, but in the case of (f), if you skip the shift code and simply compare the new and old character strings, you will find that the fourth hide of the double character string, the character “Kan”) The latter half and the third hide of the new character string will be compared, and the comparison will be performed while the positional relationship is incorrect.

Figure 4 (a) - (el is a diagram showing an example of overprinting a 2-byte command on a double character string;
On a double character string consisting of two hide characters, (1)) is written on a double character string consisting of two hide characters and one byte character, (C
) is on a double character string consisting of 1 hide character and 3 characters, fdl is on a double character string consisting of 1 hide character, 2 characters, and 2 byte characters, and (e) is on a double character string consisting of 1 hide character and 2 byte characters, in that order. This is an example in which commands of 2 bytes each are typed on a double character string.

Among these five examples, the third byte of the country character string is a single-hide character (bl, (C1 and the third byte is the last half of a two-hide character) (el is fine, but (al and (d
Since the third byte of the country character string for i corresponds to the first half of the 2-pi-1 character, the NIJ L'L code is inserted into the fourth byte. Therefore, the data structure when these (a) to (0) are sent to the BOST computer is as shown in the figure (fl to (j
As seen in (a) above and fdl, NIILL
As a result of the padding, when comparing the old and new strings, the 4th byte of the new string should be compared with the character (not shown) following the 2-hide character in the old intersecting string, but instead
It will be compared with the second half of the Hyde character, and the comparison position will be incorrect.

An object of the present invention is to provide a character string comparison method that can accurately detect N[ILL padding from compressed data as described above and facilitate extraction of input commands. One embodiment of this will be described with reference to FIGS. 5 and 6.

As mentioned above, each command is composed of one or more hide characters. In this embodiment, the case of one character and two characters will be explained.

Figure 5 shows that if the command is 1 hide character 11 [1i1,
FIG. 6 is a flowchart showing the main part of the NIJLL packing detection procedure in the case of two pieces. The length of a command is generally detected immediately when the command is entered. If the detected command length is 1 byte, the procedure shown in FIG. 5 is selected, and if the detected command length is 2 bytes, the procedure shown in FIG. 6 is selected.

First, when the command is l-hide, as shown in FIG. 5, the shift attribute of the country character string is checked at the position where the symbol "]" indicating the command is entered [reference numeral 1 in the same figure].

When this is a KS shift [Path 1], Fig. 3 (a
l, (as seen in C1l, it does not occur if < NULL is filled.

Therefore, the comparison can be performed in order without any special operation. Therefore, the pointers for both the new and old character strings are advanced by 2 (FIG. 2), and the characters at the positions indicated by both pointers are compared.

Also, if the shift attribute of the country character string is A shift, the third
(b) [i.e. (d)] and (C) [i.e. (f)] in the figure.
There are two cases. Therefore, the position where the pointer to the country string is advanced by 1, that is, the second byte of the country string, is KS.
Check whether it is a shift or not (Figure 3). If this second
If it is a hide or S shift code [pass 2], this byte has the same shift attribute as the first byte, and this character is a 1 hide character (see Figure 3 (bl, (el)). In this case, the comparison of character strings can be continued as is, and the pointers for both the new and old character strings are advanced by 2 [FIG. 4].

On the other hand, if the second byte is S shift [pass 3
], Figure 3 (C1, (As seen in 0, the N0LL code is removed from the third byte of the new character string, and the character that should normally be in the next fourth byte is stuffed into this position. Therefore, this character should be compared with the character in the 5th byte of the country string, so the pointer for the country string is advanced by 4 bytes, the pointer for the new string is advanced by 2 bytes [see Figure 5], and the pointer for the new character string is advanced by 2 bytes. Old shift attribute is KS
It sets that the shift is 1- (FIG. 6), and proceeds to compare the next character.

By the above simple steps, N for 1 Hyde command can be obtained.
ULL filling detection is performed accurately.

If the input command length is 2 hides, the procedure shown in FIG. 6 is selected.

In this case, first check the shift attribute of the country character string [Figure 1
1], and when this is a KS shift, it is shown in Fig. 4(a).

(As shown in bl, there are two cases, so to see one of them, move the old pointer forward by 2.
Check whether the byte is an A shift code (Fig. 6, 12).

If this third byte is not an A shift I code, this corresponds to the case of (al, (fj) in Figure 4, so the third hide of the new string has the NULL code removed and the character that should originally be in the fourth byte. Therefore, the old pointer is advanced by 4. The new pointer is advanced by 3 [Fig. 6, 13], and the next character is compared [bus l].

When the third byte above is an A shift code, the fourth byte
In the case of Figures (bl and (g)), NIJLL padding has not occurred. Therefore, the old pointer advances by 4, the new pointer advances by 3 [Figure 6, 14], and the shift attribute of the character indicated by the old pointer is A shift. That is cent C Figure 6 1
5], Compare the next character [Pass 2].

Further, when the shift attribute of the first byte of the double character string is A shift, there are three cases as shown in FIG. 4 (C1 to fQl).

Then, it is checked whether the position where the old pointer is advanced by one is the KS shift code (FIG. 6, 15).

If this byte is not a KS shift code, it is further checked whether the position where the old pointer is advanced by 2 is a KS shift code (FIG. 16). If this is not a KS shift code, it corresponds to the case of Fig. 4 (c+, , th+), and H
Since ULL padding does not occur and no shift code is inserted, there is no shift in the position of the new and double character strings, so both the new and double pointers are advanced by 3 [Figure 6, 17] and the next character is compared. [Path 3]

If the third byte of the double character string in Figure 6 16 above is the KS shift code, this is the fdl in Figure 4,
(In the case of ll, NIILL padding has occurred in the new character string. Therefore, the old pointer advances by 5, the new pointer advances by 3 [Fig. 6, 18], and further shifts the character at the position pointed to by this old pointer. After determining that the attribute is KS shift (see Figure 6, 19), the next character is compared.

In FIG. 6 15, the second hide of the double character string is KS.
When it is a shift code, it is shown in FIG. 4(e).

(Since it corresponds to Jl, the old pointer is 4. The new pointer is 3.
[Fig. 6, 20], further sets that the shift attribute of the character in the byte pointed to by the new value of this old pointer is KS shift [Fig. 6, 21], and compares the next character.
bus 5].

As described above, comparison of 2-byte commands can be performed accurately and easily.

In this way, according to this embodiment, NULL can be set by a simple operation.
It is possible to accurately detect padding, and it is possible to easily extract commands overwritten on old character strings.

Note that the present invention is not limited to the above-mentioned embodiment, and can be implemented with various modifications.

For example, the series of procedures described above can be implemented in software using a program, but it is of course also possible to implement them in firmware.

(f) As described in detail, according to the present invention, commands overwritten on old character strings containing a mixture of 1-byte and 2-byte characters on the display screen of a Japanese language processing device can be easily processed. It can be accurately and easily detected using a simple procedure.

[Brief explanation of the drawing]

Figures 1 and 2 are diagrams showing the structure of data to explain N[ILL stuffing when data is sent from a terminal device to a host computer, and Figures 3 and 4 are 1-byte commands and 2-byte commands. Figures 5 and 6 showing combinations of commands and old character strings are flowcharts showing an embodiment of the character string comparison method in the Japanese language processing apparatus according to the present invention. In the figure, 1 to G and II to 21 are new and
The processing in the procedure for comparing double strings is shown. Figure 1 (CI >< b) 2nd FM s 3 Figure 4 Figure 5

Claims (1)

[Claims] Consists of one or more 1-byte characters that are input from a terminal device connected to a host computer and overprinted on a character string containing a mixture of 1-byte and 2-byte characters that is displayed on the display device of the terminal device. When the command is recognized on the host computer side, the pointers for the country character string and the new character string are advanced by a predetermined number of bytes, respectively, according to the number of bytes of the input command and the shift attribute of the character in the manual position of the command. A character string comparison method for a Japanese language processing device, characterized in that characters at positions indicated by two pointers are compared.