KR20010064236A - A detecting method of use error for process class definition in object-oriented CHILL - Google Patents

Abstract

PURPOSE: A method for detecting an error with respect to a process class definition using of an objected-oriented CHILL is provided to detect an attribute clearing error of an abstraction/completion process object, a result mode clearing error of an element procedure having an internal visualization and a transient clearing error in a static compile time for preventing an access error of an object constituting element which may be generated at an execution of an objected-oriented program in a single succession of a process class. CONSTITUTION: It is decided whether an inputted process class entry has an abstraction attribute(S201). An abstraction/completion attribute error is detected at a static time in a compile processing time by perceiving information with respect to a completion attribute of an abstraction process class entry and an existing or not of the upper class and an upper/lower class relation, an existing or not of a result mode with respect to a clearing of an element procedure having an internal visualization, a condition_collection of a signal and a transient clearing or not. An abstraction/completion attribute error is detected at a static time in a compile processing time by perceiving information with respect to a completion attribute of a node process class entry and an existing or not of the upper class and upper/lower class relation, an existing or not of a result mode with respect to a clearing of an element procedure having an internal visualization, a condition_collection of a signal and a transient clearing or not.

Description

A detecting method of use error for process class definition in object-oriented CHILL}

The present invention provides an abstraction of the process class itself in order to form a hierarchy of process classes in the analyzer of static data words of the object-oriented fill compiler and to prevent access errors of the object elements when creating process objects. Error detection method of state_set / transition based on termination attribute and signals used for asynchronous communication. Specifically, it is given to process class when defining process class for process class hierarchy under single inheritance of object-oriented fill language. This method relates to a method for detecting an error in which an incorrectly specified (error) of an abstract / end attribute and an element procedure of internal visibility are incorrectly specified in a state_set / transition.

Currently, the object-oriented Chill language, recommended by the Telecommunication part of International Telecommunication Union (ITU-T) as a standardized programming language for telecommunications implementation, is modular, parallel, distributed, real-time, strong type checking. It has object-orientation, genericity and overloading functions in addition to existing fill functions such as strongly type checking and decompilation.

The International Telecommunication Union-Telecommunications Department (ITU-T) is easy to expand when building new communication software systems, improves the reusability and modularity of existing programs, and allows users to easily program them. Linguistic syntax and functions have been introduced into the object-oriented fill language and standardized.

In general, exchanges require reliability for software execution by parallel object-oriented programming. Therefore, many data attributes are required when defining various types of data including objects in order to perform strong type checking for reliability of parallel object-oriented program execution.

However, other existing object-oriented programming languages tend to weakly define static class properties and type checking to improve execution performance, which leads to easy object-oriented programming but has an important problem that causes execution errors in object-oriented programs. .

In order to solve the above problems, the present invention provides a property specification error and an internal visibility error of an abstract / termination process object in order to prevent an access error of an object constituent element that may occur when executing an object-oriented program under a single inheritance of a process class. Its purpose is to provide a method for detecting the result mode specification error and the state_set and transition specification error of an element procedure with static at compile time.

1 is a configuration diagram of an embodiment of a hardware system to which the present invention is applied.

2 is a flow chart of a method for detecting a programming error of a user when defining a process class of an object-oriented fill in accordance with an embodiment of the present invention.

3 is an exemplary diagram of a "stack" process class definition statement specified as an object-oriented fill.

Explanation of symbols on the main parts of the drawings

101: main memory board 102: central processing unit

103: Unix operating system 104: auxiliary storage

105: input / output device 106: system bus

In order to achieve the above object, the present invention provides a method for checking at compile time whether a user correctly uses a process object model of an object oriented fill language, the first method of determining whether an input process class entry has an abstract attribute. process; Compiles the information about the exit attribute of the input abstract process class entry, the existence of the parent class and the parent / child class relationship, the result mode for specifying the element procedure of internal visibility, and the state_set and transition for the signal. A second step of detecting abstract / end attribute errors at a static time at execution time; And information about the exit attribute of the input node process class entry, whether there is a parent class and parent / child class relationship, whether there is a result mode for specifying element procedure of internal visibility, and whether state_set and transition for signal are specified. And a third step of detecting an abstract / end attribute error at a static time at compile time.

Hereinafter, exemplary embodiments of the present invention will be described in detail with reference to the accompanying drawings.

1 is a configuration diagram of a hardware system to which the present invention is applied, wherein a main memory board 101, a central processing unit 102, a Unix operating system 103, an auxiliary storage device 104, and an input / output device 105 are provided. It is configured to be connected via a system bus 106.

Looking at the function of each block shown, the main memory board 101 is a board on which the object-oriented Chill compiler is mounted, the central processing board 102 is a board for executing the compiler mounted on the main memory board (101). The input / output device 105 is a device that receives an object-oriented fill program as an input and shows a result of the execution. The UNIX operating system 103 controls the boards and devices, and messages sent and received between each board and device are transmitted through the system bus 106.

On the other hand, in the conventional parallel object execution model, a thread dependency occurs between parallel objects by driving parallel threads in an element procedure centered on a class / object, so that a master parallel object terminates its slave. This implies the inefficiency of execution, which must wait until all concurrent objects are terminated. Although the use of parallel objects is limited to the heap area (Java language) to avoid this to some extent, it has a garbage collection function of orphan parallel objects, which violate some of the real-time constraints by performing them at specific times. Had the result. Therefore, by introducing a process object model that does not have thread dependencies at all in object-oriented painting and establishing a system, it can be a programming language for communication implementation suitable for a real-time embedded communication system.

An example of a "stack" process class definition statement specified as an object-oriented fill is shown in FIG. 3 to facilitate understanding of the present invention.

The example of FIG. 3 is a process class definition statement that performs a stacking operation, but is separated into a specification part and a body part like a moreta mode. The process object model, like traditional parallel object-oriented programming languages, inherits not only properties and methods, but can also inherit the internal state of the process (which indicates the current available state of the communication protocol that can conditionally accept external signals). And unlike task classes, process classes have sequential objects in thread-driven procedures, so newly created process objects have no thread dependencies with other parallel objects.

This process class definition method is a very important function to object-oriented and componentize the S / W structure of a communication system, and the compiler needs to accurately determine its definition error.

2 is a flow chart of examining class definition statements to determine errors in the use of process class definitions in object-oriented painting.

First, it is determined whether the input process class definition entry has an abstract attribute (S201). This is because the programmer may or may not specify an abstract attribute when defining a new process class.

As a result of the determination in step S201, if the input process class has an abstract attribute, as a verification operation, it is determined whether a component inside the process class itself according to the abstract attribute specification has at least one incomplete procedure of internal visibility ( S202). This is because at least one has an abstract property. If it does not have an incomplete element procedure having at least one internal visibility, it violates the definition rule of the abstract process class and outputs the corresponding error (S11).

However, as a result of the determination in step S202, if there is more than one, it is determined whether the abstract process class has a termination attribute (S203). As a result, if it has a termination attribute, the abstract process class can no longer be extended and a node subclass cannot be generated, thus violating the abstract concept and outputting the corresponding error and terminating (S211).

If the process class inputted as a result of the determination in step S201 does not have an abstract attribute, the verification operation determines whether an element inside the process class itself according to the node attribute has at least one incomplete procedure of internal visibility ( S204). This is because having at least one violates node attributes. If there is an incomplete element procedure having at least one internal visibility, it violates the definition rule of the node process class and outputs the corresponding error and terminates (S211).

If the determination result in step S204 does not have any non-nuclear element procedures, it is determined whether the node process class has the termination attribute (S205). If it is determined that the node process class has an exit attribute, the node process class can no longer be extended, and it is determined whether the parent class of the node process class has an exit attribute (S206). If so, the current node class cannot be generated, and thus the corresponding error is output and terminated (S211).

As a result of the determination in steps S203 and 205, if the abstract / node process class does not have a termination attribute, it is determined whether the corresponding process class has an upper class name (S207). As a result, if it has a parent class name, it is determined whether the name is a process class name (S208), and if it is not a process class name, it violates the principle of process class inheritance (allowing homogeneous inheritance under single inheritance only) and outputs an error message. It ends (S211).

As a result of the determination in step S207, the corresponding process class does not have an upper name, or, as a result of the determination in the step S208, the upper name is a process class name, or in step S206, the higher class of the node process class has an end attribute. If not, it is determined whether the element procedure having the internal visibility has the result mode (S209). Because an element procedure with internal visibility causes an element procedure call upon receipt of a signal from the process, it should not have a result mode like a signal.

As a result of the determination in step S209, if there is a result mode, the corresponding error message is output and terminated (S211), otherwise, the process class receives the available state_sets and state variations for the signals to be received. It is determined whether there is the transition information indicated (S210). This is because, unlike task mode, a process class must have an available state and a state transition operation inside a process that can transmit a message and receive a signal through a signal communication, not a message through a method call. If it is determined that there is no state_set and transition, it violates the principle of process class definition. Therefore, the corresponding error message is output and terminated (S211). If the state_set and transition information representing state change are both present, all process class definition rules are satisfied. It will end normally.

As described above, the present invention provides a state_set / transition specification error for an abstract / termination attribute and a signal in order to prevent an access error of an object component that may occur when executing a parallel object-oriented program under a single inheritance of a process class. By detecting at static compile time to improve the accuracy and flexibility of running parallel object-oriented programs, you can detect usage errors according to explicit rules about the modularity and inheritance of process objects.

The technical spirit of the present invention has been described above with reference to the accompanying drawings, but this is by way of example only and not intended to limit the present invention. In addition, it is obvious that any person skilled in the art can make various modifications and imitations without departing from the scope of the technical idea of the present invention.

Claims (4)

In the error detection method for using the process class definition of object-oriented fill, A first step of determining whether an input process class entry has an abstract attribute; Compiles the information about the exit attribute of the input abstract process class entry, the existence of the parent class and the parent / child class relationship, the result mode for specifying the element procedure of internal visibility, and the state_set and transition for the signal. A second step of detecting abstract / end attribute errors at a static time at execution time; And Compiles the information about the exit attribute of the input node process class entry, whether there is a parent class, the parent / child class relationship, the result mode for specifying the element procedure of internal visibility, and the state_set and transition for the signal. And a third step of detecting an abstract / termination attribute error at a static time at execution time. The method of claim 1, The second process, Detecting whether an element within a process class itself according to the abstract attribute specification has at least one incomplete procedure of internal visibility; A second step of outputting a corresponding error message if the at least one incomplete element procedure is not found and ending if the at least one incomplete element procedure is detected, and determining whether the abstract process class has a termination attribute; A third step of outputting a corresponding error message and ending if it has a termination property as a result of the determination of the second step, otherwise determining whether the abstract process class has a higher class name; A fourth step of determining whether the upper name is a process class when the upper class name is determined as the determination result of the third step; A fifth step of determining whether an element procedure having internal visibility of the constituent elements has a result mode if the upper name is not a process class and outputs an error message if the upper name is not a process class; And And as a result of the determination of the fifth step, outputting the corresponding error message when the result mode is finished and ending; if not having the result mode, determining a state_set and a transition; Error detection method for using process class definitions. The method according to claim 1 or 2, The third process, A first step of determining whether a component inside a node process class itself that does not specify an abstract attribute has at least one incomplete procedure of internal visibility; A second step of determining whether the node process class has a termination attribute if it has at least one incomplete element procedure as a result of the determination of the first step, outputting a corresponding error message and ending; A third step of determining whether a higher class of the node process class has an end attribute if it is determined that the second step has a termination attribute; A fourth step of outputting a corresponding error message if the higher class of the node process class has a termination property as a result of the determination in the third step; A fifth step of determining whether the node process class has a higher name if the node process class does not have a termination attribute as a result of the determination of the second step; A sixth step of determining whether the upper name is a process class if the upper class name is determined as the determination result of the fifth step; A seventh step of outputting a corresponding error message if the upper name is not a process class as a result of the determination of the sixth step; When the parent class of the node process class does not have an exit attribute as a result of the determination in the third step, the node process class does not have a parent name, or the parent name of the node process class is the process class as a result of the determination in the fifth step An eighth step of determining whether the element procedure with the internal visibility of has the result mode; A ninth step of outputting a corresponding error message if the result mode has a result mode and ending if it has a result mode, and determining whether there is a state_set and a transition if the result mode has no result mode; And As a result of the determination in the ninth step, if the state_set and the transition do not have a corresponding error message is outputted and ends, and if the state_set and the transition both have a tenth step of terminating normally; Error detection method for using process class definitions. A computer-readable recording medium having recorded thereon a program that provides an error detection method for using a process class definition of an object-oriented fill, comprising: A first step of determining whether an input process class entry has an abstract attribute; Compiles the information about the exit attribute of the input abstract process class entry, the existence of the parent class and the parent / child class relationship, the result mode for specifying the element procedure of internal visibility, and the state_set and transition for the signal. A second step of detecting abstract / end attribute errors at a static time at execution time; And Compiles information about the exit attribute of the input node process class entry and whether there is a parent class and parent / child class relationship, the result mode for specifying element procedure of internal visibility, and whether state_set and transition for signal are specified. A computer-readable recording medium having recorded thereon an executable program including a third step of detecting an abstract / termination attribute error at a static time at execution time.