KR101422737B1 - Mixed language code simultaneous running device and method - Google Patents

Abstract

A multi-language code concurrent execution apparatus and method thereof are disclosed. An apparatus for concurrently executing a multi-language code for interpreting and executing a user-written code in which a plurality of programming languages are mixed includes an editor receiving the user-created code; A run-time execution unit for dividing the user-created code input by the editor into coding segments, converting the user-generated codes into an internal integrated syntax structure from a programming language grammar structure corresponding to the coding segment, and sequentially executing the user- And an execution auxiliary engine for assisting in function processing, variable processing or debugging necessary in the sequential execution process.

Description

[0001] The present invention relates to a device for simultaneously executing multiple language codes,

The present invention relates to an apparatus and a method for simultaneously executing a multi-language code.

Conventional programming software (IDE, integrated development environment) recognized only one programming language, and was able to process only the source code written in one programming language. As a result, many of the open codes that have been written in the past have been translated into the corresponding programming languages, or independently developed, resulting in poor code reusability, redundant development costs, and errors in the translation process.

In recent years, various operating systems such as Android OS, Mac OS, iOS have been used in addition to Windows, resulting in costly acquisition and translation of a new programming language required for program development on each operating system.

In addition, even in the case of researchers, there is a burden to learn a language in order to use various programming codes implemented by various researchers.

Korean Patent Laid-Open Publication No. 10-2006-0104505 discloses a comprehensive character string analyzer having an intermediate language conversion step of converting a first data file written in a certain programming language into a second data file written in a specific intermediate language, There is a limitation that the general-purpose code still written in one language is executed by other commercially available programming software.

Korean Patent Laid-Open No. 10-2006-0104505

The present invention can copy and use code implemented in another programming language in the past without any modification, so that it is possible to simultaneously execute a multi-language code in which a separate translation process or independent redevelopment is not required, thereby reducing development cost and increasing recyclability and safety Apparatus, and method.

An object of the present invention is to provide an apparatus and a method for simultaneously executing a multi-language code in which the same operation can be performed with a code written in a programming language on another operating system without having to acquire a separate programming language for each operating system, .

Since the present invention can take and copy codes of various programming languages utilized by researchers in the past, it is possible to reduce the burden on the researchers to learn various programming languages, thereby enhancing the concentration and efficiency of research, Method.

Other objects of the present invention will become readily apparent from the following description.

According to an aspect of the present invention, there is provided an apparatus for concurrently executing a multi-language code for interpreting and executing a user-written code in which a plurality of programming languages are mixed, the apparatus comprising: A run-time execution unit for dividing the user-created code input by the editor into coding segments, converting the user-generated codes into an internal integrated syntax structure from a programming language grammar structure corresponding to the coding segment, and sequentially executing the user- And an execution auxiliary engine for assisting in function processing, variable processing, or debugging, which are necessary in the sequential execution process, are provided.

Wherein the runtime execution unit comprises: a converter for dividing the user-generated code into a plurality of coding zones according to a programming language used for creating a syntax and converting the statements divided into coding zones into the internal integrated syntax structure; And a sequential executor for sequentially executing the transformation statements converted into the internal integrated syntax structure.

The runtime execution unit may further include a preprocessor for performing grammar checking based on a grammar of a programming language corresponding to the coding segment, the phrases classified by the coding segment.

The internal unified syntax structure may be a tree node structure as a node structure for a sequentially executable procedure.

The tree node structure converts the statements in an arbitrary coding section into a syntax tree on a row-by-row basis, and the child nodes of the syntax tree can have independent subtree-capable subtrees.

The sequential executor may sequentially execute instructions corresponding to nodes of the syntax tree and the subtree according to a tree node structure.

The runtime execution unit may further include an input / output unit for input / output with a user interface and an operating system device.

Wherein the execution auxiliary engine includes a built-in function including at least one of a mathematical function, a string function, a file function, and a time / date function, and a function for processing a user- A processing engine; A variable processing engine for converting and verifying a data type when storing and outputting a variable value defined by the user creation code; And a debugging engine that performs processing for an error that occurs during the sequential execution process.

According to another aspect of the present invention, there is provided a method for concurrently executing a multi-language code in a multi-language code concurrent execution apparatus for interpreting and executing a user-written code in which a plurality of programming languages are mixed and a recording medium on which a program for executing the same is recorded / RTI >

A method for simultaneously executing a multi-language code according to an embodiment includes: (a) receiving the user creation code through an editor; (b) dividing the user creation code input by the editor into coding segments; (c) converting from a programming language grammar structure corresponding to the coding segment into an internal integrated syntax structure; And (d) sequentially executing the transformation statements converted into the internal unified syntax structure. The internal unified syntax structure may be a tree node structure as a node structure for a sequentially executable procedure. The tree node structure converts the statements in an arbitrary coding section into a syntax tree on a row-by-row basis, and the child nodes of the syntax tree can have independent subtree-capable subtrees.

The method may further include, before the step (c), performing a grammar check based on a syntax of a programming language corresponding to the coding segment, the phrases classified by the coding segment.

The step (d) may sequentially execute the instruction words corresponding to the nodes of the syntax tree and the subtree according to the tree node structure.

The step (d) may be assisted with necessary function processing, variable processing, or debugging in the sequential execution process through the execution assistant engine.

Other aspects, features, and advantages will become apparent from the following drawings, claims, and detailed description of the invention.

According to the embodiment of the present invention, it is possible to copy and use codes implemented in other programming languages in the past without modification, so there is no need for a separate translation process or independent redevelopment, thereby reducing development cost, increasing recyclability and safety .

In addition, it is possible to perform the same operation with code written in a programming language on another operating system without having to acquire a separate programming language for each operating system, thereby reducing the redevelopment cost of heterogeneous operating systems.

In addition, since it is possible to copy and use codes of various programming languages utilized by researchers in the past, the burden of researchers acquiring programming languages is reduced, thereby enhancing concentration and efficiency of research.

1 is a block diagram of an apparatus for simultaneously executing a multi-language code according to an embodiment of the present invention;
2 is a diagram illustrating an example of a programming coding syntax written in a plurality of programming languages;
FIG. 3 is a diagram showing an internal integrated syntax structure and a Venn diagram showing the inclusion relation between various programming languages,
4 is a diagram illustrating an example of user-written code for conversion to an internal unified syntax structure,
FIG. 5 is a diagram showing a syntax tree of execution when the user creation code illustrated in FIG. 4 is converted into an internal integrated syntax structure;
FIG. 6 is a diagram illustrating an independent node structure for subtrees included in the basic tree of FIG. 5;
7 is a flowchart of a method for simultaneously executing multiple language codes according to an embodiment of the present invention;

BRIEF DESCRIPTION OF THE DRAWINGS The present invention is capable of various modifications and various embodiments, and specific embodiments are illustrated in the drawings and described in detail in the detailed description. It is to be understood, however, that the invention is not to be limited to the specific embodiments, but includes all modifications, equivalents, and alternatives falling within the spirit and scope of the invention. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS Hereinafter, the present invention will be described in detail with reference to the accompanying drawings.

The terms first, second, etc. may be used to describe various components, but the components should not be limited by the terms. The terms are used only for the purpose of distinguishing one component from another.

The terminology used in this application is used only to describe a specific embodiment and is not intended to limit the invention. The singular expressions include plural expressions unless the context clearly dictates otherwise. In the present application, the terms "comprises" or "having" and the like are used to specify that there is a feature, a number, a step, an operation, an element, a component or a combination thereof described in the specification, But do not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, or combinations thereof.

Also, the terms " part, "" ... "," engine ", and the like described in the specification mean units for processing at least one function or operation, and may be implemented by hardware or software or a combination of hardware and software .

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT Hereinafter, embodiments of the present invention will be described in detail with reference to the accompanying drawings. Referring to the accompanying drawings, the same or corresponding components are denoted by the same reference numerals, .

FIG. 1 is a block diagram of an apparatus for simultaneously executing a multi-language code according to an embodiment of the present invention. FIG. 2 is a diagram illustrating an example of a programming coding syntax written in a plurality of programming languages. And the programming language.

The apparatus for simultaneously executing a multi-language code according to an embodiment of the present invention may include a syntax using several programming languages (for example, Fortran, Basic, C, Lisp, etc.) And a user-defined function, a variable, and a class written in each programming language are mutually shared while being mutually shared and simultaneously executed. Thus, it is possible to recognize and execute the program independently of each programming language as written in one programming language.

Referring to FIG. 1, an apparatus for simultaneously executing a multi-language code according to an exemplary embodiment of the present invention includes an editor 100, a runtime executing unit 200, and an execution assistant engine 300.

The editor 100 is a code creation window capable of inputting and editing of a multilingual programming coding source to be simultaneously executed. For example, the user can directly type the source code on the editor 100 through a user input device such as a keyboard, a mouse, or the like, or copy or edit part or all of the already-implemented code.

The programming coding source input to the editor 100 in the present invention can be written in a plurality of programming languages. In this case, the programming coding syntax can be divided into one or more coding sections for each programming language.

Referring to FIG. 2, an example of a programming coding syntax written in a plurality of programming languages is shown. In FIG. 2, the programming coding syntax is divided into a first coding section A1 and a second coding section A2. The first coding section A1 is a Basic section of a programming language. The second coding section A2 is a second coding section Is illustrated as a compartment for Fortran among programming languages.

For the coding syntax described in the first coding section A1, the command and the sentence structure follow Basic, so that the grammar, internal variable processing, and the like are interpreted in the basic language format. For the coding syntax described in the second coding section A2, the instructions and the sentence structure conform to Fortran, so that the grammar, internal variable processing, and the like are interpreted in the Fortran language format.

In each of the coding sections A1 and A2, the instruction language and grammar structure in the corresponding coding section are created by the programming language and the programming language format to be used in the analysis process .

The syntax until the language definition command is declared is used, and the syntax until the declaration of the language definition command is defined as a single coding section. In the corresponding coding section, .

In FIG. 2, programming language types are described at the end of the Language command, such as 'Language Basic' and 'Language Fortran', so that the coding syntax is interpreted according to the rules of the programming language type in each coding section.

That is, although language is defined for each language by declaring a programming language type after the Language command, this is only an example, and the scope of the present invention is not limited to this, and it is possible to distinguish each compartment, It is needless to say that the present invention can be used as a language definition command for each segment if it is a command capable of recognizing the language.

In addition, when the program is coded without declaring a programming language type using the compartmentalized language definition command, it can be determined to follow the grammar of the language type set by the user or the device provider by default. Here, as the default language type, a system basic language such as Basic or the like may be used.

The multi-language code input to the editor 100 is divided into coding segments by the definition word for each segment, and the language-specific analysis problem can be easily solved by classifying the programming language type to be used for analysis in each coding segment .

Referring again to FIG. 1, the runtime execution unit 200 converts the multilingual code input to the editor 100 into an internal integrated syntax structure of the same type, and performs sequential execution and debugging.

The runtime execution unit 200 includes a converter 220, a sequential executor 230, and an input / output unit 240. And may further include a preprocessor 210 according to an embodiment.

The converter 220 separates the user-written code input into the editor 100 into coding segments, interprets them as a programming language type suitable for each coding segment, and performs syntax conversion so as to have an internal integrated syntax structure of the same type.

The user creation code input to the editor 100 is a multi-language code as illustrated in FIG. 2, and can not be interpreted by only one programming language grammar. Accordingly, the translator 220 needs to convert the command and grammar structure of the user-written code into a grammatical structure that can be recognized by the sequential executor 230 at the subsequent stage for each programming language type defined for each coding segment.

Prior to the syntax conversion in the converter 220, the preprocessor 210 disposed at the previous stage of the converter 220 checks whether the syntaxes in each coding section are syntactically defective for each programming language type defined for each coding division . In the present invention, the functions of the preprocessor 210 may be integrally implemented in the converter 220.

To this end, the runtime execution unit 200 may be provided with a separate memory (for example, a database or the like) for instructions and syntax structures for various programming language types that can be applied to the user- ) So that interpretation of the entire user-written code (including grammar checking if necessary) can be completed by varying the interpretation method of the instruction and grammar structure according to the programming language type defined for each coding section do.

For the syntax conversion processing in the converter 220, the runtime execution unit 200 implements all of the functional instruction words and data structures of various programming language types in an internal integrated syntax structure in advance, It can be processed beforehand.

Referring to FIG. 3, an internal integrated syntax structure and a relation between various programming languages are shown.

The user-created code input through the editor 100 is a multi-language code in which coding statements written in various programming languages are mixed. Therefore, the internal integrated syntax structure must include all functional commands and data structures of each of the programming languages, so that the translator 220 can smoothly perform the syntax conversion.

For example, in the case illustrated in FIG. 3, it is preferable that the internal integrated syntax structure 10 includes both the C structure 21, the basic structure 22, and the Lisp structure 23. Specifically, the functions that can be processed by the internal integration syntax include a subset of the union of the functions of the Basic language, the functions of the C language, and the functions of the Lisp language (see Equation 1). In addition, the data structure possible in the internal integration syntax also includes a subset of the data structure of the Basic language, the data structure of the C language, and the data structure of the Lisp language as a subset (see Equation 2).

[Equation 1]

∪ (function of C language) ∪ (function of Lisp language) ∪ ...}

&Quot; (2) "

Possible data structure in internal integration syntax ⊃ {(Basic language data structure) ∪ (C language data structure) ∪ (Lisp language data structure) ∪ ...}

That is, the internal unified syntax structure corresponds to the entire set U, and various programming languages exist as a subset of the entire set U.

In the present embodiment, the internal integrated syntax structure is a node structure for a procedure that can be executed sequentially, and a tree node structure is applied, which will be described later with reference to related drawings.

Referring again to FIG. 1, in the process of interpreting the user-written code into the internal integrated syntax structure recognizable by the sequential executor 230, in particular, the tree node structure, the variables defined in the user-written code, , Interpretation of various declaration statements such as Explicit, and conversion to a node structure.

The sequential executor 230 sequentially executes commands corresponding to the elements (nodes) with respect to the syntactically-transformed internal unified syntax by the converter 220. [

The internal integrated syntax structure is a tree node structure having a basic tree (syntax tree) having a top node and a child node, and a syntax structure capable of being sequentially executed according to a subtree. Accordingly, the sequential executor 230 sequentially executes the contents recorded in the corresponding node (i.e., the instruction corresponding to the corresponding node) according to the order of the nodes, and is able to process debugging for the errors that occur on the execution.

The sequential executor 230 is assisted by the execution auxiliary engine 300 for sequential execution and / or debugging.

The execution assistant engine 300 assists the function processing, the variable processing, or the debugging, which are required at the time of execution or debugging in the runtime execution unit 200, in particular, the sequential execution unit 230. The execution auxiliary engine 300 includes at least one of a function processing engine 310, a variable processing engine 320, and a debugging engine 330.

The function processing engine 310 processes various functions required for sequential execution such as a mathematical function, a string function, a user-defined function newly defined in user-created code, and the like.

Among the functions required for sequential execution, intrinsic functions such as mathematical functions and string functions are functions that are basically used in various programming language data structures included in the internal integrated syntax structure. User-defined functions are functions newly defined through user- to be. In the case of a user-defined function, the transformation is recorded in the internal integrated syntax structure (tree node structure). When the function is called in the code, the node argument of the function name is found and the child nodes of the node parameter are sequentially executed.

The function processing engine 310 includes a built-in function processing unit and a user defined function processing unit. The built-in function processor processes various mathematical functions, a string function, a file function, and a time / date function for various data types such as a matrix, a complex number, a string, and a date. The user-defined function processor handles the partial role of indexing the user-called function, verifying the assigned variable and the returned value, and processing the recursive call.

The variable processing engine 320 transforms and verifies the data type at the time of storing and outputting the variable value defined in the user created code. It also performs standardized processing on various variables such as local variables, global variables, parameters, constant variables, and static variables.

Variables that can be processed by the variable processing engine 320 include variables that can be defined according to various programming language data structures included in the internal integrated syntax structure.

For example, in Fortran you can define a complex number as a variable type, and in Basic you can specify a variable-length string type. That is, it is not possible to designate variables of variable length string type when coding using Fortran, and it is impossible to design a complex number type variable when coding using Basic.

However, in the present embodiment, the internal integrated syntax structure includes all the programming language data structures, so that variables of complex type and variable length string type can be specified. In addition, it supports and processes variable types supported by various programming languages such as mathematical expressions, matrices, sets, tables, and lists.

That is, the variable processing engine 320 enables compatible support and processing for polymorphic variable types.

The debugging engine 330 performs processing for errors that occur during sequential execution.

The mutual data transfer between the engines included in the execution auxiliary engine 300 is processed by the sequential executor 230. That is, the sequential execution unit 230 calls and processes each engine as needed. For example, the value of the variable X is received by the variable processing engine 320, and if there is an input instruction for X, the sequential executor 230 notifies the variable processing engine 320 that the value of X has been changed, The controller 320 may store the changed X value.

The input / output unit 240 included in the runtime execution unit 200 performs recording and output such as input / output of defined variables, file input / output, provision of a user input / output interface, and the like.

The input / output unit 240 performs input / output with respect to a user interface and an operating system device, and processes input / output related to commands such as Print, Input, File I / O, Table, Chart,

Hereinafter, the configuration and function of the multi-language code concurrent execution apparatus according to an embodiment of the present invention have been described. In the following, a tree node structure as an internal integrated syntax structure will be described.

FIG. 4 is a diagram showing an example of user-created code for converting into an internal integrated syntax structure, FIG. 5 is a diagram showing a syntax tree of execution when the user-created code illustrated in FIG. 4 is converted into an internal integrated syntax structure, FIG. 6 is a diagram illustrating an independent node structure for subtrees included in the basic tree of FIG.

Referring to FIG. 4, a source code written using a general programming language shows a coding syntax for defining a function of a Main name using a Function declaration in the programming language.

The Main function first calls a variable X of the Matrix type, and the variable X receives a matrix element of (a, b), (c, d) or fetches a pre-stored value. Then, for variable Y, the output value of the FuncUser function, to which the variable X is applied as a parameter, is stored, and the Y value is output.

The user-written code as illustrated in FIG. 4 is arranged in a tree node so that it can operate in a sequential executor, and the tree node is classified into attributes such as execution statements, variables, built-in functions, labels, user defined functions, It is organized.

Each node again has independent tree nodes that define the detail structure. That is, there is a tree (syntax tree) for processing the syntax, and each node includes an independent tree (subtree) which defines detailed structure together with syntax information.

Referring to FIG. 5, a syntax tree is shown when the user creation code illustrated in FIG. 4 is converted into an internal integrated syntax structure (tree node structure).

A syntax tree is a basic tree that is the basis of execution, and includes a top node and a child node that is dependent on the top node. Each node (top node and child node) has an independent subtree.

5, the definition statement 'Function Main ()' of the Main function using the Function declaration statement corresponds to the top node, and the statements describing the Main () function of FIG. 4 correspond to each child node on a line basis do. The child node 1 is associated with the identifier '{' that opens the block, the child node 2 is associated with the syntax 'Matrix X' defining the variable X, and the child node 3 is associated with the syntax X = Matrix Y = FuncUser (X) 'described for the variable Y corresponds to the child node 4 and the output of the variable Y corresponds to the child node 5 The syntax 'Print Y' corresponds to the child node 6, and the identifier '}' for closing the block corresponds to the child node 6.

Each of the top node and the child node of the basic tree again has independent tree nodes that define the detailed structure of the node, that is, a sub-tree.

Referring to FIG. 6, the subtrees corresponding to the top node of the basic tree again have a tree node structure including a top node and a child node.

In the subtree 1, a command 'Define Function' for defining a function is recorded in the top node. In the child node, a name, a parameter, a return type, Attributes related to recursive type are recorded. &Quot; Main " is recorded in the child node corresponding to the name, and there is no value to be recorded with respect to the other attributes. According to subtree 1, the name Main function which does not include any additional parameter can be newly defined.

In Sub Tree 2, a command 'Block Open' is opened to open a block in the top node, and a child node indicates an attribute indicating that the object to be opened is a function block.

In the subtree 3, a command 'Define Variable' for defining a variable is recorded in the top node. In the child nodes, a variable type, a variable name, a variable dimension ) Is recorded. According to subtree 3, a variable named X of the matrix type can be newly defined.

In the subtree 4 and the subtree 5, a command 'Put' indicating the input of a value is recorded in the top node. In the child nodes of the subtree 4, variables X and Matrix ((a , b), (c, d)) is recorded, and the subtree structure described in relation to the variable Y and the function FuncUser (X) is recorded in the child nodes of the subtree 5. According to subtrees 4 and 5, the values for variable X and variable Y can be determined.

Referring to Sub Tree 6, a command 'Print' indicating an output is recorded in the top node, and a subtree structure describing the variable Y is recorded in the child node. According to the subtree 6, the value of the variable Y can be output as the execution result of the Main function.

In the subtree 7, a command 'Block Close' is recorded in the top node to close the block. The child node indicates an attribute indicating that the object to be closed is a function block.

As described above, when the tree structure is transformed into a tree structure, it can be interpreted irrespective of the programming language used for writing the source code, and each node of the basic tree can be sequentially executed.

By having such a tree node structure, it is possible to execute a mutual variable or function call without discrimination by syntactically analyzing user-written code in which a plurality of programming languages are mixed.

In addition, it becomes possible to directly transplant user-written code directly into the corresponding programming language without converting various sources of various programming languages used in the past. This has the advantage of lowering the cost of prosperity and translation mistakes and improving the research capability of general researchers, not professional programmers.

7 is a flowchart of a method for simultaneously executing multiple language codes according to an embodiment of the present invention. Each step of FIG. 7 can be performed in each component of the multi-language code concurrent execution apparatus 1 shown in FIG.

In step S400, a user creation code is input through the editor 100. [ User-written code is a multi-language code that is a mixture of statements written in multiple programming languages. The input of the user-written code is a concept including not only direct input through the user input device but also copying and editing from other source code.

In step S410, the converter 220 divides the user creation code input to the editor 100 by coding division. Categorization can be done based on the declaration statement using the language-specific definition command contained in the user-written code. Until an arbitrary compartmentalized language definition command comes up and appears next, the language to be used defined by the compartmentalized language definition command becomes the programming language in the corresponding coding compartment.

In step S420, the converter 220 converts the statements created for each coding segment into a common internal integration syntax. Here, the common internal integration syntax may be a tree node structure. Syntaxes written in various programming languages are converted into a common internal integration syntax, so that they can be executed without language discrimination.

Before the execution of step S420, a grammar check (step S415) using the programming language corresponding to the statements created by the preprocessor 210 for each coding section may be performed in advance. For example, a C language grammar check may be performed on a coding segment written in C language, and a Basic language grammar check may be performed on a coding segment written in Basic language.

In step S430, the sequential executor 230 sequentially executes the user-created codes converted into the internal integrated syntax on a statement-by-phrase basis.

The internal integration syntax has a tree node structure, so that the nodes of the basic tree are executed sequentially. The nodes of the basic tree have independent subtrees, and each node of the subtree is sequentially executed when the corresponding node is executed. If there is a user-defined function call during the execution of the node, the child node of the corresponding node parameter is sequentially executed by finding the node parameter of the corresponding function.

At least one of the function processing engine 310, the variable processing engine 320 and the debugging engine 330 among the execution auxiliary engine 300 may be called and used as needed during the sequential execution process by the sequential execution unit 230 .

In step S440, when the sequential execution result user input value is required, the input / output unit 240 receives the user input value, executes the user creation code using the user input value, and outputs the result.

The simultaneous execution of the multi-language code of FIG. 7 has been described assuming that each component of the multi-language code concurrent execution apparatus 1 illustrated in FIG. 1 receives the user-written code and executes the syntax. However, the present invention is not limited thereto. More specifically, each component of the multi-language code concurrent execution apparatus 1 illustrated in FIG. 1 may be divided into a plurality of configurations according to the environment to which the present invention is applied, or may be implemented as a single configuration by incorporating functions It should be interpreted as integrating or dividing into its function regardless of its name.

It is a matter of course that the above-described simultaneous execution of a multi-language code can be performed by an automated procedure in a time series sequence by a built-in or installed program in the digital processing apparatus. The codes and code segments that make up the program can be easily deduced by a computer programmer in the field. In addition, the program is stored in an information storage medium readable by the digital processing apparatus, and is read and executed by the digital processing apparatus to implement the method. The information storage medium includes a magnetic recording medium, an optical recording medium, and a carrier wave medium.

According to the present invention, it is possible to simultaneously describe a plurality of programming languages in one code page. As for the division of each language, it is possible to compartmentalize through the declaration statement using the language definition command for each compartment as described above.

In addition, it is possible to simultaneously execute various programming languages such as C, Fortran, and Basic simultaneously described in one user-written code, so that functions, variables, and global declarations described in different programming languages can be crossed and used together . That is, it is possible to merge several programming languages and make cross calls with each other sharing functions or variables. One example is calling a Plus function written in Fortran in the Basic syntax in user-written code as illustrated in FIG.

In addition, a programming language interpreted as an executable node structure is sequentially executed according to contents defined by the corresponding node, and an error occurring on execution is handled by debugging.

It will be apparent to those skilled in the art that various modifications and variations can be made in the present invention without departing from the spirit or scope of the invention as defined in the following claims And changes may be made without departing from the spirit and scope of the invention.

1: Multi-language code concurrent execution device 100: Editor
200: runtime execution unit 210: preprocessor
220: converter 230: sequential launcher
240: I / O unit 300: execution auxiliary engine
310; Function Processing Engine 320: Variable Processing Engine
330; Debugging engine

Claims (15)

A multi-language code concurrent execution apparatus for interpreting and executing a user-written code in which a plurality of programming languages are mixed,
An editor receiving the user creation code;
A run-time execution unit for dividing the user-created code input by the editor into coding segments, converting the user-generated codes into an internal integrated syntax structure from a programming language grammar structure corresponding to the coding segment, and sequentially executing the user- And
And an execution auxiliary engine that assists in function processing, variable processing, or debugging necessary in the sequential execution process,
Wherein the execution auxiliary engine comprises:
A built-in function including at least one of a function, a function, a string function, a file function, and a time / date function; a function processing engine for processing a user-defined function newly defined by the user;
A variable processing engine for converting and verifying a data type when storing and outputting a variable value defined by the user creation code;
And a debugging engine that performs processing for an error that occurs during the sequential execution process.
The method according to claim 1,
The run-
A converter for dividing the user-generated code into a plurality of coding sections according to a programming language used for writing a syntax and converting the statements divided into coding sections into the internal integrated syntax structure;
And a sequential executor for sequentially executing the transformation statements converted into the internal integrated syntax structure.
3. The method of claim 2,
Wherein the runtime execution unit further comprises a preprocessor for performing grammar checking based on a syntax of a programming language corresponding to the coding segment, the syntaxes being classified according to the coding segment.
3. The method of claim 2,
Wherein the internal integrated syntax structure is a tree node structure as a node structure for sequentially executable procedures.
5. The method of claim 4,
Wherein the tree node structure converts the statements in an arbitrary coding section into a syntax tree on a row-by-row basis, and the child nodes of the syntax tree have a subtree that can be independently executed sequentially.
6. The method of claim 5,
Wherein the sequential executor sequentially executes instructions corresponding to nodes of the syntax tree and the subtree according to a tree node structure.
3. The method of claim 2,
Wherein the runtime execution unit further comprises an input / output unit for input / output with a user interface and an operating system device.
delete There is provided a method for simultaneously executing a multi-language code in a multi-language code concurrent execution apparatus for interpreting and executing a user-written code in which a plurality of programming languages are mixed,
(a) receiving the user creation code through an editor;
(b) dividing the user creation code input by the editor into coding segments;
(c) converting from a programming language grammar structure corresponding to the coding segment into an internal integrated syntax structure; And
(d) sequentially executing the conversion statements converted into the internal unified syntax structure,
The internal integrated syntax structure is a tree node structure as a node structure for sequentially executable procedures,
Wherein the tree node structure converts the statements in an arbitrary coding section into a syntax tree on a row-by-row basis, and the child nodes of the syntax tree have a subtree that can be independently executed sequentially.
10. The method of claim 9,
Further comprising the step of performing a grammar check based on the grammar of the programming language corresponding to the coding section before the step (c).
delete delete 10. The method of claim 9,
Wherein the step (d) sequentially executes the instruction words corresponding to the nodes of the syntax tree and the subtree according to a tree node structure.
10. The method of claim 9,
Wherein the step (d) is supplemented with necessary function processing, variable processing or debugging through the execution assistant engine in the sequential execution step.
A program of instructions executable by a digital processing apparatus to perform the method of simultaneous execution of multiple language codes according to any one of claims 9 to 10 and 13 to 14 is tangibly embodied, A recording medium that can be read by an apparatus.

Images