JP3220134B2 - Natural language text editor - Google Patents

Description

Description: TECHNICAL FIELD The present invention relates to a data processing device for editing a natural language text, and more particularly, to an editing device in which punctuation is taken into consideration.

[Conventional technology]

"Text Editing", VP
Series Reference Library (VP Series Refe
rence Library), version 1.0 (Xerox Corporation, 1985, pp. 47-56), and a viewpoint document editor (View
Point Document Editor). On pages 49-52, a multiple-clicking method for selection is described, in which a mouse, button,
The number of clicks indicates the desired unit of text. That is, 1
Click to select a letter, 2 click to select a word, 3
Clicking selects a sentence, 4 clicking selects a paragraph.
Editors use special rules for interpreting text as words or sentences. As described on page 49, the selection of characters, words, sentences or paragraphs by the multiple-clicking method is extended by the selection adjustment method and can include additional characters, words, sentences or paragraphs, respectively. Move, copy and delete operations apply to this selection. In the case of a move or copy operation, the selection unit by multiple clicking is placed between other text units of the same level. That is, words are placed between words, sentences are placed between sentences, and paragraphs are placed between paragraphs. The multiple-clicking selection unit also includes leading or trailing spaces. Thus, for example, words can be moved or deleted from a sentence, with the remaining words and punctuation marks remaining properly spaced in the sentence. Similarly,
Sentences can be moved or deleted from the paragraph, leaving residual sentences properly spaced within the paragraph.

[Problems to be solved by the invention]

The present invention provides for improved text processing,
An object of the present invention is to provide a text processing apparatus that uses information about a punctuation structure of a text. Also, the present invention
It is an object of the present invention to provide an editor that can provide fix-up data that defines a series of operations that automatically correct a text-type punctuation structure after a user processes text. It is another object of the present invention to provide an editor that can provide fix-up data that defines a series of operations that perform a higher level operation that improves text processing more efficiently.

[Means for solving the problem]

One well-known problem with conventional text editors is that after an operation that processes the text, the user may inspect the text to correct many punctuation features, including punctuation, capitalization, and spacing. What is needed is that it is customary. For example, moving a word to or from the beginning or end of a sentence may result in the sentence being incorrectly punctuated with improper capitalization and spacing. This problem can be avoided by providing the text data corresponding to the text with structural data indicating the autonomous punctuation structure of the text. This punctuation structure indicates that this
It is autonomous in the sense that it defines the distribution of one or more punctuation features and the dependencies between them without reference to the lexical content of the text. With such a data structure, it is easy to confirm that an operation on text yields one structure from one proper text-type punctuation structure. Each operation is performed in a manner that maintains a data structure so that the system can provide the proper punctuation for the text.
That is, for example, it is implemented in such a way that a character sequence for display is algorithmically derived from a data structure.

One aspect of the present invention is based on recognizing the problem of how to use data structures as described above. Generating and maintaining a text data structure with structural data indicative of an autonomous punctuation structure consumes considerable time and memory, and such methods are computationally inefficient. Such a method also limits the operations available to the method corresponding to the data structure, so that the user can directly edit the text characters as can be done with conventional commercial text editors for natural language text. It cannot be easily selected and processed. Furthermore, such a method can be implemented with an underlying structure-based editor that is specifically designed to handle such data structures, which is fundamentally less than conventional text editors. Differently. Conventionally, commercially available text editors do not handle such data structures and cannot be easily extended to include such methods.
Therefore, users using one of the conventional text editors on the market cannot benefit from such methods and must continue to modify many punctuation features after processing the text.

This aspect of the invention is based on the recognition that text can be analyzed in text units, each of which has a special text type, and all punctuation features are bounded by such text units. It is caused by. This aspect is further based on the finding that punctuation errors can be analyzed in two basic types of errors: errors in the placement of text-type boundaries and erroneous combinations of punctuation features in text-type boundaries. And The second type of error is referred to as a textual punctuation feature error, and after the processing operation, the result is text having the proper textual punctuation structure and the punctuation feature at each textual boundary is relative to this boundary. It can be modified by performing a series of operations that indicate that it is appropriate. In other words, the modification sequence of the operation modifies the text data corresponding to the text, so that the modified text data corresponds to the modified text having a proper text-type punctuation structure.

This aspect of the invention is further based on the recognition that the sequence of operations that results in the proper text-based punctuation structure can be performed with a conventional commercially available text editor. The text editor can act as a host to a punctuation device as a program that performs a punctuation action, and the punctuation device is configured to define an appropriate sequence of operations to be performed by the host editor. Contains functions that can be invoked by the editor. The editor as host (below,
In cooperation with the host editor) and the punctuation device, it provides the technical effect of utilizing the data structure described above and eliminates the disadvantages mentioned above.

In order to show the above and other objects, features and advantages of the present invention, the present invention will be described in detail with reference to the drawings with reference to embodiments thereof.

〔Example〕

First, the meaning of the terms used in this specification will be described.

"Text" means a sequence of written words, typically a sequence.

"Written word" means a word recorded in the form of individual elements such as letters, codes, and the like. Words recorded in continuous form, such as recorded continuous speech,
Therefore, it is not a written word. Text is thus zero or more words, each having at least one individual element.

“Natural language text” means a text in one natural language, such as English.

A "unit of text" or "text unit" is one unit by which text can be divided.

A “textual type” is a unit of text of a category that has syntactic or semantic significance but has no lexical significance. In order to distinguish special tokens or instances of the text type from more complex units of text, including, for example, a series of text type units, the term "text type unit" is used herein.
type unit).

A "textual type rule" is a rule whose applicability is determined according to the text type. In other words, if the text is split into text type units,
One text type rule applies to units that are instances of one text type, but not to units of another type.

"Grammer of textual types"
Is a set of text type rules, each rule indicating, for each text type, the text type of the text unit into which the text type unit of the respective text type can be split. Further, "text-type grammar" defines all and only acceptable partition portions of a text-type unit.

"Punctuation features (or forms of punctuation)" (punc
A tuational feature is a feature that relates to one or more textual units and is determined by the syntactic or semantic significance of the textual units of the relationship. For example, one punctuation feature may be grouping text-type units, nesting one text-type unit within another text-type unit, separating text-type units, separating text-type units, or text-type units. Indicates highlighting or other highlighting. Commonly used punctuation features in English include commas, periods, semicolons, colons, dashes, quotes, parentheses, square brackets,
There are non-alphanumeric typographic features such as spaces and punctuation, including underscores, etc., alphanumeric element features such as cases and fonts, and formatting features such as carriage returns, tabs, centering, and indentation.

"Punctuational structur" of text
e) is the structure that contains the punctuation features of the text. The texts typically presented for inspection and editing are:
It is based on a data structure that contains data indicating punctuation structures, such as punctuation marks, space or character codes indicating capitalization. The text data structure may correspond to text having incorrect punctuation characteristics, in which case the text will be incorrectly punctuated. As mentioned above, punctuation errors are analyzed into errors in positioning text-type boundaries and errors in combining punctuation features that occur in text-type boundaries. For example, the following sentence (1) indicates a boundary positioning error. That is, in this sentence, it is inappropriate to end the phrase after the false "dog". Sentence (2) indicates a punctuation feature error. That is,
It is inappropriate to include a comma and a space before the period at the end of the sentence, even if the phrase ends on this boundary. Sentence (3) shows both types of errors in a single sentence. That is, it is inappropriate to end a clause after the word "dog", and to include a comma and a space before the semicolon at the end of the clause, even if the phrase ends on this boundary. Because it is inappropriate.

(1) The dog, bit the man. (2) The dog bit the man., (3) The dog,; bit the man. The second type of error shown in the sentences (2) and (3) is text This is referred to herein as an error in a "textual type punctuational structure" because it is identified by applying type rules to the text. Such error-free text is referred to as "correct textual type punctuation."
uational structure). The present invention can correct text-type punctuation errors. However, as shown in sentence (1), the text appears to have a proper text punctuation structure, but is still incorrectly punctuated.

In the data structure "text data" (text dat
a) means data corresponding to a natural language text. Text data includes alphanumeric and punctuation codes, capitalization codes, carriage control codes, and the like (in this specification, these are collectively referred to as “text codes” (text c
ode)), and is often encoded using standard print or display codes.
Text data, however, is encoded in various other ways. For example, text data is encoded as a bitmap.

In a data structure containing text data consisting of text codes, a "punctuation code" (punctuational
The term code) refers to a text code used by the system to indicate the punctuation characteristics of natural language text represented by the text data. Basic codes generally include text codes indicating punctuation, spaces and capitalization.

A "word unit" is a sequence of text codes that has no lexical significance and cannot be divided into smaller sequences based on punctuation codes for the purposes of a given system. . Thus, a word unit is an atomic word unit, and the text code within the word unit could also be a punctuation code, but is referred to herein as a "character code".
Call it e). Punctuation codes within word units may or may not indicate punctuation features. Punctuation codes indicating capital letters at the beginning of a sentence indicate punctuation features. However, for example, a punctuation code indicating an uppercase letter at the beginning of a proper noun does not indicate a punctuation feature.

A "textual type boundary" is one or more punctuation codes that separate particular text types in text data that are between word units and that correspond to text having the proper punctuation structure. It is a sequence. "Word boundary", "phrase boundary"
(Phrase boundary), "sentence boundar"
Text-type boundaries, such as y), are often referred to herein as text-type.

A "natural boundary" occurs at each end of each word unit in the text data. Natural boundaries may include textual boundaries or may not include punctuation codes. Natural boundaries without punctuation codes can still delimit certain text types. Such a natural boundary is often referred to herein as a designated type of sky natural boundary. For example,
The sky-natural boundaries of a type paragraph generally occur at the beginning and end of a document.

A “manipulation operation” for text data corresponding to one text is an operation of modifying the text data so as to correspond to one modified text. Processing operations are generally defined for arguments that are part of the text and operations on the arguments, such as operations such as move, copy, cut, paste, or delete. A "selection operation" is an operation on a portion of a text that can be performed later as an argument to a processing operation.

"Fix-up data" refers to modifying text data corresponding to one text so that the modified text data corresponds to a modified text having a proper text-type punctuation structure. Is data that defines a sequence of one or more processing operations. The processing operation defined by the fix-up data is performed on text data corresponding to text having an incorrect text-type punctuation structure or on text data corresponding to text having an appropriate text-type punctuation structure; In each case, the result has a proper text punctuation structure.

 Next, general features will be described.

1 to 4 illustrate the general features of the present invention. FIG. 1 is a flow chart of processing text and providing fixup data. FIG. 2 is a diagram showing the configuration of a system having a host editor and a punctuation device for performing the steps in FIG. FIG. 3 is a flowchart showing the general steps in a selection operation using the system of FIG. FIG. 4 is a flowchart illustrating the general steps in a processing operation or other operation involving providing fixup data using the system of FIG.

The steps in FIG. 1 begin in box 10 when the data processor receives a request for a processing operation. As shown in the text frame 12, the request includes a primary selection indicated by the shaded area 14, a depression of the copy button 16, and a secondary selection of the position indicated by the pointer 18. Therefore, the text frame 12 indicates the move / copy / paradigm of the text processing. However, as described above, the present invention is similarly applicable to the cut-copy-paste paradigm.

After receiving the request in box 10, the data processor processes the text data corresponding to the text in text frame 12 to obtain processed text data corresponding to the text shown in text frame 22 in box 20. The space after the word "To be" and each of these words, which was the primary selection in the shaded area 14, has been copied to the location indicated by the pointer 18 and is now in the shaded area 24. Is appearing. This operation resulted in three errors in capitalization and spacing. Therefore, the processed text data in the text frame 22 has an improper text punctuation structure.

Finally, in box 30, the data processor:
Fixup data is provided that defines one or more sequences of operations for further processing the text data such that the corresponding text has a proper textual punctuation structure. This sequence is then performed to obtain modified text data corresponding to the modified text shown in text frame 32.

FIG. 1 shows how the present invention can make text processing more efficient.
The user is spared the task of requiring the necessary operations to correct each of the capitalization and spacing errors.

FIG. 1 also shows the extent to which fixup data can be obtained. One aspect of the present invention is based on the recognition that, as noted above, the appropriate operation is almost always inferred from the affected natural boundaries, if any, and from applicable text types. I have. For example, the beginning of the shaded area 24 in the text frame 22 has a natural boundary at the end of the left word unit and a natural boundary at the beginning of the right word unit, and a space should be inserted; And that the capitalization of the connection should be changed to lowercase. Similarly, the end of the shaded area 24 has the natural boundaries of the type words on the left and the natural boundaries of the type sentences on the left, resulting in the replacement of spaces and periods by periods. Once the fix-up data defining these operations is provided, the text data is modified accordingly to provide text having the proper text-type punctuation structure, as shown in text frame 32.

FIG. 2 shows how the steps shown in FIG. 1 are implemented in a conventional commercially available text editor. The system 50 shown in FIG. 2 includes a processor 52, which receives input signals from a keyboard / mouse 54 or other suitable input device and provides output for presentation by a display 56. Processor 52 executes instructions from program memory 60. This program memory has a host editor 62 and a punctuation device 64. The host editor 62 and the punctuation device 64
Each has a set of routines, but since they perform separate roles, each is treated as a single entity. In executing host editor 62 and punctuation device 64, processor 52 also accesses various data structures in data memory 70. Some of these data structures are shown in FIG.

In the execution of the host editor 62, the processor 52
As described above, a text data structure 72 having a series of text codes is accessed. Processor 52 also has access to host select data structure 74. The host selection data structure is, for example, a cut buffer or temporary memory for storing one or more selections and other data related to the selection. For the purposes of the present invention, the nature of the details of the text data structure 72 and the host selection data structure 74, and how the host editor 62 manages them, is not important. However, it should be understood that the host editor 62 can provide related data for causing the punctuation device 64 to perform its role. For example, it is sufficient that the host editor 62 be able to provide the code from the text data structure 72 and the code from the buffer location in the host selection data structure 74, as described below.

The data memory 70 also has a punctuation device selection data structure.
76, in which the punctuation device 64 stores data relating to the selection. As described above, this data includes, for example, information about punctuation boundaries in the area surrounding the end of the selection. Pattern 78 is a set of patterns that punctuation device 64 uses to identify textual boundaries. The punctuation device 64 provides the fixup data by loading the fixup data structure 80, from which the host editor 62 retrieves this data. Upon locating the endpoint of the selection, the punctuation device 64 provides data defining the endpoint by loading the endpoint data structure 82, from which the host editor 62 similarly retrieves this data. I do. If desired, additional data structures can be provided for additional communication between the host editor 62 and the punctuation device 64.

FIG. 3 illustrates the general steps performed by the system 50 in handling a user request for a selection operation. This request is, for example, a mouse event such as a button click. In response to the user request, processor 52 executes at box 100 the appropriate routine from host editor 62 to receive the user request. As shown in box 100, FIG. 3 shows the response to a request related to the text type of the currently selected text. If these can be handled, the steps shown in FIG. 3 are not followed.

The host editor 62 calls the punctuation device 64 at box 102 and provides data regarding the request received at box 100. This data, for example,
Includes the current pointer position and the indication that the mouse button was clicked with the pointer at this position. This may also include handling for the end pointer data structure 82. The host editor 62 does not need to perform any steps on its own selection data structure 74 before calling the punctuation device 64. That is, it can rely on the punctuation device 64 to provide appropriately qualified choices.

When called by the selection request by the host editor 62,
The punctuation device 64 branches at box 104 based on whether it needs data for additional text codes from the text data structure 72 to determine a new selected endpoint location. If not, the current selection is unchanged by request, and the punctuation device 64 then exits in box 106 after performing any other suitable steps.

If data for the additional text code is needed, the punctuation device 64 will
Request data to indicate at which end of the current selection an additional code is required. In response,
Host editor 62 provides additional code in box 112. The punctuation device 64 then determines in box 114 whether the additional code includes the new endpoint location and this is done using the pattern 78. If not, the punctuation device returns in box 110 to request additional codes. Or, if the punctuation device has found one endpoint and needs a code to find another, it can return to box 110 as well.

When the punctuation device receives a code containing the new endpoint location of the selection, the punctuation device will:
In box 116, select data structure 76 accordingly
Change the data in. Next, in box 118, the punctuation device loads the data into the endpoint data structure 82 and provides the identified endpoint to the host editor 82. When the punctuation device 64 returns control to the host editor 62, the host modifies its selected data structure 74 in box 120 according to the endpoint in the endpoint data structure 82. Next, in box 122, the host editor 62
Properly displays the new selection, such as a reverse video.

FIG. 4 illustrates the general steps performed by the system 50 in handling a user request for a processing operation or the like using the fix-up data method. At box 140, host editor 62 receives the arguments defining the arguments and operations on the arguments, as described above. The response of host editor 62 to this request depends on what operation is being requested, as indicated by the branch in box 142. If the request is for a copy operation in the cut-copy-paste paradigm (ccp), the host editor 62 can perform its own copy operation in box 144, and The punctuation device 64 can be called to copy the data in its selected data structure 76 into a cut buffer data structure (not shown). This relatively simple procedure is sufficient because the copy operation does not require a fix-up data method.

The request is for deletion in the cut-copy paradigm,
More complex procedures are required for operations that use the fix-up data method, such as cut or paste, copy or move in the copy / move paradigm, or other operations such as text type changes described below. Follows. In box 146, host editor 62 processes text data structure 72, if necessary, according to its usual operations. Then, in box 148, the host editor 62 invokes the punctuation device 64 and provides data indicating the operation required in box 140 and data of a relationship such as a clue to the fixup data structure 80. In box 150, punctuation device 64 obtains fix-up data that defines a series of operations that lead to a proper text punctuation structure. The punctuation device then proceeds to host editor 62
Before returning to, the fixup data is loaded into the fixup data structure 80 at box 152. The host editor 62 performs a series of operations according to the data in the fixup data structure 80 at box 154, and then displays the fixup text at box 156.

FIG. 4 illustrates not only how each of the editor's conventional processing operations can be extended to provide fix-up data, but also how the conventional editor operates. Can be extended to include higher-level operations, such as changing the text type of some of the text. To add a higher level operation, the host editor 62 is modified so that a request for a higher level operation can be identified, and a request for a higher level operation is received in box 140 And a corresponding call to the punctuation device 64 is made in box 148. The punctuation device 64 then obtains in box 150 fix-up data that defines a series of operations that are effective to perform the higher level operations. These steps continue as in FIG.

 Next, the implementation of the above-described features will be described.

The present invention was implemented on a Macintosh workstation. This implementation includes a routine that responds to calls from the host editor. These routines are referred to as "TIAB" in the following description.

To better understand this implementation, the host editor includes the calls that the host editor provides to the TIAB, the calls that the TIAB provides the host editor, and the data structures used by the host editor and the TIAB to communicate data to each other. Consider the interface between the and the TIAB. Next, consider TIAB's internal operations, including TIAB calls to TIAB functions that identify textual boundaries and provide fixup data.

 First, the host TIAB interface will be described.

The interface between the host editor and the TIAB is split into two parts. One part of the host is called the host editor interface, by which the host editor calls the TIAB with the relevant data in response to a request from the user, and thereby the TIAB hosts the data in response to the call. This is the interface that returns to the editor. The other part is called the TIAB interface, which allows the TIAB to call the host editor to get the data needed to identify textual boundaries and thereby provide the requested data to the host editor Interface.

 Next, the host editor call to TIAB will be described.

TIAB includes several functions that can be invoked by the host editor. These functions can be invoked in any suitable order to provide editing operations based on the punctuation structure. The host editor is generally used to obtain data related to the selection operation, or to obtain fix-up data that defines a series of operations that should follow a processing operation or perform a higher level operation. , Call the TIAB function.

 Next, the selection operation call will be described.

Multiple TIAB functions can be invoked in connection with the selection operation. FIG. 5 illustrates the general steps that occur when a user requests a selection operation, that is, steps that are consistent with the operation of the host as described above with respect to FIG. However, FIG. 5 does not show all the steps performed by the host editor in determining that a user has requested a selection operation. That is, each host editor has its own way to receive the user's request and determine this requested operation. Conventional editors can easily be modified to interpret a subset of the user's requirements as a requirement for a type selection operation available from the TIAB.

The sequence of FIG. 5 begins at box 200 by receiving a request from a user. This step implies an operation performed by the host editor to determine whether the requested operation is a selection operation, which determines which of the available selection operations is being requested. To do. The host editor then branches explicitly or implicitly between the two types of selection operations, as shown in box 210. One type of selection operation involves modifying a text-based selection, while the other type of selection operation involves changing an insertion point, a selection. If the operation changes the insertion point without changing the text unit selection, it need not include the punctuation structure, and thus does not require TIAB assistance in determining the endpoint of the new selection. However, if this operation changes the text unit selection, TIAB is called to determine the appropriate endpoint for selection based on the text type boundaries.

For operations that change the insertion point, the host editor performs the steps in box 212 to determine the new insertion point, and writes the description to the host editor's selected data structure, typically without calling the TIAB. To load.
Next, the host editor invokes the TIAB function and converts the data of the relationship, such as data based on the description of the new insertion point, into the TIAB.
Load into AB's selection data structure. Upon return of this function, the host editor displays the text with this new insertion point in box 216.

Box 22 for changing text unit selection
At 0, the host editor calls the appropriate TIAB function to determine the endpoint for the new selection. Therefore,
Selection operations involving text need not be based on, or constrained by, the usual selection operations of the host editor, but may be defined by the TIAB in a manner that facilitates its execution. is there. Several distinct types of selection operations on text units can be performed by the TIAB function.

One TIAB function can change the current selection, include or exclude one instance of the currently selected text type to the left or right of the current selection, and leave the current text type unchanged. Thus, this function is invoked with data indicating to the left or right of the current selection and in which direction the change should be made. It is invoked in response to a specially defined user request.

Other TIAB functions extend the current selection to include the position derived from the current mouse position and the current character position in the text, such as any instances of the text type between the current selection and the case. It can include the current selected text type case. This feature allows the user to use a custom mouse, for example, by dragging the pointer from the current selection to the next text unit while holding the mouse button down, or by clicking the designated mouse button to adjust the selection. Called when invoking the underlying adjustment function. The call to this function resulting from the dragging of the pointer contains data indicating the anchor point of the text in addition to the current mouse position, in this case extending the selection forward or backward from the anchor point to the current mouse position. be able to.

Other TIAB features can change the text type of the current selection to the next higher level text type, and if necessary extend one or both ends of the current selection to make the new text type Any additional text code needed to reach the surrounding text type boundaries can be included. Suitably, this function is invoked in response to multiple mouse clicks where the pointer is at the same location. Other relevant TIAB functions, on the other hand, change the text type of the current selection to the next lower-level text type, and, if necessary, text from the right edge of the current selection to reach the text type boundary of the new text type. Drop the code.

When making calls to any of these functions,
The host editor includes a pointer to the data structure to return the description of the new selection. This technique includes new selection endpoints, eg, offset and length. Each TIAB function then returns, at box 222, the description of the new selection in its data structure. The host editor then loads the editor into its selection data structure and displays the new selection in box 224.

In this way, the host interface invokes the TIAB function to obtain an endpoint for selecting a new text unit. Next, a call for fixup data made by a host interface to which the TIAB is responsive to provide the fixup data will be described.

The host editor can also invoke the TIAB function as part of a response to a request for an operation requesting fixup data, such as one of the processing operations. As described above with reference to FIG.
Copy operations in the copy-paste paradigm are different from other processing operations. This is because this does not require the TIAB to provide fixup data, and therefore the only required TIAB function is to copy the TIAB's selected data into its cut buffer data.
However, for other processing operations, the host editor uses TI
Call the AB function to provide the fixup data, and then the host editor can perform a series of operations defined by the fixup data. Furthermore, the host editor can be extended with additional operations, for each of which the host editor also invokes the TIAB function, defining a series of operations that are effective to perform this additional operation. Provide fixup data.

The portion of the host interface that invokes the TIAB function to provide fixup data can be configured so that the host editor first performs its own appropriate operation, for example, a processing operation. The host editor then clears the TIAB's token and character cache. This is required every time the host changes its text buffer, because the TIAB cache is no longer valid. At this point, the host editor invokes the appropriate TIAB function and provides fixup data that defines a series of operations on the location in the text data, or each series of operations on both ends of the text unit.

TIAB provides functions for cutting, pasting, deleting, changing the text type of selections, and changing capitalization in the cut-copy-paste paradigm. Several functions are provided to provide fixup data, including functions for adding and removing parentheses, respectively. When one of these TIAB functions returns with fixup data, the host editor performs the sequence of operations defined by this fixup data, and then completes with the appropriate calls to the other TIAB functions.

FIG. 6 illustrates the general steps performed by a conventional host editor upon receiving fixup data returned by the TIAB function. These steps are, alternatively, implemented as part of the TIAB, but they are dependent on the underlying functionality available in the host editor, and therefore,
Inclusion within specializes the TIAB to the host editor. The fixup data is used to provide the data used in the steps of FIG. Furthermore, the fix-up data structure may include data that allows the host editor to undo the sequence of operations defined by the fix-up data, and may include the host to perform other appropriate functions. Other data for enabling the editor can be included.
The basic sequence of operations defined by the data in the fixup data is shown in FIG. The instances of this basic sequence can be combined to make any necessary modifications to the text.

The sequence in FIG. 6 begins at box 250 by receiving a fixup data structure. TIAB providing fix-up data
The function can return a clue, such as a pointer, to the instance of the data structure containing the fixup data. The host editor routine that called TIAB then performs the steps in FIG.
This clue can be included in calls to other host editor functions.

The test in box 252 determines whether the delete length field in the data structure has a value greater than zero, indicating that one or more characters should be deleted. If so, box 254
In step (c), a series of codes starting from the position indicated by the offset field is selected from the text data of the designated length. Then, in the step in box 258, the selection made in box 254 is deleted.

Next, the test in box 260 determines whether the insertion length field has a value greater than zero, indicating that one or more characters are to be inserted. If so, the step in box 262 selects an offset position to establish an insertion point. At the step in box 264, the token and character cache of the TIAB is cleared. Then, in the step in box 266, the code in the insertion character field is inserted from the selection made in box 262 at a position equal to the sum of the offset position and the insertion length.

In the step in box 270, it is determined whether the new offset field has a value less than zero, indicating that the insertion point, if any, should go to the end of the inserted code. If so, in step 272, the position that is the sum of the offset position and the insertion length is loaded into the new offset field. Alternatively, the TIAB can provide the correct value for the new offset field.

The test in box 274 determines whether the capitalization character field has a value equal to zero, indicating that capitalization does not need to be changed. If the uppercase character field is less than zero, the character should be changed to the lower case; if it is greater than zero, the character should be changed to the upper case. The step in box 276 selects or deletes the text code at the location indicated by the capitalization offset field. Then box 278
Step, insert the appropriate case text code at the capitalization offset position. As an alternative to capitalization, deletions and insertions as described above may be performed.

Finally, the host editor sets its selection to the location indicated by the new offset field. At this point, the host editor may perform further operations before completing the requested operation, as described above. Yet another operation is for the TIAB to invoke a select load function to keep the host's currently selected track.

Although the fixup data defines a sequence of operations that results in a proper textual punctuation structure, users may find undesirable results. Thus, the host editor also allows the user to select an operation to cancel a series of operations performed in the manner shown in FIG. Undoing this sequence of operations includes changing capitalization back to its original state, deleting inserted characters, and inserting deleted characters, at which point the text data is acquired with fix-up data. Is restored to its previous state. To allow this, the fixup data structure has fields for storing the required data.

This is also a factor 2 for some requests for processing operations.
Allow a staged approach. For example, in the cut-copy-paste paradigm, deletion is performed by deletion and type over, or by deletion and moving the insertion point to another position. The two fixup data are different because the modifications made are different.
Thus, the host editor will first treat the delete request as if it were one of these two options, and if it found that it was the other,
The sequence of operations already performed can be canceled, and then fix-up data for the appropriate sequence of operations for the other option can be obtained.

The host interface to TIAB can be extended to provide additional selection operations or additional operations that provide fixup data. In each case, a TIAB function is added to handle additional operations.

Next, consider the TIAB interface to the host. Through this TIAB interface, the TIAB function obtains the data needed to identify the text type or to identify the proper sequence of operations to provide the proper text punctuation structure. Compared to this host interface, the TIAB interface is relatively simple.

 Next, a TIAB call to the host will be described.

The main purpose of TIAB calling the host editor is to obtain data about the host's text data structure. Thus, the TIAB interface to the host includes some host functions that the TIAB can call for this purpose. The implementation of these functions depends on the manner in which the host editor is implemented, but if the host editor uses a conventional text data structure having a series of text codes, the implementation of each of the functions is relatively small. Easy.

The TIAB includes an interface function that calls a host editor pointer function to obtain a pointer to a location in the text data structure and the length of the text code string starting at that location. The host editor pointer function is implemented in turn by the appropriate call to the underlying function. For example, if the host editor on a Macintosh workstation is a Text Editor
If you are using a routine in ROM commonly known as t), you can get a pointer by calling ^* (( ^** TEH) .hText) and (( ^** TE
H) Length can be obtained by calling .teLength. The host editor pointer function then returns a value indicating the actual offset to the TIAB interface function.

In general, the TIAB requires that the host editor perform memory management on text blocks. The general approach for obtaining a text code for TIAB is as follows. That is, the host editor pointer function provides a means by which the host editor can indicate the range of text codes in its internal data structure that are read (but not modified) by the TIAB. If the host editor presents its internal data in such a way that it is inconvenient or impossible, the host manages the memory block and copies it from its internal data structure by the host editor It will provide a different set of functions to fill with characters. This includes the following functions: A text block that is gaining the ability to return a pointer to the text block using the host editor's preferred memory management method and to return the number of text codes actually copied, and the host editor responds thereto. A single text block release function to release a text block to which a function-acquiring text block is allocated, and a host processor to respond and release all text blocks to which a function-obtaining text block is allocated. All text block release function, and the last character position function that returns the index of the last text code in the text buffer of the host editor to indicate the number of text codes in the buffer, and the specified number of texts starting at the specified offset Copy Tokodo a specified text block, and the character copy function to return the number of copied text code includes. Upon releasing a text block, the TIAB can use the full text block release function or loop at each iteration through an array that calls a single text block release function.

Although the TIAB interface to the host is relatively simple, some TIABs rely on data obtained from the host.
The function performs complex calculations. Next, consider the internal work of TIAB.

 First, a TIAB call to the TIAB will be described.

The high-level TIAB functions invoked by the host editor are divided into two groups, as described above for the host interface to the TIAB. One is to provide a new selection endpoint, and the other is to provide fixup data. But TIAB against host editor
The interface has one major low-level function, the TIAB interface function, which calls the host and gets the code from the host's text data structure. There are some intermediate level TIAB functions between the high level functions and the TIAB interface functions.

The first level above the TIAB interface functions is to access code that extends forward from a given position in the text data structure of the host editor, or to obtain code that extends backward from a given position, or It contains several functions that are each called to obtain the code at the location.

TIAB does not make use of the meaning or other differences between words in text, except for differences specifically related to punctuation structure. Accordingly, the TIAB tokenizes the text codes that make up the text so that each word is identified by its essence when the word, capitalized word, abbreviation, capitalized abbreviation, and atomized word are identified. Most differences between words are ignored by expressing them in one of a small number of types, including. The essence of the word means a punctuation code, ie, a punctuation code that is part of a word and is otherwise represented by a punctuation token, but is treated differently when it occurs as part of a word. TIAB
Treats other codes related to punctuation structures as punctuation tokens of the type, ie, other types of tokens such as commas, quotes, colons, spaces, periods, multiple dashes, ellipsis, etc.

Some TIAB functions at the next level scan through the text code sequence to find each token boundary and return the appropriate token code. You can call other functions to find token boundaries. These tokenization functions depend on the number of auxiliary functions that manage the token cache they share, and therefore
Tokenization occurs dynamically and is stored to the extent possible in the token cache.

The high-level TIAB function that identifies the new selection endpoint depends on two intermediate functions that find text-type boundaries and identify the endpoint of the selection before and after the selection.

TIAB includes high-level features that provide fix-up data, some of which are specialized for the task of obtaining information about natural boundaries for use in providing fix-up data It is determined according to the intermediate function.

Next, the operation of some of these functions will be discussed in detail. After examining the representative functions that indicate the role performed by the functions at the low level, the main features of the intermediate and high level functions are discussed.

First, code access and search will be described.

FIG. 7 shows steps in a forward character search function for searching a text code forward from a designated position in a text data structure of a host editor.
FIG. 8 shows steps in the forward character set search function for searching the text data structure for a text code in a specified set of codes.

The forward search function, at box 300, at a location in the host's text data structure called the offset,
And with pointers to two locations. In one of the storage locations, the function loads a pointer to a start code, and in the other of the storage locations,
The function loads a length indicating the number of valid codes starting with the start code. In a test of box 302, it is determined whether the offset received in box 300 is less than zero, indicating a position before the beginning of the host editor's text buffer or other text data structure. If so, the forward character search function returns FALSE in box 304, indicating a failure to search for any code.

If the offset is greater than zero, box 30
In a six-step test, it is determined whether this offset is greater than or equal to the offset of a block of code called an exclusion block. The exclusion block is a test area that the TIAB interface function ignores. Thus, the exclusion block allows the paste operation to operate on the text codes as if they were after the delete operation and before the insert operation, perform the delete operation, then call TIAB, then paste Do not perform the operation and then call the TIAB again. If the offset is as large as or greater than the exclusion block offset, the exclusion block length is added to the offset in box 308.

The steps starting at box 310 relate to caches, each containing an array of entries corresponding to a block of text code. Each block's cache entry contains data defining the block, including the block's offset, length, and a pointer to the first code in the block. In the cache, entries are categorized by offset. The steps required to set up the cache include checking at box 310 whether the cache contains valid data. If not, in box 312 the cache is cleared,
Thereafter, the cache block to be loaded with the retrieved text code is selected, and in box 314 the offset and length of the text code to be retrieved are set. If the cache is valid, as measured in box 316, but the offset is above or below the cache limit, the cache block to be loaded, the offset, and the length for the search are set in box 314. , A block of text code that is similarly set and does not overlap with the previously cached highest or lowest level block is retrieved.

If the offset received in box 300 is within the cache limit, an iterative loop begins at the step in box 320, which proceeds through the previously loaded cache block and includes the offset, or Search for a cache block that has a larger cache block offset than the offset received in box 300. The test in box 322 determines whether the offset is in the next cache block, and if so, in a step in box 324 the appropriate code in the cache block is taken into account, if necessary, taking into account exclusion blocks. The code pointer and the length of the code sequence following this code in the cache block are loaded. A test in box 326 then determines whether the length of the code sequence is greater than zero. If not, box 30 as above
At 4, FALSE is returned. However, in the long case, TRUE is returned in box 328,
Indicate success.

The offset is not in any cache block, but
If it is before the offset of the previously loaded cache block, as measured by the test in box 330, then in box 332 the starting offset and length of the text code to be searched are set; These may be contiguous with previously loaded cache blocks.

If the offset does not point to a location in any previously loaded cache block outside or within the cache limits, then in box 334 the starting offset and length of the text code to be searched. Calls the TIAB interface function. First, the TIAB interface function sets up a cache block header for the text code to be searched. A call to the host pointer function causes the TIAB interface function to request a pointer to the code and length and load the pointer to the code into the appropriate cache block field. If the length is zero, the TIAB interface function calls the character copy function to get the text code. If not, the TIAB interface function sets the cache block length equal to the length from the host pointer function, and adjusts the cache block limit to include the block of text code, and finally
Returns TRUE. The forward character search function then branches at box 336 based on the result returned by the TIAB interface function. If the result is FALSE, the forward character search function also returns FALSE in box 304.
If the result is TRUE, indicating a search for a text code, then in a step in box 324, as described above,
Code pointer and length are loaded and box
Return TRUE or FAL in 326 tests
It is measured whether to return SE.

The TIAB function for searching for a backward character is similar to the forward character searching function, except that it searches for a code that moves backward from the offset. Another TIAB function uses the forward character search function to search for a code at a specified position.

The forward character set search function shown in FIG. 8 is called with two pointers. In box 350, one of the pointers is for data indicating a position in the text data structure and the other is for a bit set identifier indicating a set of text codes. In the step in box 352, the forward character search function is invoked to provide the position as an offset. The branch in box 354 is based on the result returned by the forward character search function, and the forward character set search function
If the forward character search function returned FALSE, box 356 returns FALSE. However, if the forward character search function successfully searches the sequence of text codes,
At 360 steps, an iterative loop is started, which loops through the code. The test in box 362 determines whether each code is in the set indicated by the bit set identifier. If a code is found in the set, the forward character set search function changes the position to this code and returns TRUE to indicate that the code was found in the set. If there are no codes in the set, the forward character set search function returns to the step in box 352 to search for another sequence of text codes.

Some other TIAB features include forward character set
Similar to the search function, it includes a function of searching backward and forward for a specified code and a function of searching backward for a code in a specified set.

 Next, token scanning will be described.

FIG. 9 illustrates the general steps in the backward token scan function. This function checks the text code pattern and converts the recognized pattern into a token code. Although many patterns are recognized, which causes the backward token scan function to include complex pattern matching operations, the steps in FIG. 9 do not provide details about pattern recognition.

In box 370, the backward token scan function
Begin by receiving a pointer to a scan record, ie, a data structure that has a record of the scan for the token. The scan record contains pointers to boundaries in the text data structure. In the test in box 372, it is determined whether the token boundary preceding this boundary in the text has already been scanned. If so, in the step in box 374,
The previous result from the token cache is retrieved and this is returned.

If the leading boundary had not been previously scanned, the backward character search function is invoked at the step in box 376 to retrieve the sequence of text codes to be scanned, and a similar invocation is performed if necessary. And elsewhere in the backward token scan function. If one of these functions returns FALSE, the scan will fail and a value indicating a scan failure will be returned.

In the step in box 380, a series of steps is followed to scan the text code backwards to find the next token boundary. The test in box 380 detects whether the next code is one of the punctuation codes corresponding to the token code. If so, the test in box 382 determines whether this is a punctuation code that occurs within a word. If this is not the case, the appropriate token code for the punctuation code is returned in the step in box 384.

If the word is not detected, an iterative loop is started at the step in box 390, which loops through the codes in the word and has a relationship with which token code it should be assigned to. Get any information about the abbreviation, uppercase letter, number, or other property of. This continues until a word break is detected in box 322. The appropriate token code for the word is then returned.

The backward token scan function can be complicated because the rules for word formation to which it applies are relatively complex. These can be adapted to the terms of English or other languages. The backward token scan function allows words with certain internal hyphens and apostrophes, and under certain conditions, words with commas, periods and colons. For example, the following are treated as words: That is, it's 10:30 ＄ 1,000.00 real-time This feature also allows word boundaries to be detected in word internal punctuation marks. That is, it is often convenient to be able to select word parts in this manner.

There are several other functions, including the forward token scan function, similar to the backward token scan function. That is, a function that determines whether the current position is on a token boundary, and moves forward to the next token boundary if not, and a next token boundary if the current position is not a token boundary. There is a function to move to the back. These two functions are useful for initiating a scan on token boundaries.

Table 1 shows the relationship between the text code resulting from the token scan and the token code. The text codes in Table 1 form a sentence as shown in the title.

On the other hand, token codes include codes indicating the occurrence of each of several types of punctuation codes, including left quotes (LQ), commas (C), right quotes (RQ), spaces (Sp ), And a period (P). In addition, token codes include codes for word-based types, including capitalized words (W-Cap) and plain words (W).

The TIAB function performs various operations on the token code stream to find the endpoint and provide fixup data. Next, some of these operations will be discussed.

 First, the endpoint will be described.

Some TIAB selection functions respond to host editor calls for qualification of selections. Each of these TIAB selection functions provides a new selection endpoint in response. No.
Figure 10 shows the general steps followed by these functions.

The sequence of FIG. 10 begins when one of the TIAB selection functions is invoked by the host editor. As shown in box 400, the call includes a pointer to the endpoint data structure. When the TIAB selection function returns, the host editor retrieves new endpoints from the endpoint data structure and uses them to define new selections. Calls to the TIAB selection function may also include other data. For example, a call to the function to extend the current selection by dragging would include one location and anchor point in the text data structure of the host editor, and a call to the function to extend the current selection by one instance of the text type would be: Contains code that indicates how to extend the selection and from which of its old endpoints.

The TIAB selection function begins at box 402 and measures whether it has been properly invoked. For example, the selection extension is not appropriate if there is no currently selected text unit. Similarly, the ability to raise the level of the currently selected text type is not appropriate if the currently selected text unit is the highest level text type.
If the call is not appropriate, the TIAB selection function returns the value FALSE in box 404, to which the host editor responds with an appropriate error message or signal, for example, by flushing the current selection.

If the TIAB selection function was properly invoked, this will obtain the data at box 410 to provide the endpoint and also to enable the subsequent function to provide fixup data. to continue. This data is kept in the TIAB selection data structure. This data includes, for example, data indicating the endpoints of the new selection, such as offset and length, as well as the type of the selection itself and, if the selection is for type brackets, the underlying type. Data indicating one or more text types related to the new selection, such as the token at the end of the selection, token length, and characteristics at the endpoint of the new selection, such as the text type of natural boundaries. , As well as data indicating whether the selection is capitalized. Each of the TIAB selection functions acquires this data in its own way.

The simplest of the TIAB selection functions, that is, lowering the text type level of the current selection, can adjust the right endpoint of the current selection to get a new selection, but this adjusts the right endpoint of the current selection Only when it is appropriate to do so. For example, if the current selection is of type bracket or dash, this feature will not adjust the right endpoint, but will be based on if the type on which the selection is based is larger than the type character. Decrement the existing type. However, if the selection is of a type that is larger than the type character, and if it has a natural boundary to its right with a length greater than zero, the function drops the token at the natural boundary, If this is one of the closing brackets of the selection type before decrementing, add one after.

In contrast, all of the other TIAB selection functions described above
Relies on intermediate TIAB functions to find text-type boundaries after or before a given position as needed. These intermediate functions are called with pointers to the scan record data structure,
Through this, each function returns the position at the end of the text type boundary. Each function also returns a value indicating the text type of the border.

As mentioned above, text-type boundaries always contain at least one token, and the boundary finding function
This is performed by matching the token stream with the token pattern implicitly included in the operations performed by these. What is included in this pattern is as follows. That is, a comma token is a text type boundary of a type phrase, optionally followed by a space token. Also, a semicolon, colon, dash, or three-dot ellipsis token is of the type clause, optionally followed by a space token. A period, question mark, or simple mark is followed by at least two space tokens (or followed by only one space token according to option flags intended to be set by the host editor in response to a user request);
It is of type statement. In these patterns, comma or period tokens can be followed by single or double quotation marks, and the textual type boundary of the type statement can be any number of right quotation marks and parenthesis tokens before the space token. Can be included. While these patterns are appropriate for English, similar patterns can be formulated for other natural languages. Upon identifying the text type of a text type boundary, the boundary finder loads the data defining its end and returns that type. As a special case, the boundary after the find function preliminarily measures whether its start is immediately after the token of the type abbreviation. In this case, this causes the boundary type to return immediately after the abbreviation.

Table 2 shows the relationship between the token code excerpt from the stream and the text-type code returned by the boundary after the discovery function.

The text type codes in Table 2 include characters (Ch), words (W), phrases (F), clauses (Cl), and sentences (S),
Token codes include those introduced above with respect to Table 1 and the semicolon (SC).

As can be seen from Table 2, the text type code for each token code indicates the text type of the preceding text code, so that when a series of punctuation tokens occurs, each has the same corresponding text type code. Has become. For example, each of the series of token codes corresponding to commas, quotes and spaces has a text type code for a phrase, each corresponding to a semicolon and space has a code for a clause, a period and two Each of the space counterparts has a code for the sentence. A series of tokencodes having the same text type is therefore treated as a unit having this text type and as a unit having a designated end and, if necessary, a length.

Each of the three TIAB selection functions, which depend on the boundary finding function, has a separate set of operations. The function of extending the current selection by one case calls the appropriate one of the four functions, each of which in turn calls the appropriate one of the boundary finding functions. These four functions extend from right endpoint to right, left endpoint to right, right endpoint to left, and left endpoint to left. The function that extends the current selection by dragging determines whether to invoke the boundary finding function based on whether the location in the call is before or after the anchor. The function that raises the level of the text type, after incrementing the type of the current selection, invokes both boundary finding functions in a loop that iteratively expands the selection until a suitable parenthesized or unbracketed selection is reached. This feature therefore responds to multiple clicks, with each successive click
Increment the active text type from letters to words, phrases, sections, sentences and paragraphs, and select the minimum surrounding area for that type. If the selection begins within a parenthesized structure, such as an insertion or quotation, multiple clicks will select this structure at the appropriate point in the sequence. However, if the parenthesized structure is part of the surrounding text that should be selected as a result of a click,
This structure is chosen as a whole.

After obtaining the new selection endpoint, each of the TIAB selection functions also obtains other relevant data such as boundary features and capitalization. This data is based on the aforementioned TIAB
Stored in the selection data structure.

Each of the TIAB selection functions terminates by loading the new selection endpoint into the endpoint data structure at box 412, and then
Return RUE. The host editor can then search for the new selection endpoint and use it to determine the new selection, which can be displayed as described above with respect to FIG.

 Next, the fixup data will be described.

Some TIAB features provide fixup data, including the ability to add and remove parentheses, change text type, cut select, delete select, paste select, and change capitalization. Of these features,
The cut, delete, and paste selection functions are called by the host editor after performing processing operations in the cut-copy-paste paradigm. As mentioned above, the copy selection function is also invoked as a result of a processing operation, but does not provide fixup data,
The copy selection function simply uses the TIAB selection data structure
Other TIABs that serve as AB cut buffer data structures
Copy into the selection data structure. Others of these functions provide higher level operations by providing fixup data that defines how higher level operations can be performed.

In general, the TIAB functions that provide fixup data are based on English language conventions, so each function implicitly includes a set of rules used to obtain the appropriate fixup data. Other natural languages with different conventions require different rules, and thus different features, to provide fixup data, but the sequence of operations leading to proper textual punctuation structure applies to other written natural languages Should be possible.

The parenthesis addition and deletion functions and capitalization change functions have relatively simple rules, and these rules are applied using functions such as the forward and backward natural boundary scan functions and the forward and backward token scan functions. Apply. These scanning functions scan through the text data and provide the appropriate information by returning the text type at the natural boundary and by loading the scan record data structure. On the other hand, the text type change function and the copy, delete and paste select functions have much more complicated rules, rely on an intermediate fixup search function to obtain data for the fixup operation, and The fixup search function calls the scan function as needed.

The forward and backward token scanning functions have been described above with respect to FIG. The forward and backward natural boundary scanning functions begin at the token boundary in the text data, and identify the text type of the natural boundary that includes the following tokens in a given direction, most of which implicitly include this functionally: Apply the set of rules specified. These two functions are also invoked by some of the TIAB selection functions described above, but they play a more prominent role within the TIAB fixup function.

Although the TIAB fixup functions differ greatly from each other, they follow a general pattern that involves some similar steps. All of these are called with at least one pointer to a fixup data structure, and most of these are
Called with two pointers to a fixup data structure for one end, or one of two alternative fixup data structures. Before starting to load the fixup data structure, each fixup function initializes this data structure with the appropriate offset indicating where the series of scans should be performed. Each fixup function then obtains the fixup data and loads it into the fixup data structure and qualifies the TIAB selection data structure as appropriate for processing. Finally, each fixup function returns control to the host editor function that called it, which then retrieves the fixup data and performs the sequence of operations described above with respect to FIG.

FIG. 11 schematically illustrates the nature of the data provided by the fix-up search function when called for a natural boundary, and shows how it provides data for a natural boundary. In the method shown in FIG. 11, a series of text-type codes corresponding to token codes include type character codes, and between each pair of adjacent characters, type words, phrases, clauses, and sentences shown in Table 2. Or there are other types of runs that are appropriate for word breaks, such as paragraph runs. Therefore, the text type frame in FIG.
430 contains six text type codes, the first and last of which are type characters denoted as T _ch , the second through fifth of which are other types appropriate for inter-word breaks denoted as T _hr It is.

A position 432 in FIG. 11 indicates a position in the text frame 430 at which the fixup search function starts. If the starting position 432 is within a natural boundary that is a run of the appropriate type at the break between words as in FIG.
Find 4 and right end 436. It can then get all the information it needs to load the fixup data structure. This is the starting position
Load the text type of the code between 432 and left end 434 and the text type of the code between start position 432 and right end 436. It also loads the number of token codes between the start position 432 and the left edge 434, and the number of token codes between the start position 432 and the right edge 436. This loads the tokencode of the token to the left of start position 432 and the tokencode of the token to the right. If necessary, this sets a flag, indicating that the start position 432 is immediately before the word and follows a natural boundary with a text-type code that is that of a paragraph type sentence, and the following word Indicates that it will start with a capital letter.

FIG. 12 shows the text frame 450 containing the values loaded by the fixup search function for each position.
3 shows some of the results of applying the fix-up search function at each position in FIG. Text frame 450
The text codes in correspond to the following strings: Ab), c Such a string may, for example, contain a quotation and occur at the end of an insertion phrase nested within a clause within a sentence.

The result box 452 shows the result of invoking the fix-up search function at positions between character codes within a word unit, where the type in each direction is character (CH) and the length is zero. Similarly, in result box 454, the type to the left is character and its length is zero. But to the right, the type is right parenthesis (RB) and the length is one. Result box 456
Indicates a type right parenthesis to the left, and length 1, and a type phrase to the right, and length 2. Result box 458 shows the type phrase in both directions, and a length of one. But currently TI
If the AB selection was greater than zero in length, the type to the right would be a type word because the text code at this position is a space. Finally, the result box 460
Indicates a type phrase and a length of 2 to the left, except for a type character and a length of 0 to the right.

The text type change function uses data provided by the fix-up search function, as can be seen from FIGS. 13 and 14. FIG. 13 shows steps in a series of operations for changing a text unit selection from a type word to a type phrase, and FIG. 14 shows steps for changing an insertion point selection from a type sentence to a type clause. It is.

A text frame 480 in FIG. 13 shows a shaded text unit selection of a type word. To change this to a type phrase, the text type change function calls the fixup search function at each end of the text unit selection to determine the length of the natural boundary of the type word,
Load data into fixup data structures.
This results in deletion of the text code at the natural boundary, as shown in text frame 482. The text retype function then determines what text code to insert at each end of the text unit to provide the natural boundaries of the type phrase, and loads the data into the fixup data structure. This is a text frame 484
As shown in the figure, the insertion is proper. Fix up
When the data structure is returned to the host editor,
It goes without saying that the operation at each end of the selection is performed separately. However, the same result is obtained as shown in FIG.

The text frame 490 in FIG. 14 shows the insertion point selection within the natural boundary of the type sentence. To change to a type clause, the text type change function calls the fix-up search function at the insertion point selection to determine the length to each end of the natural boundary. The text type change function then determines, as shown in box 492, what length should be removed to remove the natural border, and what text code to provide the natural border for the type clause, in this case. Determines whether to insert a semicolon and space, as shown in box 494, and loads the data indicating the deletion and insertion into the fixup data structure. In addition, the text type change function includes fixup data indicating the change of capitalization after the new natural boundary, as shown in box 494.

Other TIAB fixup operations that invoke the fixup search function perform similar steps. The delete selection function, also called by the cut selection function, calls the fixup search function for data on the left and right natural boundaries of the text unit selection being deleted. The delete selection function then applies an implicit set of rules, for example, whether to delete one natural boundary or both natural boundaries, insert another natural boundary in its place, and Determines whether to change the capitalization after the. Upon receiving a user request to perform a paste operation in the cut-copy-paste paradigm, the host editor, if currently selected,
The current selection can be deleted, and the contents of the cut buffer can be inserted at the insertion position after deletion. The host editor then invokes the paste select function, which first calls the fixup search function, and uses the excluded block described above to be adjacent to the insertion point after deletion in a manner similar to the delete selection function. Obtain data about natural boundaries. The paste select function then uses this data and the natural boundary data around the edges of the cut buffer contents obtained during the cut or copy operation to obtain fixup data, and applies slightly different rules to the left of the insertion phrase. And apply to the right.

In addition to invoking the fixup search function, the paste select function invokes several other functions to assist in obtaining fixup data and, if necessary,
Qualify the TIAB selection data structure. However, in general, the paste selection function follows the same general steps as other TIAB fixup functions.

 Next, other items will be described.

Various modifications, extensions and changes can be made to the above disclosure within the scope of the present invention. The traditional host editor provides a TIAB selection function and TI
By providing a routine for invoking the AB fixup function, and by modifying the routine that performs the processing operation to call the TIAB fixup function, and for responding to TIAB calls for data. By providing the routine, it could be modified to accept TIAB. In contrast, the present invention can be implemented without a separate host editor, but by including these functions within the TIAB.

The above embodiment is suitable for the cut-copy-paste paradigm of text editing. This can easily be extended to handle the edit move / copy paradigm or any other suitable paradigm.

In general, the rules and patterns applied may be implicit in function, or, alternatively, the rules and patterns may optionally be included in a separate data structure as shown for the pattern in FIG. Good. The rules and patterns described above resolve all ambiguities in punctuation in a given manner, but may also inspire the user to resolve some troublesome ambiguities.

TIAB assumes that the position in the host editor's character buffer can be described as a 32-bit integer.
This can be generalized with a more abstract notion of buffer location, so it is more easily applicable to more types of host editors.

When the host editor accesses a function, such as spell checking or search and find, the result of invoking such a function may have implications for the punctuation structure. Therefore,
Additional fixups can be added to TIAB to perform such operations.

Although the present invention has been described with reference to various embodiments in which modifications, changes, and extensions have been made, other modifications, changes, and extensions are possible within the scope of the present invention. That is, the present invention is not limited to the above description or drawings, and the scope of the present invention is as described in the claims.

[Brief description of the drawings]

FIG. 1 is a flowchart with parallel text frames showing the general steps in the processing operation according to the invention;
FIG. 2 is a block diagram showing components of a device including a host editor and a punctuation device according to the present invention.
FIG. 4 is a flowchart showing the general steps in a selection operation performed by a device similar to the device of FIG.
The flowchart is performed by a device similar to the device of FIG. 2 and shows general steps in a processing operation or other operation involving fix-up data, FIG.
FIG. 6 is a flowchart showing host editor steps in modifying a selection, FIG. 6 is a flowchart showing host editor steps in performing a series of operations defined by fix-up data, and FIG. FIG. 8 is a flowchart showing steps in searching for a text code from a text data structure, FIG. 8 is a flowchart showing steps in searching a text data structure of a host editor for a text code, and FIG. FIG. 10 is a flowchart showing steps in scanning a code, FIG. 10 is a flowchart showing general steps in a punctuation device selection operation, FIG. 11 is a schematic diagram showing a series of text type codes including text type boundaries, FIG. Figure determined between adjacent text codes Schematically illustrates a series of text codes indicating the characteristics of the text type boundaries, 13 schematic diagram showing the text code sequence indicating a change of the text type of the text type boundary at the end of the text unit selection, 14
The figure is a schematic diagram showing a text code sequence showing a text type change at a text type boundary containing an insertion point. 52: Processor 60: Program memory 62: Host editor 64: Punctuation device 70: Data memory 72: Text data structure 74: Host selection data structure 76: Selection data structure of punctuation device 78: … Pattern 80 …… Fixup data structure 82 …… Endpoint data structure

Continuation of the front page (56) References JP-A-62-290966 (JP, A) JP-A-61-107469 (JP, A) JP-A-63-193263 (JP, A) JP-A-2-56671 (JP) , A)

Claims (4)

(57) [Claims] An input unit for inputting a sentence; a selecting unit for selecting a position or a portion of the sentence input by the input unit; and an editing unit for editing the selected position or the portion of the sentence. And a punctuation mark or space containing at least one of a comma, a period, a semicolon, a colon, a dash, a quotation mark, parentheses, and square brackets related to the boundary of the edited text. Correction data generating means for generating data for correction by deletion or insertion of one or both of the punctuation mark and space; and correct punctuation mark at the boundary of the edited sentence in accordance with the correction data Or a sentence correcting means for performing a correction for providing a space. 2. The natural language text editing apparatus according to claim 1, wherein the editing is any one of copy, move, insert, and delete. 3. A natural language text editing apparatus according to claim 2, wherein said correction data generating means includes a punctuation mark associated with a boundary of a character string inserted by said editing means or a character string deleted by said editing means. A natural language text editing device for generating data for correcting a mark or a space. 4. A natural language text editing apparatus according to claim 3, wherein said correction data generating means defines one or more sequences of processing operations for correcting an incorrect sentence. Natural language text editing device.