JP2010140408A - Source code converting device - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To convert a source code written in a certain programming language into a source code written in a different programming language. <P>SOLUTION: A source code processing device acquires a Hitachi source code 200, and parses it to generate a conversion source AST. The AST is a model obtained by structuring nodes corresponding to components of a source code according to its logical structure. A conversion destination AST corresponding to IBM-COBOL is generated from the conversion source AST. According to the nodes included in the conversion destination AST and its structure, an IBM source code 202 is generated. <P>COPYRIGHT: (C)2010,JPO&INPIT

Description

  The present invention relates to a technique for supporting analysis of a computer program, and in particular, analysis of a source code.

  Business systems that support the operation of companies and public facilities, so-called enterprise systems, are now being introduced as the foundations of large and small organizations. The business system aggregates, accumulates, analyzes, and processes data obtained from node terminals and databases, and outputs information with higher added value. The number of program files that make up a business system may reach hundreds of thousands and sometimes millions. Business systems continue to evolve to make more complex organizational management more efficient.

Business systems require inspection and correction of source code not only during development, but also during maintenance work and reconstruction. Various software analysis tools (hereinafter simply referred to as “analysis tools”) are provided to support the analysis of source code.
JP 2007-156791 A

The source code included in the business system is often written in a programming language called COBOL (COmmon Business Oriented Language). However, there are many derivations in COBOL. For example, COBOL provided by Hitachi, Ltd. (hereinafter referred to as “Hitachi COBOL”) includes a unique part that is not found in COBOL provided by other vendors. The same applies to COBOL provided by IBM (International Business Machines) (hereinafter referred to as “IBM COBOL”). For this reason, even if a certain vendor provides a useful analysis tool for IBM and COBOL, a situation occurs in which the source code described in Hitachi COBOL cannot be analyzed. Traditionally, in this situation,
1. The user rewrites the source code to be analyzed from Hitachi COBOL to IBM / COBOL.
2. Create an analysis tool for Hitachi COBOL.
Such countermeasures were often taken.

  The present invention has been completed on the basis of recognition of the above problems by the present inventor, and its main object is to provide a technique for converting source code described in one programming language into source code in another programming language. It is to provide.

One embodiment of the present invention relates to a source code conversion apparatus.
The apparatus generates a first syntax model indicating a logical structure of the first source code by a set of basic nodes from the first source code which is a source code described in the first programming language, and performs the second programming. By converting a basic node to a conversion destination node that is a node corresponding to a component that can be used in the language, a second syntax model indicating the logical structure of the first source code by an aggregate of conversion destination nodes is generated, and The second source code as the source code described in the second programming language is generated according to the conversion destination node and its structure included in the two syntax model.

  Here, the first programming language and the second programming language may be programming languages of the same type but different in details, such as Hitachi COBOL and IBM COBOL. Alternatively, different programming languages such as COBOL and JAVA (registered trademark), COBOL and C ++, JAVA (registered trademark) and C ++ may be used.

  It should be noted that any combination of the above-described components, and the present invention expressed by a method, system, recording medium, and computer program are also effective as an aspect of the present invention.

  ADVANTAGE OF THE INVENTION According to this invention, it becomes easy to convert the source code described in one programming language into the source code described in another programming language.

FIG. 1 is a schematic diagram showing a language conversion process of source code.
In the present embodiment, a process of converting source code described in Hitachi COBOL (hereinafter referred to as “Hitachi source 200”) into source code described in IBM / COBOL (hereinafter referred to as “IBM source 202”). Will be described as an example.

There are three main functions for realizing language conversion of the source code, which are called a parser, a processor, and a writer, respectively. Each function is in charge of analysis processing, conversion processing, and generation processing.
Analysis process (S1): First, Hitachi source 200 is acquired as the first source code, the parser parses it, and an abstract syntax tree as the first syntax model (hereinafter referred to as “AST (Abstract Syntax Tree)”). Is generated. The AST is formed as a tree structure in which nodes are associated with source code components such as operators and their operands. The AST can be generated by application of existing technology adopted by a general compiler or interpreter. As in the Hitachi source 200, the source code as the conversion source is “conversion source source”, the AST generated from the conversion source source is “conversion source AST”, and the node included in the conversion source AST is “basic node” or “ This is called a “transformer node”. The conversion source AST may be an AST corresponding to the language structure of the conversion source, or may be an AST as a standard model corresponding to another programming language, for example, a standard COBOL language structure. The analysis process will be described in detail with reference to FIG.

  Conversion process (S2): The processor converts the conversion source AST into an AST corresponding to the IBM source 202 as the second source code. As in the IBM source 202, the source code as the conversion destination is “conversion destination source”, the AST generated for the conversion destination source is “conversion destination AST”, and the nodes included in the conversion destination AST are “conversion destination node”. Call it. The conversion destination AST as the second syntax model corresponds to the language structure of the conversion destination source. The conversion process will be described in detail with reference to FIGS.

Generation process (S3): The writer generates an IBM source 202 that is a conversion destination source from the conversion destination AST. The generation process will be described in detail with reference to FIG.
As described above, the conversion source AST is generated from the Hitachi source 200 which is the conversion source, the conversion destination AST is generated from the conversion source AST, and the IBM source 202 which is the conversion destination source is generated from the conversion destination AST. Thus, the Hitachi source 200 is converted to the IBM source 202.

  In order to realize language conversion processing, 1. 1. Rules for generating conversion source AST from conversion source (hereinafter referred to as “first AST rule”); 2. rules for generating the conversion destination AST from the conversion source AST (hereinafter referred to as “second AST rule”); Three types of rules are required: a rule for generating a conversion source from the conversion destination AST (hereinafter referred to as “source generation rule”). By providing these rules as a library for various programming languages, language conversion processing between various programming languages is realized.

FIG. 2 is a functional block diagram of the source code processing device 100.
Each block shown here can be realized in hardware by an element such as a CPU of a computer or a mechanical device, and in software it is realized by a computer program or the like. Draw functional blocks. Therefore, those skilled in the art will understand that these functional blocks can be realized in various forms by a combination of hardware and software.
The source code processing device 100 is a device responsible for the functions of the parser, processor, and writer shown in FIG. In the present embodiment, the main function of the source code processing apparatus 100 will be described as being realized as software on a computer. More specifically, each function of the source code processing device 100 in the present embodiment is mainly described by JAVA (registered trademark) or Scala, and is realized by a computer program executed on a JVM (Java Virtual Machine). .

The source code processing device 100 includes a UI (user interface) unit 110, a data processing unit 120, and a data holding unit 140.
The UI unit 110 is in charge of user interface processing. The data processing unit 120 executes various data processing based on data acquired from the UI unit 110 or the data holding unit 140. The data processing unit 120 also serves as an interface between the UI unit 110 and the data holding unit 140. The data holding unit 140 is a storage area for holding various data.

UI unit 110:
The UI unit 110 includes an input unit 112 and an output unit 116. The input unit 112 detects various user inputs and acquires data such as files from an external device. The output unit 116 displays various types of information and transmits data such as files to an external device. The input unit 112 includes a code acquisition unit 114. The code acquisition unit 114 acquires a conversion source source such as the Hitachi source 200 in FIG. The output unit 116 includes a code output unit 118. The code output unit 118 outputs a conversion destination source such as the IBM source 202 of FIG.

Data processing unit 120:
The data processing unit 120 includes a first syntax model generation unit 122, a second syntax model generation unit 124, a code generation unit 126, a check unit 128, and an annotation node setting unit 130. The first syntax model generation unit 122 includes a first AST rule 152. The first syntax model generation unit 122 refers to the first AST rule 152 and generates a conversion source AST from the conversion source. The second syntax model generation unit 124 includes a second AST rule 154. The second syntax model generation unit 124 refers to the second AST rule 154 and generates a conversion destination AST from the conversion source AST. The code generation unit 126 includes a source generation rule 156. The code generation unit 126 refers to the source generation rule 156 and generates a conversion destination source from the conversion destination AST.

  The inspection unit 128 scans the node of the conversion source AST or the conversion destination AST, and specifies a location that matches a predetermined “detection condition”. The inspection unit 128 includes a coding rule 158. All or part of the detection conditions are defined as coding rules 158. The detection conditions will be described in detail with reference to FIG. The annotation node setting unit 130 sets “annotation node” to AST when a location that matches the detection condition is detected. The annotation node setting unit 130 includes an annotation node setting rule 160. In the annotation node setting rule 160, a detection condition and an annotation node are associated with each other. It is set in this annotation node setting rule 160 which annotation node should be set when a location that matches a certain detection condition is detected. Details of the annotation node setting will be described in detail with reference to FIG. The detection condition and the annotation node are introduced in order to determine whether a predetermined coding rule is observed for AST or whether there is a description portion inappropriate for the programming structure.

Data holding unit 140:
The data holding unit 140 includes a first syntax model holding unit 142 and a second syntax model holding unit 144. The first syntax model holding unit 142 holds the conversion source AST generated by the first syntax model generation unit 122. The second syntax model holding unit 144 holds the conversion destination AST generated by the second syntax model generation unit 124.

  The analysis process (S1), that is, the function as a parser is mainly realized by the input unit 112 and the first syntax model generation unit 122. The conversion process (S2), that is, the function as a processor is mainly realized by the second syntax model generation unit 124. The generation process (S3), that is, the function as a writer is mainly realized by the code generation unit 126 and the output unit 116.

  The source code processing device 100 inspects the description content of the source code by setting a detection condition in addition to the function as a “source code conversion device” for converting the source source language into the destination source. It also has a function as an “inspection device”. Hereinafter, the function as the “source code conversion apparatus” and the function as the “source code inspection apparatus” will be described separately.

[Function as a source code converter]
FIG. 3 is a schematic diagram for explaining the process of generating the conversion source AST from the Hitachi source 200.
The Hitachi source 200 shown in the figure compares the variable “A” and the variable “B”, and sets the character string “Y” in the variable “FLAG” when the condition “A and B are both 1” is satisfied. In other cases, the variable “FLAG” is set to the character string “N”. The syntax “EVALUATE AB” on the first line indicates the processing content that “A” and “B” are to be compared.

  When the code acquisition unit 114 acquires the Hitachi source 200, the first syntax model generation unit 122 first acquires the syntax “EVALUATE A B”. The components of this syntax are “EVALUATE”, “A”, and “B”. First, based on the first AST rule, the first syntax model generation unit 122 sets a conversion source node EvaluateStatement 206 corresponding to “EVALUATE”, and sets a conversion node EvaluateTagList 208 corresponding to a variable list declaration of “EVALUATE”. The component is a statement such as a variable, a constant, a declaration, or a function described in the source code, and the node is an AST element associated with the component. Some nodes, such as EvaluateStatement 206, are set corresponding to the components that are explicitly described in the source code. Other nodes such as EvaluateTagList 208 are associated with other nodes such as EvaluateStatement 206. Some nodes are set as follows.

Corresponding to the arguments “A” and “B” of “EVALUATE”, two nodes of Expression: “A” 210 and Expression: “B” 212 are set as child nodes of EvaluateTagList 208. Furthermore, a node “None214” for indicating the juxtaposition of the arguments “A” and “B” is also set. In Hitachi source 200, arguments can be written as they are like “EVALUATE AB”, but in IBM source 202, “ALSO” is placed between arguments “A” and “B” like “EVALUATE A ALSO B”. Are described. When generating the conversion source AST 204 from the Hitachi source 200, not only Expression: “A” 210 and Expression: “B” 212 but also a node called None 214 is set. More specifically, the expression “EVALUATE” is associated with the EvaluateStatement 206, the EvaluateTagList 208, and the node (None 214) for connecting the argument and the node corresponding to the argument in the first AST rule. The first syntax model generation unit 122 assembles an appropriate transformation source node corresponding to the expression “EVALUATE” according to the first AST rule.
If the conversion source AST 204 is a standard / unified syntax model, if the first AST rule is prepared for each programming language of the conversion source, the conversion source AST 204 as a standard syntax model can be obtained from an arbitrary conversion source. Can be generated.

FIG. 4 is a schematic diagram for explaining a process of generating the conversion destination AST and the IBM source 202 from the conversion source AST.
First, the second syntax model generation unit 124 generates a conversion destination AST 220 from the conversion source AST 204. In the IBM source 202 which is the conversion destination source, the argument of “EVALUATE” is connected by the component “ALSO” like “EVALUATE A ALSO B”. Therefore, the second syntax model generation unit 124 converts the conversion source node None 214 of the conversion source AST 204 into the conversion destination node ALSO 222. The association between the conversion source node and the conversion destination node is set as a second AST rule for each programming language. The second syntax model generation unit 124 generates the conversion destination AST 220 from the conversion source AST 204 according to the second AST rule.
If the conversion source AST 204 is a standard / unified syntax model, the conversion to an arbitrary conversion destination AST is possible if a second AST rule is prepared for each programming language of the conversion destination source.

  The code generation unit 126 identifies the corresponding component of the IBM source 202 for each conversion destination node, and assembles the specified component according to the structure of the conversion destination AST 220. Such a rule is defined as a source generation rule. In this way, the IBM source 202 including the ALSO expression is generated from the Hitachi source 200 not including the ALSO expression. As a result, the Hitachi source 200 can be analyzed by an analysis tool for IBM / COBOL.

The basic concept is the same when the IBM source 202 is the conversion source source and the Hitachi source 200 is the conversion destination source. When creating the conversion source AST from the IBM source 202, the node “ALSO 222” is set from the component “ALSO”. When converting the conversion source AST to the conversion destination AST for Hitachi COBOL, the ALSO 222 is converted to None214. Alternatively, the node corresponding to the ALSO 222 may not be set as the conversion destination AST. In any case, the node corresponding to the ALSO 222 may be invalidated in the conversion destination AST. The code generation unit 126 does not describe the component corresponding to None 214 in the Hitachi source 200. With such a processing method, “EVALUATE A ALSO B” of the IBM source 202 is expressed as “EVALUATE AB” in the Hitachi source 200.
Here, the presence or absence of ALSO 222 was given as an example of the difference between Hitachi source 200 and IBM source 202. However, the first AST rule, the second AST rule, and the source generation rule are appropriately defined for differences between various other languages. It becomes possible to convert.

[Function as a source code inspection device]
FIG. 5 is a diagram showing an AST generated from a variable declaration statement “int num, iNumber”.
The AST to be inspected may be the conversion source AST or the conversion destination AST. Here, a description will be given assuming that the inspection is performed on the conversion source AST. The contents of the inspection can be arbitrarily set by the user. For example, assume that the following coding rules are set for business system development and maintenance.
R1. Int type variable names must begin with the letter “i” R2. In variable declaration, do not define multiple variables in a single type declaration. R3. Variable name must be at least 4 characters long

  Establishing coding rules is important for improving the readability of source code and preventing correction errors. In particular, it is important to establish appropriate coding rules in the development of large-scale business systems involving multiple software engineers.

  In the declaration statement “int num, iNumber” in the figure, the variable “num” does not satisfy the rule R1 because the first character is “n”. Further, since two variables “num” and “iNumber” are defined together in one int type declaration, the rule R2 is not satisfied. Furthermore, since the variable “num” has only three characters, the rule R3 is not satisfied. The source code processing device 100 can inspect whether the coding rules are actually observed and where the coding rules are not observed.

  The AST 230 shown in the figure corresponds to the declaration sentence “int num, iNumber”. When the first syntax model generation unit 122 encounters a variable declaration statement, it first sets the LocalVariableDeclaration 232 in the AST 230 based on the first AST rule. As child nodes, IntType 234 which is a node indicating an int type and VariableDeclarators 236 which is a node indicating a variable list are set. For the variable “num” and the variable “iNumber”, VariableDeclarator 238 and Identifier: “num” 240 and VariableDeclarator 242 and Identifier: “iNumber” 244 are set, respectively.

FIG. 6 is a diagram showing the AST 230 in which annotation nodes are set corresponding to the rule R1.
In the inspection unit 128, the above-described rules R1 to R3 are set as detection conditions. The inspection unit 128 first searches the AST 230 for a variable node that violates the rule R1 “int-type variable name starts with the letter“ i ””. When the inspection unit 128 scans the AST 230 and finds the IntType 234, the inspection unit 128 searches for the identifier node among the child nodes of the local node LocalVariableDeclaration 232 and checks the variable name. The variable “num” violates rule R1. The annotation node setting unit 130 sets the annotation node 250 to Identifier: “num” 240.

  The annotation node setting unit 130 finally collects the annotation nodes 250 in the AST 230, lists them, and outputs them to the output unit 116. The code generation unit 126 may generate a source code from the AST 230 including the annotation node 250. The code generation unit 126 may add a comment indicating the annotation content to a corresponding location of the annotation node 250 in the source code.

FIG. 7 is a diagram showing the AST 230 when an annotation node is set corresponding to the rules R2 and R3.
Next, the inspection unit 128 searches for a location that violates the rule R2 “Do not define a plurality of variables in one type declaration in a variable declaration”. When the inspection unit 128 scans the AST 230 and finds the LocalVariableDeclaration 232, the inspection unit 128 searches for an identifier node among the child nodes and checks the number of variables declared. The statement “int num, iNumber” violates rule R2. The annotation node setting unit 130 sets the annotation node 254 in the VariableDeclarators 236.

  The inspection unit 128 searches for a location that violates the rule R3 “variable name must be 4 characters or more”. When the inspection unit 128 scans the AST 230 and finds the LocalVariableDeclaration 232, the inspection unit 128 searches for an identifier node among the child nodes and checks the number of characters of the declared variable. Since the variable “num” violates the rule R 3, the annotation node setting unit 130 sets the annotation node 252 in Identifier: “num” 240.

  The detection condition is not limited to the condition related to the coding rule. For example, a condition that should be satisfied as the structure of the computer program may be set as the detection condition. Two examples are shown below.

Example 1. Confirmation of statements to be described at the start and end of a specific process For example, in the case of C ++, memory is dynamically allocated by a “new” operator. The operator that releases the memory is “delete”. Memory allocated with the new operator must be freed with delete after use. In addition, after opening the file descriptor by the “open” operator, the file descriptor must be closed by the “close” operator. Thus, a predetermined statement must be described as a pair before and after specific processing such as “dynamic memory allocation” and “use of file descriptor”. Hereinafter, a component to be described at the start of a specific process such as new or open is referred to as a “start element”, and a component to be described at the end is referred to as an “end element”. In one source file, the number of start elements and end elements should be the same. If the node corresponding to the start element is called “front end node” and the node corresponding to the end element is called “end node”, in AST, the number of front end nodes and the number of end nodes should be the same.
From this point of view, the source code processing device 100 may inspect whether there is a defect in the program structure based on the leading node and the terminal node.

  Here, open will be described as a start element and close as an end element. First, when the inspection unit 128 scans AST and detects a leading node corresponding to open, the number of leading nodes is incremented. When the terminal node corresponding to close is detected, the number of terminal nodes is incremented. If all the AST nodes are scanned and the number of leading and terminal nodes is not the same, the source code description may be defective. When the number of leading nodes is larger than the number of terminal nodes, there may be a file descriptor that is open and not closed. In such a case, the annotation node setting unit 130 sets an annotation node for warning to that effect.

Example 2. Confirming the override range Assume that classA defines its member function method1 (). ClassB, which inherits this class, can provide the member function method1 () of classA as its own member function without defining its own member function method1 (). In other words, classB borrows the member function of classA. The processing content executed when classA.method1 () is called is exactly the same as the processing content executed when classB.method1 () is called. Therefore, when the contents of method1 () defined in classA are modified, not only classA.method1 () but also behavior of classB.method1 () changes.

  On the other hand, method1 () with the same name may be redefined independently in classB. This is called override. In this case, the processing content executed when classA.method1 () is called is defined by classA method1 (), and the processing content executed when classB.method1 () is called is determined by classB method1 (). Defined. classA and classB can provide different methods of classA and classB while providing interface method1 () with the same name. The programming technique of override is often used when the processing contents of method1 () of classB and method1 () of classA are almost the same but slightly different.

If method1 () is redefined in classB, that is, if you override classA.method1 (), the behavior of classA.method1 () will of course change, but the behavior of classB.method1 () It does not change. If you want to change classB.method1 () along with the modification of classA.method1 (), remember to make the same modification to classB.method1 ().
From this point of view, the source code processing device 100 supports source code analysis by specifying the overridden part of each class member function.

  Specifically, the inspection unit 128 first identifies a subclass group that inherits classA, and searches for member functions defined in these subclasses. Then, a member function named method1 () is specified from among them. If method1 () is defined in the subclass of classA, you can see that it is overridden here. The annotation node setting unit 130 sets an annotation node at the corresponding location. When method1 () of classA is modified, the location of the member function that may be modified can be specified by checking the annotation node set in this way.

  The annotation node setting unit 130 finally lists the annotation node group. This list preferably also includes information indicating the position of the annotation node, such as the contents of the annotation node, the name of the source file to which the annotation node belongs, the line number, the digit position, the line text, and the parent node name. Since the user can grasp the location to be confirmed from a large amount of source code by using the list of annotation nodes, the development and maintenance of the source code is facilitated.

The source code processing apparatus 100 has been described above based on the embodiments.
If the source code processing apparatus 100 prepares the “first AST rule”, “second AST rule”, and “source generation rule”, the source code described in various programming languages is source code described in another programming language. Can be converted to For this reason, it becomes easy to apply various analysis tools to a business system in which various programming languages are mixed. Since the source code is not directly converted, but is converted between ASTs reflecting the logical structure of the source code, the logical structure of the conversion source source is easily reflected in the conversion destination source.

  Further, by identifying the corresponding part from the AST according to the detection condition and setting the annotation code, the source code can be easily analyzed. Since this is not a text search of the source code but an AST that reflects the logical structure of the source code, there is a possibility of coding rule violations or coding mistakes from a huge amount of source code. This makes it easier to find the location accurately.

  The present invention has been described based on the embodiments. The embodiments are exemplifications, and it will be understood by those skilled in the art that various modifications can be made to combinations of the respective constituent elements and processing processes, and such modifications are within the scope of the present invention. .

  Various aspects of the invention ascertained from the above embodiments and modifications will be exemplified below, including those already described in the claims. The following inventions are recognized in connection with the source code inspection apparatus.

A1. A code acquisition unit for acquiring source code;
A syntax model that shows a logical structure of the source code by a collection of nodes by extracting nodes corresponding to the components of the source code and structuring the nodes according to the arrangement of the components in the source code. A syntax model generation unit for generating
An inspection unit that scans each node in the syntax model and identifies a location that matches a detection condition set in advance for the component of the source code;
An annotation node setting unit for setting an annotation node that is a node indicating an annotation at the specified location;
A source code inspection apparatus comprising:

  A2. The source code inspection apparatus according to A1, wherein the inspection unit sets the annotation node to a node corresponding to a variable whose name does not conform to a predetermined naming rule.

A3. The inspection unit further specifies a leading node corresponding to a component to be described at the start of a predetermined process and a terminal node corresponding to a component to be described at the end of the predetermined process, and the leading node The number of nodes and the number of terminal nodes are the same,
The annotation node setting unit further sets an annotation node indicating that a coding rule relating to the leading node and the terminal node is not satisfied when the number of the leading nodes and the number of the terminal nodes are not the same. The source code inspection apparatus according to A1 or 2, wherein:

A4. In the checking unit, a first member function defined in a first class is overridden by a second member function defined in a second class that inherits the first class. Whether or not
The annotation node setting unit sets the annotation node to a node corresponding to the second member function when the second member function overrides the first member function. 4. The source code inspection device according to any one of 3 to 4.

A5. Processing to get the source code,
A syntax model that shows a logical structure of the source code by a collection of nodes by extracting nodes corresponding to the components of the source code and structuring the nodes according to the arrangement of the components in the source code. Processing to generate
A process of scanning each node in the syntax model and identifying a location that matches a detection condition set in advance for the constituent elements of the source code;
A process of setting an annotation node that is a node indicating an annotation at the specified location;
A source code inspection program characterized by causing a computer to execute.

It is a schematic diagram which shows the language conversion process of a source code. It is a functional block diagram of a source code processing device. It is a schematic diagram for demonstrating the process which produces | generates conversion origin AST from a Hitachi source. It is a schematic diagram for demonstrating the process which produces | generates the conversion destination AST and IBM source from the conversion origin AST. It is a figure which shows AST produced | generated from the variable declaration sentence of "int num, iNumber". It is a figure which shows AST to which the annotation node was set corresponding to rule R1. Furthermore, it is a figure which shows AST when an annotation node is set corresponding to rules R2 and R3.

Explanation of symbols

  100 source code processing device, 110 UI unit, 112 input unit, 114 code acquisition unit, 116 output unit, 118 code output unit, 120 data processing unit, 122 first syntax model generation unit, 124 second syntax model generation unit, 126 Code generation unit, 128 checking unit, 130 annotation node setting unit, 140 data holding unit, 142 first syntax model holding unit, 144 second syntax model holding unit, 200 Hitachi source, 202 IBM source, 204 source AST, 220 conversion AST ahead.

Claims (5)

A code acquisition unit for acquiring source code described in a first programming language as first source code;
A logical structure of the first source code is obtained by extracting a node corresponding to a component of the first source code as a basic node and structuring the basic node according to an arrangement of the component in the first source code. A first syntax model generation unit for generating a first syntax model indicating the basic node by an aggregate of the basic nodes;
A second that indicates the logical structure of the first source code by a collection of the conversion destination nodes by converting the basic node into a conversion destination node that is a node corresponding to a component usable in the second programming language. A second syntax model generation unit for generating a syntax model;
By arranging the components that can be used in the second programming language according to the transformation destination node and its structure included in the second syntax model, the source code described in the second programming language is used as the source code described in the second programming language. A code generator for generating a second source code;
A source code conversion device comprising:   In the first source code, the first syntax model generation unit explicitly describes components that are optional in programming languages other than the first programming language among components that can be omitted in the first programming language. 2. The source code conversion apparatus according to claim 1, wherein the corresponding basic node is extracted even if not described, and the first syntax model is generated including the extracted basic node.   The second syntax model generation unit corresponds to the component to be omitted for the component to be omitted in the second programming language among the components defined in the first programming language. 3. The source code conversion apparatus according to claim 1, wherein a conversion destination node is invalidated in the second syntax model. A process of acquiring source code described in a first programming language as first source code;
A logical structure of the first source code is obtained by extracting a node corresponding to a component of the first source code as a basic node and structuring the basic node according to an arrangement of the component in the first source code. Generating a first syntax model that represents a set of basic nodes as follows:
A second that indicates the logical structure of the first source code by a collection of the conversion destination nodes by converting the basic node into a conversion destination node that is a node corresponding to a component usable in the second programming language. Processing to generate a syntax model;
By arranging the components that can be used in the second programming language according to the transformation destination node and its structure included in the second syntax model, the source code described in the second programming language is used as the source code described in the second programming language. Processing to generate the second source code;
A source code conversion program for causing a computer to execute. Obtaining a source code described in a first programming language as a first source code;
A logical structure of the first source code is obtained by extracting a node corresponding to a component of the first source code as a basic node and structuring the basic node according to an arrangement of the component in the first source code. Generating a first syntax model that represents a set of basic nodes;
A second that indicates the logical structure of the first source code by a collection of the conversion destination nodes by converting the basic node into a conversion destination node that is a node corresponding to a component usable in the second programming language. Generating a syntax model;
By arranging the components that can be used in the second programming language according to the transformation destination node and its structure included in the second syntax model, the source code described in the second programming language is used as the source code described in the second programming language. Generating a second source code;
A source code conversion method comprising:

Images