KR102439456B1 - Compilation device and method of partial source code - Google Patents

Abstract

An apparatus and method for compiling partial source code are disclosed. An apparatus according to an exemplary embodiment includes a source parsing module that parses a partial source code and generates a source symbol table and a dummy class candidate list therefrom; a target identification module for identifying a target class for which actual dummy class generation is required from among one or more dummy class candidate classes included in the dummy class candidate list; a dummy class information generating module for obtaining information of the identified target classes and generating a dummy class information list therefrom; a dummy class creation module for generating one or more dummy classes by referring to the dummy class information list; and a compilation module that compiles the partial source code using the generated dummy class.

Description

Apparatus and method of compilation of partial source code {APPARATUS AND METHOD FOR COMPILING PARTIAL SOURCE CODE}

The disclosed embodiments relate to techniques for compiling program source code.

Static program analysis refers to a method of analyzing computer software without actually executing a program. Most static program analysis is generally performed using source code, but recent static program analysis tools use compiled files instead of source codes to increase the accuracy of analysis.

In order to compile the source code, all classes and libraries referenced by the written source code are required. Therefore, if the scale of the software to be developed is large, complex preliminary preparations such as having to receive libraries and classes constituting the entire software system from the data storage are required for the analysis of some changed source codes.

Korea Patent Publication No. 10-1412614 (2014. 06. 20)

The disclosed embodiments are intended to provide technical means for effectively compiling a partial source code without class and library information referenced by the partial source code.

According to an exemplary embodiment, there is provided a source parsing module that parses a partial source code and generates a source symbol table and a dummy class candidate list therefrom; a target identification module for identifying a target class for which actual dummy class generation is required from among one or more dummy class candidate classes included in the dummy class candidate list; a dummy class information generating module for obtaining information of the identified target classes and generating a dummy class information list therefrom; a dummy class creation module for generating one or more dummy classes by referring to the dummy class information list; and a compilation module that compiles the partial source code using the generated dummy class.

The dummy class candidate list may include Fully-Qualified Class Names (FQCNs) of one or more classes used in the partial source code.

The source parsing module generates an anonymous class corresponding to the method call when the partial source code includes a complex method call syntax, and uses the FQCN of the generated anonymous class as the dummy class candidate. You can register on the list.

The source parsing module is, when the dummy class candidate class is included in at least one of a class provided by the Java virtual machine, a class included in the partial source code, or a preset dummy class exclusion target class, sets the corresponding class to the target class can be excluded from

The dummy class information generating module may generate the dummy class information list by secondary parsing the partial source code with reference to the source symbol table and the dummy class target list.

The dummy class information list includes a package name of each target class, a class name, a superclass name, a list of interfaces requiring declaration, a list of type arguments of generics, a list of constructors, whether an annotation class, an exception It can include whether it is a class, a list that requires field definitions, and a list that requires method definitions.

The dummy class information generation module is, when the partial source code includes an object creation syntax, obtains an FQCN of a parameter included in the object creation syntax and registers it in the dummy class information list, from the partial source code If the FQCN of the parameter cannot be obtained, the highest level object (java.lang.Object) may be registered in the dummy class information list.

The dummy class creation module, when an anonymous class is included in the dummy class dummy class information list, first writes a bytecode for the anonymous class, and then writes a bytecode for the non-anonymous class after the creation of the anonymous class is completed. can write

According to another exemplary embodiment, there is provided a method performed in a computing device having one or more processors and a memory storing one or more programs to be executed by the one or more processors, the method comprising: parsing a partial source code; generating a source symbol table and a dummy class candidate list; identifying a target class for which actual dummy class generation is required from among one or more dummy class candidate classes included in the dummy class candidate list; obtaining information of the identified target classes, and generating a dummy class information list therefrom; a dummy class creation step of creating one or more dummy classes with reference to the dummy class information list; and performing compilation on the partial source code using the generated dummy class.

The dummy class candidate list may include Fully-Qualified Class Names (FQCNs) of one or more classes used in the partial source code.

The generating of the dummy class candidate list includes generating an anonymous class corresponding to the method call when the partial source code includes a complex method call syntax, and FQCN of the generated anonymous class. may be configured to register in the dummy class candidate list.

The generating of the dummy class candidate list may include, when the dummy class candidate class is included in one or more of a class provided by the Java virtual machine, a class included in the partial source code, or a preset dummy class exclusion target class. It may be configured to exclude a class from the target class.

The generating of the dummy class information may include generating the dummy class information list by secondary parsing the partial source code with reference to the source symbol table and the dummy class target list.

The dummy class information list includes a package name of each target class, a class name, a superclass name, a list of interfaces requiring declaration, a list of type arguments of generics, a list of constructors, whether an annotation class, an exception It can include whether it is a class, a list that requires field definitions, and a list that requires method definitions.

The generating of the dummy class information includes, when the partial source code includes an object creation syntax, obtains an FQCN of a parameter included in the object creation syntax and registers it in the dummy class information list, wherein the partial source code If the FQCN of the parameter cannot be obtained from , the highest level object (java.lang.Object) may be registered in the dummy class information list.

In the dummy class creation step, when an anonymous class is included in the dummy class dummy class information list, the bytecode for the anonymous class is first written, and then the bytecode for the non-anonymous class is completed after the creation of the anonymous class is completed. can be configured to write

According to the disclosed embodiments, it is possible to effectively compile the partial source code without class and library information referenced by the partial source code, and it is possible to reduce the time required for static analysis based on the compiled class.

1 is an exemplary diagram for explaining the operation of a Java compiler;
2 is a block diagram illustrating a compilation device according to an embodiment;
3 is a flowchart illustrating a method of compiling a partial source code according to an embodiment;
4 is a flowchart illustrating a process of generating a dummy class target list in a target identification module according to an embodiment;
5 is a flowchart for describing in detail a process for an import statement during a process of generating a dummy class information list according to an embodiment.
6 is a flowchart illustrating in detail a process for a field declaration syntax during a process of generating a dummy class information list according to an embodiment;
7 to 9 are flowcharts for explaining in detail a processing process for an object creation syntax during a dummy class information list creation process according to an embodiment;
10 to 13 are flowcharts for explaining in detail a process for a method call syntax during a process of generating a dummy class information list according to an embodiment;
14 is a flowchart illustrating in detail a process for a parameter declaration syntax during a process of generating a dummy class information list according to an embodiment;
15 is a flowchart for explaining in detail a process for a variable declaration syntax during a process of generating a dummy class information list according to an embodiment;
16 is a flowchart for explaining in detail a process for an annotation designation syntax during a process of generating a dummy class information list according to an embodiment;
17 is an exemplary diagram of a partial source code
18 is a block diagram illustrating and describing a computing environment including a computing device suitable for use in example embodiments;

Hereinafter, specific embodiments of the present invention will be described with reference to the drawings. The following detailed description is provided to provide a comprehensive understanding of the methods, apparatus, and/or systems described herein. However, this is merely an example and the present invention is not limited thereto.

In describing the embodiments of the present invention, if it is determined that the detailed description of the known technology related to the present invention may unnecessarily obscure the gist of the present invention, the detailed description thereof will be omitted. And, the terms to be described later are terms defined in consideration of functions in the present invention, which may vary according to intentions or customs of users and operators. Therefore, the definition should be made based on the content throughout this specification. The terminology used in the detailed description is for the purpose of describing embodiments of the present invention only, and should in no way be limiting. Unless explicitly used otherwise, expressions in the singular include the meaning of the plural. In this description, expressions such as “comprising” or “comprising” are intended to indicate certain features, numbers, steps, acts, elements, some or a combination thereof, one or more other than those described. It should not be construed to exclude the presence or possibility of other features, numbers, steps, acts, elements, or any part or combination thereof.

Prior to a detailed description of the embodiments of the present invention, the operation of a general source code compiler is illustrated in FIG. 1 . The illustrated embodiment shows a Java compiler for compiling Java source code. However, it should be noted that the disclosed embodiments are also applicable to a compiler in a language other than Java source code within the scope not departing from the scope of the present invention.

An operation of the source code compiler according to the exemplary diagram shown in FIG. 1 will be described as follows.

① Source Files are files containing the Java source code to be compiled, and have a *.java extension.

② Bytecode classes are class files that have instructions to be executed on the Java Virtual Machine (JVM), and are translated and executed by the Java Virtual Machine into actual machine code.

③ Library Files are structured bundle files of class files with bytecode.

④ Compiled Bytecode Classes are bytecode files compiled by the Java compiler.

As shown in FIG. 1 , the source code compiler generates (4) compiled bytecode classes by compiling (1) source files with reference to (2) bytecode classes and (3) libraries. That is, when compiling a source file, the source code compiler must designate the bytecode class and library referenced by the source code in the source file. If the referenced bytecode class or library is not on the specified path, the source code compiler cannot compile the source file.

2 is a block diagram illustrating the compilation apparatus 200 according to an embodiment. The compilation device 200 according to an embodiment means a device that receives a partial source code and compiles the partial source code. In the disclosed embodiments, the partial source code means a source code that must refer to one or more of a separate bytecode class or library for compilation. The compilation apparatus 200 according to an embodiment does not refer to the above-described bytecode class or library when compiling such partial source code, but generates a dummy class corresponding to the required bytecode class or library and uses it is configured to perform compilation of the partial source code using

As shown, the compilation device 200 according to an embodiment includes a source parsing module 202, a target identification module 204, a dummy class information generation module 206, a dummy class creation module 208, and a compilation module ( 210).

The source parsing module 202 receives a partial source code, parses it (primary parsing), and generates a source symbol table and a dummy class candidate list therefrom. Specifically, the source parsing module 202 may construct an Abstract Syntax Tree (AST) from the input partial source code, and generate the source symbol table and the dummy class candidate list using the constructed AST.

The target identification module 204 generates a list of target classes to actually generate a dummy class from among the dummy class candidates included in the dummy class candidate list (Dummy Class Target List).

The dummy class information generation module 206 secondary parses the partial source code and generates a dummy class information list therefrom. That is, the dummy class information list is a list in which information of target classes that need to be actually created is stored. In one embodiment, the dummy class information generating module 206 obtains information of the identified target classes by secondary parsing the partial source code with reference to the source symbol table and the dummy class target list, and from this, the dummy class You can create a list of information.

The dummy class creation module 208 creates an actual dummy class by referring to the dummy class information list generated by the dummy class information generation module 206 . The dummy class generated by the dummy class creation module 208 is a kind of shell class having the same appearance and structure as the actual class.

The compilation module 210 compiles the partial source code using the dummy class.

3 is a flowchart illustrating a method 300 for compiling partial source code according to an embodiment. The method 300 illustrated in FIG. 3 may be performed, for example, by the above-described compilation device 200 . In the illustrated flowchart, the method is described by dividing the method into a plurality of steps, but at least some of the steps are performed in a different order, are performed together in combination with other steps, are omitted, are performed in sub-steps, or are not shown. One or more steps may be added and performed.

In step 302, the source parsing module 202 receives and parses the partial source code (primary parsing), and generates a source symbol table and a dummy class candidate list therefrom. .

Java source code includes package declaration syntax, import syntax, class or interface declaration syntax, constructor declaration syntax, field declaration syntax, method call It can be divided into syntax, method declaration syntax, parameter declaration syntax, variable declaration syntax, annotation designation syntax, and the like. The source symbol table is a table in which information such as packages, classes, interfaces, imports, fields, methods, variables, and parameters defined and used in the corresponding partial source code is recorded. Table 1 shows the structure of a source symbol table according to an embodiment.

Item data being stored data type example Package declared package name string com.sds.sample Class the class name of the source string Main Imports declared imports List Inner Classes Inner class/interface list List Fields List of declared field names and FQCNs List Variables List of declared variable names, method names to which they belong, and FQCNs List Methods List of declared method names, parameter names and types List

Table 2 illustrates a list linked to the Imports item of the source symbol table listed in Table 1.

Item data being stored data type example FQCN FQCN of class declared Import string org.library.Address static Whether to declare static True/False False asterisk Whether asterisk(*) is specified True/False False

Table 3 illustrates a list linked to the Inner Classes item of the source symbol table listed in Table 1.

Item data being stored data type example Class inner class name string inner

Table 4 illustrates a list linked to the Fields item of the source symbol table listed in Table 1.

Item data being stored data type example Field field name string addr FQCN FQCN for the field string com.library.Address

Table 5 exemplifies the list linked to the Variables item of the source symbol table listed in Table 1.

Item data being stored data type example variable variable name string data declared method A method in which a variable is declared string process FQCN FQCN of variable string com.library.Data

Table 6 illustrates a list linked to the Methods item of the source symbol table listed in Table 1.

Item data being stored data type example Method method name string process Parameters List of declared parameters List

Table 7 exemplifies the list connected to the Parameters item of the list listed in Table 6.

Item data being stored data type example Parameter declared parameter type string String

The source symbol table as described above is created as many as the number of .java files constituting the partial source code.

Next, the dummy class candidate list is a list that records the Fully-Qualified Class Name (FQCN) of classes used in the partial source code. ) means Unlike the source symbol table, only one dummy class candidate list can be generated for the entire partial source code. In one embodiment, the source parsing module 202 provides the FQCN of the imported class from the partial source code, the FQCN for the declared field type, the FQCN of the anonymous class generated in response to the complex method call, and the declared parameter type. The FQCN, the FQCN for the declared variable type, and the FQCN for the specified annotation type can be registered in the dummy class candidate list.

Table 8 illustrates a dummy class candidate list according to an embodiment.

org.apache.log4j.Logger, org.apache.commons.cli.CliParser com.sds.Data com.library.Address com.library.Checker …

Hereinafter, a detailed process of generating a source symbol table and a dummy class candidate list will be described.

When the parsed partial source code includes a package declaration syntax, the source parsing module 202 registers the package name in the source symbol table.

If the parsed partial source code includes an import statement, the source parsing module 202 checks the FQCN and import type (static and asterisk designation) of the class declared to be imported, and imports entries in the source symbol table (see Table 2). ) is recorded in In addition, when an asterisk (*, asterisk) is not specified as a result of the check of the import type, the source parsing module 202 registers the FQCN of the imported class in the dummy class candidate list.

When the parsed partial source code contains a class or interface declaration syntax, the source parsing module 202 determines whether the declared class or interface is an inner class, and if it is an inner class, the corresponding class name It is recorded in the inner class entry of the source symbol table (refer to Table 3).

When the parsed partial source code includes a constructor declaration syntax, the source parsing module 202 determines whether one or more parameters of the corresponding constructor are included, and if included, determines each parameter type. Record the method entry in the source symbol table (see Tables 6 and 7) along with the constructor method name.

If the parsed partial source code includes a field declaration syntax, the source parsing module 202 checks the FQCN for the declared type, and records the field name and FQCN in the field item (see Table 4) of the source symbol table. . In addition, the source parsing module 202 registers the identified FQCN in the dummy class candidate list.

When the parsed partial source code includes a method call syntax, the source parsing module 202 determines whether the method call is a complex method call. In this case, the composite call means a method in which the method is called again with respect to the result of the method call (eg, a call method such as data.first().second();). In the case of a complex call, the source parsing module 202 generates an anonymous class corresponding to the call, and registers the FQCN of the generated anonymous class in the dummy class candidate list. In this case, the source parsing module 202 may use one anonymous class for the entire partial source code, use a different anonymous class for each class, or use a different anonymous class for each complex method call. . That is, a new anonymous class can be created according to the name of the method to be created, the number of parameters, and the parameter type and registered in the dummy class candidate list. In addition, when the anonymous class is registered in the dummy class candidate list as described above, the source parsing module 202 changes the corresponding compound method call and records it in the Variables item (see Table 5) of the source symbol table together with the FQCN of the anonymous class. For example, suppose you have the following compound call syntax:

data.first.second();

In this case, the variable name and FQCN recorded in the Variable item of the source symbol table can be composed as follows.

variable name: data.first()

FQCN: anonymous.Anonymous (example of FQCN of generated anonymous class)

When a method declaration syntax is included in the parsed partial source code, the source parsing module 202 records the declared method name and parameter type in the Methods item (see Tables 6 and 7) of the source symbol table.

When the parsed partial source code includes a parameter declaration syntax, the source parsing module 202 obtains the FQCN for the declared parameter type from the source symbol table. When the FQCN is obtained, the source parsing module 202 uses the parameter name as a variable name and records it in the Variables item (see Table 5) of the source symbol item together with the FQCN. Also, the source parsing module 202 registers the FQCN for the obtained parameter type in the dummy class candidate list.

When the parsed partial source code includes a variable declaration syntax, the source parsing module 202 obtains the FQCN for the type of the declared variable from the source symbol table, and sets the variable name and the obtained FQCN as Variables of the source symbol item. Record the item (see Table 5). Also, the source parsing module 202 registers the FQCN for the obtained variable type in the dummy class candidate list.

When the parsed partial source code includes an annotation specification syntax, the source parsing module 202 obtains the FQCN for the specified annotation type from the source symbol table, and adds the FQCN for the obtained annotation type to the dummy class candidate list. Register.

Next, in step 304 , the target identification module 204 generates a list of target classes for which a dummy class is to be actually generated from among the dummy class candidates included in the dummy class candidate list (Dummy Class Target List). Specifically, it is determined whether there is a need to generate a dummy class for each of the candidate classes included in the dummy class candidate list generated in step 302 of the target identification module. In one embodiment, the user may designate a specific reference class or library as a target for exclusion from creation of a dummy class. For example, in the case of a reference class or library including program code essential for the execution of the partial source code, it is impossible to execute the partial source code only with the dummy class. Therefore, in this case, the user can exclude the required reference class or library from the dummy class creation target, and in this case, the target identification module 204 only generates the dummy class for the remaining classes or libraries except for the specified reference class or library (target ) is specified.

4 is a flowchart illustrating a process of generating a dummy class target list according to an embodiment.

In step 402 , the target identification module 204 receives the dummy class candidate list generated by the source parsing module 202 .

In step 404, the target identification module 204 selects one of the dummy class candidates included in the dummy class candidate list.

In step 406 , the target identification module 204 determines whether the selected dummy class candidate is a class provided by the Java Virtual Machine (JVM).

If the determination result is not the class provided by the Java virtual machine, next in step 408, the target identification module 204 determines whether the selected dummy class candidate is a class included in the partial source code.

If the determination result is not a class included in the partial source code, next in step 410, the target identification module 204 determines whether the reference class is a reference class designated as an exception target by the user or a class included in the library.

If the determination result is not the designated reference class or the class included in the library, the target identification module 204 adds the selected dummy class candidate to the dummy class target list in step 412 .

However, if the selected class is a class provided by the Java virtual machine, a class included in the partial source code, or a class included in a reference class or library designated as an exception target, the target identification module 204 selects the selected dummy class. Delete the candidate and go to step 414.

In step 414, the target identification module 204 determines whether there are remaining dummy class candidates in the dummy class candidate list. If it exists, it moves to step 404 and repeats steps 406 and less for the remaining dummy class candidates. If it does not exist, the process ends.

Next, in step 306, the dummy class information generating module 206 secondary parses the partial source code and generates a dummy class information list therefrom. In an embodiment, the dummy class information generating module 206 may generate the dummy class information list by secondary parsing the partial source code with reference to the source symbol table and the dummy class target list.

The reason for parsing the partial source code again (secondary parsing) in the dummy class information generating module 206 is that there is a limit to grasping the entire structure of the partial source code only by the primary parsing in the source parsing module 202. to be. For example, suppose that statement A in the partial source code calls method B. Since the parsing of the source code is performed sequentially, the detailed information of method B cannot be known if method B has not yet been parsed. Accordingly, the source parsing module 202 records the reference information necessary for the secondary parsing in the source symbol table through the primary parsing of the source code, and the dummy class information generation module 206 refers to the source symbol table and refers to the dummy class. Creates a list of information.

Table 9 is an example for explaining a dummy class information list according to an embodiment. As shown in Table 9, the dummy class information list includes the package name, class name, superclass name, interface list that requires declaration, the type argument list of generics of each dummy class creation target class, It contains a list of constructors, whether it is annotated class, whether it is an exception class, a list that requires field definitions, and a list that requires method definitions.

Item data being stored data type example Package The package name of the dummy class string org.address Class dummy class name string Address Super Class The superclass name of the dummy class (FQCN) string org.address.Node Interfaces List of Interfaces that require declaration List Type Arguments List of Type Arguments in Generics List Constructors List of constructors with parameters List Annotation Annotation class? True/False False Exception Exception class? True/False False Methods List of Method Definition Required List Fields Field Definition Required List List

Table 10 illustrates a list connected to the Interfaces item of the dummy class information list shown in Table 9.

Item data being stored data type example Interface Interface's FQCN string org.library.Data

Table 11 exemplifies a list connected with the Type Arguments item of the dummy class information list shown in Table 9.

Item data being stored data type example Type Type Argument string org.library.Type

Table 12 exemplifies a list connected to the Constructors item of the dummy class information list shown in Table 9.

Item data being stored data type example Parameters List of constructor parameters List addr

Table 13 illustrates a list connected to the Methods item of the dummy class information list in Table 9.

Item data being stored data type example Method method name string process Parameters List of declared parameters List Return Return Type (FQCN) string java.lang.String Exceptions List of declared exceptions List

Table 14 exemplifies a list connected to the Parameters item of the list listed in Tables 12 and 13, respectively.

Item data being stored data type example Parameter Declared Parameter Type string String

Table 15 illustrates a list connected to the Exceptions item of the list listed in Table 13.

Item data being stored data type example Exception Declared Exception type string java.lang.Exception

Table 16 illustrates a list associated with the Fields item of the dummy class information list shown in Table 9.

Item data being stored data type example Field field name string count Static Static or not True/False False Field Type FQCN for Field string java.lang.Integer

The dummy class information generation module 206 performs the import syntax, the field declaration syntax, the object creation syntax, the method call syntax, and parameters among the partial source code through secondary parsing of the partial source code. (Parameter) declaration syntax, variable (Variable) declaration syntax, and annotation designation syntax are identified, and a dummy class information list is created through processing for each syntax.

5 is a flowchart for describing in detail a process for an import statement during a process of generating a dummy class information list according to an embodiment.

In step 502, the dummy class information generation module 206 identifies the import syntax in the partial source code.

In step 504, the dummy class information generation module 206 determines whether the imported class in the identified import syntax is a dummy class generation target. Specifically, the dummy class information generation module 206 refers to the dummy class target list and determines that the imported class is a dummy class generation target if the imported class is a class included in the dummy class target list. If, as a result of the determination, the dummy class is not a target of generation, this process is terminated.

If it is determined as a result of the determination that the dummy class is to be generated, the dummy class information generating module 206 adds information about the corresponding class to the dummy class information list in step 506 . Specifically, the dummy class information generating module 206 determines whether information on the class determined to be the dummy class generation target already exists in the dummy class information list in step 504. will be added to the list.

6 is a flowchart illustrating in detail a process for a field declaration syntax during a process of generating a dummy class information list according to an embodiment.

In step 602, the dummy class information generation module 206 identifies the field declaration syntax in the partial source code.

In step 604, the dummy class information generating module 206 obtains the FQCN for the type declared in the identified field declaration syntax from the source symbol table.

In step 606, the dummy class information generation module 206 determines whether the obtained FQCN is a dummy class generation target. Specifically, the dummy class information generating module 206 refers to the dummy class target list and determines that the obtained FQCN is a class included in the dummy class target list as a dummy class generation target. If, as a result of the determination, the dummy class is not a target of generation, this process is terminated.

As a result of the determination, if the dummy class is to be generated, the dummy class information generating module 206 adds information about the corresponding class to the dummy class information list in step 608 . Specifically, the dummy class information generation module 206 determines whether information on the class determined to be the dummy class generation target in step 606 already exists in the dummy class information list, and if not, converts the corresponding class information into the dummy class information. will be added to the list.

7 to 9 are flowcharts for explaining in detail a processing process for an object creation syntax during a dummy class information list creation process according to an embodiment.

In step 702, the dummy class information generation module 206 identifies the object creation syntax in the partial source code.

In step 704, the dummy class information generation module 206 obtains the FQCN for the type declared in the identified object creation syntax from the source symbol table.

In step 706, the dummy class information generation module 206 determines whether the obtained FQCN is a dummy class generation target. Specifically, the dummy class information generating module 206 refers to the dummy class target list and determines that the obtained FQCN is a class included in the dummy class target list as a dummy class generation target. If, as a result of the determination, the dummy class is not a target of generation, this process is terminated.

As a result of the determination, if the dummy class is to be generated, in step 708 , the dummy class information generation module 206 determines whether a type parameter of generics exists in the constructor of the corresponding object creation syntax. In Java, the type argument of generics can be specified using <> like ArrayList<String>.

If it is determined in step 708 that a generic type argument exists, the dummy class information generation module 206 generates information on the class determined as a target for generating the dummy class in step 706 in the dummy class information list in step 706. do. If it is determined in step 708 that the generic type argument does not exist, the process moves to step 718.

In step 712, the dummy class information generation module 206 obtains a type argument of generics from the object creation syntax.

In step 714 , the dummy class information generating module 206 obtains the FQCN of the declared type from the type argument of the generics obtained in step 712 .

In step 716, the dummy class information generating module 206 registers a Type Arguments item in the dummy class information list using the FQCN obtained in step 714 (see Table 11).

In step 718, the dummy class information generation module 206 determines whether a parameter exists in the constructor of the corresponding object creation statement.

If the parameter exists as a result of the determination in step 718, the dummy class information generation module 206 in step 720 generates information on the class determined to be a dummy class creation target in the dummy class information list in step 706. If the corresponding class information has already been generated through step 710, this process may be omitted. If the parameter does not exist as a result of the determination in step 718, the process moves to step 728.

In step 722, the dummy class information generation module 206 obtains parameter type information from the object creation syntax.

In step 724 , the dummy class information generating module 206 obtains the FQCN of the declared type from the parameter type information obtained in step 722 . If the FQCN of the parameter is unknown, the dummy class creation module can designate “java.lang.Object”, which is the top-level object of all objects.

In step 726, the dummy class information generating module 206 registers a parameter item in the dummy class information list by using the FQCN obtained in step 724 (see Tables 12 and 14).

In step 728, the dummy class information generation module 206 determines whether the corresponding object creation syntax is generated by the anonymous class creation method.

If it is determined in step 728 that the anonymous class generation method is used, the dummy class information generation module 206 generates information on the class determined to be the target of generation of the dummy class in step 706 in the dummy class information list in step 730. . If the corresponding class information has been previously generated through step 710 or step 720, this process may be omitted. If it is determined in step 728 that the anonymous class is not generated by the method of generating an anonymous class, this step is terminated.

In step 732 , the dummy class information generating module 206 searches for the anonymous class definition (body) part of the partial source code.

In step 734, the dummy class information generation module 206 determines whether the found definition part is a method declaration syntax. If, as a result of the determination, the searched definition part is not a method declaration syntax, this step is terminated.

If the found definition part is a method declaration syntax as a result of the determination, in step 736, the dummy class information generation module 206 determines the declared parameter type, return type, and exception type of the method. type) to obtain the FQCN.

In step 738, the dummy class information generating module 206 registers a method item in the dummy class information list using the FQCNs obtained in step 736 (see Tables 13 to 15).

10 to 13 are flowcharts for explaining in detail a process for a method call syntax during a process of generating a dummy class information list according to an embodiment.

In step 1002, the dummy class information generation module 206 identifies the method call syntax in the partial source code.

In step 1004 , the dummy class information generation module 206 identifies the object possessing the method in the identified method invocation syntax.

In step 1006, the dummy class information generation module 206 determines whether the identified target is a class or an object.

If the identified target is a class or object as a result of the determination, then, in step 1008, the dummy class information generation module 206 determines whether the identified target is an imported class.

If the identified object is an imported class as a result of the determination, then, in step 1010, the dummy class information generation module 206 obtains the FQCN for the declared type of the imported class from the source symbol table.

In step 1012, the dummy class information generation module 206 determines whether the obtained FQCN is a dummy class generation target. If it is determined as a result of the determination that the dummy class is to be generated, this process is terminated.

In step 1014, the dummy class information generating module 206 registers the identified method information in the dummy class information list. Specifically, the dummy class information generating module 206 registers the method information in the Methods item (refer to Tables 13 to 15) of the class that is the subject of method possession. The registered information includes method parameter type, return type, and exception type information. If the exception type is a dummy class generation target, the dummy class information generation module 206 registers dummy class information corresponding to the corresponding exception type in the dummy class information list. In this case, the exception class information among the dummy class information is recorded as True (Exception=True).

On the other hand, if the identified target is not a class or object as a result of the determination in step 1006, the dummy class information generation module 206 determines whether the identified target is a return object of another method in step 1016 (that is, for compound method calls).

If the identified target is a return object of another method as a result of the determination, the dummy class information generation module 206 acquires the FQCN of the return object in step 1018 .

In step 1020, the dummy class information generation module 206 determines whether the obtained FQCN is a dummy class generation target. If it is determined as a result of the determination that the dummy class is to be generated, this process is terminated.

In step 1022, the dummy class information generation module 206 registers the identified method information in the dummy class information list. The process of registering method information in the dummy class information list is the same as described in step 1014 above.

Meanwhile, if it is determined in step 1008 that the identified target is not an imported class, in step 1024, the dummy class information generation module 206 determines whether the identified target is a variable.

If the identified target is a variable as a result of the determination, in step 1026, the dummy class information generating module 206 obtains the FQCN of the target variable.

In step 1028, the dummy class information generation module 206 determines whether the obtained FQCN is a dummy class generation target. If it is determined as a result of the determination that the dummy class is to be generated, this process is terminated.

In step 1030, the dummy class information generating module 206 registers the identified method information in the dummy class information list. The process of registering method information in the dummy class information list is the same as described in step 1014 above.

Meanwhile, if it is determined in step 1024 that the identified object is not a variable, in step 1032 , the dummy class information generating module 206 determines whether the identified object is a field.

If the identified target is a field as a result of the determination, in step 1034, the dummy class information generation module 206 acquires the FQCN of the target field.

In step 1036, the dummy class information generation module 206 determines whether the obtained FQCN is a dummy class generation target. If it is determined as a result of the determination that the dummy class is to be generated, this process is terminated.

In step 1038, the dummy class information generation module 206 registers the identified method information in the dummy class information list. The process of registering method information in the dummy class information list is the same as described in step 1014 above.

14 is a flowchart for explaining in detail a process for a parameter declaration syntax during a process of generating a dummy class information list according to an embodiment.

In step 1402, the dummy class information generation module 206 identifies the parameter declaration syntax in the partial source code.

In step 1404, the dummy class information generating module 206 obtains the FQCN for the type declared in the identified parameter declaration syntax from the source symbol table.

In step 1406, the dummy class information generation module 206 determines whether the obtained FQCN is a dummy class generation target. Specifically, the dummy class information generating module 206 refers to the dummy class target list and determines that the obtained FQCN is a class included in the dummy class target list as a dummy class generation target. If, as a result of the determination, the dummy class is not a target of generation, this process is terminated.

If it is determined as a result of the determination that the dummy class is to be generated, the dummy class information generation module 206 adds information about the corresponding class to the dummy class information list in step 1408 . Specifically, the dummy class information generating module 206 determines whether information on the class determined to be the dummy class generation target already exists in the dummy class information list in step 1406, and if it does not exist, converts the corresponding class information into the dummy class information will be added to the list.

15 is a flowchart illustrating in detail a process for a variable declaration syntax during a process of generating a dummy class information list according to an embodiment.

In step 1502, the dummy class information generation module 206 identifies the variable declaration syntax in the partial source code.

In step 1504, the dummy class information generation module 206 obtains the FQCN for the type declared in the identified variable declaration syntax from the source symbol table.

In step 1506, the dummy class information generation module 206 determines whether the obtained FQCN is a dummy class generation target. Specifically, the dummy class information generating module 206 refers to the dummy class target list and determines that the obtained FQCN is a class included in the dummy class target list as a dummy class generation target. If, as a result of the determination, the dummy class is not a target of generation, this process is terminated.

As a result of the determination, if the dummy class is to be generated, the dummy class information generation module 206 adds information about the corresponding class to the dummy class information list in step 1508 . Specifically, the dummy class information generation module 206 determines whether information on the class determined as the target of generating the dummy class in step 1506 already exists in the dummy class information list, and if there is not, the corresponding class information is converted into the dummy class information. will be added to the list.

In step 1510, the dummy class information generation module 206 determines whether a variable declared in a corresponding variable declaration syntax and a created object type are different. If the determination result is not different, the process ends.

If, as a result of the determination, the type of the created object is different from the variable declared in the corresponding variable declaration syntax, the dummy class information generating module 206 acquires the type of the created object in step 1512 .

In step 1514, the dummy class information generation module 206 obtains an FQCN for the obtained type.

In step 1516, the dummy class information generating module 206 changes the upper class information of the dummy class among the dummy class information generated in step 1508 to the FQCN obtained in step 1514.

16 is a flowchart for describing in detail a process for an annotation designation syntax during a process of generating a dummy class information list according to an embodiment.

In step 1602, the dummy class information generation module 206 identifies an annotation specification syntax in the partial source code.

In step 1604, the dummy class information generation module 206 obtains the FQCN for the type declared in the identified annotation designation syntax from the source symbol table.

In step 1606, the dummy class information generation module 206 determines whether the obtained FQCN is a dummy class generation target. Specifically, the dummy class information generating module 206 refers to the dummy class target list and determines that the obtained FQCN is a class included in the dummy class target list as a dummy class generation target. If, as a result of the determination, the dummy class is not the target of generation, this process is terminated.

If it is determined as a result of the determination that the dummy class is to be generated, the dummy class information generation module 206 adds information about the corresponding class to the dummy class information list in step 1608 . Specifically, the dummy class information generation module 206 determines whether information on the class determined to be a dummy class generation target in step 1606 already exists in the dummy class information list, and if not, converts the corresponding class information into the dummy class information will be added to the list. On the other hand, in this case, in the dummy class information, whether it is an annotation class is specified as True.

Referring back to FIG. 3 , in step 308 , the dummy class creation module 208 creates an actual dummy class by referring to the dummy class information list generated by the dummy class information generation module 206 . The dummy class generated by the dummy class creation module 208 is a kind of shell class having the same appearance and structure as the actual class. Specifically, the dummy class creation module 208 records the bytecode for each dummy class into a file with reference to each dummy class information included in the dummy class information list.

In one embodiment, the dummy class creation module 208 writes the bytecode for the anonymous class first, when the anonymous class exists among the classes included in the dummy class information list, and after the creation of the anonymous class is completed, the non-anonymous class It can be configured to write bytecode for The reason we write the anonymous class first is that we refer to the anonymous class from another dummy class.

Finally, in step 310, the compilation module 210 compiles the partial source code using the dummy class.

17 exemplifies partial source files that can be compiled by the above-described compilation device. For the Main.java source code shown in FIG. 17 , the source parsing module may generate a source symbol table as follows.

Item data Line Package com.sds.sample One Class Main 8 Imports fqcn=org.library.Address, static=false, asterisk=false 3 fqcn=org.library.Node, static=false, asterisk=false 4 fqcn=org.library.PrintUtils, static=true, asterisk=false 6 Inner classes Inner 32 Fields name=name, fqcn=java.lang.String 10 name=addr, fqcn=org.library.Address 11 name=boxedAge, fqcn=org.library.Node 12 Variables name=name, method=hello, fqcn=java.lang.String 14 name=boxedAge, method=hello, fqcn=org.library.Node<java.lang.Integer> 14 name=message, method=hello, fqcn=java.lang.String 19 name=city, method=setAddress, fqcn=java.lang.String 25 name=postal, method=setAddress, fqcn=java.lang.String 25 name=address, method=setAddress, fqcn=java.lang.String 25 Methods name=hello, parameters String 14 Node<Integer> 14 name=setAddress parameters String 25 String 25 String 25

After parsing the Main.java source, the classes identified as dummy class targets by the target identification module are org.library.Address and org.library.Node.

Table 18 shows dummy class information of org.library.Address.

Item data Package org.library Class Address super class java.lang.Object Interfaces - Type Arguments - Constructors name=Address Parameters java.lang.String Annotation False Exception False Methods name=setCity, return=void Parameters java.lang.String Exceptions - name=setPostal, return=void Parameters java.lang.String Exceptions - name=setAddress, return=void Parameters java.lang.String Exceptions -

Table 19 shows dummy class information of org.library.Node.

Item data Package org.library Class Node super class java.lang.Object Interfaces - Type Arguments A Constructors - Annotation False Exception False Methods -

18 is a block diagram illustrating and describing a computing environment 10 including a computing device suitable for use in example embodiments. In the illustrated embodiment, each component may have different functions and capabilities other than those described below, and may include additional components other than those described below.

The illustrated computing environment 10 includes a computing device 12 . In one embodiment, computing device 12 may be a compilation device according to embodiments of the present invention. Computing device 12 includes at least one processor 14 , computer readable storage medium 16 , and communication bus 18 . The processor 14 may cause the computing device 12 to operate in accordance with the exemplary embodiments discussed above. For example, the processor 14 may execute one or more programs stored in the computer-readable storage medium 16 . The one or more programs may include one or more computer-executable instructions that, when executed by the processor 14, configure the computing device 12 to perform operations in accordance with the exemplary embodiment. can be

Computer-readable storage medium 16 is configured to store computer-executable instructions or program code, program data, and/or other suitable form of information. The program 20 stored in the computer readable storage medium 16 includes a set of instructions executable by the processor 14 . In one embodiment, computer-readable storage medium 16 includes memory (volatile memory, such as random access memory, non-volatile memory, or a suitable combination thereof), one or more magnetic disk storage devices, optical disk storage devices, flash It may be memory devices, other forms of storage medium that can be accessed by computing device 12 and store desired information, or a suitable combination thereof.

Communication bus 18 interconnects various other components of computing device 12 , including processor 14 and computer readable storage medium 16 .

Computing device 12 may also include one or more input/output interfaces 22 and one or more network communication interfaces 26 that provide interfaces for one or more input/output devices 24 . The input/output interface 22 and the network communication interface 26 are coupled to the communication bus 18 . Input/output device 24 may be coupled to other components of computing device 12 via input/output interface 22 . Exemplary input/output device 24 may include a pointing device (such as a mouse or trackpad), a keyboard, a touch input device (such as a touchpad or touchscreen), a voice or sound input device, various types of sensor devices, and/or imaging devices. input devices and/or output devices such as display devices, printers, speakers and/or network cards. The exemplary input/output device 24 may be included in the computing device 12 as a component constituting the computing device 12 , and may be connected to the computing device 102 as a separate device distinct from the computing device 12 . may be

Meanwhile, an embodiment of the present invention may include a program for performing the methods described in this specification on a computer, and a computer-readable recording medium including the program. The computer-readable recording medium may include program instructions, local data files, local data structures, etc. alone or in combination. The medium may be specially designed and configured for the present invention, or may be commonly used in the field of computer software. Examples of computer-readable recording media include hard disks, magnetic media such as floppy disks and magnetic tapes, optical recording media such as CD-ROMs and DVDs, and program instructions specially configured to store and execute program instructions such as ROMs, RAMs, flash memories, and the like. Hardware devices are included. Examples of the program may include not only machine language codes such as those generated by a compiler, but also high-level language codes that can be executed by a computer using an interpreter or the like.

Although representative embodiments of the present invention have been described in detail above, those of ordinary skill in the art to which the present invention pertains will understand that various modifications are possible within the limits without departing from the scope of the present invention with respect to the above-described embodiments. . Therefore, the scope of the present invention should not be limited to the described embodiments, and should be defined by the claims described below as well as the claims and equivalents.

200: compilation device of partial source code
202: source parsing module
204: target identification module
206: dummy class information generation module
208: Dummy class creation module
210: compilation module

Claims (16)

a source parsing module that parses the partial source code and generates a source symbol table and a dummy class candidate list therefrom;
a target identification module for generating a dummy class target list by identifying a target class requiring actual dummy class generation among one or more dummy class candidate classes included in the dummy class candidate list;
a dummy class information generating module for obtaining information of the identified target classes and generating a dummy class information list therefrom;
a dummy class creation module for generating one or more dummy classes by referring to the dummy class information list; and
and a compilation module that compiles the partial source code using the generated dummy class.
The method according to claim 1,
The dummy class candidate list includes a Fully-Qualified Class Name (FQCN) of one or more classes used in the partial source code.
3. The method according to claim 2,
The source parsing module,
When the partial source code includes a complex method call syntax, an anonymous class corresponding to the method call is created, and the FQCN of the generated anonymous class is registered in the dummy class candidate list. Source code compilation device.
The method according to claim 1,
The source parsing module,
When the dummy class candidate class is included in one or more of a class provided by the Java virtual machine, a class included in the partial source code, or a preset dummy class exclusion target class, the corresponding class is excluded from the target class, partial source Compilation device for code.
The method according to claim 1,
The dummy class information generating module generates the dummy class information list by secondary parsing the partial source code with reference to the source symbol table and the dummy class target list.
6. The method of claim 5,
The dummy class information list includes a package name of each target class, a class name, a superclass name, a list of interfaces requiring declaration, a list of type arguments of generics, a list of constructors, whether an annotation class, an exception A compilation device for partial source code, including whether it is a class, a list of field definitions required, and a list of method definitions required.
6. The method of claim 5,
The dummy class information generation module is, when the partial source code includes an object creation syntax, obtains an FQCN of a parameter included in the object creation syntax and registers it in the dummy class information list, from the partial source code A device for compiling partial source code, wherein when the FQCN of the parameter cannot be obtained, a top-level object (java.lang.Object) is registered in the dummy class information list.
The method according to claim 1,
The dummy class creation module, when an anonymous class is included in the dummy class information list, first writes the bytecode for the anonymous class, and writes the bytecode for the non-anonymous class after the creation of the anonymous class is completed. , which is a compilation device of partial source code.
one or more processors, and
A method performed in a computing device having a memory storing one or more programs to be executed by the one or more processors, the method comprising:
parsing the partial source code and generating a source symbol table and a dummy class candidate list therefrom;
generating a dummy class target list by identifying a target class for which actual dummy class generation is required among one or more dummy class candidate classes included in the dummy class candidate list;
obtaining information of the identified target classes, and generating a dummy class information list therefrom;
a dummy class creation step of creating one or more dummy classes with reference to the dummy class information list; and
and performing compilation on the partial source code using the generated dummy class.
10. The method of claim 9,
The dummy class candidate list includes a Fully-Qualified Class Name (FQCN) of one or more classes used in the partial source code.
11. The method of claim 10,
The step of generating the dummy class candidate list comprises:
When the partial source code includes a method call syntax of a complex method, an anonymous class corresponding to the method call is created, and the FQCN of the generated anonymous class is registered in the dummy class candidate list , how to compile partial source code.
10. The method of claim 9,
The step of generating the dummy class candidate list comprises:
When the dummy class candidate class is included in one or more of a class provided by the Java virtual machine, a class included in the partial source code, or a preset dummy class exclusion target class, configured to exclude the corresponding class from the target class, How to compile partial source code.
10. The method of claim 9,
The step of generating the dummy class information includes:
and generate the dummy class information list by secondary parsing the partial source code with reference to the source symbol table and the dummy class target list.
14. The method of claim 13,
The dummy class information list includes a package name of each target class, a class name, a superclass name, a list of interfaces requiring declaration, a list of type arguments of generics, a list of constructors, whether an annotation class, an exception How to compile partial source code, including whether it is a class, a list of field definitions required, and a list of method definitions required.
14. The method of claim 13,
The step of generating the dummy class information includes:
When the partial source code includes an object creation syntax, the FQCN of the parameter included in the object creation syntax is obtained and registered in the dummy class information list, but the FQCN of the parameter cannot be obtained from the partial source code In this case, a method of compiling a partial source code, in which the top-level object (java.lang.Object) is registered in the dummy class information list.
10. The method of claim 9,
The dummy class creation step is
Compilation of partial source code in which, when an anonymous class is included in the dummy class information list, the bytecode for the anonymous class is first written, and the bytecode for the non-anonymous class is written after the creation of the anonymous class is completed Way.

Images