JP2720643B2 - Program generator generator - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a program generator generator.

[0002]

2. Description of the Related Art In recent years, a program generator has been actively used to create a program for an electronic computer. A program generator converts a program written in one programming language into a program written in another programming language.

[0003] The program generator also includes a compiler in a broad sense. A compiler is a high-level programming language, which is also called a high-level programming language. A program written in C, Fortran, Pascal, etc. is a machine language that can be directly executed by computer hardware, or a form that can be easily converted to a machine language. Into an assembler language.

In the past, most of the widely used program generators were compilers. That is, the generated program is mainly a simple language such as an assembler language. However, because many computers have become popular with high-level programming languages such as C language, which have high program compatibility between different models,
A program generator that converts a higher-level programming language such as the C language or a special programming language into a widely used programming language such as the C language has been used. In particular, Michel Bee et al., “Matchmaker: Un-Interface Specification
Distributed Processing "(Michael
B. Jones, Richard F. Rashid, Mary R. Thompson, "M
atchmaker: An Interface Specification Language for
Distributed Processing ", Proceeding of the 12th A
CMSIGACT-SIGPLAN Symposium on Princeples of Progra
mming Language, ACM, January 1985.) When creating a program for performing data communication between computers, a program generator has been widely used.

[0005] In this case, the program generator reads a specification description in which data communication specifications are described, and generates a program for performing data communication in accordance with the description.

When creating such a program generator, the program generator may be created using a normal programming language. However, if a support device for facilitating the creation is used, the program generator can be more easily created. Becomes Such a support device is referred to as a program generator generation device.

[0007] There are various types of program generator generation devices. Here, the case where a typical one is used, yacc, will be described. yacc
Is mainly for automatically generating a parsing unit in a program generator, and a user needs to describe an operation for utilizing a result of the parsing in the C language. Note that yacc and yacc
For the method of constructing a compiler using, see C. Yoshiyuki Kondo, "C Compiler Programming with Yacc,"
For details, see SoftBank Corp. Publishing Division, 1990.

Hereinafter, the configuration of a conventional program generator generation device will be described with reference to FIG. The general lexical analysis, parsing, generation of a parsing table, and the configuration and method of generating a parser are detailed in Masataka Sasa, "Programming Language Processing System", Iwanami Shoten, 1989. Here, details are omitted.

FIG. 21 is a block diagram showing a procedure for generating a program when using yacc as a program generator generating apparatus. In FIG. 21, 2
101 is a specification description describing the specification of the program generator to be generated, 2102 is a program generator generation device, 2102a reads the specification description 2101 and decomposes it into a lexical specification description lexical analysis unit 2102b
Is a specification description parsing means for parsing the specification description decomposed into lexical characters by the specification description lexical analysis means 2102a;
02c is a syntax analysis table generating means for generating a syntax analysis table required for the syntax analysis of the input program 2106 based on the result of the syntax analysis of the specification description, and 2102d is a syntax analysis table of the specification description and a generated syntax. A syntactic analysis unit generating means 2103 for generating a syntactic analysis unit based on the analysis table is a syntactic analysis unit generated by the program generator generation device 2102, a user program 2104 written by the user in C language, and a , Parsing section 210
3. A compiler for compiling and linking the user program 2104; 2106, an input program to the program generator; 2107, a program generator for converting the input program 2106;
Reference numeral 108 denotes an output program generated by the program generator 2107.

In the above configuration, first, the specification description lexical analysis means 2102a reads the specification description 2101 and decomposes the contents into lexical expressions. Next, the specification description parsing means 2102b performs a syntax analysis of the specification description decomposed into lexical characters. Next, the syntax analysis table generation means 2102c
Based on the result of the syntax analysis of the specification description, a syntax analysis table necessary for analyzing the syntax of the input program 2106 is generated. Next, the syntax analysis unit generation means 2102d generates a syntax analysis unit which is a part of the program generator, based on the generated syntax analysis table and the result of the syntax analysis. Next, the user program 2104, that is, the program generator 21 previously created by the user.
07, a part other than the parser 2103 and the generated parser 2103 are compiled and linked, and a program generator 2107 is generated as a format executable by a computer. By using the generated program generator 2107, the input program 2106 can be converted into an output program 2108.

[0011]

However, in the above conventional configuration, a common problem is that the program generator
The data generation device 2102 generates a parser,
Program that manages character strings
The user must program and the program
Generators cannot be created efficiently
Had problems. Further, as a first problem, the program generator generation device 2102 only generates a parser. When creating a program generator that generates a program written in a high-level language such as the C language, a part of the generated program is often handled as a character string, but a program for handling such a character string is often used. Is not generated, the program generator developer creates the user program 21
04 or the specification description 2101, there is a problem that the amount of work for development increases.

A second problem is that, as in the above-described data communication program generation device, the input of the program conversion device is a simple specification description that generates a large amount of programs in accordance with the specification description. In some cases, a large amount of character strings are included in the specification description generated by the program. In such a case, for example, if the character string is written directly in the yacc specification description file, the specification description becomes difficult to read, and it becomes difficult to understand the entire specification. Was.

Further, as a third problem, even when an attempt is made to change a character string in a specification description, the entire specification description is read by yacc, a syntax analysis unit is generated, and the entire program generator is generated. Must be recreated. Therefore, there is a problem that the same work as in the case of the first development occurs due to a small change, and it takes a long time.

As a fourth problem, when a program generator for generating a high-level language program with the above configuration is generated, it is instructed to insert a long character string in the specification description 2101 or into the long character string. In many cases, a character string in which a part of a long character string is replaced with a certain character string in the input program 2106 is generated.
Here, this long character string is called a template, and a character string inserted in the middle of the template is called an insertion character string. However, since the conventional configuration example does not have a function for generating a procedure for character string replacement, the first half and the second half are divided at the place where the template is replaced, and the first half of the template is output, and then the inserted character string is output. Finally, the user must create a program that outputs the latter half of the template. When such a method is used, a lot of work for development is required, and there is a problem that the operation becomes difficult to understand when the program of the part is viewed later.

The present invention solves the above-mentioned first to fourth problems of the prior art. In order to solve the first problem, it is possible to omit the creation of a program for performing a character string operation, and to improve the efficiency of the development of a program generator. It is an object of the present invention to provide a program generator generation device that can be improved.

Another object of the present invention is to provide a program generator generating apparatus that reduces errors by generating a program generator from a specification description in a format that is easier to read than in the past.

In addition, a third object of the present invention is to provide a program generator capable of coping with the change in a short time with a small amount of work without performing a work such as recompilation when the specification is changed. It is an object of the present invention to provide a program generator generation device that generates a program.

Another object of the present invention is to provide a program generator generating apparatus which can easily realize a function of inserting a character string.

[0019]

In order to achieve this object, a program generator generating apparatus according to the present invention firstly comprises:
Specification description lexical analysis means for reading the specification description of the program generator to be generated into lexical characters, character string extracting means for separating and extracting character strings in the lexical characters obtained by decomposition, and storage of extracted character strings Location
Assign a unique identifier to a location
A character string management unit generating means for generating a character string management unit for managing in over data, and specification description parsing means parses the specification description that has been processed by the character string extraction unit, the output of said syntax analysis means It has a syntax analysis table generating means for generating a syntax analysis table based on.

Second, specification description lexical analysis means for reading the specification description of the program generator to be generated into lexical data, and file insertion instruction detecting means for detecting a file insertion instruction from the lexical data obtained by the decomposition. The contents of the file specified according to the file insertion instruction.
Of the string managed by the string management unit in the ram generator
File insertion means to be inserted into the set, specification description parsing means for parsing the specification description processed by the file insertion means, and syntax analysis table generation for generating a syntax analysis table based on the output of the syntax analysis means Means.

[0021] Thirdly, decomposing Specification lexical analysis means lexical reads Specification of a program generator to be generated, the program di from the lexical obtained by decomposing
The input program is converted to the output program by the generator
A runtime file insertion instruction detecting means for detecting a runtime file insertion instruction , which is executed at the time of execution when converting to a
A method for inserting the contents of a file specified according to a file insertion instruction into an output program during conversion of a program
Continue with the generated program generator program
File insertion procedure insertion means to be inserted into the program, specification description syntax analysis means for performing syntax analysis of the specification description processed by the file insertion procedure insertion means, and a syntax analysis table based on the output of the syntax analysis means. It is configured to have a syntax analysis table generating means.

Fourth, specification description lexical analysis means for reading the specification description of the program generator to be generated into lexical characters, and character string replacement instruction detection for detecting a character string replacement instruction from the lexical characters obtained by the decomposition. Means and specifications
Program change when converting to a program generator
In the program of the program generator that generates a procedure for performing character string replacement according to the character string replacement instruction at the time of conversion
Character string replacement procedure insertion means for inserting into a character string and said character string replacement
The system comprises a specification description parsing means for parsing the specification description processed by the procedure inserting means, and a parsing table generating means for generating a parsing table based on the output of the parsing means.

[0023]

According to the present invention, first, the character string extracting means separates and extracts a character string from the specification description decomposed into lexical characters, and the character string extracted by the character string management section generating means is stored in a program generator. By generating a character string management unit managed by the above, it is possible to omit creation of a program for performing character string management, and to improve the efficiency of development of a program generator.

Second, the file insertion instruction detecting means detects the file insertion instruction from the lexical characters obtained by the decomposition,
By inserting the contents of the file specified by the detected file insertion instruction into the list of lexical characters, the file insertion means can insert the contents of the file placed separately from the specification description into the program generator. This makes it possible to generate a program generator from a concise and easy-to-read specification description.

Thirdly, the effective file command detecting means detects the runtime file inserting command from the lexical characters obtained by the decomposition, and the file inserting procedure inserting means detects the file specified according to the file inserting command at the time of program conversion. By inserting a procedure for inserting the contents of the specified file into the output program into the program generator, when the program generator converts the program, by inserting the contents of the specified file into the output program,
A program generator can be generated from a simple and readable specification description.

Fourth, the character string replacement instruction detecting means detects the character string replacement instruction from the lexical characters obtained by the decomposition, and the character string replacement procedure inserting means inserts the character string according to the character string replacement instruction at the time of program conversion. By inserting a replacement procedure into the program generator and generating a program generator that replaces a character string during operation, the program generator can be generated from a simple and readable specification description.

[0027]

【Example】

Embodiment 1 Hereinafter, a first embodiment of the present invention will be described with reference to the drawings.

FIG. 1 is a block diagram showing a procedure for generating a program and a configuration of a program generator generating apparatus according to the first embodiment of the present invention. In FIG.
101 is a specification description that describes the specifications of the program generator to be generated, 102 is a program generator generation device, 102a is a specification description lexical analysis unit that reads the specification description 101 and decomposes it into lexical characters, and 102b is a specification description lexical analysis unit 102a. Detects and extracts a character string portion from the specification description that has been decomposed into lexical characters, assigns an identifier to the character string, and replaces the character string itself in the sequence of lexical characters in the specification description with the assigned identifier. , A character string management unit generating means for generating a character string management unit 104 for managing the character string extracted by the character string extraction means 102b in the program generator 108, and 102d a specification description Lexical analysis means 10
2a is decomposed into lexical characters, and the character string extracting means 102
b. a specification description parsing means for parsing a specification description in which an identifier indicating a character string is inserted by b;
Input program 1 based on the result of parsing the specification description
A syntactic analysis table generating means for generating a syntactic analysis table necessary for parsing 07; a syntactic analysis section generating means for synthesizing a specification description and generating a syntactic analysis section based on the generated syntactic analysis table , 103 are syntax analyzers generated by the program generator generator 102, 104
Is a character string management unit generated by the character string management unit generation unit 102c; 105 is a user program written by the user in C language; 106 is a syntax analysis unit 103;
The program generation unit 104, a compiler for compiling and linking the user program 105, 107 is an input program to the program generator, and 108 is
A program generator 109 for converting the input program 107 is an output program generated by the program generator 107.

The operation of the above-configured program generator generator will be described with reference to the flowchart shown in FIG.

First, the specification description lexical analysis means 102a reads the specification description 101 and decomposes its contents into lexical characters (step (a) in FIG. 2). Next, character string extracting means 1
Reference numeral 02b denotes a character string portion detected from the specification description decomposed into lexical characters by the specification description lexical analysis means 102a, and a unique identifier is assigned to each character string. The assigned identifier is inserted instead of the column itself (step (b) in FIG. 2). Next, the character string management unit generation unit 102c generates a character string management unit 104 for managing the character string extracted by the character string extraction unit 102b in the program generator 108 (step (c) in FIG. 2). Next, the specification description parsing means 102d performs a syntax analysis of the specification description in which the specification description lexical analysis means 102a decomposes into lexical characters and the character string extracting means 102b inserts an identifier indicating a character string (step (d in FIG. 2). )). Next, the syntactic analysis table generating means 102e, based on the result of the parsing of the specification description,
A syntax analysis table required for the syntax analysis of step 7 is generated (step (e) in FIG. 2). Next, the parsing unit generating means 102f generates a parsing unit based on the parsing of the specification description and the generated parsing table (step (f) in FIG. 2).

The user compiles and links the user program 105 created in advance, the syntactic analysis unit 103 and the character string management unit 104 generated by the above operation by the compiler 106, 108 is generated.

Next, the generated program generator 108 will be described with reference to the drawings.

FIG. 3 is a block diagram showing the configuration of the program generator 108. In FIG.
Is a lexical analyzer that reads the input program 107 and decomposes it into lexical characters; 103 is a parse analyzer that parses the input program 107 parsed into lexical characters by the lexical analyzer 301; Output program 109 based on the analysis result of program 107
, A data management unit 303 for managing basic data structures used in the program generator 108, and a character string management unit 104 for managing a character string in the data management unit 303. , 30
Reference numeral 4 denotes a library function group that provides procedures for performing highly versatile operations such as operations on data managed by the data management unit 303 and output operations.

The operation of the program generator 108 configured as described above will be described with reference to the flowchart shown in FIG.

First, the lexical analyzer 301 reads the input program 107 and decomposes its contents into lexical characters (step (a) in FIG. 4). Next, the parsing unit 103 sets the lexical analysis unit 3
A syntax analysis is performed on the input program 107 in which 01 has been decomposed into words (step (b) in FIG. 4). Next, the code generator 3
02 synthesizes an output program based on the result of the syntax analysis (step (c) in FIG. 4). When synthesizing a character string, it does not synthesize the character string itself, but uses an identifier assigned to the character string. Next, the code generation unit 302 outputs an output program based on the synthesized data structure (step (d) in FIG. 4).

Next, how a character string is handled in the program generator 108 will be described with reference to the drawings.

FIG. 5 is a structural diagram showing a character string and a structure related to concatenation among data structures handled by the data management unit 303. In FIG. 5, 501 is 2
A cons cell 502 expressing the concatenation of two data is a character string object that stores a character string. The configuration of this data structure is close to the data structure used by the language processing system of Lisp, which is a programming language for symbol processing.
For details on the Lisp language processing system, see Shigeki Goto, "Symbol Processing Programming", Iwanami Shoten, 1988.

The cons cell 501 has two areas in which pointers, identifiers and the like can be stored. This data structure is mainly used to express an operation of connecting character strings and the like. The character string object 502 stores a character string, and stores a character string therein. An area called a tag contains an identifier indicating what kind of data structure this data structure is. This tag is Cons cell 501
In general, when a cons cell is shown graphically, the region of the tag is not shown, so that it is omitted in FIG.

FIG. 6 is a diagram showing the specification description 101.
When a description corresponding to grammar symbols b, c, and d appears successively in the input program 107, 601 can be regarded as a grammar symbol a by combining the three grammar symbols. A rule 602 indicating the specification of performing the operation shown in the curly braces is that when two descriptions corresponding to the grammar symbol a appear two consecutively in the input program 107, the two grammar symbols are put together. , A grammar symbol e, and a rule indicating that the operation shown in the curly braces is performed in that case. This specification description method is based on the specification description method of yacc. The part of the grammar before the curly braces is called a production, and the action inside the braces is called an action. $$ in the action is a symbol indicating the attribute value of the grammar symbol located to the left of: in the grammar rule. $ 1, $ 2, .... are the first grammar symbol, the second grammar symbol,. . . Is a symbol indicating the attribute value of. Function li shown during action
st is a function for concatenating values given as arguments using the cons cell 501.

FIG. 7 is a diagram showing a program when the character string management unit 104 generated when the program generator generating apparatus 102 reads the specification description shown in FIG. 6 is realized in C language. In FIG. 7, make
The function _string is a function that generates a character string object 502, stores a given character string therein, and returns a pointer to the character string object 502.
The array string_storage is an array for storing and placing the pointer. The subscript of the array is one-to-one with the identifier assigned to the character string by the character string extracting means 102b.
For example, the character string object of the character string given the identifier i is set so that the subscript in the array is included in the element of i.

FIG. 8 shows a sequence of grammatical symbols b, c, and d shown in rule 601 in FIG.
FIG. 4 is a structural diagram showing a data structure generated when an action of a rule 601 is executed.

FIG. 9 is a structural diagram showing a data structure generated when the grammar symbol a shown in the rule 602 in FIG. 6 appears in the input program 107 and the action of the rule 602 is executed. is there. 8 and 9, pointers 0, 1, and 2 indicate character strings 0, 1, and 2, respectively. In order to output a concatenated character string when character string concatenation is represented by such a data structure, a tree structure composed of cons cells must be used.
When a character string object is found by searching sequentially from the left, the character string may be output.

As shown in FIG. 9, when a character string in the specification description 101 is linked in the program generator 108, it is treated as a pointer. A character string management unit is also generated as in the present invention, and the program generator 108
Is used, the character strings can be stored at different positions, and only the pointers indicating the stored character strings can be connected to perform composition. As a result, the character strings can be efficiently synthesized without copying the character strings. Here, a method of using a pointer to indicate a character string object has been described, but this may be an identifier of the character string object.

Next, the advantages of the present invention as compared with the conventional example will be described. In a conventional example having no function of generating a character string management unit, the following three methods can be considered as a method of realizing a function of synthesizing a character string written in such a specification description.

In the first method, every time a character string is synthesized, all the character strings to be synthesized are sequentially copied to one buffer from the beginning. In this method, a buffer copy occurs every time synthesis is performed, so that the execution speed becomes slower.If the length of a character string obtained by synthesis increases, a large buffer is required for each synthesis. There are two problems of consuming a large amount of memory.

The second method is a method of recognizing a character string based on the value of a pointer. In this embodiment, all data has an area for storing an id, and it is determined whether the data pointed to by a certain pointer is a character string or a cons cell by checking the value of the id.
By changing this method, the area where the cons cell is present is limited, and if the pointer points inside the cons cell, it is recognized as a cons cell, and if it is out of the range, it is recognized as a character string. Can be To combine the character strings, the same operation as in the present embodiment may be simply performed using the head address of the character string as a pointer. This method eliminates the disadvantages of the first method in terms of memory efficiency.
However, there are the following problems. The action part in the specification description is treated as a character string in the C language program after being processed by yacc. Then, when compiled by a C language compiler, the string
The location in the object code varies depending on the language processing system, the OS, the model of the computer, and the like. It is generally difficult to know the position where the character string exists. Such a program that operates based on information about the position of an uncertain character string is generally not preferable because it is poor in portability and maintainability.
In this example, only the combination of cons cells and character strings is shown, but if the data handled in the generator contains, for example, data such as symbols, characters, and numeric values used in normal language processing systems, When printing out the data structure pointed to by the pointer by limiting the existing range for each character, it is necessary to compare (address number of data types-1) addresses for one pointer, Execution speed becomes slow. From this point as well, the second method is not preferable.

The third method is to give up the automatic management of character strings, and to create the character string management part by the user. In this method, the program generator itself can be exactly the same as in this embodiment,
The execution speed and the memory efficiency are not inferior to this embodiment. However, the character string itself is included in the source code written by the user, and the character string is designated by an identifier or the like in the specification description. In other words, it is not possible to write a character string directly in the specification description, and the specification concerning parsing and operation according to the syntax and the character string used at that time are placed in a remote location, for example, in a separate file. Will be. As a result, the readability of the specification description is greatly impaired as compared with the present embodiment. Also, since the user needs to create a character string management unit,
Development efficiency is also reduced.

On the other hand, when the present invention is used, a rule for syntactic analysis and a character string used for character string synthesis can be directly written at a close position, that is, at the action part of the rule, and When the generator synthesizes a character string, the character string can be expressed by connecting identifiers or pointers. The present invention is superior to the conventional example in this point.

Also, by automatically generating a character string management unit for handling character strings and providing standard procedures such as character string concatenation and output to the user as a standard library, A user can generate a program generator simply by writing rules for parsing and rules for synthesizing strings in a specification description. In other words, there is no newly developed part in the user program 105, and time for the development can be saved. As a result, the development efficiency and maintainability of the program generator can be improved.

In FIG. 6, each grammatical symbol has only one attribute value based on the standard notation of yacc. However, in yacc, the data type of the attribute value is specified for each grammatical symbol. You can also. By making this data type a structure having a plurality of elements, a plurality of attribute values can be used in the specification description. It is also possible to provide a function that does not require the user to specify the data type of the attribute value of each grammatical symbol, but can handle the attribute value specified in the generation rule.

As described above, according to the present embodiment, by providing the character string extracting means and the character string management section generating means in the program generator generating apparatus, the creation of the program for managing the character string is omitted and the generation is performed. In this way, it is possible to perform efficient character string synthesis in the generated program generator, thereby improving the development efficiency of the program generator.

(Embodiment 2) Hereinafter, a second embodiment of the present invention will be described with reference to the drawings.

FIG. 10 is a block diagram showing a program generator generation process and a configuration of a program generator generation device according to the second embodiment of the present invention.

Elements that differ between the configuration in FIG. 10 and the configuration in FIG. 1 will be described. In FIG. 10, reference numeral 1002b denotes a file insertion instruction detecting unit that detects a file insertion instruction from the sequence of lexical characters generated by the specification description lexical analysis unit 1002a. File insertion means for inserting the inserted file 1009, 1009 is a file insertion means 1
002c is an inserted file to be inserted into the lexical sequence of the specification description. Others are the same as FIG.

The operation of the above-configured program generator generator will be described with reference to the flowchart shown in FIG. In FIG. 11, steps (a), (d), (e), and (f) are the same as the operations in FIG. 2 is different from the operation of FIG. 2 in that a file insertion instruction is detected from the lexical sequence generated in step (a) (step (b)), and the contents of the file specified by the detected file insertion instruction are read. Then, insert it into the lexical sequence generated in step (a) (step (c))
That is, the step was added.

Based on this processing flow, FIGS.
An actual use example will be described with reference to FIGS.

FIG. 12 is a diagram showing a part of the specification description 1001. In FIG. 12, reference numeral 1201 denotes a rule indicating one of program conversion rules.

FIG. 13 is a diagram showing an inserted file. The contents shown in FIG. 13A are stored in a file named file1, and the contents shown in FIG. 13B are stored in a file named file2. It is assumed that

FIG. 14 shows a case where the present invention is used.
FIG. 9 is a diagram showing a specification description that produces a result equivalent to the specification description shown in FIG.

In FIG. 12, the character string "include" is a reserved word, and the program generator generates a command to insert a file having the same name as the character string in parentheses following it at that position. Apparatus 10
02 is an insertion instruction to instruct No. 02.

Program generator generation device 1002
Converts this command into a file insertion command detecting means 1002b.
And inserts the contents of the specified file at that location. In FIG. 12, the character string include is 2
Appears once, but when the first instruction is detected,
When the second instruction is detected in the file named file1, the file named file2 is inserted. f
It is assumed that the contents of a file named ile1 and file2 are as shown in FIG. As a result of inserting the respective contents, the arrangement of the lexical characters passed to the specification description parsing means 1002d becomes equal to the case where the description shown in FIG.

In the example shown in FIG. 13, the contents of file1 and file2 are as short as several tens of characters. However, when describing the specifications of a program generator for generating a program of a high-level programming language, one character string is 1000 characters. When such a character string is included in the specification description, the specification description becomes difficult to read and the maintainability deteriorates.
When a character string is described in the specification description, characters indicating a line feed and characters indicating the start and end of the character string must be treated specially. This is called escape in the C language, and uses a special notation to represent these characters. Therefore, it is difficult to understand the contents of the character string. Therefore, in such a case, it is easier to read the specification description by writing the contents of the character string in another file and writing only the file insertion instruction indicating that the file is to be inserted in the specification description .

As described above, when the present embodiment is compared with the conventional one, the program generator according to the present embodiment has an excellent effect that the specification description is easy to read.

As described above, according to the present embodiment, by providing the file insertion instruction detecting means and the file inserting means in the program generator generating apparatus, the program generator can be generated from the specification description in a more readable form. And the efficiency of program generator development can be improved.

(Embodiment 3) Hereinafter, a third embodiment of the present invention will be described with reference to the drawings.

FIG. 15 is a block diagram showing a program generator generation process and a configuration of a program generator generation device according to the third embodiment of the present invention.

Elements different between the configuration in FIG. 15 and the configuration in FIG. 10 will be described. In FIG. 15, reference numeral 1502b denotes a runtime file insertion instruction detecting unit that detects a runtime file insertion instruction from the sequence of lexical characters generated by the specification description lexical analysis unit 1502a. The file insertion procedure insertion means 1509 for inserting a procedure for inserting the run-time inserted file 1509 when the program generator is executed is a run-time inserted file inserted into the output file 1508 at the time of execution. Others are the same as the configuration of FIG.

The operation of the above-configured program generator generator will be described with reference to the flowchart shown in FIG. In FIG. 16, steps (a), (b), (d), (e), and (f) are the same as the operations in FIG. The difference from the operation of FIG.
When the program generator operates, it reads the contents of the specified file and inserts the procedure to be inserted into the output program into the lexical sequence (step (c)). )).

Next, effects of the above configuration will be described with reference to the drawings. When this configuration is used, the specification description described in FIG. 12 produces the same result as in FIG. 14 as in the second embodiment, and the program generator can be generated using the more readable specification description. It is possible to improve the efficiency of program generator development. In addition, the runtime inserted file 1
509 is inserted into the output program 1508 when the program generator 1507 is operated, not when the program generator 1507 is generated. Therefore, when the runtime inserted file 1509 is changed, the program generator The change can be reflected in the output program 1508 without recompiling.

As a result, when developing a program generator, the time required for making a change to the file to be inserted at the time of execution can be reduced, and the efficiency of development can be improved. As described above, according to the present embodiment, the program generator is generated from the specification description in a more readable form by providing the execution-time file insertion instruction detection means and the file insertion procedure insertion means in the program generator generation apparatus. And when the file to be inserted changes, the change can be reflected in the output program without generating and compiling the program generator, improving the efficiency of program generator development Can be done.

Note that, unlike the second embodiment, in the third embodiment, a procedure must be inserted into the program generator 1507. The procedure is performed by the syntax analyzer 150.
3, it may be expressed as a program,
By using the same method as in the first embodiment, a part for managing the procedure is separately generated, and the program generator 150
7 may be incorporated.

Embodiment 4 Hereinafter, a fourth embodiment of the present invention will be described with reference to the drawings.

FIG. 17 is a block diagram showing a program generator generation process and a configuration of a program generator generation device according to the fourth embodiment of the present invention.

Elements different from the configuration in FIG. 17 and the configuration in FIG. 1 will be described. In FIG. 17, reference numeral 1702b denotes a character string replacement instruction detecting means for detecting a character string replacement instruction from the sequence of lexical characters generated by the specification description lexical analysis means 1702a. This is character string replacement procedure insertion means for inserting a procedure for performing character string replacement when the generator is executed. Others are the same as FIG.

The operation of the above-configured program generator generator will be described with reference to the flowchart shown in FIG. In FIG. 18, steps (a), (d), (e), and (f) are the same as the operations in FIG. 2 is different from the procedure in FIG. 2 in that a character string replacement instruction is detected from the lexical sequence generated in step (a) (step (b)), and a specified character string replacement is performed during operation of the program generator. Is inserted into the lexical sequence (step (c)).

Based on this processing flow, an example of use will be described with reference to FIGS. 19 and 20.

FIG. 19 is a diagram showing a part of the specification description 1701. FIG. 20 is a diagram showing a specification description that produces a result equivalent to the specification description shown in FIG. 19 when the present invention is used.

In FIG. 19, the character string “replace” is a reserved word, and the same part as the character string of the second argument in the character string of the first argument enclosed in parentheses is followed by This is a character string replacement command that indicates replacement with a three-argument character string. Program generator generation device 1
702 designates this command as a character string replacement command detecting means 170
2b, a procedure for replacing the designated character string is inserted at that position when the program generator 1707 operates.

When the character string replace is detected in FIG. 19, a procedure for replacing the character string FUNCTION in the character string of the first argument with the attribute value of the grammatical symbol b in the generation rule is inserted. . If the attribute value of the grammar symbol “b” is a character string “multiply”, the character string “FUNCTION” is replaced with the character string “multiply”, so the specification description in FIG. 19 has the same meaning as the specification description in FIG. have.

When describing the specifications of a program generator for generating a program of a high-level programming language, which is the main object of the present invention, parts to be changed according to the contents of an input program are scattered in a large number of fixed character strings. Often. In such a case, the program generator generating apparatus according to the present embodiment converts a portion to be changed into a specific character string, collectively describes a large amount of character strings, and executes a program by a character string replacement instruction. Character string replacement can be performed during the operation of the conversion device, and excellent effects can be obtained in terms of readability of specification description and development efficiency.

As described above, according to the present embodiment, the character string replacement instruction detecting means is provided in the program generator generating device.
And the provision of a character string replacement procedure insertion means,
The program generator can be generated from the specification description in a more readable form, and the development efficiency of the program generator can be improved.

In the first to fourth embodiments, the respective embodiments have been described as being independent. However, by combining them arbitrarily, further effects can be obtained.

[0083]

As described above, according to the present invention, first, by providing a character string extracting means and a character string management section generating means in the program generator generating apparatus, the creation of a program for performing character string management can be omitted. In addition, efficient character string synthesis in the generated program generator can be performed, and the development efficiency of the program generator can be improved.

Second, by providing the file insertion instruction detecting means and the file inserting means in the program generator generating apparatus, the program generator can be generated from the specification description in a more readable form. Efficiency can be improved.

Third, by providing the file insertion instruction detecting means and the file insertion instruction inserting means in the program generator generating apparatus, the program generator can be generated from the specification description in a more readable form, and Even when a change occurs in the inserted file, the change can be reflected in the output program without generating and compiling the program generator, so that the efficiency of the program generator development can be improved.

Fourth, by providing the character string replacement instruction detecting means and the character string replacement procedure inserting means in the program generator generation device, the program generator can be generated from the specification description in a more readable form. The efficiency of program generator development can be improved.

[Brief description of the drawings]

FIG. 1 is a block diagram showing a program generator generation process and a configuration of a program generator generation device according to a first embodiment of the present invention.

FIG. 2 is a flowchart illustrating an operation of the program generator generation device according to the first embodiment;

FIG. 3 is a block diagram illustrating a configuration of a program generator generated by the program generator generation device according to the first embodiment;

FIG. 4 is a flowchart showing the operation of the program generator generated by the program generator generation device of the first embodiment.

FIG. 5 is a structural diagram showing a basic data structure used in the program generator generated by the program generator generating device of the first embodiment.

FIG. 6 is a diagram showing a specification description used as an input of the program generator generation device in the first embodiment.

FIG. 7 is a diagram illustrating a program in which a character string management unit generated by the program generator generation device according to the first embodiment is realized in C language;

FIG. 8 is a structural diagram showing an example of a data structure used inside the program generator generated by the program generator generating device in the first embodiment.

FIG. 9 is a structural diagram showing an example of a data structure used inside the program generator generated by the program generator generating device in the first embodiment.

FIG. 10 is a block diagram showing a program generator generation process and a configuration of a program generator generation device according to a second embodiment of the present invention.

FIG. 11 is a flowchart illustrating the operation of the program generator generation device according to the second embodiment.

FIG. 12 is a diagram showing a specification description used as an input of a program generator generation device in a second embodiment.

FIG. 13A is a diagram showing a file named file1 among files to be inserted into the specification description by the program generator generating apparatus according to the second embodiment. Of the files that the program generator generator inserts into the specification description,
Diagram showing what is named le2

FIG. 14 is a diagram showing a specification description that produces a result equivalent to the specification description of FIG. 12;

FIG. 15 is a block diagram showing a program generator generation process and a configuration of a program generator generation device according to a third embodiment of the present invention.

FIG. 16 is a flowchart showing the operation of the program generator generation device according to the third embodiment.

FIG. 17 is a block diagram showing a program generator generation process and a configuration of a program generator generation device according to a fourth embodiment of the present invention.

FIG. 18 is a flowchart showing the operation of the program generator generation device according to the fourth embodiment.

FIG. 19 is a diagram showing a specification description used as an input of the program generator generation device in the fourth embodiment.

FIG. 20 is a diagram showing a specification description that produces a result equivalent to the specification description of FIG. 19;

FIG. 21 is a block diagram showing a configuration of a conventional program generator generation device.

[Explanation of symbols]

 101 specification description 102 program generator generation device 102a specification description lexical analysis means 102b character string extraction means 102c character string management part generation means 102d specification description syntax analysis means 102e syntax analysis table generation means 102f syntax analysis part generation means 103 syntax analysis part 104 characters Column management unit 105 User program 106 Compiler 107 Input program 108 Program generator 109 Output program 301 Lexical analysis unit 302 Code generation unit 303 Data management unit 304 Library function group 501 Cons cell 502 Character string object 601 Rule 602 Rule 1001 Specification description 1002 Program generator generation Apparatus 1002a Specification description lexical analysis means 1002b File insertion instruction detection means 1002c File insertion Means 1002d Specification description syntax analysis means 1002e Syntax analysis table generation means 1002f Syntax analysis section generation means 1003 Syntax analysis section 1004 User program 1005 Compiler 1006 Input program 1007 Program generator 1008 Output program 1009 Inserted file 1201 Rule 1501 Specification description 1502 Program generator generation Device 1502a Specification description lexical analysis means 1502b Runtime file insertion instruction detection means 1502c File insertion procedure insertion means 1502d Specification description syntax analysis means 1502e Syntax analysis table generation means 1502f Syntax analysis generation means 1503 Syntax analysis section 1504 User program 1505 Compiler 1506 Input Program 1507 Program generator 1508 Output program Gram 1509 file to be inserted at execution time 1701 specification description 1702 program generator generation device 1702a specification description lexical analysis means 1702b character string replacement instruction detection means 1702c character string replacement procedure insertion means 1702d specification description syntax analysis means 1702e syntax analysis table generation means 1702f syntax analysis Part generation means 1703 syntax analysis part 1704 user program 1705 compiler 1706 input program 1707 program generator 1708 output program 2101 specification description 2102 program generator generation device 2102a specification description lexical analysis means 2102b specification description syntax analysis means 2102c syntax analysis table generation means 2102d syntax analysis Section generation means 2103 syntax analysis section 2104 user program 2105 compiler 2106 Input program 2107 Program generator 2108 Output program

 ──────────────────────────────────────────────────の Continuing on the front page (72) Inventor Iban I Petch 1006 Kadoma Kadoma, Kadoma City, Osaka Prefecture Inside Matsushita Electric Industrial Co., Ltd. In-house (56) References Masataka Sasa "Programming Language Processing System" Iwanami Shoten (1989) 293− 305

Claims (4)

(57) [Claims] 1. A specification description lexical analysis means for reading a specification description of a program generator to be generated into a lexical character, a character string extracting means for separating and extracting a character string in the lexical character obtained by the decomposition, and an extraction. Character string storage
Location by assigning a unique identifier to the storage location.
A character string management unit generating means for generating a character string management unit to be managed in the gram generator ; a specification description parsing means for parsing the specification description processed by the character string extracting means; and an output of the syntax analysis means A syntactic analysis table generating means for generating a syntactic analysis table on the basis of a syntactic analysis table; an output of the syntactic analysis means; Program generator generator. 2. A specification description lexical analysis means for reading a specification description of a program generator to be generated into a lexical form, a file insertion instruction detecting means for detecting a file insertion instruction from the lexical form obtained by the decomposition, The contents of the file specified according to the insert
Of a set of character strings managed by the character string management unit in the generator
File insertion means for inserting into the file, specification description syntax analysis means for performing syntax analysis of the specification description processed by the file insertion means, and syntax analysis table generation means for generating a syntax analysis table based on an output of the syntax analysis means. And a syntactic analysis unit generating means for generating a syntactic analysis unit for performing syntactic analysis in the program generator based on the output of the syntactic analysis means and the syntactic analysis table. 3. A specification description lexical analysis means for reading a specification description of a program generator to be generated and decomposing it into lexical data,
Data to convert an input program to an output program
Run-time file insertion, executed at run time
And run-time files inserted instruction detection means for detecting the instructions, specifications
Is the time to convert the description into a program generator.
Procedure to insert the contents of the specified file into the output program according to the file insertion instruction during program conversion
In the generated program generator program
File insertion procedure insertion means for inserting into a file, specification description syntax analysis means for performing syntax analysis of the specification description processed by the file insertion procedure insertion means, and syntax analysis for generating a syntax analysis table based on the output of the syntax analysis means A program generator generation apparatus, comprising: a table generation unit; and a syntax analysis unit generation unit that generates a syntax analysis unit that performs syntax analysis in a program generator based on the output of the syntax analysis unit and the syntax analysis table. 4. A specification description lexical analysis means for reading a specification description of a program generator to be generated into a lexical character, and a character string replacement instruction detecting means for detecting a character string replacement instruction from the lexical character obtained by the decomposition. Program specifications
A procedure for performing character string replacement according to a character string replacement instruction during program conversion when converting to a
Character string replacement procedure insertion means inserted into the program of the generated program generator and the character string replacement procedure
Specification description parsing means for parsing the specification description processed by the insertion means, parsing table generating means for generating a parsing table based on the output of the parsing means, output of the parsing means, A program generator generation device having a syntax analysis section generation means for generating a syntax analysis section for performing syntax analysis in a program generator based on the syntax analysis table.