JPH01214967A - Character processing device and method - Google Patents

Abstract

(57) [Summary] This bulletin contains application data before electronic filing, so abstract data is not recorded.

Description

[Detailed Description of the Invention] [Field of Industrial Application] The present invention is a character processing device that inputs characters such as kanji while performing kana-kanji conversion and creates and edits documents such as Japanese documents. The present invention relates to a character processing device that can perform correct conversion from the next input when the clause break of a sentence containing kana is changed.

[Prior Art] In a character processing device such as a Japanese word processor that inputs Japanese sentences, the method of inputting kanji is generally to input a kana string from a keyboard or the like, and then convert the input kana string into kana-kanji characters. It is. Particularly in recent years, some models offer ``solid writing conversion,'' which allows the operator to manually write kana continuously without being aware of the breaks in phrases.

However, since the analysis ability of the system is still insufficient for this kind of solid writing conversion, if the phrase break presented by the system is different from the conversion desired by the operator (erroneous conversion,
or incorrect division). In such cases, the operator generally operates so-called break change keys (break reduction, break expansion) to specify the desired bunsetsu division.

For example, when inputting the input sequence ``Something has been said about that item,'' the system incorrectly reads ``A consensus has been reached on the /problem/at a fixed price.'''/J indicates a break between clauses).

In such a case, the operator instructs ``separation expansion'' for the phrase ``seki''. As a result, the correct translation is ``The following agreement was reached regarding the issue.''

For such delimiter changing operations, if the operator is not trained, it will be very inconvenient for the operator.For example, in the above example, the next time you should ask the operator again, "A fixed price/agreement was reached/regarding/the issue."
, the operator must perform another delimiter change.

For this reason, some models are equipped with a so-called break learning function to reflect the break changes made by the operator in the next time.The zero break learning function is performed by increasing or decreasing the frequency of individual words.

To explain using the previous example, the conversion of ``kanshiikano'' is ``seki shi'' and ``seki shite'' frequency! 2. Frequency of "list price" -
4. If the frequency of ``r or less'' = 3, the frequency of ``regarding/list price'' is -2+4-6, and the frequency of ``regarding/less than'' is -2+3.
-5, so "regarding/list price" is converted as the first candidate. At this point, change the delimiter to “Regarding/
When changing the frequency to "List price" frequency - 3
If you reverse the frequency between 4 and 4 for ``, r or less'', the next time you enter ``How about something'' again, the frequency for ``Regarding/List price'' will be -2 + 3!5, and the frequency for ``Regarding/below''. -2+4W
6, the correct conversion "with respect to/below" is obtained, and segmentation learning has been performed.

[Problem that the invention seeks to solve] However,
In this conventional method of segmented learning, unexpected erroneous conversions may occur in unrelated contexts, which may actually worsen the conversion rate.

For example, in the example above, the frequency of ``r or less'' has increased, so if you continue to input ``I would like to ask you what you think about it'' and convert it, you will get ``I would like to give 7 opinions regarding / below / about it''. etc., and the operator desires “and/
Seki/landlord/,! There is a possibility that ``Mise wo 7 kan'' will not be converted.

In other words, the word "regarding" is "regarding" and "regarding".
Although it is often used as ``related'', it is not usually used as ``related'', and conventional segmented learning based on frequency cannot deal with this phenomenon.

In order to solve the above problem, it is possible to memorize the local pronunciations of one bunsetsu before and after the delimiter is changed. This method memorizes the appropriate division and converts ``kanshita'' into ``sekishi/J'' and converts ``kanshita'' into ``sekishi/ta.'' However, even in that case, the problem still remains.For example, if the input is ``I will accept your concerns,'' it would naturally be converted to ``I will make a proposal/regarding the r problem.'' , ``I will accept/respect/regarding/regarding/regarding the issue.'' is unnatural. This is different from the case of "with respect to/below". In other words, there are cases where it is better to convert the same pronunciation of ``kanshite'' to ``mashi/te'' and cases where it is better to convert it to ``kishite/''.

To summarize the above, it should be translated as ``How do you think about it'' → ``The following is the following'', ``How do you think about it'' and ``The landlord's concern'', and ``How do you think about it'' → ``Suggestions regarding the matter''. Therefore, the conventional method of segment learning that corresponds to the frequency of individual words, or the method that memorizes local pronunciations for one sentence segment, has the side effect of segment learning, resulting in inconvenient kana-kanji conversion. Put it away.

[Means for Solving the Problems (and Effects)] The present invention performs a break change when a break change is activated, reads the two sentence segments before and after the break change, and reads the result of the break change. By memorizing the bunsetsu division positions,
The present invention proposes a delimiter learning means that is less likely to cause side effects, thereby providing a character processing device equipped with solid kana-kanji conversion that is highly operable.

[Example 1 The present invention will be described in detail below with reference to the drawings.

FIG. 1 is an example of the overall configuration of the present invention.

In the illustrated configuration, the CPU is a microprocessor that performs calculations, logical judgments, etc. for character processing, and includes an address bus AB, a control bus CB, and a data bus D.
B to control each component connected to those buses.

The address bus AB transfers address signals indicating the components to be controlled by the microprocessor cPU. The control bus CB transfers and applies control signals for each component to be controlled by the microprocessor CPU. The data bus DB transfers data between each component device.

Next, the ROM is a read-only fixed memory, and the microprocessor CP, which will be described later with reference to FIGS. 9 to 14,
The control procedure by U and fixed data such as a word dictionary and a grammar dictionary are stored.

A word dictionary stores information such as pronunciation, notation, and grammar in correspondence, and a zero-grammar dictionary that is referenced in kana-kanji conversion, etc. contains connection rules between words, etc. that are required for morphological analysis, syntactic analysis, etc. It is memorized.

Further, the RAM is a writable random access memory having a configuration of 1 word and 16 bits, and is used for temporary storage of various data from each component. The ULDT is the delimited learning data detailed in FIG. HENTBL is a conversion candidate table detailed in FIG. KBBU
F is a keyboard buffer for storing input reading sequences, and is configured as shown in FIG.

KB is a keyboard, and has character symbol keys such as alphabet keys, hirakana keys, katakana keys, etc.
It is equipped with various function keys for instructing various functions to the character processing device, such as a cursor movement key, a kana-kanji conversion key, a delimiter reduction key, and a delimiter expansion key.

D! S is an external storage for storing document data, and stores created documents, and the stored documents can be called up when necessary by instructions from the keyboard.

CR is a cursor register. The CPU can read and write the contents of the cursor register.

A CRT controller CRTC, which will be described later, displays a cursor at a position on the display device fJCRT corresponding to the address stored here.

DB[JF is a display buffer memory, which stores a pattern of data to be displayed.When displaying the contents of one document data, the pattern is developed on DBUF.

CRTC is cursor register OR and buffer DBυF
It plays the role of displaying the contents stored in the CRT on the display device CRT.

Further, a CRT is a display device using a cathode ray tube or the like, and a CRT controller controls the dot-configured display pattern and cursor display on the display device CRT.
Furthermore, CG is a character generator that stores patterns of characters and symbols to be displayed on the display device CRT.

In the character processing device of the present invention, which is composed of each of these components, the keyboard operates in response to various inputs from B, and when inputs from the keyboard K B hl, etc. are supplied, the interwoven signal is first output. is sent to the microprocessor CPU, and the microprocessor CPU
Various control signals stored in the OM are read out, and various controls are performed in accordance with these control signals.

FIG. 2 is a diagram showing the screen configuration of the apparatus of the present invention. In FIG. 2, CRT means a display screen. CM is a cursor that indicates the position where a character will be entered when the next key input is performed. TS is a text screen on which the contents of stored documents are displayed. MS is a monitor line, which is an area where key data entered manually is displayed one by one. When performing kana/asagaku conversion, etc., the reading sequence is displayed on the MS, and after conversion, the conversion result is transferred to the TS. Note that the kana/asagaku conversion key is indicated by "/".

FIG. 3 is a diagram showing an operation method for delimiting and expanding according to the present invention. First, the operator inputs "so" into the document,
In addition, when trying to enter "The following agreement has been reached regarding problem
”. (a) ``In some way, I was able to find something/'' was converted into kana and sagaku and became ``We reached an agreement on the list price for the r problem'', which appears on the text screen. (b) At this time, the operator realizes that the part ``Seki Shigai no'' is not the phrase division he desires, and moves the cursor to the position of ``Seki.'' (C) Next, input the delimiter expansion key to instruct expansion of the phrase "Seki". It will be reconverted and displayed as "Below or less". (d) FIG. 4 is a diagram showing an operation method for dividing and reducing in the present invention. First, the operator inputs "so" into the document,
Furthermore, when trying to enter "I paid for the proposal,"
Enter the pronunciation ``Teian ni taitai wo wo hattata'' and then enter the kana-kanji conversion key ``/''. (a
) ``I paid the doctor for the proposal/'' is converted into kana and becomes ``I paid the doctor for the proposal'' and enters the text screen <, (b) At this time, the operator says ``The doctor for the proposal'' Realizing that part 2 was not the phrase division he wanted, he moved the cursor to ``r pair''. (C) Next, input the delimiter reduction key to instruct reduction of the clause ``tita''. It will be reconverted and displayed as "for consideration." (d
) FIG. 5 is a diagram showing the structure of the delimited learning data KULDT.

The reading is an area that stores the readings of two clauses related to the break change. The number of readings of the first clause stores the number of readings of the part of the reading that becomes the first clause after the delimiter is changed. The number of readings for the second clause is the number of readings for the second clause after changing the reading-norichi division.
Stores the reading count of the part that becomes a clause.

For example, consider a case where the input ``About the situation'' is converted to ``Regarding/the following/agreement'', and is modified to ``Regarding/the following/agreement'' by changing the delimiter. At this time, the readings for the two clauses are "Kansei Ikano", and the readings of the first clause after the break change are "Kansete" and the readings of the second clause are "Ika no". Therefore, the break learning data To register, reading - "Kanseiikano", number of readings of the first clause = 4
, the number of readings of the second clause is -3.

As another example, input ``It's very hot in this room.''
Consider a case where the text is converted to "To Furuno/Yawata/It's strange/hot" and is modified to "This/room is/very/hot" by changing the delimiter. At this time, the reading of the two clauses before the break change is “
The reading of the two clauses after the change is "Konoheyaha", so the longer one "Konoheyaketa" is the reading of the delimiter learning data.After changing the 0 delimiter The reading of the first clause is "Kono" and the reading of the second clause is "Heyaha". Therefore, the reading of the first clause is "Kono Heyaketa" and the number of readings of the first clause is 2. , 2nd clause reading proverb 3
becomes.

FIG. 6 is a diagram showing an example of clause candidates that are analyzed during the process when performing kana-kanji conversion.

Possible phrase structures for the input ``Kansei Ika no Goi'' are illustrated. The leftmost candidate is the first clause, “kan”
``Seki'' means that there is a possibility of ``regarding''. In reality, for example, there are homophones for ``kan'' such as ``can'', ``kan'', and ``kan'', but these are omitted in the diagram to avoid complication.

Candidates for the second clause include ``r death'', ``shite'', and ``designation'' for the first clause ``kan'', and ``tei'', ``list price'', and ``list price'' for the first clause ``seki''. ”, and the first clause “regarding” is replaced with “stomach”, “medical”, and “medical”.
This means that there is a possibility that

The structure of the clause is expressed in the same manner below.

FIG. 7 is a diagram showing the structure of a conversion candidate table HENTBL for internally describing the above-mentioned bunsetsu candidates.

The "Yomi" column describes the reading of each clause. The "Dictionary" column describes the address of the part of the word dictionary in which the word in the independent part of the phrase exists.

In the figure, addresses are enclosed in square brackets. "
``Number of okurigana'' is the number of readings of the okurikana part of the reading written in ``yomi'' excluding the reading of the independent part 0 For example, for ``Kishite'', the number of readings of the okurikana ``shite'' is written. Describe. The "Next Candidate" column is a pointer that indicates the next candidate phrase that can replace the phrase. In the diagram of clause candidates in Figure 6, it links clauses arranged vertically. For example, "kan" is "seki" and there is no zero-order candidate linked to "seki". stores "-1" to indicate that the link will not continue any further. The ``primary clause'' column is a link to the clause following that clause. The phrase candidate diagram in Figure 6 links the part phrase in the right position.0For example, ``r death'' is ``shite''.
When there is no zero-order clause linked to "designation,""r-1" is stored to indicate that the link will not continue any further.

FIG. 8 is a diagram showing the structure of the BBUF in the keyboard buffer. Key data input from the keyboard is temporarily stored in this KBBUF.

For example, in the case of kana-kanji conversion, the reading sequence is stored in this KBBUF until the conversion conditions are met, and when the conversion conditions are met, it is converted to kanji and the buffer is cleared.

Characters are stored as 2 bytes per character using, for example, the JIS It means to do.

The operation of the above embodiment will be explained according to the flow.

FIG. 9 is a flowchart of the part that takes in key human power and performs processing.

Step 9-1 is a process of taking data from the keyboard into the BBUF in a large buffer.

In step 9-2, the key content of BBUF is checked in the manual buffer, and the process branches to each process depending on the type of key. If KBBUF contains data of a kana-kanji conversion key, kana-kanji conversion must be performed and the process branches to step 9-3. If the beginning of the BBUF is a delimiter reduction key or a delimiter expansion key, the delimiter must be changed and the process branches to step 9-4. If the key content is other than the above, normal WA collection processing is performed, and the process branches to step 9-5 to perform other processing found in general word processors such as cursor movement, insertion, deletion, etc.

In step 9-3, the KB is
The input reading sequence on the BUF is converted into kana-kanji, output to a document, and displayed.

In step 9-4, the delimiter is changed as detailed in FIG. 14, and the document is output and displayed.

FIG. 10 is a detailed flowchart of step 9-2 "kana-kanji conversion". In step 10-1, the input pronunciation sequence on KBBUF is subjected to morphological analysis, syntactic analysis, etc. with reference to a word dictionary, grammar dictionary, etc., and a conversion candidate table WENTBL is created.

In step 10-2, as detailed in FIG. 11, a first candidate is determined which of the conversion candidates should be converted.

In step 1O-3, the determined first candidates (adopted clauses) are converted clause by clause into sentences containing kanji and kana.

The converted character string created in step 10-4 is set in the document. Furthermore, the area near where the converted character string is set is displayed so that the content of changes to the document can be seen.

FIG. 11 is a detailed flowchart of Step 1O-2r, ``Determination of first candidate''.

Step 11-1 is variable initialization processing.

Initialize the current clause pointer, which is a pointer that points to a clause in the conversion candidate table HETBL, to 1, and point it to the mt candidate of the first clause.0 Next, determine what clause number the adopted clause is. The counter i shown is initialized to 1. Finally, the input reading pointer, which is a pointer indicating which part of the reading on the input reading buffer KBBUF is currently being processed, is initialized to 1 to indicate the beginning of the reading.

In step 11-2, it is determined whether all clauses have been processed by then. Specifically, the current clause pointer is -1
Determine whether or not. When the processing of all the clauses has been completed (when the current clause pointer is 1), the process returns.

In stage 11-3, a break learning search is performed as detailed in FIG. 12, and it is searched whether the pronunciation currently being processed is registered in the break learning data.

If there is, it will be output as adoption break learning.

In step 11-4, it is determined whether or not the adoption delimiter learning has been output, and if so, the process proceeds to step 1-5, but if not, the process branches to step 11-8.

In step 11-5, a conversion candidate search is performed as detailed in FIG. 13, and a search is made to see if there is a conversion candidate matching the adopted delimiter learning output in step 11-3. If there are any, the first adopted conversion candidate and the second conversion candidate are output.

Also, at this time, the adopted bunsetsu number 2 is set.

It is determined whether a matching conversion candidate is found in step 11-6, and if found, step 1-7
Branch to step 11-85 if not found
Branch out.

In step 11-7, the first adopted conversion candidate and the second conversion candidate output in step 11-5 are used as the i-th clause and the i-th
It is adopted as a +1 clause and branches to step 11-10.

In step 11-8, since there is no matching segment learning, the adopted clause is determined according to the usual two-clause longest matching method.

In step 11-9, the number of adopted clauses is set to 1.

In step 11-10, the value of the number of adopted clauses is added to i.

In step 11-11, the current clause pointer is updated to point to the next clause of the adopted clause. Specifically, the value in the column "Primary Clause" of the conversion candidate table HENTBL is substituted. When the conversion candidate is adopted in step 11-5, the "primary phrase of the second adopted conversion candidate" is substituted. Also, the input reading pointer is updated by adding the number of readings of the adopted clause. When a conversion candidate is adopted in step 11-5, the sum of the reading numbers of the first adopted conversion candidate and the second adopted conversion candidate is added.

FIG. 12 is a detailed flowchart of the step 11-3r section learning search.

In step 12-1, variables are initialized. That is, the value of the "r medical pointer" which is a blank pointing to the delimited learning data currently being processed is initialized to 1. Further, the value of the variable "maximum number of readings", which means the one with the largest number of readings among the matching delimiter learning data, is initialized to O.

In step 11-2, it is determined whether there is no more delimited learning data to be processed. Specifically, the determination is made based on whether the value of the medical pointer has become -1. If the delimited learning data ends (medical pointer=-1), the process branches to step 12-8.

In step 12-3, the reading of the delimited learning data currently being processed (pointed to by the medical pointer) is compared with the current input reading (reading on the KBBUF, from the position indicated by the input reading pointer).

In step 12-4, it is determined whether the comparison in step 12-3 matches. If they do not match, the process branches to step 12-7.

In step 12-5, it is checked whether the number of readings of the matching delimiter learning data exceeds the maximum number of readings. If not, proceed to step 12-7.

In step 12-6, the found delimiter learning data is set as the currently employed delimiter learning data.

In step 12-7, in order to process the next segment learning data, the medical pointer is updated by +1 to indicate the next segment learning.

FIG. 13 is a detailed flowchart of steps 11-5r conversion candidate search.

In step 13-1, the conversion candidate table)IEN
A quantity, which is a variable indicating the clause currently being processed among the clauses on the TBL, is initialized and set to the value of the current clause pointer.

In step 13-2, it is determined whether the next candidate for the current phrase has already ended. Specifically, the value of i is -
Determine whether it is 1 or not. If the next candidate ends (i
--1), the process branches to step 3-14.

In step 13-3, it is compared whether the number of readings of the conversion candidate pointed to by i and the number of readings of the first clause in the adopted break learning match.

In step 13-4, it is determined whether the reading numbers match, and if they match, the process proceeds to step 13-6 to check the second bunsetsu. If it doesn't match,
The process branches to step 13-5, and the value of i is updated to indicate the next candidate for i (by substituting the "next candidate" column of HENTBL), and the process returns to step 13-2.

In step 13-6, the conversion candidate indicated by i is set as the first adopted conversion candidate.

In step 13-7, the value of j is initialized to indicate the next clause of the conversion candidate of l. (Substitute the column "Primary Clause of HENTBL.") In step 13-8, it is determined whether the next candidate for j has already ended.

Specifically, the determination is made based on whether the value of j is -l. If the next candidate is the end (j=-1), step 12-
Branches into 14.

In step 13-9, the number of readings of the conversion candidate pointed to by j is compared with the number of readings of the second clause in the adopted break study.

In step 13-10, it is determined whether the reading numbers match, and if they match, proceed to step 13-12; if not, proceed to step 13-1t,
Update the value of j to indicate the next candidate for j (I(ENTBL
), and the process returns to step 13-8.

In step 13-12, the conversion candidate indicated by j is set as the second adopted conversion candidate.

In step 13-13, the number of adopted clauses is substituted to 2 and the process returns.

In step 13-'14, the number of adopted phrases is set to 0 and the process returns.

FIG. 14 is a detailed flowchart of step 9-4 "change delimiter".

In step 14-1, a process of delimiting or decompressing is executed depending on whether the input key is a delimiting key or an expanding key. This processing is actually realized in a Japanese word processor, etc., and is a well-known technique, so it will not be specifically described.

In step 14-2, the number of readings for the two clauses before the delimiter is changed is taken out and substituted into .

In step 14-3, the number of readings for the two phrases after the delimiter change is extracted and substituted into L2.

In step 14-4, the values of Ll and L2 obtained earlier are compared, and if L t > L 2, that is, if the number of readings for two clauses before changing the break is long, step 14-5 Branch into. If LI≦L2, that is, if the number of readings for two clauses after the delimiter change is long, the process branches to step 14-6.

In step 14-5, the readings for the two sentence segments before the break change are set as the "readings" for registering the break learning data.

In step 14-6, the readings for the two phrases after changing the delimiter are set as "readings" for registering the delimiter learning data.

In step 14-7, the number of readings of the first clause after changing the break is set as the "number of first clause readings" for registering the break learning data.

In step 14-8, the number of readings of the second clause after the break is changed is set as the "number of second clause readings" for registering the break learning data.

In step 4-9, the delimited learning data is registered as set above.

In step 14-10, a search is made for delimiter learning data that is inconsistent with the registered delimiter learning data, and if contradictory delimiter learning data is found, it is deleted.

The contradictory delimited learning data refers to the following learning data.

■Have a reading that matches the registered break learning data r reading, or have a break learning that is longer than the registered break learning data ``reading'' and match the input reading;
In other words, this inconsistent segmentation learning data deletion process prevents the occurrence of a case where the learning effect cannot be obtained.

[Other Embodiments] In the above description, the timing at which the delimiter learning data is registered is when the operator explicitly specifies a delimiter change, that is, when the delimiter reduction key or the delimiter expand key is operated. However, if the operator does not know how to change the delimiters and is presented with an incorrectly divided conversion result, there is a possibility that the input reading sequence will be divided into smaller parts the next time. be. An embodiment configured to perform segmentation learning also in the above case will be described below.

FIG. 15 is an example of the operator's input described above. In (a), ``that'' has already been input on the text screen, and the operator is about to input ``The following agreement has been reached regarding problem r''. However, last time I entered the reading in succession and it was converted incorrectly, so this time I decided to break up the manual unit into smaller units and started the conversion by typing ``Mondai Nikante/''. Then, as shown in (b), the user enters ``I was able to understand 9 squid/'' as shown in 0th order (C), which is converted to ``correctly regarding the r problem''. As a result, as shown in (d), it is converted to ``The following agreement has been obtained.'' By performing this series of operations, the section ``Regarding/Below'' will be learned in sections, and the next time, if you enter ``I was able to find out about a lot of things'', you will be able to correctly enter `` The following agreement has been reached regarding the issue.''

The flow chart of "kana-kanji conversion" shown in FIG. 10 is changed as shown in FIG. 16.

In step 16-1, the input pronunciation sequence on KBBUF is subjected to morphological analysis, syntactic analysis, etc. with reference to a word dictionary, a grammar dictionary, etc., and a conversion candidate table HENTBL is created.

In step 16-2, as detailed in FIG. 11, a first candidate is determined which of the conversion candidates should be converted.

In step 16-3, it is determined whether the current conversion is immediately after the conversion of the previous clause. If it is immediately after conversion, the process proceeds to step 16-4, and registration processing of delimited learning data is performed. If it is not immediately after, the process branches to step 16-9 and the process of registering the delimited learning data is skipped.

In step 16-4, the stored pronunciation of the previous converted clause is retrieved, merged with the pronunciation of the first clause to be converted this time, and used as the "reading" for registering the delimiter learning data.

In step 16-5, the number of pronunciations of the previously converted clause is taken out and set as the "first pronunciation number of clauses" for registration of delimited learning data.

In step 16-6, the number of pronunciations of the first clause to be converted this time is extracted and set as the "second pronunciation number" for registering the delimiter learning data.

In step 16-7, the delimited learning data is ¥IJ& as set above.

In step 16-8, a search is made for delimiter learning data that is inconsistent with the registered delimiter learning data, and if contradictory delimiter learning data is found, it is deleted.

In step 16-10, the determined first candidates (adopted clauses) are converted clause by clause into sentences containing shallow academic kana.

The converted character string created in step 16-11 is set in the document. Furthermore, the area near where the converted character string is set is displayed so that the content of changes to the document can be seen.

[Effects of the Invention] As is clear from the above description, according to the present invention, even if the system side performs conversion based on wrong phrase division, if the operator changes the delimiter, the reading before and after the change is correct. Then, the system memorizes the bunsetsu division position resulting from the break change as break learning data, and the next time you enter the same reading, you can refer to that break learning data and perform the correct conversion. The hassle of operating the . Moreover,
Since the pronunciation of two clauses is stored as the pronunciation for activating the segment learning data, the side effect of erroneous conversion occurring in another situation due to segment learning and causing inconvenience is eliminated.

As described above, it is possible to realize a character processing device with high operability.

[Brief explanation of the drawing]

Figure 1 is a block diagram of the overall configuration of the present invention Figure 2 is a CRT
Whistle 3 shows the screen configuration of the screen. FIG. 4 shows the operation method of delimiter expansion in the present invention. FIG. 5 shows the configuration of the delimiter learning data KULDT. Fig. 6 shows an example of phrase candidates that are analyzed during the process when performing kana-kanji conversion. Whistle 7 shows the structure of the conversion candidate table HENTBL. Fig. 8 shows the structure of the keyboard buffer KBBUF. FIGS. 9 to 14 are flow charts showing the operation of the character processing device of the present invention. FIG. 15 is a flow chart showing display examples of the present invention.・External memory CPU...Microprocessor ROM
...Memory for extraction only RAM ...Random access memory KBBUF ...Keyboard buffer KULDT ...Separated learning data HENTBL
...conversion candidate table

Claims (4)

[Claims] (1) An input means for inputting a Japanese pronunciation sequence, a conversion means for converting the pronunciation sequence into a sentence containing kanji and kana, and a delimiter change for changing the way in which clauses are separated in the converted sentence containing kanji and kana. the means, the first clause whose delimiter is subject to change, and the second clause following the first clause.
Separation learning data that stores the pronunciation before or after the separator change for the bunsetsu along with the way the bunsetsu is separated after the separator change, and the a break learning data registration means for creating and registering break learning data, and the converting means refers to the break learning data and, if there is break learning data having a pronunciation that matches the input pronunciation sequence, converts it according to the bunsetsu break. Character processing characterized in that when an operator operates a delimiter changing means to correct the way in which phrases are delimited and then inputs the same reading again, the character processing is converted as desired by the operator. Device. (2) A patent claim characterized in that when the converting means refers to the delimiter learning data and there is a plurality of delimiter learning data having pronunciations that match the input pronunciation, the instructions of the longest matching delimiter learning data are followed. The character processing device according to item 1. (3) The pronunciation stored in the break learning data is the longer one of the readings for two clauses before changing the breaks and the readings for two clauses after changing the breaks. The character processing device according to item 1. (4) The character processing device according to claim 1, wherein the delimiter learning data registration means deletes other delimiter learning data that contradicts the delimiter learning data after registering the delimiter learning data.