JPH04317133A - Program conversion device - Google Patents

Abstract

PURPOSE:To improve the execution efficiency of a program by permitting a user to learn a type inference result and to save labour writing a data type propaganda sentence in a source code. CONSTITUTION:A data type information retrieval means 11 detects data type information on variables existing in the source code, registers information on the data types of the fetched variables in a data type information storage table 14. A type inference means 12 infers the data type to the variable whose data type existing in the source code is not clear based on data type information on the registered variables. An inference result is stored in the data type information storage table 14 and a data type information addition means 13 merges the inference result in the source code and outputs the source code to which the inference result and data type information are added.

Description

[Detailed description of the invention]

0001

[Industrial Application Field] The present invention relates to a conversion method for programs running on a computer, and in particular to a program that performs type inference on variables in an input program and merges the inference results into the input program. This invention relates to a conversion device.

0002

2. Description of the Related Art Variables on a program written in a programming language such as C, LISP, or FORTRAN are converted into corresponding machine language data according to their attribute "data type" and executed. This "data type" is generally explicitly specified by a program syntax element such as a "data type declaration statement." C and F
In languages such as ORTRAN and BASIC, it is necessary to give data types to variables as attribute information, but
In languages such as LISP and SMALLTALK-80, there is no need to declare data types for variables, and data types can be dynamically changed during program execution. For example, in C, if int a; is declared, a
means an integer. On the other hand, in LISP, a variable a used without a declaration means a pointer to value data, and the data at the address pointed to by the pointer may be an integer or a character. Also, variables in languages such as LISP are treated as direct value data when the data type is explicitly specified by a declaration statement, similar to C or FORTRAN, but when the data type is not specified, The variable becomes a pointer to value data and is treated as indirect value data.

By the way, from the standpoint of creating a program, it is troublesome to declare data types one by one as in C or FORTRAN, so I don't want to declare them.On the other hand, when data types are not declared as in LISP etc. To retrieve data, the value of the address pointed to by the pointer must be referenced each time, and when executing a program, such data representation requires more access time and storage space than direct data representation. Therefore, execution efficiency is poor. Therefore, Compiling Func
tionalLanguages, John Will
ey & Sons, 1988, “Inferrin
g types inSmalltalk” Proc
eeding of 8th ACM Symposia
um on Principles of Progr.
amming Languages, 1981, “A
Theory of Type Polymorphism
sm in Programming”, Journal
of Computer and System S
sciences, vol. 17, 1978, “Coe
rcion and type inference”
, proceeding of 11th ACM Sy
mposium on principles of
Programming Languages, 198
4, etc., the data type is inferred from program structures such as constant assignment to variables and application functions, and is converted into a representation as direct as possible.
A technique for code optimization called "type inference" has been proposed.

0004

[Problem to be Solved by the Invention] However, the conventional type inference described above is performed inside the compiler in a way that is invisible to the user, and if the data type of a variable cannot be specified as a result of inference, indirect expression is used. Since the data type of the variable is compiled, the user cannot know whether the data type of the variable can be specified if the data type of the variable is given. Furthermore, even if the results of data type inference were to be displayed to the user, rewriting the data type declaration statements for all of the data would be a heavy task for the user.

The present invention is intended to solve the above problems, and it performs type inference on variables in an input program, outputs the inference results in a way that the user can understand, and also outputs the inference results in a data type declaration statement. By merging data type declaration statements into the source code in the format, the user can save the effort of writing data type declaration statements in the source code, and furthermore, the user can maintain data type consistency based on the inference results for the generated declaration statements. The object of the present invention is to provide a program conversion device that can edit the program and compile each variable into a direct data type representation, thereby improving program execution efficiency.

[0006]

[Means for Solving the Problems] As shown in FIG. 1, the present invention provides an apparatus 1 for converting a source program into source code or machine language of the same or another programming language.
data type information detection means 1 for detecting data type information regarding variables existing in input source code;
1, a data type information storage table 14 that holds detected data type information, and a type for variables whose data type has not been explicitly declared based on the data type information about each variable held in the table. Type inference means 12 performs inference and registers the inference results in the table; Data type information addition means 13 adds data type information to the source code for variables whose data types are not explicitly declared based on the type inference results. and an output means 3 for outputting a type inference result.

[0007]

According to the present invention, when a source code is input, the data type information detecting means detects and extracts data type information of a variable such as a data type declaration statement existing in the source code.

[0008] Information regarding the data type of each extracted variable is stored and saved in a data type information storage table. After the processing by the data type information detection means is completed, the type inference means uses the data type information for each variable registered in the data type information storage table to determine whether the data type is unknown for variables that appear in the source code. Infer data types from program structures such as constant assignment operations and application functions.

[0009] This inference result is stored in the data type information storage table, and the inference result is merged into the source code by the data type information addition means, and the source code with the inference result and data type information added is output. .

0010

[Embodiment] FIG. 1 is a functional block diagram of a program conversion device of the present invention, FIG. 2 is a diagram showing the device configuration, FIG. 3 is a diagram showing a data type information storage table, and FIG. 4 is a diagram showing a common Li
The explanatory diagrams of sp, FIGS. 5 and 6, are diagrams showing the processing flow of data type inference. In the figure, 1 is a program conversion device, 11
12 is a data type information detection means, 12 is a type inference means, 13 is a data type information addition means, 14 is a data type information storage table, 2 is an input means, 3 is an output means, 21 is a CPU, 211
212 is a data type information detection unit, 212 is a type inference unit, 213 is a data type information addition unit, 22 is main memory, 221 is data type information, 222 is inference information, 23 is an output device, 24 is an input device, 25 is an external device Storage devices 30, 31, and 32 are frames, and 35 and 36 are top levels.

The input means 2 in FIG. 1 corresponds to the input device 24 consisting of a mouse, keyboard, etc. in FIG. It will be done. The data type information detecting means 11 of FIG. 1, which corresponds to the data type information detecting unit 211 of the CPU 21, detects and extracts information regarding the data type declaration of a variable, such as a data type declaration statement existing in the read source code. Information regarding the data type of each extracted variable is stored and saved in the data type information storage table 14. On the other hand, for variables whose data types appearing in the source code are unknown in the processing by the data type information detection means 11, the type inference means 12 corresponding to the type inference section 212 of the CPU 21 stores them in the data type information storage table 14. The data type is inferred by referring to the stored information and determining whether an integer or character is assigned to a variable in the program, etc. is stored in the data type information storage table 14.

[0012] The inferred result is sent to data type information adding means 1.
3, the data type declaration statement is merged into the source code, and the source code in which the type inference result and the data type declaration statement have been merged is outputted through the output means 13. Therefore,
The user can see the source code in which the data type inference result and the data type declaration statement have been merged on a display screen or in a printout.

[0013] Common Lisp will be explained below as an example.

First, data type declaration in Common Lisp will be explained. Declarations regarding the data type of variables are made using the proclaim form and declare form as shown below.

(proclaim(integer *count
r*))(defun careful(x y
) (declare(integer
x) (float y) (setq
z (+ x y)) With this form *counter*
, x are declared as integer types, and y as float types.

First, in the data type information detecting means 11 of FIG. 1, Common Lisp source code is inputted in units of top-level forms from an input device. As shown in the program example in Figure 4, the top-level form is a program unit of the highest level concept written from the leftmost end, 35 and 36 in the figure are called the top level, and frame 30 is the unit. and is input for each unit.

The frame names indicate the units of the program, and in the example of FIG. 4, frame 30, frame 31, frame 32
There are frames at each level as shown in the figure, variables are defined for each frame, and frames 31 and 3 as shown in the figure
If the same variable "a" is defined in frame 32 and frame 31, "a" in frame 32 is not applied to frame 31. Therefore, the variables "a" of frames 31 and 32 are named, for example, foo-let1-a and foo-let2-a to distinguish them. Each of these frame names is a name given to a nested relationship such as a function or a block similar to a frame.

Among these forms, procla
The im form and declare form are taken out and registered in the data type information storage table 14. As shown in FIG. 3, variable names, corresponding frame names, data type names, and inference types are registered in the data type information storage table. Note that T in the frame name in FIG. 3 indicates the top level.

[0019] Also, the data type name for the function name is (function (<Argument data type 1><Argument data type 2>...) <Return value data type>) as shown in cdr in the table in Figure 3. It is stored in such a format. Further, the inference type column indicates whether or not what is stored is a result obtained by type inference, and those described as T indicate inference results. This data type information storage table pre-stores data type information regarding basic Common Lisp built-in functions, such as addition and subtraction, in addition to those defined by the user, and data types are also registered for these functions. There is.

[0020] When the registration of data type information in the table is completed, the type inference means 12 inputs the source code again from the beginning in units of top level forms.
The data types that appear in each form are determined. If an undefined variable that is not registered in the data type storage table is found, type inference is performed based on whether an integer is assigned to the variable, whether a character is assigned, etc., as described above. The resulting data type is registered as a data type name in the data type information storage table 14, and T is set in the inferred type column.

[0021] Note that global variables such as function names may be defined after the variable reference, so
This type inference is performed by repeatedly reading the source file until the type inference for all undefined variables in the file converges, that is, until no further inference can be made.

When such processing is completed, first, the data type information adding means 13 selects the frame name T, among the entries (locations) in the data type information storage table
That is, at the top level and the inference is T (inferred data type) for all variables (proclaim'(int
A proclaim form such as eger z)) is generated and outputted by the output means 3. At the same time, the type inference results are displayed to the user from the output device 23. When this process is completed, the form in the source code is read from the beginning again from the input device, and the entry is checked from the frame name in the data type information storage table 14 for variables used in each frame in the form, and inferences are made. For all variables of the specified data type (T), a declare form as shown in the underlined part below is output from the output device.

(defun baz(n) (declare(integer n
)) (let ((foo'(name
)) (declare(sy
mbol foo))
……
)) At the same time, the type inference results are displayed on the output device.

The above processing flow will be explained with reference to FIGS. 5 and 6.

First, input one top-level form from the source file, check whether the form includes a proclaim form or a declare form, and if so, store the declared data type in the data type information storage table. This is then done for all top-level forms (steps 101-104). When this process is finished, rewind to the source file, fill in one top-level form from the source file,
Type inference is made for undefined variables from the information in the data type information storage table and the structure of the program, and the inferred variables and their data types are stored in the data type information storage table (steps 105 to 109). This process is performed for the top level of all files (step 110),
Next, a proclaim form for variables whose frame name is T in the data type information storage table and whose inference is T (inferred data type) is generated and output, and at the same time the inferences made for these variables are displayed. Display the results (step 111). Next, rewind to the source file, input one top-level form from the source file, check for each frame in the form whether there is a variable T in the data type information storage table, and if so, declare form for that variable. , output a top-level form that merges the form,
This is done for the top level forms in all files and the process ends.

[0026] The following is a Common Lis.
This figure shows an example in which a program without a data type declaration written in p is converted according to the present invention.

The input program is as follows.

{DSK}<home>reggae>ymasud
a>CLICHE>TIS>gabriel>infe
red>fft. lisp;1;;;FFT--Thi
s is an FFT benchmark wri
ttn by Harry Barrow. ;;;It
tests a variety of float
ing point operations, inc.
luding array ref-erences. (defvar** ft-re** (ma
ke-array 1025. :element-t
ype'float: initial-eleme
nt 0.0)) (defvar** ft-im*
* (make-array 1025.:e
element-type 'float :initi
al-element 0.0)) (defun ff
t
;fast fourie
r transform (areal
aimag
;areal = real par
t (prog
;
aimag = imaginary part
(ar ai i j km n le le1
ip nv2 nm1 ur ui wr wi tr
ti) (setq ar areal
;init
realize ai aimag
n (array-dimens
ion area 0) n
(1-n) nv2 (floo
r n 2) nm1 (1-
n) m 0
;compute
m = log(n) i 1
) l1 (cond ((< i n )
(setq m (1+ m)
i (+i i))
(go l1))) (cond ((n
ot (equal n (expt 2 m)))
(princ“error...
array size not a power o
f two. ”) (read) (return (terpri)
)))) (setq j 1

;interchange elements
i1)
;in b
it-reversed order l3 (con
d ((< i j ) (set
q tr (aref ar j) t
i (aref ai j) (s
etf (aref ar j) (aref ar
i) (setf (aref
ar j) (aref ai i)
(setf (aref ar i) tr)
(setf (aref ar
i) ti))) (setq k nv2) l6 (cond ((< k j )
(setq j (− j k)
k (/k2))
(go 16))) (setq
j (+ j k) i (1+
i)) (cond ((< i n )
(go 13))) (
do ((l 1 (1+ l)))
((> l m))
;loop through stages
(setq le (expt 2 l)
le1(floor
le 2) ur 1.
0 ui 0.0
wr (cos (/ pi (
float le1)))
wi (sin (/ pi (float le
1)))) (do ((j 1 (1
+ j))) ((> j l
e1)) ;loop t
hru butterflies
(do ((i j (+ i le)))
((> i n))
;do a butterf
ly (setq i
p(+i le1)
tr(- (* (aref ar
ip) ur)
(* (aref ai ip)
ui)) ti(+ (* (
aref ar ip) ui)
(* (aref
ai ip) ur)))
(setf (aref ar ip) (-
(aref ar i) tr))
(setf (aref ai ip
)(- (aref ai i) ti))
(setf (aref a
r i) (+ (aref ar i) tr))
(setf (aref
ai i) (+ (aref ai i) ti))
)) (setq tr (-(* u
r wr) (* ui wi))
ti (+(* ur wi) (* u
i wr)) ur t
r uiti)
(return)
));;; the timer which does
s 10 calls on fft (defun
fft-bench () (dotimes
(i 10) (fft **fft-re
** **fft-im**))) ;;; cal
l: (fft-bench) As a result of program conversion according to the present invention,
The following proclaim and declare were inserted, and a program with data type declarations could be obtained as output.

{DSK}<home>reggae>ymasud
a>CLICHE>TIS>gabriel>infe
red>fft. lisp；1；；；；；；CLICHE Type Inferer ou
tput for the source file
: ;;; {DSK}<home>reggae>
ymasuda>CLICHE>TIS>gabrie
l>infered>fft. lisp；1；；；；；；Source file created
Monday, 4 February 1991, 1
3:39:54 ;;; Type infered
file created Saturday, 1
6 February 1991, 16:24:20;
;;;;;;;;; Inference Level: 2;
;; ;;; The literal NIL is ig
nored in type inference.
;;; ;;; Type Reduction Rules
are follows. ;;; ratio
nal -->fixnum;;; (in-package 'tis) (proclaim '((simple-array
float 1025)
**fft-re**)) (proclaim `(
(simple-array float 1025)
**fft-im**)
)(proclaim `(function fft
((simple-array fioat 102
5)
(simple-array fioat 1
025))
symbol)) (proclaim `(func)
tion fft-bench nil nil))
(defvar **fft-re** (make-
array 1025: element-type
'float: initial-

el
element0.0))(defvar **fft-i
m** (make-array 1025:ele
ment-type 'float: initial
−

element0.0))(defu
n fft (areal aimag)
(declare ((simple-array
float 1025)
areal) (
(simple-array float 1025)
aimag))
(prog (ar ai i j km
n le le1 ip nv2 nm1 ur ui
wr wi tr ti)
(declare ((simple-array
float 1025)
ar)
((simple-array f
loat 1025) ai) (fi
xnum i)
(fixnum j)
(fixnum k)
(fixnum
m)
(fixnum n)
(fixnum le)
(fixnum l
e1)
(fixnum ip)
(fixnum nv2)
(fixnum
nm1)
(float wr)
(float wi)
(float tr
) (f
loat ti) (set
q ar real ai aimag n (ar
ray-dimension area 0)
n
(1-n)
nv2
(floor n 2)
nm1
(1-n)
m 0 i 1)
l1 (cond ((< i
n)) (s
etq m (1+ m)
i
(+i i))
(go l1
))) (cond ((not (e
qual n (expt 2 m)))
(prince “erro
r. ．． ．． array size not a po
Were of two. ”)
(read)
(return (terpri)
)) (setq j 1
i 1) l3 (cond ((< i
j) (s
etq tr (aref ar j)
Ti
(ar
ef ai j))
(setf (aref ar j)
(a
ref ar i))
(setf (aref ai j)
(
aref ai i))
(setf (aref ar i)

tr) (
setf (aref ai i)
ti)))
(setq k nv2)
l6 (cond ((< k
j) (s
etq j (- j k)
k
(/k2)
) (go
l6))) (setq
j (+ j k )
i
(1+i))
(cond ((< i in)
(go l3)))
(do ((l 1 (1+ l)))
((< l m)
(declare (fixnu)
m l)) (set
q le (expt 2 l)
le1
(floor le 2
)
ur 1.0 ui 0.0 wr (cos (/
pi (float le1)))
wi
(sin (/ pi (
float le1)))
(do ((j 1 (1+ j)))
((> j le1)
(declare (fi)
xnum j)) (do
((i j (+ i le)))
((> i n))
(declare (fixn)
um i)) (se
tq ip (+ i le1)
tr
(- (* (aref ar
ip)
ur)
(* (aref ai ip
)
ui))
Ti
(+ (* (aref ar ip)

ui)
(* (aref ai ip)
ur)
)) (setf
(aref ar ip)
(- (aref ar i)
tr
)) (setf
(aref ai ip)
(- (aref ai i)
Ti
)) (setf
(aref ar i)
(+ (aref ar i)
tr
)) (setq
(aref ai i)
(+ (aref ai i)
Ti
)))) (setq tr
(- (* ur wr)
(* ui wi))
Ti
(+ (* ur wi)
(* u
i wr)) u
r tr ui ti)) (ret
urn t))) (defun fft-bench
nil (dotimes (i 10)
(decl
are (fixnum i))
(fft **ff
t-re** **fft-im**)))) In the above example, the result of type inference is displayed and the result is merged with the source code and output. The invention is not limited to this, and may be realized as a processing system that simply inputs source code and outputs the result of type inference merged with the source code. The program conversion device of the present invention may be incorporated as a function. Further, the type inference results may be output to a screen, a file, or a file in which declaration statements are output.

[0030]

[Effects of the Invention] As described above, according to the present invention, from the result of type inference, the user can know for which variable data type information is lacking, and the result of type inference can be used as a data type declaration statement as a source. Because it is inserted into the code, the user does not have to insert data type declarations each time after checking the inference results as in the past, and the user can edit these output data type declarations to specify the appropriate data type. This allows the compiler to output object code more efficiently.

[Brief explanation of drawings]

FIG. 1 is a functional block diagram of a program conversion device of the present invention.

FIG. 2 is a diagram showing the device configuration.

FIG. 3 is a diagram showing a data type information storage table.

FIG. 4 is an explanatory diagram of COMMON LISP.

FIG. 5 is a diagram showing the processing flow of type inference.

FIG. 6 is a diagram showing the processing flow of type inference.

[Explanation of symbols]

DESCRIPTION OF SYMBOLS 1...Program conversion device, 11...Data type information detection means, 12...Type inference means, 13...Data type information addition means, 1
4...Data type information storage table, 2...Input means, 3...Output means, 21...CPU, 211...Data type information detection unit,
212...Type inference unit, 213...Data type information addition unit, 22
...Main memory, 221...Data type information, 222...Inference information, 23...Output device, 24...Input device, 25...External storage device, 30, 31, 32...Frame, 35, 36...Top level.

Claims (1)

[Claims] 1. In an apparatus for converting a source program into source code or machine language of the same or different programming language, data type information detection means for detecting data type information regarding variables existing in input source code; Based on a data type information storage table that holds detected data type information and data type information regarding each variable held in the table, type inference is performed for variables whose data types are not explicitly declared; a type inference means for registering the inference results in the table; a data type information addition means for adding data type information to the source code for variables whose data types are not explicitly declared based on the result of the type inference; and a type inference result. A program conversion device comprising: output means for outputting.