Source code translating method, recording medium containing source code translator program, and source code translator device

[0002] This application is based on Patent Application No. 2000-15021 filed Jan. 24, 2000 in Japan, the content of which is incorporated hereinto by reference.

[0003] 1. Field of the Invention

[0004] The present invention relates generally to a method of translating a source code, a recording medium for containing a source code translator program, and a source code translator device, and more particularly to such method, recording medium, and device as mentioned above that may be used in conjunction with a compiler, a preprocessor, an extensible programming language implementation, a source code parsing tool, a source code translating tool, and the like.

[0005] 2. Description of the Prior Art

[0006] (1) Definition of Terms

[0007] Before proceeding, the definitions for the terms that are used throughout the specification are provided, as follows:

[0008] Abstract Syntax Tree

[0009] The internal representation of a source code written in the Structured Programming Language. Representing a source code in the form of the abstract syntax tree makes it easier to parse and translate the source code than treating it as a character string.

[0010] Expression

[0011] In C, Java and like programming languages, the syntax defines constants, variables, operators, assignment expressions and the like as “expression”. The left side and right side operands of a binary operator are also defined as “expression”.

[0012] Statement

[0013] In C, Java and like programming languages, the syntax defines if-statement, while-statement, compound statement and the like as “statement”.

[0014] Expression Statement

[0015] This is the term that is used in the specifications of C, Java and like programming languages. Any expression that contains semicolon “;” is called “expression statement”. In the syntax, the expression statement is defined as one of the statements.

[0016] Separator

[0017] The separator or delimiter is a symbol that may be used with any expression to allow the expression to be treated as if it were a statement. In C, C++, Java and like programming languages, the semicolon “;” is used as a separator, for example.

[0018] Backquote Macro

[0019] In some programming languages, that enable the program itself to be operated within a given program, this is the construct that may be used to separate the program itself from that given program. In the Lisp programming language, for example, (+ x 1) is a program code that says “Add 1 to x”. When this program code itself is to be described within a Lisp program, it may be described as (+ x 1). A value may be embedded directly inside a program code written in backquote. For example, in LISP, ‘(+ x 2, (+ y 1)) means a program code described as ‘(+ x 2), if y contains a value of 1.

[0020] Construct

[0021] Component which constructs a source code written in programming language. Variables, constants, operators, assignment expressions, if-statement, while-statement, and the like are called “construct”, for example.

[0022] (2) Prior Art

[0023] Next, a source code translator program according to the prior art is discussed. Firstly, the following discussion covers the typical conventional source code translator program that is designed to process a source code written in C or like programming language.

[0024] By definition, the source code translator program is a program that accepts a source code written in a particular language as input, and performs certain conversion processing against the input source code to produce the corresponding output source code in any language that may be the same as or different from the original language. The source code translator program is also called “preprocessor”. Generally, the source code translator program parses the construct of the input source code, and converts the source code into the internal representation that makes the subsequent translation process easier. In many cases, this internal representation has a tree structure, which is known as the “Abstract Syntax Tree”.

[0025] In the prior art, when a source code containing any expression statements is represented as the abstract syntax tree, the abstract syntax tree may be described in a straightforward way by using nodes that represent the expression statements. Here, the expression statement refers to any expression that is followed by a semicolon “;”, which is usually found in C, for example.

[0026] Now, the expression statement is discussed in a little more detail.

[0027] In the C language, and other languages, such as C++ and Java, that are similar in the syntax rules to C, the statement and the expression are distinguished from each other. For example, “x”, “0”, “x+1”, and “x=0” are an expression, respectively, whereas if-statement and while-statement are statements. In C, any expression followed by “;” is usually treated as a statement. This may be called the expression statement. For example, “x=0;” is an expression statement, which is considered as a statement.

[0028] To provide a better understanding of the prior art, consider a specific case for a simple language where the syntax is defined by BNF (Backus-Naur Form), as shown below:

[0029] statement ::= if-statement | expression-statement

[0030] if-statement ::= “if” “(“expression”)” statement

[0031] “else” statement

[0032] expression-statement ::= expression“;”

[0033] expression ::= equality-comparison | assignment |

[0034] variable | constant

[0035] equality comparison ::= expression “==” expression

[0036] assignment ::= expression “=” expression

[0037] FIG. 1 depicts the abstract syntax tree that may be represented according to the prior art. FIG. 1 shows how the following program code written in the above simple language,

[0038] if (x==0) y=0; else y=1;

[0039] may be represented as the abstract syntax tree by using the prior art.

[0040] FIGS. 2 through 6 show a recursive algorithm according to the prior art that converts an abstract syntax tree into an appropriate character string for output. Specifically, FIG. 2 is a flowchart showing the steps in a typical prior art procedure for translating the abstract syntax tree into a character string. FIG. 3 is a flowchart showing the steps in a typical prior art procedure for producing an if-statement as output. FIG. 4 is a flowchart showing the steps in a typical prior art procedure for producing an “expression statement” as output. FIG. 5 is a flowchart showing the steps in a typical prior art procedure for producing an “equality comparison” as output. FIG. 6 is a flowchart showing the steps in a typical prior art procedure for producing an “assignment” as output. Now, those procedures are described below as they are related to the abstract syntax tree shown in FIG. 1.

[0041] The process starts with invoking the “Procedure for Outputting an Abstract Syntax Tree” shown in FIG. 2. The abstract syntax tree being processed corresponds to the abstract syntax tree T11 in FIG. 1. The procedure in FIG. 2 takes a branch, depending on the type of the root node in the abstract syntax tree being processed. Since the root node in the abstract syntax tree T11 is if-statement, a branch occurs to invoke the “Procedure for Producing “if” Statement”(Step S21).

[0042] In the “Procedure for Producing “if” Statement” in FIG. 3, a string “if (” is first produced (Step S31). To output “x==0” contained in the first occurrence of the subtree, the “Procedure for Outputting an Abstract Syntax Tree” in FIG. 2 is recursively invoked (Step S32). Then, an output string of “)” is obtained (Step S33). Then, to output “y=0;” contained in the second occurrence of the subtree, the “Procedure for Outputting an Abstract Syntax Tree” in FIG. 2 is recursively invoked (Step S34). Then, an output string “else” is obtained (Step S35). Finally, to output “y=1;” contained in the third occurrence of the subtree, the “Procedure for Outputting an Abstract Syntax Tree” in FIG. 2 is recursively invoked (Step S36). Then, the procedure in FIG. 3 ends, returning to the step that invoked this procedure.

[0043] Specifically, the steps S32, S34 and S36 recursively invoking the procedure in FIG. 2 are described. In the following, the procedure for producing “y=1;” in Step S36 is used as an example, and is described in further details. (Note that the procedure for producing “x==0” in Step S32 and the procedure for producing “y=0;” in Step S34 are not described, as those procedures are recursively performed in the same manner as that in Step S36.) Step S36 recursively invokes the “Procedure for Outputting an Abstract Syntax Tree” in FIG. 2. Here, the abstract syntax tree being processed is named as “T12”. Since the type of the root node in the abstract syntax tree being processed is an expression statement, a branch is taken, invoking the “Procedure for Producing an Expression Statement” (Step S22).

[0044] In the “Procedure for Producing an Expression Statement” in FIG. 4, to output “y=1” contained in the subtree, the “Procedure for Outputting an Abstract Syntax Tree” in FIG. 2 is recursively invoked (Step S41). Then, an output string “;” is provided (Step S42). Then, the procedure in FIG. 4 ends, returning to the step that invoked this procedure.

[0045] Now, the procedure for producing “y=1” in Step S41 where the “Procedure for Outputting an Abstract Syntax Tree” is recursively invoked is discussed in further details. Step S41 is provided for recursively invoking the “Procedure for Outputting an Abstract Syntax Tree” in FIG. 2. Here, the abstract syntax tree being processed is named as “T13”. Since the type of the root node in the abstract syntax tree being processed is an assignment, a branch is taken, invoking the “Procedure for Producing an Assignment” (Step S24).

[0046] In the “Procedure for Producing an Assignment” in FIG. 6, to output “y” contained in the first occurrence of the subtree, the “Procedure for Outputting an Abstract Syntax Tree” in FIG. 2 is further recursively invoked (Step S61). Then, an output string “=” is produced (Step S62). Then, to output “1” contained in the second occurrence of the subtree, the “Procedure for Outputting an Abstract Syntax Tree” in FIG. 2 is recursively invoked (Step S63). Then, the procedure in FIG. 6 ends, returning to the step that invoked this procedure.

[0047] Next, the procedure for producing “y” in Step S61 where the “Procedure for Outputting an Abstract Syntax Tree” is recursively invoked is discussed in further details. Step S61 is provided for recursively invoking the “Procedure for Outputting an Abstract Syntax Tree” in FIG. 2. Here, the abstract syntax tree being processed is named as “T14”. Since the type of the root node in the abstract syntax tree is a variable, a branch occurs, where a variable name “y” is produced (Step S25). Then, the procedure in FIG. 2 ends, returning to the step in FIG. 6 that invoked this procedure.

[0048] Then, the procedure for producing “1” in Step S63 where the “Procedure for Outputting an Abstract Syntax Tree” is recursively invoked is discussed in further details. Step S63 is provided for recursively invoking the “Procedure for Outputting an Abstract Syntax Tree” in FIG. 2. Here, the abstract syntax tree being processed is named as “T15”. Since the type of the root node in the abstract syntax tree being processed is a constant, a branch occurs where a constant name “1” is produced (Step S25). Then, the procedure in FIG. 2 ends, returning to the step in FIG. 6 that invoked this procedure.

[0049] Through the recursively invoking steps performed as described above, the abstract syntax tree T11 of FIG. 1 is processed to provide a string “if (x==0) y=0; else y=1;”.

[0050] By using the internal representation of the abstract syntax tree containing expression statements represented by nodes as has been described so far in connection with the prior art, there is a problem in that the processing by the source code translator program becomes complicated, and there is another problem in that the work of describing a backquote macro becomes complicated. Those two problems are discussed below more clearly.

[0051] The first problem of the prior art is first discussed. The source code translator program accepts a program code as input, parses the construct of the program code, and turns it into an internal representation in the form of an abstract syntax tree. Then, it performs the conversion processing for the abstract syntax tree, which is finally converted back to a character string that is provided as output. When programming the conversion processing for the abstract syntax tree, programmers must always be aware of the distinction between a statement and an expression. This raises another problem.

[0052] For example, suppose that programmers failed to make this distinction between the statement and expression, and have inadvertently built an abstract syntax tree in which an expression appeared in the place where a statement should have appeared. An example of such abstract syntax tree is illustrated in FIG. 7. (Note that this also shows the abstract syntax tree using the representation according to the present invention, which will be described later.) As shown, the second and third occurrences of the subtree where if-statement appears should have contained a statement, but the subtree representing an assignment, which is one type of the expression, actually appeared in the abstract syntax tree of FIG. 7. If this abstract syntax tree is output as a character string using the procedures in FIGS. 2 through 6 of the prior art, it would result in a wrong program in which a separator “;” is lacking, as shown below.

[0053] if (x==0) y=0 else y=1

[0054] Similarly, if an abstract syntax tree built by programmers should inadvertently contain a statement that appeared in the subtree of the expression statement, the resulting program would contain a double separator “;”, as shown below.

[0055] if (x==0) y=0;; else y=1;;

[0056] In order to avoid that such erroneous programs be produced, the programmer who is responsible for writing a source code translator program must be aware of the distinction between the statement and expression when handling the abstract syntax tree. Thus, the work of writing such programs would become complicated.

[0057] Next, the second problem of the prior art is discussed. For example, the Lisp language provides the function called the “backquote macro” (Backquote macro is also known as quasiquote). Here, the backquote macro refers to the function that allows the program itself to be treated as data, and is required when operating on the program using the language for that program. The following is an example of how a program code may be described using the backquote macro in Lisp:

[0058] ‘(if condition ,exp1 ,exp2)

[0059] There are several existing systems in which this backquote macro function is additionally implemented on C language, but any of those systems has a common problem in that the description using the backquote function is not as easy as for the Lisp language. This is because, in Lisp, the individual items contained in the syntax are all expressions, which makes it easier to describe, whereas in C, the expression and statement must be separated distinctly, which makes it more difficult to describe. The following is another example of how a program code may be described using the backquote macro:

[0060] ‘[Statement] {if (condition) ,[Expression]exp1;else,[Expression]exp2;}

[0061] To ensure that the construct of the backquote macro is parsed accurately, it is required that a non-terminal sign (in this case, statement) at the time of start, and a non-terminal sign (in this case, expression) at the time when a value is embedded must be specified. It may be understood from the above that the programmer's task of describing a program code by using the backquote macro would become complicated, which would reduce the practical utility of the backquote macro.

[0062] In light of the problems of the prior art that are associated with the source code conversion processing as well as the source code description using the backquote macro, the present invention provides a method of translating a source code, wherein an abstract syntax tree may be described without using nodes representing expression statements, so that such abstract syntax tree may be converted into a character string as appropriate.

[0063] So the object of the present invention is to meet the following requirements, that is,

[0064] (a) To eliminate the need of being aware of the distinction between the expression and statement when building an abstract syntax tree, and to thereby make it easier to implement a source code translator program; and

[0065] (b) To simplify the construct of the backquote macro. For example, this includes ensuring that the equivalent of the program code described using the backquote macro in the Lisp language, as given below,

[0066] ‘(if condition ,exp1 ,exp2)

[0067] can be written in C, as follows:

[0068] ‘{if (condition) ,exp1;else,exp2;}

[0069] Thus, programmers can write any program code more easily, without worrying about the need of distinguishing between the statement and expression, as it usually occurs in the prior art.

[0070] According to one aspect of the present invention, there is a method of translating an input source code described in a particular programming language that meets the following requirements, into a corresponding output source code in any language that may be the same as or different from the original language, the requirements being that:

[0071] a statement and an expression be distinguished according to the syntax rules;

[0072] any expression statement containing an expression followed by a separator be defined as one of the statements;

[0073] for each construct, whether it is an expression or a statement be predefined; and

[0074] for each construct, whether each of the items comprising the construct is an expression or a statement be able to be determined, wherein so that an input source code represented as an abstract syntax tree without using nodes corresponding to separators representing expression statements may be produced as a corresponding output source code, the method comprises the steps of:

[0075] outputting the abstract syntax tree as a statement;

[0076] outputting the abstract syntax tree as an expression; and

[0077] producing each corresponding construct, wherein

[0078] said step of outputting the abstract syntax tree as a statement depends on the type of the root node in the abstract syntax tree being output, and includes the steps of:

[0079] if the root node is a node representing a statement, producing each corresponding construct according to the type of that statement; and

[0080] if the root node is a node representing an expression, outputting the abstract syntax tree as an expression and then producing a separator representing an expression statement, wherein

[0081] said step of outputting the abstract syntax. tree as an expression depends on the type of the root node in the abstract syntax tree, and includes the step of producing each corresponding construct according to the type of that expression.

[0082] According to another aspect of the present invention, there is a recording medium for containing a source code translator program for translating an input source code described in a particular programming language that meets the following requirements, into a corresponding output source code in any language that may be the same as or different from the original language, the requirements being that:

[0083] a statement and an expression be distinguished according to the syntax rules;

[0084] any expression statement containing an expression followed by a separator be defined as one of the statements;

[0085] for each construct, whether it is an expression or a statement be predefined; and

[0086] for each construct, whether each of the items comprising the construct is an expression or a statement be able to determined, wherein so that an input source code represented as an abstract syntax tree without using nodes corresponding to separators representing expression statement may be produced as a corresponding output source code, the source code translator program comprises the steps of:

[0087] outputting the abstract syntax tree as a statement;

[0088] outputting the abstract syntax tree as an expression; and

[0089] producing each corresponding construct, wherein

[0090] said step of outputting the abstract syntax tree as a statement depends on the type of the root node in the abstract syntax tree being output, and includes the steps of:

[0091] if the root node is a node representing a statement producing each corresponding construct according to the type of that statement; and

[0092] if the root node is a node representing an expression, outputting the abstract syntax tree as an expression and then producing a separator representing an expression statement, wherein

[0093] said step of outputting the abstract syntax tree as an expression depends on the type of the root node in the abstract syntax tree, and includes the step of producing each corresponding construct according to the type of that expression.

[0094] According to a further aspect of the present invention, there is a source code translator device for translating an input source code described in a particular programming language that meets the following requirements, into a corresponding output source code in any language that may be the same as or different from the original language, the requirements being that:

[0095] a statement and an expression be distinguished according to the syntax rules;

[0096] any expression statement containing an expression followed by a separator be defined as one of the statements;

[0097] for each construct, whether it is an expression or a statement be predefined; and

[0098] for each construct, whether each of the items comprising the construct is an expression or a statement be able to be determined, wherein so that an input source code represented as an abstract syntax tree without using nodes corresponding to separators representing expression statements may be produced as a corresponding output source code, the source code translator device comprises:

[0099] means for outputting the abstract syntax tree as a statement;

[0100] means for outputting the abstract syntax tree as an expression; and

[0101] means for producing each corresponding construct, wherein

[0102] said means for outputting the abstract syntax tree as a statement depends on the type of the root nodes in the abstract syntax tree being output, and,

[0103] if the root node is a node representing a statement, produces each corresponding construct according to the type of that statement; and

[0104] if the root node is a node representing an expression, outputs the abstract syntax tree as an expression and then produces a separator representing an expression statement, wherein

[0105] said means for outputting the abstract syntax tree as an expression depends on the type of the root node in the abstract syntax tree, and produces each corresponding construct according to the type of that expression.

[0106] The source code translating method of the present invention is provided for solving the problems of the prior art that are encountered when the conversion processing occurs for a given source code, and when source code is described using the backquote macro. According to the method of the invention, any source code may be described in the form of an abstract syntax tree without using any node representing the expression statement, and such abstract syntax tree may then be converted into an appropriate output character string.

[0107] Therefore, the present invention provides the following advantages in that:

[0108] 1. programmers can build an abstract syntax tree without having to be aware of the distinction between the expression and statement. This makes it easier to implement the source code translator program.

[0109] 2. the syntax of the backquote macro can be simplified. For example, the equivalent of the following description using the backquote macro in the Lisp language,

[0110] ‘(if condition ,exp1 ,exp2)

[0111] may be written in C, as follows:

[0112] ‘{if (condition) ,exp1;else,exp2;}

[0113] As programmers can now write any source code without having to worry about the distinction between the expression and statement, as opposed to the prior art, they can describe the source code more easily.

[0114] The above and other objects, effects, features and advantages of the present invention will become more apparent from the following description of embodiments thereof taken in conjunction with the accompanying drawings.

[0115] FIG. 1 illustrates the abstract syntax tree as represented in the prior art:

[0116] FIG. 2 is a flowchart depicting the steps in the procedure for converting the abstract syntax tree into a character string so that it is provided as output in accordance with the prior art;

[0117] FIG. 3 is a flowchart depicting the steps in the procedure for producing if-statement in accordance with the prior art;

[0118] FIG. 4 is a flowchart depicting the steps in the procedure for producing an expression statement in accordance with the prior art;

[0119] FIG. 5 is a flowchart depicting the steps in the procedure for producing an equality comparison in accordance with the prior art;

[0120] FIG. 6 is a flowchart depicting the steps in the procedure for producing an assignment in accordance with the prior art;

[0121] FIG. 7 illustrates the abstract syntax tree as represented according to the present invention;

[0122] FIG. 8 is a flowchart depicting the steps in the procedure for producing the abstract syntax tree as a statement in accordance with the present invention;

[0123] FIG. 9 is a flowchart depicting the steps the procedure for producing if-statement in accordance with the present invention;

[0124] FIG. 10 is a flowchart depicting the steps in the procedure for outputting the abstract syntax tree as an expression in accordance with the present invention;

[0125] FIG. 11 is a flowchart depicting the steps in the procedure for producing an equality comparison in accordance with the present invention;

[0126] FIG. 12 is a flowchart depicting the steps in the procedure for producing an assignment in accordance with the present invention; and

[0127] FIG. 13 is a block diagram illustrating the configuration of the preprocessor.

[0128] In the following description, it is assumed that the programming language to which the present invention may be applied meets the following requirements:

[0129] (i) According to the syntax rules, a statement and an expression are distinguished.

[0130] (ii) Any expression statement containing an expression followed by a separator is defined as a statement. (e.g., in the C language syntax, “;” is defined as a separator, and any expression statement containing an expression followed by “;” is defined as an statement.

[0131] (iii) For each construct, whether the construct is an expression or a statement is predefined. (e.g., in C, if-statement is always a statement, and 1+2 is always an expression. When a construct is given, this construct never depends upon its context, that is, it should be either an expression or a statement.)

[0132] (iv) For each construct, whether each of the components of the construct is an expression or a statement can be determined. (e.g., in C, if-statement includes three elements, such as a condition expression, “then” clause, and “else” clause. In this case, the condition expression should always be an expression, “then” clause and “else” clause should always be a statement.)

[0133] According to the present invention, any source code written in any programming language that provides the features listed above may be described without using nodes representing expression statements. When an expression statement is to be described, this may be done by using the abstract syntax tree itself that represents the expression contained in that expression statement.

[0134] In general, the abstract syntax tree that has been built without using the expression statement in accordance with the present invention may be produced as a character string, by using the algorithm that includes the procedures listed below:

[0135] (a) Ps: procedure for outputting the abstract syntax tree as a statement;

[0136] (b) Pe: procedure for outputting the abstract syntax tree as an expression; and

[0137] (c) Pi (i=0, 1, . . . ): procedure for producing each construct (if statement, assignment, equality comparison, . . . ).

[0138] Specifically, each of those procedures is described below.

[0139] The process starts with the procedure for outputting the abstract syntax tree as a statement, Ps, which takes a branch, depending on the type of the root node in the abstract syntax tree being processed. If the root node is a node representing a statement, then the procedure Ps invokes the procedure for producing a character string, Pi, depending upon the type of that statement. If the root node is a node representing an expression, then the procedure Ps first invokes the procedure for outputting the abstract syntax tree as an expression, Pe, and then produces a separator for representing an expression statement. When the procedure for outputting the abstract syntax tree as an expression, Pe is invoked, it takes a branch, depending upon the type of that expression, and then invokes the procedure for producing a character string, Pi.

[0140] When the procedure for outputting each construct, Pi(i=0, 1, . . . ), is invoked, for each of the component of the construct, if it is a statement, Pi recursively invokes Ps; if it is an expression, Pi recursively invokes Pe. Pi also outputs a character string if it is required to fill any space between the two adjacent components.

[0141] With invoking these procedures as described above, the abstract syntax tree will finally be output as the appropriate character string.

[0142] Now, consider a specific case with a simple language where the syntax is defined by BNF, as follows:

[0143] statement ::= if-statement | expression-statement

[0144] if-statement ::= “if” “(“expression”)” statement

[0145] “else” statement

[0146] expression-statement ::= expression“;”

[0147] expression ::= equality-comparison | assignment |

[0148] variable | constant

[0149] equality-comparison ::= expression “==” expression

[0150] assignment ::= expression “=” expression

[0151] FIG. 7 illustrates how the following program code can be represented by the abstract syntax tree, using the present invention.

[0152] if (x==0) y=0; else y=1;

[0153] The present invention differs from the prior art shown in FIG. 1 in that the above program code may be represented as the abstract syntax tree without having to use any node that represents the expression statement. When an expression-statement “y=0;” is to be described, this may be done by using the abstract syntax tree itself that represents the expression “y=0”. Note that the abstract syntax tree shown in FIG. 7 is a data structure that will be built by a syntax parser in the source code translator program that parses the construct of the input source code written as a character string.

[0154] FIGS. 8 through 12 illustrate the recursive algorithm that translates this abstract syntax tree into a character string so that it can be provided as output. Specifically, FIG. 8 is a flowchart depicting the steps in the procedure for outputting the abstract syntax tree as a statement in accordance with the present invention. FIG. 9 is a flowchart depicting the steps in the procedure for producing if-statement in accordance with the present invention. FIG. 10 is a flowchart depicting the steps in the procedure for outputting the abstract syntax tree as an expression in accordance with the present invention. FIG. 11 is a flowchart depicting the steps in the procedure for producing an equality comparison in accordance with the present invention. FIG. 12 is a flowchart depicting the steps in the procedure for producing an assignment in accordance with the present invention. Now, those procedures are described below as they are related to the abstract syntax tree shown in FIG. 7.

[0155] The process starts with invoking the “procedure for outputting the abstract syntax tree as a statement” shown in FIG. 8. The abstract syntax tree being processed corresponds to the abstract syntax tree T71 in FIG. 7. The procedure in FIG. 8 takes a branch, depending on the type of the root node in the abstract syntax tree being processed. Since the type of the root node in the abstract syntax tree T71 is an if-statement (Step S84), the process take a branch, where the “procedure for producing if-statement” is invoked (Step S81). In the “procedure for producing if-statement” in FIG. 9, a string “if (” is first produced (Step S91), and to produce “x==0” contained in the first occurrence of the subtree, the “procedure for outputting the abstract syntax tree as an expression” in FIG. 10 is then recursively invoked (Step S92). Then, a string “)” is produced (Step S93); to produce “y=0;” contained in the second occurrence of the subtree, the “Procedure for outputting the abstract syntax tree as a statement” is then recursively invoked (Step S94). Then, a string “else” is produced (Step S95); and to produce “y=1;” contained in the third occurrence of the substree, the “procedure for outputting the abstract syntax tree as a statement” in FIG. 8 is finally recursively invoked (Step S96). Then, the procedure in FIG. 9 ends, returning to the step that invoked this procedure.

[0156] More specifically, the steps S92, S94, and S96, which recursively invoke the corresponding procedures, are described below. For sake of simplicity, however, the following description is limited to Step S96 where “y=1;” is produced (Note that, although the description of Step S92 where “x==0” is produced and Step S94 where “y=0;” is produced is omitted, those steps are recursively performed in the same manner as Step S96). Step 96 recursively invokes the “procedure for outputting the abstract syntax tree as a statement” in FIG. 8. Here, the abstract syntax tree being processed is named as T72. Since the type of the root node in the abstract syntax tree being processed is an assignment, which is one type of the expression, the procedure takes a branch, invoking the “procedure for outputting the abstract syntax tree as an expression” in FIG. 10, where a string “y=1” is produced (Step S82), and then a string “;” is produced (Step S83). Then, the procedure in FIG. 8 ends, returning to the step that invoked this procedure.

[0157] Next, Step S82 where “y=1” is produced is described in more details. Step S82 recursively invokes the “procedure for outputting the abstract syntax tree as an expression” in FIG. 10. Here, the abstract syntax tree being processed is named as T72. Since the type of the root node in the abstract syntax tree being processed is an assignment (Step S107), the procedure branches, where the “procedure for producing an assignment” is invoked (Step S102). In the “procedure for producing an assignment” in FIG. 12, to produce “y” contained in the first occurrence of the subtree, the “procedure for outputting the abstract syntax tree as an expression” in FIG. 10 is recursively invoked again (Step S121). Then, a string “=” is produced (Step S122), and to produce “1” contained in the second occurrence of the subtree, the “procedure for outputting the abstract syntax tree as an expression” in FIG. 10 is recursively invoked once more (Step S123). Then, the procedure in FIG. 12 ends, returning to the step that invoked this procedure.

[0158] Next, Step S121 where the “y” is produced is described in further details. Step S121 recursively invokes the “procedure for outputting the abstract syntax tree as an expression” in FIG. 10. Here, the abstract syntax tree being processed is named as T73. Since the type of the root node in the abstract syntax tree being processed is a variable (Step S109), the procedure branches, where a variable name “y” is produced (Step S103). Then, the procedure in FIG. 10 ends, returning to the step in FIG. 12 that invoked this procedure.

[0159] Next, Step S123 where the “1” is produced is described in further details. Step S123 recursively invokes the “procedure for outputting the abstract syntax tree as an expression” in FIG. 10. Here, the abstract syntax tree being processed is named as T74. Since the type of the root node in the abstract syntax tree being processed is a constant, the procedure branches, where a constant name “1” is produced (Step S103). Then, the procedure in FIG. 10 ends, returning to the step in FIG. 12 that invoked this procedure.

[0160] Note that if the type of the root node is unexpected, it generates an error that is processed accordingly(Step S86).

[0161] Through the steps performed as above, the abstract syntax tree T71 in FIG. 7 maybe output as a character string “if (x==0) y=0; else y=1;”. Note that the above description is only provided as one example, and the present invention may also apply to any programming language whose construct rules allow for other statements such as “while” than “if”, and other expressions such as arithmetic and other operations.

[0162] The method of translating source code according to the present invention may be implemented on any suitable recording medium on which the source code translator program is recorded.

[0163] Finally, possible applications of the present invention are presented.

[0164] The present invention has been implemented as a preprocessor designed specifically for use in the Java programming language, which has been tested for its operation. FIG. 13 illustrates one example of the configuration of such preprocessor. This preprocessor accepts source code written in the Java language as input, and passes it through the translation or conversion stage where some conversion processing occurs. The output of the preprocessor is passed to another destination as the Java source code. The preprocessor has its internal structure that is essentially similar to the usual compiler.

[0165] More specifically, the source code input to the preprocessor (10) is passed through the token parser (1) and the syntax parser (2) where the construct of the input source code is parsed, and its construct is translated or converted from the character string into an abstract syntax tree. The abstract syntax tree is then passed through the PROCESSING section (3) where the translation or conversion processing takes place. The output of the PROCESSING section (3) is passed through the OUTPUT section (4) where the abstract syntax tree is translated or converted back into the character string that is provided as the output source code. The abstract syntax tree may be represented by using the method of the present invention, and the algorithm in the OUTPUT section (4) may be implemented by using the present invention.

[0166] It should be understood that the translation or conversion processing in the PROCESSING section (3) may include the optimization processing, document reduction processing, translation or conversion into a different programming language, and other various types of processing.

[0167] The present invention has been described in detail with respect to preferred embodiments, and it will now be more apparent from the foregoing to those skilled in the art that changes and modifications may be made without departing from the invention, therefore, in the apparent claims to cover all such changes and modifications as fall within the true spirit of the invention.