JP5325309B2 - Method for optimizing character string processing during program execution, and computer system and computer program thereof - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To provide a mechanism for producing a program of high execution efficiency without lowering productivity of the program. <P>SOLUTION: There is provided a method of optimizing processing on character strings in program execution using characteristic information representing characteristics of the character strings made to correspond to the character strings in a computer system which executes a program including processing on character strings. The method includes the steps of: determining characteristic information on at least one character string of a first character string and a second character string as a result of arithmetic processing based on characteristics as to the first character string and the arithmetic processing the relating to the first character string; and making the determined characteristic information correspond to the at least one character string. The present invention relates to the computer system that executes the program including the processing on the character strings and optimizes the processing on the character strings in the program execution using the characteristic information, and the computer program. <P>COPYRIGHT: (C)2012,JPO&amp;INPIT

Description

  The present invention relates to a method for optimizing character string processing during program execution, and a computer system and computer program therefor.

  In many programming language class libraries, a class for holding a character string (hereinafter, a character string class) is prepared as a standard class. Programmers can improve the productivity of programming work by utilizing the extensive class library provided in the system. However, the classes provided in the class library are created for general purposes. Therefore, a program with high execution efficiency is not necessarily produced using the above class.

  For example, in the Java (trademark) language, a java.lang.String class (hereinafter referred to as a String class) is prepared as one of character string classes. The String class provides a replaceFirst () method that converts a part in a character string that matches a specified regular expression to another character string. The regular expression specified in the replaceFirst () method does not necessarily include the regular expression metacharacters. For example, a regular expression that does not include the meta character “set” may be specified. With this designation, the character string “set” is converted into a character string “get”, for example.

  The above conversion can also be implemented by combining, for example, the String.indexOf () method and the String.substring () method. When conversion by the above combination is implemented, the program execution speed is faster than the implementation by the replaceFirst () method. On the other hand, the productivity and versatility of the program is lower than when the replaceFirst () method is implemented.

  When priority is given to the execution speed of the program, for example, a method can be considered in which the programmer uses the replaceFirst () method and the above combination depending on whether the regular expression includes metacharacters or not, and creates code. However, if it is not determined until the program execution whether the regular expression contains metacharacters, the programmer must prepare both the implementation with the replaceFirst () method and the implementation with the above combination, and maintain both implementations. To do is not realistic.

  The programmer improves the productivity of programming work by using the character string class prepared in the system. However, since the character string class is created for general purposes, a program with high execution efficiency is not necessarily produced. Therefore, there is a demand for a mechanism for producing a program with high execution efficiency without reducing the productivity of the program.

The present invention provides a computer system that executes a program for processing the string, by using the characteristic information representing the characteristics of the character string associated with the string, the processing of the character string at runtime the program Provide a way to optimize. The method includes causing a computer system to perform the following steps. The step is
From the characteristic of the first character string and the arithmetic processing related to the first character string, the character string of at least one of the first character string and the second character string that is the result of the arithmetic processing is calculated. Determining characteristic information;
Associating the determined characteristic information with the at least one character string.

  In one embodiment of the invention, the method includes causing the computer system to further perform the following steps. This step includes a step of selecting the optimized process according to the associated characteristic information and executing the process when executing a process related to the character string associated with the characteristic information. .

In one embodiment of the present invention, the arithmetic processing generates at least one second character string into which at least one first character string is substituted, and the at least one first character string is generated at the time of generation. Including sequentially processing character by character,
The determining step further includes a step of executing the sequential processing and a step of examining the character to be sequentially processed together with the sequential processing, whereby characteristic information of the at least one second character string is determined. .

In one embodiment of the present invention, the arithmetic processing includes sequentially processing at least one of the first character strings whose characteristic information is unknown or not associated one character at a time,
The determining step further includes a step of executing the sequential processing and a step of inspecting the character to be sequentially processed together with the sequential processing, whereby the at least one characteristic information is determined.

In one embodiment of the present invention, the arithmetic processing is arithmetic processing for at least one first character string,
The step of determining includes a step of determining characteristic information of at least one second character string from the characteristic information for each of the at least one first character string and the arithmetic processing.

  In one embodiment of the present invention, the characteristic information indicating the characteristic of the character string includes at least one first character indicating that the character string includes, does not include, or does not include whether the character string belongs to a character set. 1 information and 2nd information showing that the said character string contains the character which does not belong to the said character set, it is not included or it is unknown whether it is included.

  In one embodiment of the present invention, the character set is a second character set that collectively represents at least two first character sets, and the characters included in each of the at least two first character sets overlap. Each of the first information represents that the character string includes, does not include, or is unknown whether the character string belongs to each of the first character sets, and the second information This indicates that the character string includes characters that do not belong to all of the first character set, does not include the character string, or whether it is unknown whether the character string is included.

  In one embodiment of the present invention, the character set is a second character set that collectively represents at least two first character sets, and the characters included in each of the at least two first character sets overlap. The first information represents that the character string includes, does not include, or is unknown to include characters belonging to the second character set, and the second information is the character string. Indicates that the character does not belong to the second character set, does not include, or whether it is unknown.

  In one embodiment of the present invention, the first information and the second information are represented by bit strings, and each bit corresponds to a character set or a character set that does not belong to any character set.

In one embodiment of the present invention, the arithmetic processing combines the first character string associated with the first characteristic information and the first character string associated with the second characteristic information. Arithmetic processing,
The step of determining includes the step of determining the characteristic information obtained by the logical sum of the first characteristic information and the second characteristic information as the characteristic information of the second character string.

In one embodiment of the present invention, the calculation processing deletes the first character string associated with the second characteristic information from the first character string associated with the first characteristic information. And
The step of determining includes the step of determining the first characteristic information as characteristic information of a second character string.

In one embodiment of the present invention, the calculation processing deletes the first character string associated with the second characteristic information from the first character string associated with the first characteristic information. When the character belonging to the character set represented by the second characteristic information is not included in the first character string associated with the first characteristic information by the calculation process,
The step of determining includes a step of determining characteristic information obtained by a logical product of the first characteristic information and the second characteristic information as characteristic information of the first character string.

In one embodiment of the present invention, the step of determining character string characteristic information for at least one of the first character string and the second character string that is a result of the arithmetic processing,
Determining the characteristic information obtained by the logical sum of the first characteristic information and the second characteristic information as the characteristic information of the second character string; and determining the first characteristic information as the characteristic of the second character string. The characteristic information by combining at least two of the step of determining the information and the step of determining the characteristic information obtained by the logical product of the first characteristic information and the second characteristic information as the characteristic information of the first character string The step of determining.

  In one embodiment of the present invention, the character set includes a group of uppercase letters, a group of lowercase letters, a group of numbers, a group of two-byte characters, a group of Roman characters, a group of identical character code characters, a special character of a regular expression. This represents at least one selected from the group consisting of a group of characters that can be expressed by 8 bits and a group of special characters in URL encoding.

In one embodiment of the present invention, the arithmetic processing includes generating at least one second character string that substitutes at least one first character string,
The step of determining includes the step of determining characteristic information of the second character string from characteristic information about the at least one first character string.

In one embodiment of the present invention, the arithmetic processing includes a process of generating a character string and substituting at least one first character string into at least one second character string one character at a time during the generation,
The step of determining further includes the step of executing the process of substituting, and the step of examining the character to be substituted together with the substituting, whereby the characteristic information of the at least one second character string is determined.

  In one embodiment of the present invention, in a programming language in which the character string is handled as an object, the arithmetic processing related to the character string is the arithmetic processing related to the object, and the characteristic information is included in the object.

The present invention also provides a computer program for executing a program for processing the string. The computer program causes a computer system to execute the steps of the method described above.

The present invention also executes a program for processing the string, by using the characteristic information representing the characteristics of the character string associated with the string, optimizing the processing of the character string at runtime the program A computer system is provided. The computer system
From the characteristic of the first character string and the arithmetic processing related to the first character string, the character string of at least one of the first character string and the second character string that is the result of the arithmetic processing is calculated. A determination unit for determining characteristic information;
An association unit that associates the determined characteristic information with the at least one character string.

  In one embodiment of the present invention, when a process related to a character string associated with the above characteristic information is executed, an optimized process is selected according to the associated characteristic information and the above process is performed. An execution unit is further included.

In one embodiment of the present invention, the arithmetic processing generates at least one second character string into which at least one first character string is substituted, and the at least one first character string is generated at the time of generation. Including sequentially processing character by character,
The determination unit executes the sequential processing, and inspects the characters to be sequentially processed together with the sequential processing. Thereby, the characteristic information of the at least one second character string is determined.

In one embodiment of the present invention, the arithmetic processing includes sequentially processing at least one of the first character strings whose characteristic information is unknown or not associated one character at a time,
The determination unit executes the sequential processing, and inspects the characters to be sequentially processed together with the sequential processing. Thereby, the at least one characteristic information is determined.

In one embodiment of the present invention, the arithmetic processing is arithmetic processing for at least one first character string,
The determination unit determines characteristic information of at least one second character string from the characteristic information for each of the at least one first character string and the arithmetic processing.

In one embodiment of the present invention, the arithmetic processing combines the first character string associated with the first characteristic information and the first character string associated with the second characteristic information. Arithmetic processing,
The determination unit determines the characteristic information obtained by the logical sum of the first characteristic information and the second characteristic information as the characteristic information of the second character string.

In one embodiment of the present invention, the calculation processing deletes the first character string associated with the second characteristic information from the first character string associated with the first characteristic information. And
The determination unit determines the first characteristic information as characteristic information of the second character string.

In one embodiment of the present invention, the calculation processing deletes the first character string associated with the second characteristic information from the first character string associated with the first characteristic information. When the character belonging to the character set represented by the second characteristic information is not included in the first character string associated with the first characteristic information by the calculation process,
The determination unit determines the characteristic information obtained by the logical product of the first characteristic information and the second characteristic information as the characteristic information of the first character string.

  In one embodiment of the present invention, the determination unit may convert the characteristic information obtained by the logical sum of the first characteristic information and the second characteristic information to the characteristic information of the second character string. A step of determining, a step of determining the first characteristic information as characteristic information of the second character string, and characteristic information obtained by a logical product of the first characteristic information and the second characteristic information. The characteristic information is determined by combining at least two of the determination steps with character string characteristic information.

In one embodiment of the present invention, the arithmetic processing includes generating at least one second character string that substitutes at least one first character string,
The determination unit determines characteristic information of the second character string from characteristic information about the at least one first character string.

In one embodiment of the present invention, the arithmetic processing includes a process of generating a character string and substituting at least one first character string into at least one second character string one character at a time during the generation,
The determination unit checks the character to be substituted together with the step of executing the substitution process and the substitution. Thereby, the characteristic information of the at least one second character string is determined.

  According to the embodiment of the present invention, the optimized process that is executed at high speed according to the contents of the character string or the value of the character string is dynamically switched and executed when the program is executed. Since the optimized processing is prepared in the class library, the implementation speed of the program is improved without reducing the productivity of the programmer.

The structure of the character string object at the time of mounting by Java (trademark) in the embodiment of this invention is shown. It is a figure for demonstrating determination of the characteristic information shown in FIG. 1 in the embodiment of this invention. An implementation example for propagating characteristic information included in the character string object shown in FIG. 1 to another character string object in the embodiment of the present invention will be described. 2 shows a flowchart of processing for generating the character string object shown in FIG. 1 in the embodiment of the present invention. The example of the flowchart of the arithmetic processing which includes processing the character string contained in the character string object shown in FIG. 1 in the embodiment of this invention one character at a time is shown. The example of the flowchart of the arithmetic processing including collectively processing the character string contained in the character string object shown in FIG. 1 in the embodiment of this invention is shown. The program code for demonstrating the Example of Example 1 in the embodiment of this invention is shown. The program code for demonstrating the Example of Example 2 in the embodiment of this invention is shown. The state transition diagram regarding the program in description of the following FIG. 4D in the embodiment of this invention is shown. The program code for demonstrating the Example of Example 3 in the embodiment of this invention is shown. The program code for demonstrating the Example of Example 4 in the embodiment of this invention is shown. 3C shows an example of program code for implementing the processing of the flowchart shown in FIG. 3A in the embodiment of the present invention. 2 shows an example of a functional block diagram illustrating functions of a computer system that optimizes character string processing during program execution in an embodiment of the present invention. FIG. FIG. 6 shows a hardware block diagram of the system shown in FIG. 5 in an embodiment of the present invention.

  In the embodiment of the present invention, the “character string” refers to a series of one or more characters. The character is character data of a character code used as a character expression in the program. The character code is, for example, EUC-JP, Shift_JIS, or UTF-8, but is not limited thereto. A character may also be a meaningful character, such as a tab character, a newline character, an escape character, or a special character of a regular expression. A special character of a regular expression is a character for collectively expressing a character string of a certain pattern. The special characters of the regular expression are, for example, “+” representing one or more repetitions in the regular expression “[az] + [0-9]”, “[” and “] representing the start and end of character range specification. However, it is not limited to these.

In an embodiment of the present invention, the term "program for processing the character string", at the time of execution of the program is a program to perform some processing on the string. The above processing also includes processing for, for example, a variable, structure, or object in which the character string is stored. The above processing is, for example, processing for generating a character string, processing for copying a character string, processing for searching for any character included in the character string, processing for converting a character included in the character string into another character, character string However, the present invention is not limited to these. However, the present invention is not limited to these.

In the embodiment of the present invention, the “character string characteristic” refers to a characteristic of at least one character included in the character string. The above characteristics are that the characters are, for example, uppercase letters, lowercase letters, numbers, double-byte characters such as Japanese, Chinese, alphabets, and the same character code characters. It is a special character of regular expression, a character that can be expressed by 8 bits, a special character in URL encoding, or a character that is not the above example, but is not limited thereto.
In the embodiment of the present invention, the “character set” is a set of characters having the above-mentioned common characteristics. For example, a set of uppercase letters, a set of lowercase letters, a set of numbers, a set of 2-byte characters, a set of alphabets, a set of the same character code characters, a set of special characters of regular expressions, a character that can be expressed in 8 bits A set, a set of special characters in URL encoding, or a set of characters that do not belong to a certain set, but is not limited thereto. A plurality of character sets in which characters included in the character set do not overlap may be collectively represented as one character set.

  In the embodiment of the present invention, the “characteristic information” is information representing the character string characteristic. The characteristic information is prepared for each character string. The characteristic information includes at least one first information indicating that the character string includes, does not include, or is unknown whether the character string belongs to the character set, and the character string includes a character that does not belong to the character set. And second information indicating that it is not included or is unknown.

  In the embodiment of the present invention, “optimizing character string processing” means that when the character string processing includes a plurality of processes, the computer system executes the plurality of processes when the character string processing is executed. Is to select and execute a process with high execution efficiency according to the character string characteristic information. A process with high execution efficiency according to character string characteristic information is, for example, a process in which the first process can be applied to any character string, and a character associated with the characteristic information with the second process. In the case of a process that can be applied only to a column, the second process is executed faster than the first process and obtains the same result as the first process, but is not limited thereto. The optimized processing includes processing with high execution efficiency according to the character string characteristic information.

  In the embodiment of the present invention, “arithmetic processing relating to a character string” refers to some arithmetic processing on a character string executed in a program or an area in which the character string is stored. Arithmetic processing for the character string executed in the program includes, for example, generation of a character string, duplication of the character string, search for an arbitrary character included in the character string, conversion of the character included in the character string to another character, Extraction of an arbitrary character from a character string, connection between character strings, comparison between character strings, or acquisition of information related to a character string are not limited thereto. The processing for the area storing the character string executed in the program is, for example, securing a memory area to which the character string is allocated, but is not limited to this.

  In the embodiment of the present invention, “sequentially processing a character string one character at a time” means that the computer system individually executes processing for each character included in the character string. For example, in a process of searching for a character from a character string, when the computer system checks all characters included in the character string and uses all hit characters as search results, the search is performed sequentially for each character string. It corresponds to processing. On the other hand, when the computer system uses a hit character without checking the remaining characters when the search target character hits, the search does not correspond to processing the character string one character at a time. .

  In the embodiment of the present invention, “inspecting sequentially processed characters” means obtaining character characteristics. Characteristic characteristics are that the character to be sequentially processed is, for example, upper case, lower case, number, two-byte character, alphabet, the same character code character, It is a special character of regular expression, a character that can be expressed by 8 bits, a special character in URL encoding, or a character that is not the above example, but is not limited thereto.

Embodiments of the present invention will be described below with reference to the drawings. It should be understood that this embodiment is for the purpose of illustrating a preferred embodiment of the invention and is not intended to limit the scope of the invention to what is shown here. Further, throughout the following drawings, the same reference numerals denote the same objects unless otherwise specified.
In the following, a case where the embodiment of the present invention is implemented using Java (trademark) will be described as an example. In Java (trademark), a character string operation is executed via a character string object. Therefore, in the case of Java (trademark), the character string in the claims indicates the character string object itself or a character string included in the character string object.

FIG. 1 shows the structure of a character string object when implemented in Java (trademark) in an embodiment of the present invention.
The character string object (101) includes a character string (102) and characteristic information (103). The characteristic information (103) may be included in an area different from the character string object (101) on the memory associated with the character string object (101). The character string object (101) is stored on the memory. The character string object (101) is generated from the character string class prepared in the class library. The class library is, for example, a Java ™ class library in Java ™, but is not limited thereto. The character string class is, for example, a java.lang.String class (String class) in Java (trademark), but is not limited thereto.

  The character string (102) is invariable or variable character string data including at least one character. Invariant means that the character string does not change until the character string object (101) is released. “Variable” means that the character string can change until the character string object (101) is released.

The characteristic information (103) is information indicating what characteristic the character included in the character string (102) has. The characteristic is, for example, that the letters are uppercase letters, lowercase letters or numbers, or a combination thereof, but is not limited thereto. The characteristic information (103) includes first information (103a) and second information (103b). The first information (103a) represents that the character string (102) includes a character belonging to the character set (104), does not include the character, or does not include the character. The second information (103b) indicates that the character string (102) includes a character that does not belong to the character set (104), does not include the character, or whether it is unknown. The character set (104) is a collection of characters having the same characteristics. The character set (104) is, for example, a group of uppercase letters, a group of lowercase letters or a group of numbers, or a combination thereof, but is not limited thereto. For example, a plurality of character sets in which characters included in the character sets do not overlap may be one character set.
The characteristic information (103) may be stored in another location on the memory associated with the character string object (101).

The characteristic information (103) is used for determination for executing high-speed processing in a method for processing the character string object (101).
The characteristic information (103) indicates, for example, any of the following cases 1 to 4 by a combination of the first information (103a) and the second information (103b).
Case 1. All characters included in the character string (102) belong to the character set (104). Case 1 indicates that the first information (103a) includes characters belonging to the character set (104), and the second information (103b) does not include characters that do not belong to the character set (104). Represents.
Case 2. All characters included in the character string (102) do not belong to the character set (104). Case 2 indicates that the first information (103a) does not include characters belonging to the character set (104), and the second information (103b) includes characters that do not belong to the character set (104). Represents.
Case 3. The character string (102) includes both characters belonging to the character set (104) and characters that do not belong. Case 3 represents that the first information (103a) includes characters belonging to the character set (104), and the second information (103b) includes characters not belonging to the character set (104). ing.
Case 4. The characters included in the character string (102) have not been inspected. In case 4, it is unknown that the first information (103a) includes characters belonging to the character set (104), and the second information (103b) does not belong to the character set (104). It is unclear to contain.

The characteristic information (103) may be represented by a bit string.
Each bit corresponds to the first information (103a) or the second information (103b). The first information (103a) is, for example, “1” indicating that the character string (102) includes a character belonging to the character set (104), and not including or including a character belonging to the character set (104). Something can be represented by a bit with “0”. The second information (103b) is, for example, “1” that the character string (102) includes a character that does not belong to the character set (104), or does not include or includes a character that does not belong to the character set (104). It can be represented by a bit with “0” being unknown.
When the first information (103a) and the second information (103b) are represented by bits, the case 1 is “10”, the case 2 is “01”, the case 3 is “11”, and the case 4 Is represented by a bit string "00".

In the example represented by the bit string, when the characters included in each of the plurality of character sets are exclusive, the plurality of character sets can be handled together. In the case of handling the above collectively, 1 bit is assigned to each character set as the first information (103a), and 1 bit is assigned to the character set that does not belong to any of the character sets as the second information (103b). Assigned.
For example, a group of uppercase letters (hereinafter referred to as uppercase set), a group of lowercase letters (hereinafter referred to as lowercase set), and a group of numbers (hereinafter referred to as number set) are mutually exclusive sets of characters. Therefore, 1 bit can be assigned to the uppercase set as the first information, 1 bit can be assigned to the lowercase set as the first information, and 1 bit can be assigned to the number set as the first information. Further, one bit can be assigned as the second information to a set of characters that is neither uppercase letters, lowercase letters, or numbers (hereinafter, other sets). As a result of the assignment, the characteristic information (103) is represented by a total of 4 bits, 3 bits corresponding to the first information and 1 bit corresponding to the second information. In the following example, the 4 bits are represented in order from the right in the order of a bit string corresponding to uppercase information, a bit string corresponding to lowercase information, a bit string corresponding to a number set, and a bit string corresponding to other sets.
The characteristic information “0001” indicates that the character string “includes capital letters”.
The characteristic information “0010” represents that the character string is “including lowercase letters”.
The characteristic information “0100” indicates that the character string “includes numbers”.
The characteristic information “1000” indicates that the character string “includes characters other than uppercase letters, lowercase letters, and numbers (hereinafter, other characters)”.
Note that the number of bits where “1” is set is not limited to one. For example, the characteristic information “1110” indicates that the character string “includes lowercase letters, numbers, and other characters”.

The computer system can reduce the number of bits for representing the characteristic information by handling a plurality of character sets collectively as compared to a case where the character sets are not handled collectively.
When handling a plurality of character sets collectively, 4 bits are required in the above example. On the other hand, when a plurality of character sets are not handled together, 2 bits are required as characteristic information representing one character set as shown in the examples of cases 1 to 4 above. Therefore, when a plurality of character sets are not handled together, the number of bits required for the three character sets of the upper case set, the lower case set, and the number set is 2 bits * 3 = 6 bits.

FIG. 2A is a diagram for describing the determination of the characteristic information shown in FIG. 1 in the embodiment of the present invention.
The computer system obtains the result of the first character string (203) and the arithmetic processing (205) from the characteristic (202) of the first character string and the arithmetic processing (205) related to the first character string (203). Character string characteristic information (204 or 207) for at least one of the second character strings (206) is determined.
The characteristic (202) of the first character string is determined and stored as the first characteristic information (204), and the computer system checks the character of the first character string (203), for example. May be required. When the characteristic (202) of the first character string is obtained by the computer system, the computer system determines the obtained characteristic as the first characteristic information (204).
The first character string (203) is a character string that is a target of the arithmetic processing (205). The first character string (203) may be a single character string or a plurality of character strings. As shown in the specific example 1 (201a), when the calculation process (205) is a process of combining, for example, the character string “ABC” (203a) and the character string “DEF” (203b), the character string “ABC” ( 203a) and the character string “DEF” (203b) correspond to the first character string (203).
The first characteristic information (204) is information associated with the first character string (203). The first characteristic information (204) may already be associated with the first character string (203), or may be obtained by examining the characters of the first character string (203) by the computer system, The characteristic determined as one characteristic information (204) may be used.
The arithmetic processing (205) includes, for example, generation of a character string, duplication of the character string, search for an arbitrary character included in the character string, conversion of the character included in the character string into another character, and conversion of an arbitrary character from the character string. Extraction, combination of character strings, comparison between character strings, or acquisition of information related to character strings, but is not limited thereto.
The second character string (206) is a character string in which the result of the calculation is stored. As shown in the specific example 1 (201a), when the calculation process (205) is a process of combining, for example, the character string “ABC” (203a) and the character string “DEF” (203b), the added result The character string “ABCDEF” (206a) corresponds to the second character string (206). The second character string (206) may be a single character string or a plurality of character strings. As shown in the specific example 2 (201b), when the calculation process (205) is a process of extracting a character string by two characters from the character string “abcdef” (203c), for example, the extracted character string “ab” Each of the character string “cd” (206c) and the character string “ef” (206d) corresponds to the second character string.
The second characteristic information (207) is information associated with the second character string (206). The second characteristic information (207) can be determined from the characteristic (202) of the first character string and the calculation process (205).
In specific example 1 (201a), the first characteristic information (204a and 204b) is “all capital letters”. Thus, the characteristics (202a and 202b) are also “all capital letters”. In the operation (205a) for combining character strings of “all capital letters”, the character string resulting from the calculation is also “all capital letters”. Therefore, the second characteristic information (207a) can be determined as “all capital letters”.
In specific example 2 (201b), the first characteristic information (204c) is “all lowercase”. Therefore, the characteristic (202c) is also “all lowercase”. In the operation (205b) for extracting the character string from the character string “all lowercase”, the character string resulting from the operation is also “all lowercase”. Therefore, the second characteristic information (207b to 207d) can be determined as “all lowercase characters”.

The determination is executed at the timing shown in the following first to third modes when the program is executed. The characteristic information determined by the above determination is added to the character string object (FIG. 1, 101). By the addition, the character string and the characteristic information are associated with each other.
A. 1st aspect Characteristic information (FIG. 1, 103) can be added to a character string object (101) according to the character string object (101) being produced | generated from a character string class. The computer system can determine whether the characteristic information of the character string (FIG. 1, 102) included in the generated character string object (101) can be determined from the character string object (101) of the generation source or sequentially with respect to the character string of the generation source. When the inspection can be performed simultaneously with the processing, the characteristic information (103) obtained by the determination or the inspection is added to the generated character string object (101).
The addition of the characteristic information is possible for both the character string object that holds the variable character string and the character string object that holds the invariant character string. In particular, in a character string object that holds an invariant character string, for example, a String object in Java (trademark), once the character string object (101) is generated, the character string included in the character string object (101) does not change. . Therefore, the character string characteristic information (103) included in the character string object (101) does not change. Accordingly, the computer system performs garbage collection on the character string object (101) to which the characteristic information (103) is added according to the object generation, and the character string object (101) is garbage collected. It can be used until it is done.

B. According to the second aspect, the characteristic information (103) is checked simultaneously with the sequential processing for the character string (102) included in the character string object (101) to which the characteristic information (103) is not added. It can be added to the character string object (101).
The effect of the character string object (101) including the characteristic information (103) is that the process optimized by the characteristic information (103) is executed. Therefore, if an optimized process is never executed for a certain character string object, the inspection cost is wasted. In order to reduce the cost, when a method for processing a character string includes a process for sequentially processing the contents of the character string one character at a time, the computer system performs a characteristic check simultaneously with the processing.

C. Third Aspect The characteristic information (103) indicates that the result of the arithmetic processing is obtained when the arithmetic processing of at least one character string object (hereinafter referred to as an operation source object) to which the characteristic information (103) is added is executed. It can be added to at least one character string object (hereinafter, result object) to be stored. The computer system adds the determined characteristic information (103) to the result object in response to the determination of the characteristic information to be added to the result object from the calculation source object and the content of the calculation process. The arithmetic processing is, for example, processing for combining character strings, processing for extracting a character from a character string, or processing for converting a character string into another character string, but is not limited thereto.

Hereinafter, the third aspect will be described with an example. For example, it is assumed that the first character string object includes a first character string that is all capital letters, and the second character string object includes a second character string that is all capital letters.
When combining the first character string and the second character string, the computer system may determine that the combined character string is also composed entirely of capital letters. Therefore, the computer system can set the characteristic information added to the result object as information representing, for example, “all capital letters”.
When a certain character is extracted from the first character string, the computer system uses the first character string from which a part of the character string is extracted (hereinafter referred to as a first result character string) and the extracted part of the character string. It can be determined that both (hereinafter, the second result character string) are composed of all capital letters. A case where a character is extracted from the first character string is, for example, a case where a String (trademark) method of Java (trademark) language that extracts a part of the character string is applied to the first character string object. Therefore, the computer system can use, for example, characteristic information added to the result object including the first result character string and / or the result object including the second result character string as information representing “all capital letters”. . Note that the result object including the first result character string may be the first character string object.
When converting the first character string to another character string, for example, a lowercase character string, the computer system may determine that the converted character string is composed entirely of lowercase characters. Therefore, the computer system can use, for example, the characteristic information added to the result object as information representing “all lowercase letters”.

FIG. 2B shows an implementation example for propagating the characteristic information included in the character string object shown in FIG. 1 to another character string object in the embodiment of the present invention.
The addition of the characteristic information to the result object according to the third aspect is referred to as “propagation of characteristic information from the calculation source object to the result object”. The process for propagating includes processing contents of a method for manipulating a character string and characteristic information (hereinafter referred to as s1, s2,..., Sn) included in at least one character string object to be processed. Hereinafter, it depends on attr1, attr2,. Note that the characteristic information is represented by a bit string. The bit string may be a bit string assigned so as to collectively handle a plurality of character sets, or may be a bit string assigned 2 bits for each character set. In many cases, the process for the propagation is one or a combination of at least two of the processes indicated by the first code (211) to the third code (213) shown below.
In the process indicated by the first code (211), the characteristic information added to the result object when the character string object to which the characteristic information attr1 is added and the character string object to which the characteristic information attr2 is added is combined. This is a calculation process. In the process indicated by the first code (211), the characteristic information added to the result object is obtained by the logical sum of the characteristic information attr1 and the characteristic information attr2.
The process indicated by the second code (212) is performed when the character string included in the character string object added with the characteristic information attr2 is deleted from the character string included in the character string object added with the characteristic information attr1. This is a process of calculating characteristic information added to the result object. Here, the character string to be deleted may be a dynamic character string represented by a regular expression, for example. In the process indicated by the second code (212), characters in the character set corresponding to the characteristic information attr2 may remain in the character string object to which the characteristic information attr1 is added. Therefore, the characteristic information attr1 is the characteristic information added to the result object.
In the process indicated by the third code (213), all character strings included in the character string object added with the characteristic information attr2 are deleted from the character string included in the character string object added with the characteristic information attr1. This is a process for calculating the characteristic information added to the result object. In the process indicated by the third code (213), the characteristic information added to the result object is obtained by the logical product of the characteristic information attr1 and the characteristic information attr2.

  The class library creator determines the combination of the first code to the third code (211 to 213) from the original processing contents of the method for manipulating the character string, and adds the process for propagating the program to the program. be able to. By this addition, at the time of program execution, for example, the characteristic information is propagated and added to the result object without sequentially checking the character string included in the result object.

In the following, an example of the added code will be shown by taking three methods of the String class in Java (trademark) as an example.
The String.concat () method is a method for adding a character string to a character string. Therefore, the code to be added is the first code (211).
The String.substring () method is a method for cutting out a part of a character string. Therefore, the code to be added is the second code (212).
The String.replaceFirst () method is a method for replacing a part of a character string. Therefore, the added code is a combination code of the first code (211) and the second code (212).
The String.toUpper () method is a method for converting lowercase letters to uppercase letters. Therefore, the added code is a combination code of the first code (211) and the third code (213).

If the string object has specific characteristic information, the computer system causes the optimized code to be executed in the above method. When the character string object does not have specific characteristic information, the computer system causes the original normal version code not optimized to be executed in the above method.
To run the program, the normal version of the code is required regardless of the presence or absence of the optimized version of the code. The computer system operates the program correctly by always executing the processing for the character string object to which the characteristic information is not added with the normal version code. In addition, when the characteristic information is checked at the same time as the normal version of the code, the optimized version of the code is executed according to the characteristic information when the character string object is processed with the above method for the second time or later. Can be done.

  Below, the example of the variation of the characteristic information added to a character string object is shown. In addition, the variation of characteristic information is not limited to the example of the following Examples 1-4.

Example 1. "Do not include uppercase letters" and "Do not include lowercase letters"
Example 2. “For example, the special character strings of regular expressions such as * and [] are not included.”
Example 3 “All characters can be expressed in 8 bits”
Example 4 “Not including special characters“% ”and“ + ”in URL encoding”
When the property information represents Example 1 above, for example, when executing the String.toLowerCase () method or the String.toUpperCase () method, the process of converting the character string to lower case or the process of converting the character string to upper case may be omitted. . For example, when the String.compareIgnoreCase () method or the String.equalsIgnoreCase () method is executed, if the two strings to be compared both have characteristic information that does not include uppercase characters, In the case of having characteristic information “not included”, the comparison can be a simple 16-bit value comparison. Here, even if one of the two character strings to be compared has the characteristic information “contains a number” and the other character string has the characteristic information “does not include a number” I do not care. By making the above comparison simple, it is possible to speed up the processing. Here, the case where they have the same flag is, for example, a case where neither of the two character strings to be compared is “capital letters are included”.
When the characteristic information represents Example 2 above, for example, when executing the String.replaceFirst () method or the split () method, it is not necessary to create a java.util.regex.Matcher object. Therefore, it is possible to reduce the number of generated objects and increase the execution speed of the program.
In the case where the characteristic information represents Example 3 above, for example, when a state machine is created by compiling as a regular expression, the programmer can use 0-characters that can be expressed in 8 bits instead of implementation by a switch statement with many branches, for example. Implementation using a table indexed with a character code corresponding to 255 is possible. Thus, the implementation can speed up the processing during program execution. Compiling as a regular expression and creating a state machine means creating a program that performs state transition corresponding to the regular expression.
When the characteristic information represents Example 4 above, for example, in the java.net.URLDecoder.decode () method with the character string object to which the characteristic information is added as an argument, a process for examining the character string character by character and a work buffer Processing that uses a certain StringBuffer can be omitted. Thus, the omission can speed up the processing during program execution.

FIG. 3A shows a flowchart of processing for generating the character string object shown in FIG. 1 in the embodiment of the present invention.
The flowchart shown in FIG. 3A corresponds to the first aspect. This corresponds to the case where the process of step 304 in FIG. 3A can be determined from the character string object (101) of the generation source shown in the first mode, and the processes of step 309 and step 310 in FIG. 3A are the first mode. This corresponds to the case where it is possible to inspect simultaneously with the sequential processing for the character string of the generation source indicated by.

Step 301 represents the start of processing for generating a character string object.
In step 302, the computer system determines whether the character string assigned to the generated character string object includes characteristic information. When the characteristic information is included, the process proceeds to step 303. When the characteristic information is not included, the process proceeds to step 306.
In step 303, the computer system generates a character string object from the character string. In response to the end of the generation, the process proceeds to step 304.
In step 304, the computer system calculates characteristic information propagated to the generated character string object. As one embodiment, the computer system calculates, for example, the characteristic information included in the character string as the characteristic information to be propagated. As another embodiment, the computer system calculates a logical product result of the characteristic information included in the character string and the characteristic information given as an initial value to the character string object as the propagated characteristic information. In accordance with the calculation, the process proceeds to step 305. Note that if the propagated characteristic information is calculated as “unknown”, the process proceeds to step 305.
In step 305, the computer system adds the calculated characteristic information to the generated character string object (result object). In response to the addition, the process proceeds to step 311 and the process of generating the character string object ends.

In step 306, the computer system determines whether the character string needs to be converted to a char type. In the Java (trademark) language, for example, a character string literal is stored in a memory as a byte-type data string. Therefore, the computer system determines that the character string literal is a character string that needs to be converted to the char type. If it is necessary to convert to char type, the process proceeds to step 309. If it is not necessary to convert to char type, the process proceeds to step 307.
In step 307, the computer system generates a character string object from the character string. In the generation, the computer system collects the character strings in character string units instead of character units and assigns them to the character string object. In response to the end of the generation, the process proceeds to step 308.
In step 308, the computer system adds characteristic information indicating “unchecked” to the generated character string object (result object). In response to the end of the addition, the process proceeds to step 311 and the process of generating the character string object ends.

In step 309, the computer system generates a character string object from the character string. In the generation, the computer system converts the character string into a char type character by character and assigns it to the character string object. Further, the computer system inspects the characteristics of each character in parallel with the conversion, and obtains the characteristic information of the character string object from the result of the inspection. In response to the end of the generation, the process proceeds to step 310.
In step 310, the computer system adds the obtained characteristic information to the generated character string object (result object). In response to the end of the addition, the process proceeds to step 311 and the process of generating the character string object ends.

  FIG. 3B and FIG. 3C show examples of flowcharts of processing for executing arithmetic processing on the character string included in the character string object shown in FIG. 1 in the embodiment of the present invention.

FIG. 3B is an example of a flowchart of arithmetic processing (hereinafter referred to as first character string processing) including sequentially processing the character string included in the character string object shown in FIG. 1 character by character in the embodiment of the present invention. Show.
The first character string process is a process in which a class library creator adds a process optimized according to characteristic information and a process for adding characteristic information to the conventional process prepared in the library. The conventional processing is, for example, sequentially processing a character string included in at least one character string object (original object) received as an argument one character at a time, and processing the sequentially processed character string into another at least one character string. This is processing for converting a character string included in an object (result object).
The process of step 326 to step 328 in FIG. 3B corresponds to the second aspect, and the process of step 324 corresponds to the third aspect.

Step 321 represents the start of the first character string processing.
In step 322, the computer system determines whether or not the characteristic information added to the original object has a value capable of executing the optimized process. If a value that can execute the optimized process is set, the process proceeds to step 323. When a value that can execute the optimized process is not set, the process proceeds to step 326.
In step 323, the computer system executes a process optimized according to the characteristic information. In response to the end of the execution, the process proceeds to step 324.
In step 324, the computer system calculates characteristic information that is propagated to the result object. The calculation is performed using the third aspect. The calculation method varies depending on the contents of the optimized processing. When the computer system includes, for example, a process of converting uppercase letters to lowercase letters in the optimized process, the computer system displays characteristic information representing information “not including uppercase letters” in the characteristic information included in the original object. The characteristic information to which is added is calculated. In accordance with the calculation, the process proceeds to step 325.
In step 325, the computer system adds the calculated characteristic information to the result object. In response to the addition, the process proceeds to step 330, and the first character string process ends.

In step 326, the computer system executes a sequential process that processes the character string included in the original object one character at a time, which is a conventional process. Further, in parallel with the sequential processing, the computer system inspects the character of the character string included in the original object character by character (hereinafter referred to as a first inspection). Further, the computer system inspects the characteristic information of the result object (hereinafter, second inspection). In accordance with the end of the sequential processing, the first inspection, and the second inspection, the processing proceeds to step 327.
In step 327, the computer system determines whether there is an original object (hereinafter referred to as a first original object) to which characteristic information indicating “unchecked” is added. The computer system further determines whether there is an original object (second original object) whose characteristic information different from the added characteristic information is obtained by the first inspection. If there is the first original object or the second original object, the process proceeds to step 328. If there is no first original object and no second original object, the process proceeds to step 329.
In step 328, the computer system determines characteristic information to be added to the original object from the result of the first inspection. Then, the computer system adds the determined characteristic information to the original object. In response to the end of the addition, the process proceeds to step 329.
In step 329, the computer system obtains characteristic information of the result object from the results of the first inspection and the second inspection. The computer system adds the obtained characteristic information to the result object. In response to the end of the addition, the process proceeds to step 330, and the first character string process ends.
Step 330 represents the end of the first character string processing.

FIG. 3C shows an example of a flowchart of a calculation process (hereinafter referred to as a second character string process) including collectively processing the character strings included in the character string object shown in FIG. 1 in the embodiment of the present invention.
The second character string process is a process in which the class library creator adds a process optimized according to the characteristic information and a process for adding the characteristic information to the conventional process prepared in the library. Further, the conventional processing described above processes, for example, character strings included in at least one character string object (original object) received as an argument, and processes the processed character string into at least one other character string object ( The character string included in the result object). The process of step 344 in FIG. 3C corresponds to the third mode.

Step 341 represents the start of the second character string processing.
In step 342, the computer system determines whether or not the characteristic information added to the original object is set to a value that can execute the optimized process. If a value that can execute the optimized process is set, the process proceeds to step 343. If a value that can execute the optimized process is not set, the process proceeds to step 346.
In step 343, the computer system executes a process optimized according to the characteristic information. In response to the end of the execution, the processing proceeds to step 344.
In step 344, the computer system calculates characteristic information that is propagated to the result object. The calculation is performed according to the third aspect. The calculation method varies depending on the contents of the optimized processing. When the computer system includes, for example, a process of extracting five characters from the head in the optimized process, and the characteristic information included in the original object indicates “contains only capital letters”, the computer system Characteristic information that is propagated by the characteristic information included in the original object is calculated. In accordance with the calculation, the process proceeds to step 345.
In step 325, the computer system adds the calculated characteristic information to the result object. In response to the addition, the process proceeds to step 347, and the second character string process ends.

  In step 346, the computer system executes a process of collectively processing character strings included in the original object, which is a conventional process. In response to the end of the execution, the process proceeds to step 347, and the second character string process ends.

  4A to 4F show a program code and a state transition diagram for explaining an embodiment of the present invention.

  FIG. 4A shows a program code for explaining the example of Example 1 in the embodiment of the present invention.

In the following, a program code (401) will be described as an example, and a flow in which characteristic information is added according to object generation and an example in which processing optimized by the addition will be executed will be described.
When the computer system executes the program code (401), first, newString ("ABC") is executed. Here, since newString ("ABC") corresponds to the process of generating an object, each process of the flowchart shown in FIG. 3A is executed.
In step 302, since the character string “ABC” to be assigned to the character string object does not include the characteristic information, the process proceeds to step 306.
In step 306, since the character string “ABC” is a literal and needs to be converted to a char type, the process proceeds to step 309.
In step 309, the computer system generates a character string object s to which the character string “ABC” is substituted. In the generation, the computer system arranges the character string “ABC” on the heap memory while converting the character string “ABC” character by character into the char type. Further, the computer system checks the characteristics of the character string “ABC” character by character in parallel with the conversion. Here, it is assumed that the characteristic to be inspected is a characteristic that “lower case is not included”. As a result of the above inspection, since “A”, “B”, and “C” are not lowercase letters, the computer system determines that the character string “ABC” is a character string that does not include lowercase letters. As a result of the determination, a value representing “all characters do not include lowercase letters” is obtained as the characteristic information of the character string object s. In response to the end of the generation, the process proceeds to step 310.
In step 310, if the value representing “all characters do not include lowercase letters” is set to “01”, for example, the computer system adds the characteristic information “01” to the character string object s. In response to the end of the addition, the process proceeds to step 311 and the process of generating an object ends.

When the process of generating the object is completed, the toUpperCase () method is executed. The toUpperCase () method is a method that converts all characters in the string to uppercase.
Here, when the class library creator gives a character string with the characteristic information “01” added to the toUpperCase () method, for example, the toUpperCase () method implements an implementation that returns the given character string as it is Suppose that it was added to the implementation part. When the above implementation is added, the computer system does not need to perform the conventional process of capitalizing the character string at all in the execution. The computer system can return the character string “ABC” to which the given characteristic information “01” is added as it is as a return value of the toUpperCase () method. Therefore, the processing of the toUpperCase () method is speeded up.

FIG. 4B shows a program code for explaining the example of the second example in the embodiment of the present invention.
The program code (411) is an implementation part of the StringRepleaceFirst () method. In the conventional processing (412) of the StringRepleaceFirst () method, the Pattern.compile () method is executed, and a large number of objects can be generated.
Here, if the string passed in the argument of StringRepleaceFirst () method does not include special characters of regular expression, the process executed by the above Pattern.compile () method should be replaced with the process using another method. Is possible. The special character of the regular expression is, for example, “+” representing one or more repetitions in the regular expression “[az] + [0-9]”, “[” or “ ] ”But is not limited to these. Processing using other methods is based on a code combining, for example, the indexOf () method and substring (). The process executed by the combined code does not generate a large amount of objects and can be executed at a higher speed than the process executed by the Pattern.compile () method.
Therefore, the class library creator, for example, added a code (412) to the StringRepleaceFirst () method when the character string characteristic information passed as an argument indicates that “regular expression special character string is not included” To do. With this addition, when the character string passed as an argument does not include a regular expression, the StringRepleaceFirst () method can be executed at a higher speed than when conventional processing is executed.

FIG. 4C shows a state transition diagram regarding the program in the description of FIG. 4D below in the embodiment of the present invention.
The state transition diagram (421) represents a transition of a program code that performs pattern matching for the regular expression “[az] + [0-9]” included in the character string. By creating a state machine that implements the above program code, the programmer can create a pattern match program whose processing on the regular expression “[az] + [0-9]” is faster than the conventional pattern match program. Can be created.

FIG. 4D shows a program code for explaining the example of Example 3 in the embodiment of the present invention.
The program code (431) is an example of implementation of a state machine (see FIG. 4C) when a character string passed as an argument is limited to an 8-bit value. The program code (432) is an example of implementation of a state machine when a character string passed as an argument is not limited to an 8-bit value. When the character string passed as an argument is not limited to an 8-bit value, the programmer realizes the matching between the character contained in the character string and the regular expression by the implementation by the case statement shown in the program code (432), for example. . If the character string passed as an argument is limited to an 8-bit value, the programmer replaces the implementation with the case statement with the simple matching loop shown in the program code (431), for example with the for statement. Can be realized.

  FIG. 4E shows a program code for explaining the example of Example 4 in the embodiment of the present invention.

The program code (441) is an example of a program code in which the embodiment of the present invention is applied to the java.net.URLDecoder.decode () method. The conventional code (442) corresponds to the conventional process, and the additional code (443 to 446) corresponds to the process added to apply the embodiment of the present invention.
The java.net.URLDecoder.decode () method is a method for reading a character string character by character and returning a URL-encoded special character in the read character string to the original character. The java.net.URLDecoder.decode () method corresponds to the first character string processing.
When the java.net.URLDecoder.decode () method is executed, each process of the flowchart shown in FIG. 3B is executed.
The process of the additional code (444) corresponds to the process of step 322. In the additional code (444), it is determined whether or not a value capable of executing the optimized process is set in the characteristic information included in the character string object s passed as an argument.
For example, when the characteristic information is a value representing “not including special characters in URL encoding”, it is determined that the optimized process can be executed. If the character string does not include special characters in URL encoding, the processing corresponding to step 323 and step 324 is not in the java.net.URLDecoder.decode () method, so “return s” corresponding to step 325 is executed. Then the java.net.URLDecoder.decode () method ends.

When it is determined that the above is not possible, the processing of the conventional code (442), which is the conventional processing corresponding to step 326, is executed. In the processing of the code (442), it is checked character by character whether the special characters “+” and “%” in URL encoding are included in the character string included in the character string object s. The result of the check is set in the variable needToChange. In the java.net.URLDecoder.decode () method, the above check can also serve as the first check. Therefore, in the additional code (445), when the characteristic information is not added to the character string object s, the variable needToChange is used and the characteristic information is set to the character string object s. The processing of the additional code (445) corresponds to step 327 and step 328.
In addition, it is obvious that the result of the java.net.URLDecoder.decode () method does not include special characters in URL encoding. Therefore, in the additional code (446), characteristic information representing “not including special characters in URL encoding” is set in the character string generated by sb.toString () as a return value. The processing of the additional code (446) corresponds to step 329.

  In step 328, characteristic information is added to the character string object s. Therefore, when the URLDecoder.decode () method is executed again with the character string object s as an argument, the optimized process may be executed.

FIG. 4F shows an example of program code for implementing the processing of the flowchart shown in FIG. 3A in the embodiment of the present invention.
In the following, the flow of adding characteristic information at the time of object generation and the flow of propagation of characteristic information will be described using the program code (451) as an example.
When the computer system executes the program code (451), first, newString ("ABC") is executed. Here, newString ("ABC") corresponds to the process of generating an object, and thus each process of the flowchart shown in FIG. 3A is executed.
In step 302, since the character string “ABC” to be assigned to the character string object does not include the characteristic information, the process proceeds to step 306.
In step 306, since the character string “ABC” is a literal and needs to be converted to a char type, the process proceeds to step 309.
In step 309, the computer system generates a character string object s1 to which the character string “ABC” is substituted. In the generation, the computer system arranges the character string “ABC” on the heap memory while converting the character string “ABC” character by character into the char type. Further, the computer system checks the characteristics of the character string “ABC” character by character in parallel with the conversion. Here, it is assumed that the characteristic to be inspected is a characteristic that “lower case is not included”. As a result of the above inspection, since “A”, “B”, and “C” are not lowercase letters, the computer system determines that the character string “ABC” is a character string that does not include lowercase letters. As a result of the determination, a value representing “all characters do not include lowercase letters” is obtained as the characteristic information of the character string object s1. In response to the end of the generation, the process proceeds to step 310.
In step 310, when the value representing “all characters do not include lowercase letters” is set to “01”, for example, the computer system adds the characteristic information “01” to the character string object s1. In response to the end of the addition, the process proceeds to step 311 and the process of generating the object s1 is ended.

Next, new String ("XYZ") is executed. Here, since new String ("XYZ") corresponds to the process of generating an object, each process of the flowchart shown in FIG. 3A is executed.
In step 302, since the character string “XYZ” to be assigned to the character string object does not include the characteristic information, the process proceeds to step 306.
In step 306, since the character string “XYZ” is a literal and needs to be converted to a char type, the process proceeds to step 309.
In step 309, the computer system generates a character string object s2 to which the character string “XYZ” is substituted. In the generation, the computer system arranges the character string “XYZ” on the heap memory while converting the character string “XYZ” character by character to the char type. Further, the computer system checks the characteristics of the character string “XYZ” character by character in parallel with the above conversion. Here, it is assumed that the characteristic to be inspected is a characteristic that “lower case is not included”. As a result of the above examination, since “X”, “Y”, and “Z” are not lowercase letters, the computer system determines that the character string “XYZ” is a character string that does not include lowercase letters. As a result of the determination, a value representing “all characters do not include lowercase letters” is obtained as the characteristic information of the character string object s2. In response to the end of the generation, the process proceeds to step 310.
In step 310, when the value representing “all characters do not include lowercase letters” is set to “01”, for example, the computer system associates the characteristic information “01” with the character string object s 2. In response to the end of the association, the process proceeds to step 311 and the process of generating the object s2 ends.

  Finally, the concat () method is executed. By executing the concat () method, a String object including the character string “ABCXYZ” is generated by concatenating the character string included in the character string object s1 and the character string included in the character string object s2. At the time of generation, mergeAttr (attr, attr) prepared by the class library creator in advance in the concat () method is called. The characteristic information included in the character string object s1 and the character string object s2 is both “01” representing “all characters do not include lowercase letters”. Therefore, the logical sum “01” of “01” and “01” is added to the String object including the character string “ABCXYZ”, and the object is returned as the return value of s1.concat (s2). .

FIG. 5 shows an example of a functional block diagram illustrating functions of a computer system that optimizes character string processing during program execution in the embodiment of the present invention.
The computer system (501) includes a memory (502), a determination unit (503), an association unit (504), and an execution unit (505).

  A memory (502) is a main storage device having a storage area that an application can freely use. The storage area may store a program (509), at least one character string (508a to 508n) and at least one characteristic information (507a to 507n) corresponding to each of the at least one character string (508a to 508n). .

The program (509) is a program including processing (510) of at least one character string. The program (509) is read into the memory (502) by the computer system (501) and executed by the central processing unit (CPU).
The string processing (510) is processing including at least one optimized processing (511) and conventional processing (512).
The optimized process (511) and the conventional process (512) are processes that perform calculations using at least one character string (508a to 508n).
The optimized process (511) can be executed at higher speed than the conventional process (512) when it is executed for a character string associated with certain characteristic information.

The character string (508a to 508n) is data assigned to the memory when the program (509) is executed. The character strings (508a to 508n) can be generated, referenced, updated, or deleted, for example, when the character string processing (510) is executed.
The characteristic information (507a to 507n) is information representing the characteristic of the character string (508a to 508n). Each of the characteristic information (507a to 507n) corresponds to each of the character strings (508a to 508n).

The determination unit (503) determines the first character string from the characteristics of the first character string (508a) and the arithmetic processing in response to the execution of the arithmetic processing related to the first character string (508a). (508a) and the characteristic information corresponding to at least one character string among the second character string (508b) which is the data of the result of the arithmetic processing are determined.
The determination unit (503) includes an inspection unit (506). The inspection unit (506) obtains the characteristics of the sequentially processed characters one character at a time in accordance with the sequential processing performed on the character strings (508a to 508n) in the arithmetic processing. The determination unit (503) determines characteristic information (507a to 507n) corresponding to the character string (508a to 508n) subjected to the sequential processing from the character characteristics obtained by the inspection unit (506).

  The associating unit (504) receives the determined characteristic information from the determining unit (503) and associates it with the first character string (508a) or the second character string (509a).

  When the character string process (510) including the optimized process (511) is executed, the execution unit (505) applies the character string (508a to 508n) processed by the character string process (510). The corresponding characteristic information (507a to 507n) is referred to. The execution unit (505) causes the optimized process (511) to be executed when the referred characteristic information (507a to 507n) satisfies the condition for executing the optimized process (511). When the referred characteristic information (507a to 507n) does not satisfy the condition for executing the optimized process (511), the execution unit (505) executes, for example, the conventional process (512).

FIG. 6 shows a hardware block diagram of the system shown in FIG. 5 in the embodiment of the present invention.
The computer system (601) includes a CPU (602) and a main memory (603), which are connected to a bus (604). The CPU (602) is preferably based on a 32-bit or 64-bit architecture, such as Intel's Xeon (TM) series, Core (TM) series, Atom (TM) series, Pentium (TM) series, The Celeron (TM) series, the AMD Phenom (TM) series, the Athlon (TM) series, the Turion (TM) series or the Empron (TM) can be used. A display (606) such as an LCD monitor is connected to the bus (604) via a display controller (605). The display (606) appropriately displays information about a computer system connected to a network via a communication line and information about software running on the computer system for management of the computer system. Used for display with a graphic interface. The bus (604) is also connected to a hard disk or silicon disk (608) and a CD-ROM, DVD drive or BD drive (609) via an IDE or SATA controller (607).

  The hard disk (608) stores an operating system, a program that provides a Java (trademark) processing environment such as J2EE, and other programs and data that can be loaded into the main memory.

  The CD-ROM, DVD or BD drive (609) is used for additionally introducing a program from the CD-ROM, DVD-ROM or BD to the hard disk as necessary. A keyboard (611) and a mouse (612) are further connected to the bus (604) via a keyboard / mouse controller (610).

  The communication interface (614) follows, for example, the Ethernet (trademark) protocol. The communication interface (614) is connected to the bus (604) via the communication controller (613), and plays a role of physically connecting the computer system and the communication line (615), and the operating system of the computer system. A network interface layer is provided for the TCP / IP communication protocol of the communication function. The communication line may be a wired LAN environment or a wireless LAN environment based on a wireless LAN connection standard such as IEEE802.11a / b / g / n.

Claims (16)

In a computer system that executes a program for processing the string, if the processing of the character string including a plurality of processing Oite during the program execution, a good process of execution efficiency among the plurality of processes A method of selecting and processing the character string, wherein when executing the program,
The determination unit of the computer system includes the characteristic information about at least one first character string, or the characteristic about at least one first character string and the processing of the at least one first character string, or at least the at least one A process for an area in which one first character string is stored (hereinafter referred to as a calculation process related to the first character string ), and a process related to the at least one first character string and the at least one first character string. Determining the characteristic information of at least one second character string as a result of the arithmetic processing, and storing the determined characteristic information in a memory included in the computer system;
The associating unit of the computer system converts the characteristic information stored in the memory into the at least one first character string when the characteristic information is characteristic information about the first character string, or Executing the step of associating with the at least one second character string if the property information is characteristic information about the second character string;
Execution unit of the computer system, when the determined quality information to process the character string associated with, among the plurality of processes, a good process of execution efficiency in accordance with the determined quality information Selecting and performing the processing of the string with the selected processing ,
The characteristic is a characteristic of at least one character included in the character string. The characteristic is an uppercase letter, a lowercase letter, a number, a two-byte character, an alphabet, of a character code character that it is a special character in URL encoding, or a, not a character listed above,
The characteristic information includes at least one first information indicating that the character string includes or does not include a character belonging to a character set that is a collection of characters having the above-described common characteristics, and the character string includes: Including the second information indicating that the character set does not belong to the character set, or not included,
The arithmetic processing for the at least one first character string is arithmetic processing for a character string executed in the program, and the arithmetic processing for the character string is a copy of the first character string, the first character string Search for an arbitrary character included in the character, conversion of the character included in the first character string into another character, extraction of an arbitrary character from the first character string, and a plurality of characters in the first character string The method, which is a combination of columns or a comparison between character strings of the plurality of first character strings. The arithmetic processing related to the at least one first character string converts at least one first character string into a char type, and generates at least one second character string into which the converted char type is substituted; Sequentially processing the at least one first character string character by character at the time of generation;
The determining step further includes a step of executing the sequential processing and a step of inspecting the character that is sequentially processed together with the sequential processing, whereby characteristic information of the at least one second character string is determined. The method according to claim 1. The arithmetic processing related to the at least one first character string is arithmetic processing related to at least one first character string;
The determining step determines the characteristic information of at least one second character string from the characteristic information about each of the at least one first character string and the arithmetic processing related to the at least one first character string. The method of claim 1, comprising steps.   The character set is a second character set that collectively represents at least two first character sets, the characters included in each of the at least two first character sets do not overlap, and each of the first information is , Indicating that the character string includes or does not include characters belonging to each of the first character sets, and the second information includes characters that the character string does not belong to all of the first character sets. The method according to claim 1, wherein the method represents being or not being included.   The character set is a second character set that collectively represents at least two first character sets, the characters included in each of the at least two first character sets do not overlap, and the first information is: The character string includes or does not include a character belonging to the second character set, and the second information includes a character that does not belong to the second character set, or The method according to claim 1, wherein the method is not included.   The method according to claim 1, wherein the first information and the second information are represented by a bit string, and each bit corresponds to a character set or a character set that does not belong to any character set. The arithmetic processing related to the at least one first character string combines the first character string associated with the first characteristic information and the first character string associated with the second characteristic information. Arithmetic processing,
The step of determining includes the step of determining, as characteristic information of a second character string, characteristic information obtained by a logical sum of the first characteristic information and the second characteristic information. Method. The arithmetic processing related to the at least one first character string is an arithmetic processing for deleting the first character string associated with the second characteristic information from the first character string associated with the first characteristic information. And
The method according to claim 6, wherein the determining includes determining the first characteristic information as characteristic information of a second character string. The arithmetic processing related to the at least one first character string is an arithmetic processing for deleting the first character string associated with the second characteristic information from the first character string associated with the first characteristic information. And a character belonging to the character set represented by the second characteristic information is not included in the first character string associated with the first characteristic information by the calculation process of deleting the first character string. ,
The step of determining includes the step of determining, as characteristic information of a first character string, characteristic information obtained by a logical product of the first characteristic information and the second characteristic information. Method.   Determining the character string characteristic information for at least one of the at least one first character string and the second character string that is a result of the arithmetic processing relating to the at least one first character string; The step of determining the characteristic information by combining at least two of the determining step according to claim 7, the determining step according to claim 8, and the determining step according to claim 9. Method. The arithmetic processing related to the at least one first character string converts to at least one first character string char type, and generates at least one second character string that substitutes the converted char type. Including
The method according to claim 1, wherein the determining includes determining characteristic information of the second character string from characteristic information about the at least one first character string. The arithmetic processing related to the at least one first character string includes a process of generating a character string and substituting at least one first character string one character at a time into the at least one second character string at the time of generation,
The step of determining further includes the step of executing the process of substituting and the step of examining the character to be substituted together with the substituting, whereby characteristic information of the at least one second character string is determined; The method of claim 1.   2. The method according to claim 1, wherein in the programming language in which the character string is treated as an object, the arithmetic process related to the first character string is an arithmetic process related to the object, and the characteristic information is included in the object. In a computer system that executes a program for processing the string, if the processing of the character string including a plurality of processing Oite during the program execution, a good process of execution efficiency among the plurality of processes A computer system for selecting and processing the character string,
At the time of executing the program, characteristics of at least one first character string and processing of the at least one first character string or processing for an area in which the at least one first character string is stored (hereinafter referred to as the first character string) . since one of the arithmetic processing related to the character string) and, at least one of said at least one first character string and the at least one first of the at least one second character string which is the result of the arithmetic processing related to the character string A determination unit for determining character string characteristic information for 1;
When the program is executed, the determined characteristic information is stored in the at least one first character string if the characteristic information is characteristic information about the first character string, or the characteristic information is the second characteristic information. In the case of the characteristic information about the character string, an association unit that associates with the at least one second character string;
In the case of processing a character string in which the determined quality information is associated, among the plurality of processes, select a good process of execution efficiency corresponding to the determined characteristic information, is the selection process And an execution unit for executing the processing of the character string ,
The characteristic is a characteristic of at least one character included in the character string. The characteristic is an uppercase letter, a lowercase letter, a number, a two-byte character, an alphabet, of a character code character that it is a special character in URL encoding, or a, not a character listed above,
The characteristic information includes at least one first information indicating that the character string includes or does not include a character belonging to a character set that is a collection of characters having the above-described common characteristics, and the character string includes: Including a character that does not belong to the character set, or second information indicating that it does not include,
The arithmetic processing for the at least one first character string is arithmetic processing for a character string executed in the program, and the arithmetic processing for the character string is a copy of the first character string, the first character string Search for an arbitrary character included in the character, conversion of the character included in the first character string into another character, extraction of an arbitrary character from the first character string, and a plurality of characters in the first character string The computer system, which is a combination of columns or a comparison of character strings of a plurality of the first character strings. In a computer system that executes a program for processing a character string included in the character string object, if the processing of the character string including a plurality of processing Oite during the program execution, among the plurality of processes a method to select a good process of execution efficiency for processing the string, during the program execution,
The determination unit of the computer system includes the characteristic information about at least one first character string, or the characteristic about at least one first character string and the processing of the at least one first character string, or at least the at least one A process for an area in which one first character string is stored (hereinafter referred to as a calculation process related to the first character string ), and a process related to the at least one first character string and the at least one first character string. Determining the characteristic information of at least one second character string as a result of the arithmetic processing, and storing the determined characteristic information in a memory included in the computer system;
The associating unit of the computer system converts the characteristic information stored in the memory into the at least one first character string when the characteristic information is characteristic information about the first character string, or Executing the step of associating with the at least one second character string if the property information is characteristic information about the second character string;
Execution unit of the computer system, when the determined quality information to process the character string associated with, among the plurality of processing execution efficiency in accordance with the characteristic information of the determined string Selecting a good process and performing the process of the string with the selected process ,
The characteristic is a characteristic of at least one character included in the character string. The characteristic is an uppercase letter, a lowercase letter, a number, a two-byte character, an alphabet, of a character code character that it is a special character in URL encoding, or a, not a character listed above,
The characteristic information includes at least one first information indicating that the character string includes or does not include a character belonging to a character set that is a collection of characters having the above-described common characteristics, and the character string includes: Including a character that does not belong to the character set, or second information indicating that it does not include,
The arithmetic processing related to the at least one first character string converts at least one first character string into a char type and includes a character string including at least one second character string into which the converted char type is substituted. Generating an object, and sequentially processing the at least one first character string character by character at the time of generation,
The determining step further includes a step of executing the sequential processing and a step of inspecting the character that is sequentially processed together with the sequential processing, whereby characteristic information of the at least one second character string is determined. Said method. In a computer system that executes a program for processing a character string included in the character string object, if the processing of the character string including a plurality of processing Oite during the program execution, among the plurality of processes A method of selecting a process with high execution efficiency and processing the character string,
The associating unit of the computer system generates a character string object on a memory included in the computer system when the program is executed, and executes a step of adding characteristic information to the character string object. ,
(1) When the characteristic information of the character string included in the generated character string object can be determined from the character string object of the generation source, or when it can be checked simultaneously with the sequential processing for the character string included in the character string object of the generation source, Adding the characteristic information obtained by the determination or the inspection to the generated character string object;
(2) When the characteristics of the character string are checked at the same time as the sequential processing for the character string included in the character string object that does not include the characteristic information, the generated character string includes the characteristic information obtained by the inspection. Adding to the object, or
(3) Characteristic information determined from the calculation source object and the content of the calculation process in response to the calculation process of at least one character string object (hereinafter referred to as the calculation source object) to which the characteristic information is added. Performing at least one of the steps of adding to at least one character string object (hereinafter referred to as a result object) in which the result of the arithmetic processing is stored,
Execution unit of the computer system, when the determined quality information to process the character string associated with, among the plurality of processing execution efficiency in accordance with the characteristic information of the determined string Selecting a good process and performing the process of the string with the selected process ,
The characteristic is a characteristic of at least one character included in the character string. The characteristic is an uppercase letter, a lowercase letter, a number, a two-byte character, an alphabet, of a character code character that it is a special character in URL encoding, or a, not a character listed above,
The characteristic information includes at least one first information indicating that the character string includes or does not include a character belonging to a character set that is a collection of characters having the above-described common characteristics, and the character string includes: Including a character that does not belong to the character set, or second information indicating that it does not include,
The arithmetic processing for the at least one first character string is arithmetic processing for a character string executed in the program, and the arithmetic processing for the character string is a copy of the first character string, the first character string Search for an arbitrary character included in the character, conversion of the character included in the first character string into another character, extraction of an arbitrary character from the first character string, and a plurality of characters in the first character string The method, which is a combination of columns or a comparison between character strings of the plurality of first character strings.

Images