KR20020033930A - Method for generation of system software interface in man-machine interface module for communication system - Google Patents

Abstract

PURPOSE: A system software interface generation method is provided to construct rules on an interface for a system software in relation with TL1(Transaction Language 1) instructions, to analyze the rules with a syntax analyzer, and to automatically generate interface function codes. CONSTITUTION: The method comprises steps of enabling an MML(Man Machine Language) tool to read a script file and perform a syntax analysis on the script file(ST31-ST33), enabling the MML tool to generate a database, rule check functions and interface functions according to the syntax analysis(ST34), enabling an MMI(Man Machine Interface) core module to read characters input by an operator and to perform the syntax analysis on the input characters(ST21-ST23), calling the rule check functions according to the syntax analysis on the input characters and performing the rule check(ST24), and calling the interface function according to the instructions generated by the rule check function, and enabling each interface function to call corresponding system software(ST25-ST26).

Description

{Method for generation of system software interface in man-machine interface module for communication system}

The present invention relates to a MMI (Man-Machine Interface) of a transmission system or communication system, and in particular, when using TL1 (Transaction Language 1) as a MML (Man-Machine Language), the system software associated with each TL1 instruction. An interface is required, which creates an interface to the system software in an MMI module that is adapted to automatically generate code for the interface functions after constructing the rules for the interface in its own scripting language, interpreting it using a parser. It is about a method.

In general, when configuring MMI of a transmission system, a module for parsing an MML instruction input by an operator exists, and a system software function capable of performing an actual operation related to an instruction in a system exists.

The main features of this MMI parsing module are:

The lexical analyzer is for separating the grammatical minimum units in the input string, and the syntax analyzer is responsible for analyzing components according to the MML grammar in the input string.

The semantic analyzer is designed to analyze whether a component has the appropriate values according to the MML instruction definition of the device. The function dispatcher calls the corresponding function of the system software when it is determined that the command is appropriate. It is for.

On the other hand, when the system software function is parsed by each of the modules, it is to perform a certain function required by the command of the syntax. In this case, the software module may perform a function necessary for processing an instruction, and there are functions that are sufficient to meet the requirements of the system.

The present invention relates to the generation of an interface of the system software, which will be described below.

First, FIG. 1 is a block diagram of a module for a conventional MMI task, and FIG. 2 is a flowchart of an MMI task according to the prior art.

As shown in FIG. 1, in the prior art, the MMI module not only has all functions of generating tokens, checking grammars, and calling functions of system software, but also has dependencies inevitable by addition of instructions and modification of rules. It was a module.

The MMI module determines the type of command input through parsing and compares the command with system software functions.

In other words, the tokens generated through the parsing of the command are checked to be properly located and constructed in the MML grammar, and the values of each component can be known by going through the above process. Each component is then checked for valid and appropriate values, as in the previous steps, based on the definition of the MML rules in the device defined by the developer.

After the input command is confirmed that there is no error, a function dispatch operation is performed to call a system software function to execute the command. At this time, the interface between the MMI module and the system software should be specified in advance in the MMI code.

A process in which the MML command input by the operator in the transmission system is transferred to a function of the system software will be described with reference to FIG.

First, the character string input by the operator is read through the MML input module, and the MMI module separates the minimum units of grammar that have meaning in the MML command by using a lexical analyzer (ST11 to ST12).

When parsing separation of input commands is performed, a grammar check on the separated syntax is performed to confirm whether the proper system is formed and the meaning of each syntax according to the corresponding system is analyzed (ST13). ).

The command is interpreted through the grammar test, where a single command includes a series of commands for fulfilling the request of the command.

When the syntax of each command necessary for the execution of the command is confirmed through parsing, the corresponding command is compared with the type of system software (ST14). Thus, when a function of the system software required for the execution of the command is allocated, the MMI module calls the corresponding system software function (ST15 to ST16).

By calling a system software function, a function necessary for processing the parsed instruction is operated, and the processing of the instruction required by the operation of the function is performed.

As described above, in the operation of the MMI module, after parsing a command input by an operator is performed, a call of a system software function necessary for the execution of the command is made, and the interface between the MMI module and the system software is previously designated. It is done.

However, in the prior art described above, the MMI module is very dependent on the MML instruction set and the rule definition of each instruction. Therefore, when the definition of the instruction is to be modified, the code of the MMI module must be modified and the interface between the MMI module and the system software must be modified.

The modification of the interface of the system software and the modification of the MMI module code may be an error, and may cause a decrease in the efficiency of system operation. In other words, when the system operation environment is changed due to the low compatibility of the code, the conventional code cannot be used as it is, and there is a inconvenience that requires time and effort required to create a new module.

This drawback of the prior art may be overcome by making the system software's interface and MMI module code independent of the MML instruction set and its rule definitions.

Accordingly, the present invention has been proposed to solve the conventional problems as described above, and an object of the present invention is to use a Man-Machine Language (MML) module in TL1 (Transaction Language 1). In case of use, interface with the system software related to each TL1 command is required.The rules for the interface are composed in a script language that defines its own, analyzed using a parser, and automatically generates the code of the interface function. One MMI module provides a way to create an interface to system software.

In order to achieve the above object, the interface generation method for the system software in the MMI module according to the present invention includes a definition rule required for processing each command presented in the script file by reading a script file written in a specific system by a specific module. And a database comprising a function; MMI module reads the operator's input string to perform parsing; Performing a grammar test by calling a grammar test function stored in the database according to a result of parsing the input string; According to the command interpreted by the grammar test function, the interface function stored in the database is called, and each interface function performs a step of calling the corresponding system software.

1 is a block diagram of a conventional MMI module,

2 is an operation flowchart of an MMI module according to the prior art,

3 is a flowchart of a method for generating an interface for system software in an MMI module according to an embodiment of the present invention;

4 is a block diagram of an MMI module applied to FIG. 3.

Hereinafter, the configuration and operation of the present invention will be described based on an embodiment according to the spirit of the method for generating an interface to system software in the MMI module as described above.

First, FIG. 3 is a flowchart of a method for generating an interface for system software in an MMI module according to an embodiment of the present invention, and FIG. 4 is a block diagram of an MMI module applied to FIG.

As shown in FIG. 3, a preferred embodiment of the present invention includes the steps of MMLTOOL reading a script file to perform parsing (ST31 to ST33); Generating a database, a gram check function and an interface function according to the parsing result (ST34); MMI core module reads the operator's input string to perform parsing (ST21 ~ ST23); Performing a grammar check by calling a grammar check function generated by the MMLTOOL according to a result of parsing the input string (ST24); When the interface function generated by the MMLTOOL is called according to the command interpreted by the grammar test function, each interface function includes a step of calling the corresponding system software (ST25 to ST26).

The operation of the method configured as described above is as follows.

The method proposed by the present invention removes the contents dependent on the interface definition, MML (Man-Machine Language) code, and the like when configuring the MMI module. In other words, it separates the rule definition part depending on the system command definition from the MMI core module that can be used in common regardless of the system, and configures and processes it.

The implementation of such a function can be achieved by creating a script file described separately using a scripting language that defines rules for each command in the configuration of the MMI module. When the script file is generated, the contents of the file are read by using a certain means, and then source code for constituting a part of the MMI module having a characteristic dependent on the command is generated.

In other words, an interface for connecting an MML instruction input by an operator when configuring an MMI module of a transmission system and a system software function for processing the instruction in the system is required, even when the instruction set in the development process is changed or added. The interface is automatically changed to suit the execution of the commands presented in the script file.

As shown in Figure 4, the module in charge of the function of generating the source code by reading the script file is MMLTOOL.

At this time, as in the prior art, there is also an MMI core module that can be commonly used for parsing MML instruction strings that are not related to the characteristics of individual instructions.

Thus, in the MMI module, variable content can be removed during development, such as the instruction set and the regularity and interface definition of each instruction in the set. These contents can be written in a script file using a script language defined by itself. do.

Therefore, in the present invention, each MMI module mainly performs only functions of a lexical analyzer and a syntax analyzer of an input string.

A module called MMLTOOL is used to interpret the content described in the scripting language and generate code to perform related functions. The composition of MMLTOOL is as follows.

First of all, the lexical analyzer is responsible for separating the script file characters into tokens, which are the minimum units for the script language grammar system, and the syntax analyzer receives the tokens and takes the script language grammar. It is responsible for separating the components accordingly.

In addition, the Semantic Analyzer is responsible for analyzing the values of the components and interpreting their meanings. The Intermediate Code Generator can store and process the contents described in the scripting language as a database. It is responsible for generating source code of functions.

In addition, the Interface Generator is responsible for finding the contents related to the interface from the contents of the script file and generating the source code to implement it. In the above description, the interface refers to an interface between the MMI module and system software, and is used in the following meaning.

When executing MMLTOOL composed of the above software modules or routines, the contents related to MML grammar are generated as functions at the database and source code level. And the necessary interfaces between MMI and system software are created.

An association operation between the modules will be described in more detail with reference to FIG. 3.

First, the rules for commands and rules for the interface between system software are described in a file using a script language that defines its own. The file generated by the above scheme is called a script file.

The scripting language used in the present invention defines the grammar and the meaning so as to be suitable for describing the above contents. These script files contain a list of command sets and the interface rules between the MMI and the system software.These rules define the usage rules and parameters for each command, the range of values that can be entered as parameters, and the security level. And other optional descriptions.

For example, TL1 instruction-specific grammar rule definitions and interface definitions, which are transaction languages, may be described in a script file.

The MMLTOOL module, which takes a script file created as the system as an input, calls a lexer and a parser according to a script language grammar, and interprets the meaning of each command described in the script file. This command semantic interpretation process is called parsing.

Looking at the parsing step by MMLTOOL in more detail, the step of reading a script file (ST31); A lexical interpretation step (ST32) for separating the minimum semantic unit of each instruction described in the script file; Follows the flow of the step ST33 of performing a parse to analyze the grammatical relations between the lexical analyzed words.

Thus, when parsing is performed to produce a list of commands or a list of commands for a set of commands in a script file, MMLTOOL can parse pastries to meet grammatical requirements, such as the usage rules of each command, the definition of parameters, and the range of values available as parameters. Create a Pars Tree.

The prepared pastries and command lists are stored in a database, and source codes of grammar checking functions and interface functions that can access and interpret the stored data are also stored as files (ST34).

This scheme creates an interface between the MMI module and the system software described in the script file. In other words, after MMLTOOL is executed, the source code of grammar checking functions that can use the database and the database storing the grammar and interface for each command is generated, and the interface code between the system software and the MMI module.

When the database and source code are constructed by the script file, a series of operations may be performed in which the MMI module calls an appropriate system software function according to the input MML command string.

This operation flow is similar to the prior art, and the MMI module parses an input string to create a pastry (ST21 to ST23).

Subsequently, the grammar of the written past is examined, and there is a difference between the present invention and the prior art. That is, in the present invention, a grammar checking function that will perform grammar checking on the pastry is generated by MMLTOOL (ST24).

When the grammar check is done, the MMI module will call system software functions appropriate to the processing required by that instruction. At this time, the system software function is called through the interface function.

In other words, if there is a command whose syntax and validity are verified as a result of the grammar check, the MMI module calls an interface function necessary for processing the command (ST25). At this time, the interface function is for the interface between the MMI module and the system software, and means the interface function created by MMLTOOL and stored in the database.

The interface function called by the MMI module calls the corresponding system software function (ST26).

As described above, the present invention describes a part of an MMI module having a command-dependent nature in a script file, and then analyzes the script file using MMLTOOL and writes source code. Will be able to separate.

Although the preferred embodiment of the present invention has been described above, the present invention may use various changes, modifications, and equivalents. It is clear that the present invention can be applied in the same manner by appropriately modifying the above embodiments. Accordingly, the above description does not limit the scope of the invention as defined by the limitations of the following claims.

As described above, in the MMI module according to the present invention, an interface generation method for system software separates an MMI module that is not related to the command and can be used in common by describing rules for each command in a script file defined by itself. There is an advantage.

The present invention enables the separation between the MMI core module and the command, MMI module and system software functions, and MMI-related modules that connect the commands and functions even when the instruction set is changed / added during the development process of the MMI module The effect is to make their modifications unnecessary. This will lead to an increase in the compatibility of the MMI module being developed.

In addition, by reprocessing the script file into source code that can be used in the MMI core module by using MMLTOOL, the source code of the interface functions with the system software is automatically generated, thereby relatively changing the MMI core module requiring less modification. Apart from the likely rule of command, even if the MML instruction is changed during the development of the MMI module, it has the advantage of minimizing the change of the MMI module.

The method proposed by the present invention is applicable to an element management system (EMS) and a graphical user interface (GUI) using all equipment and interface functions using an MMI module.

Claims (3)

A step in which a specific module reads a script file written in a predetermined system and constructs a database including definition rules and functions required for processing each command presented in the script file; MMI module reads the operator's input string to perform parsing; Performing a grammar test by calling a grammar test function stored in the database according to a result of parsing the input string; A system in a transmission system M module comprising a step of calling an interface function stored in the database according to a command interpreted by the grammar test function, and each interface function calling a corresponding system software. How to create an interface to the software. The method of claim 1, wherein the script file, In the configuration of the MMI module, it is generated by describing the details of changes when the MMI module is applied to different systems, such as defining a system-specific command rule and defining an interface with the system software for executing the command. A method for generating an interface to system software in a transmission system MI module, characterized in that it is described according to a scripting language having a self-defined grammar system. The method of claim 1, wherein the building of the database by the specific module comprises: After reading the script file and parsing according to the definition rule, System software suitable for the processing of the parse tree and syntax items created by the parsing, a grammar check function for accessing the data and interpreting the semantics, and a grammar-checked command Write each interface function to call the function in a form that the MMI module can access. And generating each data or function in a database.