RU2103727C1 - Method for converting input code of translator into object code and device which implements said method - Google Patents

Abstract

FIELD: hierarchical structure of libraries. SUBSTANCE: each library provides interface for access to corresponding data structure such as data structure of character encoding table or syntactic tree. Libraries are structured in multiple levels of abstract constructions which include concrete representation, level of representation, level of definitions and conceptual level. Interface to library for example consists of conceptual level and part of level of definitions. Concrete representation and level of representations are hidden from software engineer. In addition invention provides interface means for each level of operations for creation, removal, reversal, update or output. EFFECT: increased functional capabilities. 12 cl, 4 dwg

Description

 The invention relates to a translator, in particular to the organization and construction of a translator for a high-level machine language.

 A translator is a computer program that translates a computer program compiled in the input language of a high-level translator, easily perceived by people, into a program in the output language of the translator, executed by a computer. Typically, a translator includes several functional blocks. For example, a conventional translator may include a lexical analyzer that scans the translator in the source program and identifies consecutive tokens (the minimum language units that have meaning) in the source program.

 A conventional translator also includes a parser, which receives as input a grammar that defines the language to be translated and the sequence of operations associated with the grammar. The parser forms a "syntax tree" (parsing tree) for the operators of the source program in accordance with the grammar rules and operations. For each operator of the source program, the parser generates a syntax tree for the initial data input in a recursive way "from bottom to top" in accordance with the appropriate grammar rules and definitions. Thus, a syntax tree is formed from nodes corresponding to one or more grammatical rules. Generating a syntax tree allows the parser to determine whether parts of the input program obey grammar rules or not. If not, the parser generates an error message. Thus, the parser performs parsing, but usually does not check the content ("semantics") of the source program. An example of well-known parsing tools is the LALR parser (lookahead, left right - “looking forward, from left to right”), which is described in chap. 4 monographs by Aho, Sethi, Ullman, "Compilers: Principles, Techniques and Tools".

 In conventional translators, after the input program has been parsed, it is entered into the semantic analyzer, which checks for semantic errors, such as type mismatches, etc. The semantic analyzer evaluates, for example, the "semantic attributes" of the nodes of the syntax tree. Attributes that are evaluated by looking at the attributes of their generated nodes are called "synthesized attributes." After parsing and semantic analysis, the translator generates an intermediate code, optimizes the intermediate code and generates an output program.

 The original translator program itself is quite large and complex. Many users continue to work on the source code of the translator throughout the life of the translator. Thus, various users with their different coding styles, both good and bad, contribute to the compilation of the translator source code. Even if every programmer working on the translator's source code uses good programming practice (which is unlikely), individual programming styles are different, and most translators are characterized by a wide variety of coding styles. Under these conditions, it is important for each translator that the source code can be easily updated and maintained.

 To this end, it is important to standardize the input program modules as well as the interfaces between the modules. Among the well-known decisions aimed at standardizing coding procedures, one can specify the ADT (Data Types of Abstract Constructions) and OOP (Object Oriented Programming) procedures.

 The objective of the invention is to overcome the problems and eliminate the shortcomings of the solutions known from the prior art by introducing a hierarchical structure of Technological Tools Packages (TCP) when constructing a translator. Each TCP defines an interface for manipulating a corresponding data structure, such as a character encoding table or a syntax tree. The present invention allows to structure the TCP into many levels of abstract constructions, which include: "highlighted specific presentation", "presentation level", "definition level" and "conceptual level". The interface to the TCP includes, for example, a conceptual layer and a partial definition layer. The specific presentation and level of representations are hidden from the computer system programmer. In addition, the present invention provides an interface designation at each level for performing create / delete, access, update, and output operations.

 The objectives and advantages of the invention will be clear from the following description and will become apparent when using the invention. The objectives and advantages of the invention can be achieved using the features of the invention and their combinations described in the claims.

 In FIG. 1 is a block diagram of a computer system according to a preferred embodiment of the invention; in FIG. 2 is a conceptual diagram of a TCP structure; in FIG. 3 is an example of a TCP for a syntax tree; in FIG. 4 is a flowchart illustrating translator modules providing creation of data structures in various TCPs and access to them.

 Consider the preferred embodiments of the invention, illustrated by the drawings, where the same elements are denoted by the same reference position.

 The invention relates to a device and a method that provides increased reliability, ease of maintenance and readability of software. In FIG. 1 is a block diagram of a computer system 100 according to the invention. Computer system 100 includes a central processor 102, memory 104, and I / O bus 106. Those skilled in the art will appreciate that the computer system 100 may also include many other elements not shown in the drawing to maintain its clarity, for example, disk storage devices, keyboards, displays, network connections, additional memory buses, additional central processors, etc.

 The memory 104 comprises an input program 110 of the translator, a translator 111 and an output program 124 of the translator. Translator 111 includes a lexical analyzer 112, a parser 114, a semantic analyzer 116, a code optimizer 120 (optional), and a code generator 122. The translator 111 inputs the input program 110 and processes the input program to convert it to the output program 124. Elements of the translator 112-116 process each statement in the input program 110 to generate an intermediate code. The memory 104 also includes a plurality of technology tool packages (TCPs) 133, as described below. Certain parts of the translator (for example, the syntax tree interface) are organized (or structured) as a hierarchy of technological tools packages. These TCPs in the Pascal translator do not contain information data. PTAs are structured pieces of software that manipulate some global data (and provide links to that data). In other embodiments, however, it is possible to create and encode the TCP so that they can process not only this specific data (for example, a specific list of names of the table of lists of names, one syntax tree, etc.), but any data that is suitable for functions these TCP as parameters.

 As should be clear to a person skilled in the art, all parts of the translator 111 are executed in the form of instructions stored in the memory 104 and executed by the central processor 102. The parser 114 accesses the stack memory 135 of the syntax tree. The parser 114 uses a grammar that includes rules and associated operations corresponding to the rules. Grammar operations access the TCP 133, including the TCP 134 of the syntax tree, using the interface functions in the TCP.

 The semantic analyzer 116 traverses the PTS syntax tree 134 of the syntax tree for the entire input program (or for most of it) created by the parser 114 and recursively traverses the tree, invoking the corresponding semantic analysis routines.

 Semantic analyzer 116 prints error messages and / or stops program execution if semantic errors are found. If no semantic errors are found, then the semantic analyzer 116 displays trees for software-compatible computer systems (UCS) in a pre-conversion view in a manner known to those skilled in the art (Aho et al., "Compilers: Principles, Techniques and Tools" , pp 735-737). Code Optimizer 120 (optional) optimizes this representation for preliminary conversion and displays it in an optimized form (for example, unused code fragments may be omitted). Code generator 122 preferably converts the preprocessing representation into output program 124 in a manner also well known to those skilled in the art.

 A preferred embodiment of the invention relates to a SPARCpascal translator for the Pascal programming language. The translator itself is preferably written in the universal C programming language and runs on the Solaris operating system, which is supplied by Sun Microsystems and is associated with the Unix operating system. Solaris is a trademark of Sun Microsystems. Trademarks SPARC are trademarks of SPARC International, Inc. Unix is a trademark registered in the United States and other countries, exclusively licensed through X / Orep Company, LTD.

 As shown in FIG. 4, PTSs are used for the identifier table, naming list table, interface, for example YATTR, which defines specific semantic operations for Pascal YACC grammar and UCS trees. The identifier table and the name list table (also called the character encoding table) are described in the jointly filed application for “Translator input program conversion method and device for its implementation” by the same applicant. The syntax tree is described in a jointly filed application for “A method for evaluating semantic attributes in parsing and a device for its implementation” by the same applicant. The YATTR interface is a semantic operations interface for the usual Pascal YACC grammar. UCS trees are described, for example, in the monograph Aho et al., "Compilers: Principles, Techniques and Tools", p. p. 735-737. Other embodiments of the invention use TCP for other relevant data structures.

 In FIG. 2 is a conceptual diagram of the structure of the TCP 200. After considering the conceptual model, an example of the TCP is given below. As shown in FIG. 2, each TCP defines a public interface for manipulating a corresponding data structure, such as a character encoding table or a syntax tree. As shown in FIG. 2, the TCP 200 is structured into a plurality of levels of abstract constructions that include a highlighted specific view 202, a level of representations 204, a definition level 206, and a conceptual level 208. Each of these levels of abstract constructions is represented by a horizontal line in FIG. 2.

 The invention provides for the assignment of a group of interface routines for each level for performing operations of creation / deletion 222, access 224, updates 226, and output 228; each of these groups is represented by a column in Fig. 2. The interfaces of a particular presentation 202 and presentation layer 204 are hidden to the programmer. The interface of the conceptual layer 208 contains many software-implemented procedures or functions that create interfaces by which access to the TCP can be provided by software external to the TCP. The provided interface for access to the TCP may also include part of the definition level 206. In other cases, the definition level 206 is hidden. A simplified example is given below to explain.

 If, for example, a TCP is formed to manipulate the list, its definition level may contain the following commands (attributes of abstract constructions) for each element of the list: INFO (L), which represents the information part; KEY (L) - key for associative search; NEXT (L) - pointer to the next list item. The INFO and KEY attributes can be included in the TCP interface. But there is no need to include the NEXT attribute in the interface, since at the conceptual (higher) level we can create an ELEMENTS (L, P) iterator that scans all the elements of the list. Thus, the NEXT attribute remains hidden.

 Thus, the example TCP shown in FIG. 2, has four groups of interfaces, the upper level of which is available for software that performs operations on data structures to which the TCP corresponds, and the lower levels are used internally for the TCP to provide access between different levels of interfaces. As shown by the arrows in FIG. 2, the N-level interface can only be accessed at N + 1. It is also possible (but rarely performed) to use other N-level routines for level N routines. Not all TCPs will include each of the interfaces shown in FIG. 2, but if such interfaces are necessary, then they must be consistent with the format shown in FIG. 2.

 The highlighted specific representation 202 is a real data structure stored in memory, such as a syntax tree, a character encoding table (a list of names — an NL table), an identifier table, or a data structure representing a regular grammar of a programming language. A valid representation of such a data structure is not within the scope of the present invention; any appropriate data structures may be used. View level 204 includes many operations, for example, create / delete 222, access 224, update 226, and output 228 defining access to attributes / elements of a specific view 202. Definition level 206 includes many operations, such as create / delete 222, access 224, update 226 and output 228 defining access to the attributes of abstract constructions at the level of representations 204, which may or may not correspond to specific attributes / elements. "Attributes of abstract constructions" are also called "intermediate abstract concepts." Conceptual layer 208 includes more general operations (e.g., iterators) that manipulate the data structure as a single abstract object.

 In FIG. 3 shows an example of a TCP 134 for a syntax tree. TCP 134 includes two files: a self-documenting interface file (.h) 310 and an implementation file (.c) 320. A self-documenting interface file 310 defines external procedures, functions, and variables and macros (such as for transitions between different levels of a TCP). (In a preferred embodiment, most of the interface procedures and functions are defined as macros because their implementation, i.e., a concrete representation of the abstract description, is relatively small). Implementation file 320 contains bodies (i.e., the inside of the description) of procedures, functions, and variables.

As shown in FIG. 3, syntax tree 134 includes a create / delete interface 302 for each level and a handle interface 304 for each level. In the described embodiment, the TCP syntax tree 134 does not include specific definitions for update or output interfaces. The update interface for this TCP is used in the form of assignments (naming), the left parts of which are calls to macro commands to access the interface, for example:
TR_TYPE (t) = p;
This snippet updates the TYPE attribute in node t of the syntax tree. The output interface for the syntax tree is used only for debugging and is not embedded in most versions of the translator in order to avoid increasing the size of the executable code. Other TCPs, of course, may include some or all of the interfaces for creating / deleting, accessing, updating, and output, each of these interfaces including interface routines for each of the many levels of the TCP.

 As shown in FIG. 3, a create / delete interface exists for each of the following levels: representation level 310, definition level 312, and conceptual level 314. In the described embodiment, the create / delete interfaces for definition level 312 and conceptual level 314 are substantially identical. Similarly, a “call” interface exists for each of the following levels: representation level 320, definition level 322, and conceptual level 324. Note that in the described embodiment, call interfaces for both definition level 312 and conceptual level 314 are available for software, external to the TCP 134. If necessary, some individual definition level subroutines can be made inaccessible from the outside by defining them as static (STATIC).

 The create / delete interface for a conceptual layer may include some generalized operations that create or delete an abstract object as a whole. For this example, such operations are not necessary, since there is only one syntax tree that is created implicitly, as a result of some definitions, and which is also deleted implicitly. If there were several such trees, it would be necessary to define operations at the level of abstract concepts for their creation / deletion. Such operations are often defined by the concepts of "building / destruction".

 The create / delete interface for the definition level includes many definitions used to create and delete nodes in the syntax tree. There is a substantially unlimited number of definitions that can be included in the definition level, making it virtually impossible to discuss all of them. Some examples are given below.

 For example, the "tree_asgn" procedure in TCP 134 creates a syntax tree node that contains information about the "assignment" operators (for example, a node to represent the sub-tree "V: = E"). The tree_asgn procedure introduces many parameters, creates a new tree node (by accessing the "create" level "view" procedure) and remembers the parameters in the newly created node. In a preferred embodiment, the various nodes of the syntax tree have different structures. Thus, each kind of node that can be contained in the syntax tree is created and assigned a value using one of the many routines for creating nodes within the definition level of the create / delete interface for TCP 134.

 The create / delete interface for the PTS 134 presentation level includes a subroutine for creating the node of the required structure and returning the pointer to the newly created node. As discussed above, this routine is called through the create / delete interface of the definition level. In this example, the view-level routine used for deletes is missing. The tr_free () routine frees tree memory for the entire tree, so that it can be considered as an example of a specific delete interface for the conceptual level.

 Thus, the TCP creation / deletion interface 134 contains a plurality of levels of abstract constructs, which include a highlighted specific representation, a presentation level, a definition level, and a conceptual level. The create / delete interface for TCP 134 consists of a conceptual layer and part of a definition layer. The specific presentation and level of representations are hidden from the computer system programmer.

 The “access” interface for the conceptual level for TCP 134 includes an iterator function that provides access to list items in a tree node. This is the only conceptual interface in this example. Access to tree nodes and their attributes is performed through access operations at the definition level.

 The lookup interface for the definition level includes many definitions (for example, macro definitions) used to access the syntax tree. Essentially there is an unlimited number of definitions that can be included in the level of definitions and therefore it is almost impossible to discuss all of them. Some examples are given below.

The access interface for the definition level may contain, for example, the following macro definitions in the SI programming language:
# define TR_А5С_ЬН5 (1) / * left part of the destination node * / \
((t) -> tree_ele.t_asg_node. lhs_var)
# define TR_VAR_ID (^^ variable identifier * / \
((t) -> tree_ele.t_var_node.cptr)
Using these TCP definitions 134, software tools can access the identifier (for example, "V") of the left side of the syntax tree destination node (for example, V = E) simply by using certain interfaces TR_ASG_LHS and TR_VAR_ID, which are defined at the level of definitions of TCP syntax 134 tree as follows:
TR_VAR_ID (TR_ASG_LHS (T))
The structure of the syntax tree and pointer references are hidden due to TCP 134.

In another example, the interface for defining the definition level for the TCP corresponding to the table of the list of names (in the TCP for the table of the list of names) may contain the following macro definitions in the SI programming language:
# define NL_CLOBAL (pr) / * check if the variable is global * / \
((((np) -> extra_flags) & NGLOBAL)! = 0)
define NL_ STATIC (np) / * check if the variable is static * / \
(((((np) -> extra_flags) & NSTATIC)! = 0)
Using these TCP definitions for the name list table (character encoding table), the software can check the status of the variables in the name list table to determine their status simply using the defined NL_GLOBAL and NL_STATIC interfaces as follows:
if (NL_GLOBAL (np) alpha NL_STATIC (np))
Pointer references and bitwise logical operations AND are hidden in the TCP for the table of the list of names.

 Presentation level access routines for TCP 134 include, for example, a routine (tr_alloc (n)) for allocating a tree node of n bytes.

 Thus, the TCP interface 134 contains a plurality of levels of abstract constructions, which include a highlighted concrete representation, a level of representations, a level of definitions, and a conceptual level. The public access interface to the TCP 134 consists of a conceptual layer and part of a definition layer. The specific presentation and level of representations are hidden to the computer system programmer.

 In conclusion, it can be noted that using the present invention, software can be structured according to a strict order, which provides readability, reliability and ease of maintenance of software. When using the present invention, fragments accompanied by high risk, using pointers, labels, indirect addressing, etc., are recorded only once in the corresponding TCP at the definition level. Each type of TCP interface (for example, interfaces for creating / deleting, accessing, updating, and output) contains many levels of abstract constructions, which include a highlighted concrete representation, a level of representations, a level of definitions, and a conceptual level. Each interface for a TCP consists of a conceptual layer and possibly a part of a definition layer. The specific presentation and presentation level are hidden to the programmer.

 Other embodiments of the present invention may be apparent to a person skilled in the art from the description of the invention. For example, other embodiments of the invention may use other names of the levels and interfaces described herein.

 It should be clear to a person skilled in the art that the technology using the TCP characterizes the methodology and principles of structuring when compiling programs for software tools. Thus, this technology using PTS ensures the achievement of the best results if the corresponding levels and interfaces are scrupulously defined and supported. It should be borne in mind, however, that the partial use of TCP technology will also provide advantages in terms of readability and ease of maintenance, although not to the same extent as with strict observance of the rules for the use of TCP technology. Thus, the use of TCP is not a factor that should be used either completely or not at all. It is possible to compile programs for computer systems in which the TCP technology will be used only in some parts, and in others it will be absent.

 It should also be borne in mind that the description and the given embodiments do not impose any restrictions and should be considered as possible examples, while the actual scope of the invention should be determined by the claims.

Claims (11)

 1. A method of converting an input code of a translator into object code based on structuring a computer program and performing operations by a data processing system containing a memory, characterized in that it includes forming a technology tool package (TCP) that corresponds to a data structure in memory selected from the group, consisting of a data structure of an identifier table, a data structure of a table of a list of names, a data structure of a syntax tree, and a data structure characterizing a conventional grammar of a language and programming, forming at least one interface for the data structure in the TCP, the interface being selected from the group consisting of the create / delete interface, the access interface, the update interface, and the output interface, forming at least one interface of a plurality of levels of abstract constructions, which includes a presentation layer that contains an interface for a data structure, a definition layer that includes an interface for a presentation layer, and a conceptual layer that includes an interface for a layer definitions, at least the data structure and the level of representations of the interface do not have access besides the TCP, and the conceptual level of the interface has access besides the TCP, and operations on the data structure through the conceptual level of the interface, which, in turn, provides access to the level of representations that provide in turn, access to the data structure.  2. The method according to claim 1, characterized in that the programming language Pascal is selected as the programming language.  3. The method according to claim 1, characterized in that it further includes forming a second TCP that corresponds to a second data structure selected from the group consisting of a data structure of an identifier table, a data structure of a name list table, a data structure of a syntax tree, and a data structure representing the usual grammar of a programming language, the formation of at least one interface for the second data structure, the interface being selected from the group consisting of an create / delete interface, an interface generally an update interface and an output interface for the second data structure and forming, in at least one interface for the second data structure, a plurality of levels of abstract constructions, which includes a second presentation layer containing an interface for the second data structure, a second definition level containing an interface for the second a presentation layer, and a second conceptual layer comprising an interface for a second definition layer, wherein at least a second data structure and a second presentation layer s do not have access in addition to the second TCP, and the second level has an access conceptual apart second TCP.  4. The method according to claim 1, characterized in that performing operations on the data structure includes performing operations on the data structure through the conceptual level of the interface, which, in turn, provides access to the definition interface, which, in turn, provides access to the level views, which in turn provides access to the data structure.  5. The method according to claim 1, characterized in that the interface level N + 1 can only be accessed from the interface level N.  6. A method for structuring a computer program based on the operation of a data processing system containing a memory, characterized in that it includes forming a TCP that corresponds to the data structure in the memory used in the computer program, forming at least one interface in the TCP for the data structure, moreover, the interface is selected from the group consisting of the create / delete interface, access interface, update interface and output interface, the formation of at least one interface a family of levels of abstract constructions, which includes a presentation layer containing an interface for the data structure, a definition layer containing an interface for the presentation layer, and a conceptual layer containing an interface for the definition layer, at least the data structures and the presentation layer of the interface do not have access PTS, and the conceptual level of the interface has access besides the PTS and performing operations on the data structure through the conceptual level of the interface, which, in its turn, The editor provides access to the level of representations, which, in turn, provides access to the data structure.  7. A device for converting the input code of the translator into object code based on the structuring of a computer program, comprising a memory for storing at least one data structure used by the computer program, the data structure being selected from the group consisting of the data structure of the identifier table, data structure tables of the list of names, data structures of the syntax tree and data structure representing the usual grammar of a programming language and a block of operations, stored with memory and designed to perform operations on data structures, characterized in that it contains a package of technological tools (TCP), which corresponds to the stored data structure and contains a TCP interface block providing at least one interface for the data structure selected from the group consisting of from the create / delete interface, the access interface, the update interface and the output interface, while the TCP interface unit is structured in accordance with many abstract levels, including the presentation level, the definition level, and the conceptual level, the mentioned levels correspond to the interface for the data structure, the interface for the presentation level and the interface for the definition level, at least the data structure and the presentation level do not have access besides the TCP, and the conceptual interface level has access besides PTS, an operation execution unit for performing operations on a data structure has the ability to access the conceptual level of the interface, which, in turn, is designed to I have access to the presentation layer, which ensures, in turn, access to the data structure.  8. The device according to claim 7, characterized in that the programming language Pascal is selected as the programming language.  9. The device according to claim 7, characterized in that it further comprises a second data structure stored in memory and selected from the group consisting of the data structure of the identifier table, the data structure of the name list table, the data structure of the syntax tree and the data structure representing a regular grammar a programming language, a second TCP that corresponds to a second data structure, an interface unit in a second TCP designed to provide at least one interface for a second data structure, wherein the interface is selected from the group consisting of the create / delete interface, access interface, update interface, and output interface, a plurality of levels of abstract constructions in the interface unit of the second TCP, including a presentation layer containing an interface for the data structure, a definition layer containing an interface for the presentation layer, and a conceptual level containing an interface for the level of definitions, at least the data structure and level of representations do not have external access besides the TCP, and the concept The level level has access besides the TCP, while the execution block includes a block for executing at least one computer program instruction to perform operations on the second data structure through the conceptual level of the second TCP interface, which, in turn, is designed to provide access to the second level of representations A TCP, which in turn provides access to a second data structure.  10. The device according to claim 7, characterized in that the operations unit further comprises a unit designed to perform operations on the data structure through the conceptual level of the interface, which, in turn, is designed to provide access to the definition interface, which, in turn, , is intended to provide access to the level of representations, which, in turn, provides access to the data structure.  11. The device according to p. 7, characterized in that the interface level N + 1 has access only through the interface level N.

Images