JPH04142629A - Advanced language processor - Google Patents

Abstract

PURPOSE:To simply support a new instruction by means of external attaching without affecting the environment of executing an existing instruction by dynamically calling a relevant execution routine from an extended instruction library in response to an intermediate code or machine language code that represents an extended instruction during the execution of interprinter or during the execution of interprinter following compilation. CONSTITUTION:An extended instruction library 21 stores execution instructions are exchangeable extended instructions other than a basic instruction set therein, an extended instruction analytical information memory section 16 stores extended instruction analytical information to be prepared outside the main body of interprinter or main body of compiler therein. Further, when a statement other than reserved words of a basic instruction set appear in an extended instruction analytical processing section 12, the extended instruction analytical information memory section 16 is referred and analyzed to output an intermediate code or machine instruction code in response to the extended instruction. Furthermore, during the execution of instruction in response to an intermediate code or machine language code that represents the extended instruction a relevant execution routine is dynamically called from an extended instruction library 21. With this, a new instruction can be attached externally to the present advanced language processor and simply supported without affecting the environment of executing an existing instruction.

Description

DETAILED DESCRIPTION OF THE INVENTION [Summary] A source program written in a high-level language such as BASIC is transferred to a high-level language processing device equipped with an interpreter that interprets and executes it or a compiler that translates it.

The purpose is to easily support new instructions externally without affecting the existing instruction execution environment.

an extended instruction library that stores execution routines related to exchangeable extended instructions other than the basic instruction set; an extended instruction analysis information storage unit that stores extended instruction analysis information prepared outside the interpreter body or the compiler body; and the basic instruction set. When a statement other than a reserved word appears, the extension instruction analysis processing section refers to the extension instruction analysis information storage section, analyzes it, and outputs intermediate code or machine language code according to the extension instruction. , a corresponding execution routine in the extended instruction library is dynamically called in response to intermediate code or machine language code indicating the extended instruction.

[Industrial Application Field] The present invention relates to a high-level language processing device equipped with an interpreter that interprets and executes a source program written in a high-level language such as BASIC or a compiler that translates it.

For example, B is popular as one of the high-level languages for computers.
The processing mechanism of ASIC is the operating system (
It has a history of developing in an environment without O5), and each time new functions are required, such as input/output functions for peripheral devices,
A new instruction processing mechanism will be built inside to process this.

They tended to become larger. This has caused an increase in memory load even for users who do not need new special instructions. What is needed is a means to support new instructions without burdening users of existing instructions. Furthermore, it would be convenient if the user could easily create instructions by himself/herself.

[Conventional technology]

The conventional BASIC ink printer is 2, for example, B as follows.
Interprets and executes programs written in ASIC.

When loading a source program, it reads the source line by line, searches the reserved word table, and converts it into the corresponding token code. The token code is an intermediate code indicating, for example, the type of command or function.

The converted token code is checked for syntax and stacked with operands using a syntax analysis table, and the execution routine corresponding to the token code is called to execute the instructions specified by the source program.

Further, a conventional BASIC compiler processes, for example, as follows.

A source program is input line by line and coded text, which is intermediate code text, is created using a reserved word table. A syntax check is performed on the coded text using a syntax analysis table, and machine language instructions or similar pseudocode C and below are extracted from the coded text.
(referred to as code). When processing for all source programs is completed, address resolution processing is performed on intermediate object files consisting of P code, etc., and an executable object file is output as a compilation result.

When executing the object resulting from this compilation, the loader expands the P code onto memory. and by retrieving the P-code and calling the execution routine corresponding to the P-code.

Perform the processing desired by the user.

In the conventional technology, commands in a high-level language are uniformly interpreted or translated, and when supporting O3 commands, commands related to O8 function 2 peripheral devices, etc., the commands are processed in a high-level language. It was designed to be integrated and tied into the main body.

Furthermore, when a user wants to use a function that he or she has independently developed in a program, it is necessary to create two machine language libraries and use an instruction to call the execution routine of the machine language library.

[Problems to be Solved by the Invention] In the prior art, for example, when trying to support a special instruction that handles a new peripheral device, the routine that analyzes it and the execution routine are treated the same as other existing instructions.
There is a problem in that even users who do not need the special instructions are forced to use the BASIC interpreter or BASIC compiler, which has a heavy load.

In addition, when implementing new functions in the form of a machine language library, BAS, which is originally a language for amateurs, is used.
C suddenly became a maniac and turned into an ASIC, which sometimes caused a runaway operation due to incorrect usage.

Even if there is no error in usage, the program becomes a list of descriptions of CALL instructions that call one machine language library, resulting in a program that is extremely difficult to read and maintain.

The present invention aims to solve the above-mentioned problems and provides a new command. [Means for Solving the Problems] FIG. 1 is a diagram showing the basic configuration of the present invention.

In FIG. 1, 10 is a source program written in a high-level language, 11 is a high-level language processing main unit such as an inkpreter body or a compiler body, and 12 is an extended instruction analysis process that analyzes extended instructions that are instructions other than the basic instruction set. Part 1
3 is an intermediate code or machine language code (hereinafter simply referred to as intermediate code) as a result of the analysis; 14 is a grammar definition sentence that defines a grammar in a predetermined format for extended instructions; and 15 is a grammar definition sentence 14 as extended instruction analysis information. 16 is an extended instruction analysis information storage unit that stores extended instruction analysis information; 17 is an initialization routine that performs initialization for analysis; 18 is an analysis table for analyzing extended instructions; 19 21 is an extended instruction library, 22 is a basic instruction library 520 that is provided as standard, and is a basic instruction execution routine that processes basic instructions that are provided as standard.
represents an extended instruction execution routine that processes extended instructions.

The present invention includes an extension instruction library 21 that stores various extension instruction execution routines 22 related to exchangeable extension instructions other than predetermined basic instruction cents, and performs syntax checks of these extension instructions, etc. An extended instruction analysis information storage section 16 that stores extended instruction analysis information for performing processing such as stacking operands can be prepared externally to the high-level language processing main body section 11.

The high-level language processing main unit 11 calls the extended instruction analysis processing unit 12 when a sentence other than a reserved word of the basic instruction set appears in the source program 10.

The intermediate code 13 corresponding to the extended instruction is analyzed by referring to the extended instruction analysis information storage unit 16 for the sentence.
Output.

As a result, when intermediate code 13 indicating an extension instruction appears during execution in the interpreter or execution after compilation, the corresponding extension instruction execution routine 22 in the extension instruction library 21 is dynamically called, and processing for the special instruction is executed. I do.

Regarding the basic instructions that are provided as standard in the main body from the beginning, as before, the basic instruction execution routine built into the high-level language processing main unit 11 or the basic instruction execution routine stored in the basic instruction library 19 called the runtime system is used. Processing is performed by routine 20.

In order to enable the user to easily generate the extended instruction analysis information storage section 16, a grammar definition sentence 14 that describes the grammar of the extended instruction is defined according to a predetermined rule. The 0 grammar definition sentence converter 15 is capable of specifying information that becomes the basis of extended instruction analysis information.

A grammar definition sentence 14 is input, it is analyzed, and an extended instruction analysis information storage section 16 is automatically generated.

The extended instruction analysis information storage unit 16 has various analysis tables 18 such as reserved words and syntax analysis tables for extended instructions.
It has an initialization routine 17 that initializes these tables. The extended instruction analysis information storage unit 16 includes dynamic link information that is dynamically connected to the caller during execution.
It is created in a library format and is dynamically coupled to the high-level language processing main unit 11 when called from the high-level language processing main unit 11.

[Effect]

In the present invention, for instructions other than the standard basic instruction set, information on the instruction syntax and execution library can be obtained from the outside. therefore,
Special instructions other than the basic instruction set in a high-level language such as BASIC can be used externally. That is, just as attaching an expansion board to hardware increases its functionality, attaching expansion instructions to software makes it possible to easily use instructions other than the basic instruction set, making it possible to upgrade nine functions.

In particular, the BASIC language is often used in relatively small-scale computer systems9. Since it is often necessary to add new functions, the ability to add new instructions without significantly affecting the existing execution environment is a great advantage.Of course, it can also be applied to other high-level languages.

〔Example〕

FIG. 2 is an example of a system to which the present invention is applied.

In particular, FIG. 2(a) shows an example of application to a BASIC interpreter, and FIG. 2(b) shows an example of application to a RAS I C compiler.

In FIG. 2, 30 is a data processing device equipped with a CPU, memory, etc., 31 is a BASIC interpreter main body, 32 is a reserved word table that stores reserved words related to basic instructions, and 33 is a storage that stores syntax information related to basic instructions. 34 is a token code obtained by converting the source code, 35 is extended instruction analysis information stored in the extended instruction analysis information storage unit 16 shown in FIG. 1, and 36 is BA
The SIC compiler main body 37 represents an executable program file.

When the BAS I C interpreter main unit 31 receives the source program 10, it converts it into a token code 34 using the reserved word table 32.

If the input source is not registered in the reserved word table 32, by the extended instruction analysis information 35.

It is determined whether the instruction is an extended instruction or not, and if it is an extended instruction, it is converted into a token code 34 indicating it. Furthermore, regarding the token code 34, the syntax analysis table 33
Alternatively, a syntax check or the like is performed using the extended instruction analysis information 35, and the instruction is executed by the corresponding basic instruction execution routine 20 or the dynamically coupled extended instruction execution routine 22.

The BASIC compiler main unit 36 is similar, but instead of analyzing the source program 10 and immediately executing it, it converts the analysis result into machine language code or P code and outputs it as an executable program file 37. . Note that instead of outputting directly in executable format,
Although it may be output as an object file that is subject to combined editing, in the following embodiments, in order to simplify the explanation, it will be described as output in executable format.

There are extended instructions in the source program 10.

The BASIC compiler main unit 36 analyzes the extended instruction analysis information 35 and expands it into an instruction that calls the extended instruction execution routine 22 . Therefore, when the program in the executable program file 37 is executed, the extended instruction execution routine 22 for processing extended instructions is called and processed at the necessary time.

Prior to a detailed explanation of the following nine embodiments of the present invention, techniques related to the embodiments will first be explained.

FIG. 3 is an explanatory diagram of analysis by an interpreter according to an embodiment of the present invention.

The interpreter converts the source program into token code. Tokencodes contain instructions, functions, constants, and variables, making it easier to parse the source.

It is classified into labels, comment delimiters, etc. and converted into a certain code. When loading a source program, it is converted (franchised) into a token code using the reserved word table.

The source program will be franchised as shown in FIG. 3(a). The beginning of each line is a pointer to the second line, which is 0, followed by a line number and token code, and the end of each line is indicated by a hexadecimal number 'oo'.

During analysis/execution, as shown in Figure 3 (b), the token code refers to the corresponding syntax analysis table, performs a syntax check, and loads interface information with the execution routine onto the stack. is the operand value.

Note that the syntax analysis table describes information indicating the formation of nine sentences, and stores information such as specifying the order in which tokens classified into three categories are written.

For example, the image of the syntax analysis table for the grammar expressed as "rABC character string [, numeric value]" is as follows.

As shown in Figure 3 (C), the next character type is a comma (1
), numeric type, or abbreviation. Due to the syntax check, any description that does not follow this flow will result in an error.

The information (operand values) to be passed to the execution routine.

As shown in FIGS. 3(d) and 3(e), they are stacked on a stack 40. In FIG. 3(d), a pointer to the area of the two character strings "ABCD" and a numerical value "lO" are stacked on the stack 40. When an operand is omitted, an operand with a special code indicating an omitted operand is stacked as shown in FIG. 3(e).

Although the operands stacked on the stack 40 are described in a simplified manner, the type, length (character type), etc. also exist as stack information.

Execution is performed by calling a corresponding execution routine using a dispatch table (not shown) according to the token code.The execution routine takes in operand values from the stack 40 and processes them.

On the other hand, in the case of a compiler, similar to the token code of an interpreter, the source is first converted into intermediate code information called coded text that is easy to analyze. Using this coded text, a syntax check is performed using the corresponding syntax analysis table as shown in FIG. 4(a).

The image of the syntax analysis table in the compiler is also similar to that in the interpreter, as shown in FIG. 4(b).

The compiler outputs P code (pseudo code) consisting of nine machine language codes or primitive instructions similar to machine language based on the coded text.

For example, when a source instruction such as rABC"123", A+2J is activated, a P code 41 as shown in FIG. 4(c) is generated. In the case of numerical expressions, use reverse Borland notation so that they can be executed sequentially.
A P code 41 as shown in FIG. 4 (e) is generated.

The executable program file 37 generated by the compiler in this way has a structure as shown in FIG. 5(a). The loader following the header (EXE header) of the executable file loads the runtime system, loads the following areas, and passes control to the runtime system.

The runtime system parses and executes the P-code.

The BASIC header manages the area of BASIC compilation results. Especially the LINK information.

This is an area used by CHAIN and subprograms. D
The LL table is a table that manages dynamic link libraries.

Since the P code 41 is syntactically checked at the time of compilation, it is a collection of execution-related instructions 5, for example, as shown in FIG. 5(B).・By executing this command, A
When control is transferred to the execution routine corresponding to the BC instruction, scooking to the stack 40 is performed as shown in FIG. 5(C) by executing the P code 41, and the stack 40 is passed in the state of ■.

Next, extended instructions that can be created arbitrarily by the user will be explained.

Extension instructions are defined by 2 grammar definition statements. 0 Grammar definition statements are statements that have the grammar for extension instructions and dispatch information to execution routines, and each library of supported extension instructions constitutes one file.

The syntax of the grammar definition sentence is as shown in FIG. 6(a), for example. Each item must be separated by a tab or space. The end of the sentence is a carriage return/line feed code. The items to be described in the text are as follows.

<Type>: Describe whether the grammar to be defined is "command" or "function J".

Command: Specify when writing the command grammar.

Specify when writing the grammar of a function-bifunction.

<ANK name>: Describe the ANK name of the instruction or function. The allowed ANK characters that must be written in ANK characters are alphanumeric characters and underscores. However, the first character must be a letter. If the function is of character type, specify $ at the end. When specified in lowercase letters.

Converts to uppercase. This name is also used as part of the execution routine name.

<Japanese name>: Describe the Japanese name of the "command" or "function".

<Operand description>: Describe the form of the operand in the following format. The special symbols used in the description can be either half-width or full-width. In the case of a function, at least one operand must be written as a dummy even if there is no operand.

The syntax of operand description in BNF style notation is as follows.

Operand::Intelligence operand item operand, operand item operand item:: 1 Numeric type 1 [Numeric type] Character type I
[Character type] Array variable 1 [Array variable] []: Indicates that it can be omitted.

Numerical types include integer type, single precision real number type, 9 double precision real number type constants, and two variable expressions. Character type indicates 2 character type constants, 7 variable expressions, array variables 1 character type, integer type, single precision real number type 1
Indicates an array of double-precision real numbers.

Arrays are allocated at runtime, so the type, number of array elements.

The execution routine must check for its existence.

The execution routine name of the extended instruction execution routine is determined by the user execution routine identification ID and ANK name as shown below.

For instructions = “UbS” and rANKANK name:
rUbfJ and rANK names, however, rANKANK
The first letter of the name is capitalized.

After that, the letters are lowercase. If it is a character type, the last $
cannot be written, so 24 (hexadecimal code of $)
Replace it with .

For example, the extension command rsE that sets attributes on a certain file
Suppose we create a TJ. Grammar definition sentence 14 of this is the 6th
Figure (b) Write as shown.

The execution routine name of this extended instruction execution routine 22 is:
It becomes "UbsSet".

The operands are of two character types: a file name and an attribute character, and can be used as in (a) for an ANK name or (b) for a Japanese name. In the case of (a), the file name
This means setting the attribute "A" to "FILE".

FIG. 6(c) is an example of the extended instruction rscRLOcK which locks the screen for a specified time.

The grammar definition statement 14 defines two operands: a numerical type indicating an optional waiting time and a numerical type indicating a function number.

Similarly, functions created by the user can be used. FIG. 6(d) shows the definition of the function rBIN$J or "binary $" that converts a numerical value into a binary number. It can be used as in (d) and (e).

This extended instruction execution routine 22 is incorporated into the extended library with the execution routine name "UbfBin24".

The grammar definition sentence converter 15 shown in FIG. generate.

The extended instruction analysis information consists of information as shown in FIG.

The extended instruction analysis information 35 file shown in FIG. 7 is created in a dynamic link library (DLL) format. Therefore, simply by loading this, the extended instruction analysis information 35 is developed in the memory.

The analysis table initialization routine 35-1 stores the address of the reserved word & syntax analysis information 35-2 and the DLL name table 35.
-3 address to the caller.

As shown in FIG.
An ANK reserved word defined by the LL number, instruction/function identification ID, and grammar definition statement 14.

Contains pointers to Japanese reserved words, parsing tables, and execution routines. Note that pointers to execution routines are resolved by dynamic linking at runtime.

The DLL name table 35-3 is used to find the library in which the execution routine exists when loading the execution routine.

As shown in Figure 8 (a), the syntax analysis table includes a function/instruction identifier that identifies a function or instruction, a token code such as a two-character expression, a numeric expression, and a delimiter (1), and a syntax analysis table that is followed during normal operation. It has a pointer to the entry, a pointer to the parsing table entry to follow in case of an error, etc.

For example, the syntax of operands.

When it is a "character expression, [, numerical expression]", the image of the syntax analysis table is as shown in FIG. 8(b)-d.

The token code of the extended instruction in the interpreter has a structure as shown in FIG. 9(a). It consists of a pointer to the next token, a source serial number, an extended instruction identifier indicating an extended instruction, and an entry number for reserved words and parsing information.

If the extended instruction identifier indicates that it is an extended instruction,
With applicable reserved words & parsing information.

Analyze and execute it.

The P code of the extended instruction in the compiler has a structure as shown in FIG. 9(b). There are extended instruction recognition codes for extended instructions and extended functions. The DLL number is
This is the entry number of the DLL name table. A pointer to an ANK reserved word is a pointer to an instruction or function name, and even if a monolingual reserved word is specified, it is converted to an ANK reserved word and points to it. A pointer to the execution routine.

resolved at runtime.

Execution of the extended instruction P code is performed as follows.

i) Obtain a pointer to the P-code execution routine.

j) If the pointer to the P code execution routine is not set, perform the following processing.

(a) Obtain the DLL name from the DLL number.

(b) Load the extended instruction library specified by the DLL name. If the extended instruction library is not found, an error occurs.

(C) Create an execution routine name from the character string indicated by the ANK reserved word. That is, add Ubs to the beginning of the ANK reserved word for instructions and Ubf for functions, and use this name to obtain the address of the execution routine. If the address of the execution routine cannot be obtained, an error occurs.

(d) Set the address of the execution routine in the P code.

■) Call the execution routine.

FIG. 10 shows a processing flow of the grammar definition sentence converter 15 shown in FIG. Below, ■~[ shown in Figure 10
The explanation will be given according to the phase.

■ Perform the necessary initialization and open the definition statement specification file 60 in which the definition statement file name is stored.

■ Extract one definition statement file name from the definition statement specification file 60.

■ When the data in the definition statement specification file 60 is completed, the process moves to process ■.

■ Open the definition statement file 61 with the definition statement file name taken out in process (■).

■ Extract one grammar definition sentence from the opened definition sentence file 61.

■ Determine whether the grammar definition sentence has ended, and if it has ended, move to process ■.

■ Convert the grammar definition sentence into extended instruction analysis information as shown in FIG. Thereafter, the process returns to process (2), and the next grammar definition sentence is processed in the same way.

■ When the grammar definition sentence is finished, the definition sentence file 61
Close and return to process ■.

- When processing for all definition statement files 61 is completed, the extended instruction analysis information is sorted in ascending order of reserved words.

■ Extended instruction analysis information in a dynamic link library format file (extended instruction analysis information file 62)
and completes the processing of the two-grammar definition sentence converter.

An interpreter according to an embodiment of the invention processes as shown in FIG. Hereinafter, explanation will be made according to (1) to (4) shown in FIG. 11.

(2) At the time of initialization, it is checked whether the extended instruction analysis information file 62 exists, and if it exists, it is read into the memory as the extended instruction analysis information 35.

(2) Load token conversion processing will be described later with reference to FIG.

■ Read the token code 34 created by process ■ into the buffer.

■ Determine whether it is an end token, and if it is, terminate execution.

■ If it is not an end token, the syntax is checked and the operands are stacked using the syntax analysis table 33 corresponding to the token code.In addition, in the case of an extended instruction,
Extended instruction analysis information 35 is used to perform syntax check and operand stacking.

■～■ Calls the execution routine corresponding to the token code 0 If it is a normal instruction, it will be executed by the basic instruction execution routine in ■, and if it is an extended instruction, it will be executed by the extended instruction library 21.
It is executed by the extended instruction execution routine loaded from ■. Thereafter, the process returns to process (2) and processes the ninth token.

FIG. 12 shows the processing flow of the load token conversion process of process (2) shown in FIG. The following will explain the processes ① to ② shown in FIG. 12.

■ Open the file of the source program 10 to be executed.

■ Read one line of source from the source program 10.

■ Once the source is finished, move on to 5 process ■.

■ Search the reserved word table 32 for the source.

■ If found, process ■ is executed; if not found, proceed to process ■.

- Refer to the reserved word table 32 and convert the reserved word into a token code 34 corresponding to the reserved word.

Return to processing ■.

(2) If it is not registered in the reserved word table 32 of the basic instruction set, search the reserved word table in the extended instruction analysis information 35.

■ If found, process ■ is executed; if not found, process [phase] is executed.

■ Convert the source to an extended instruction token and set it as the token code 34. After that, return to process (■).

[Phase] If there is no corresponding reserved word, convert it to a variable token. After that, return to process (■). Note that the variable token command causes an error when executed.

■ Once all sources have been processed,
Close the source program file.

Return to caller.

The compiler according to the embodiment of the present invention processes as shown in FIG. The explanation will be given below according to (1) to (4) shown in FIG.

(2) At the time of initialization, it is checked whether the extended instruction analysis information file 62 exists, and if it exists, it is read into the memory as the extended instruction analysis information 35.

■ Read one line of source from the source program 10.

■ Once the source has finished, move on to process ■.

(2) Conversion into coded text 70 using the reserved word table 32. If it is not found, the extended instruction analysis information 35 is used to convert it into coded text 70.

■ In the case of an extended instruction that performs a syntax check on the coded text 70 using the syntax analysis table 33,
A syntax check is performed using the extended instruction analysis information 35.

■ If you have performed a syntax check, coded text 7
Create the corresponding P code based on 0.

It is stored in the intermediate object file 71. In the case of an extended instruction, a P code for the extended instruction is created. after that,
Return to processing ■.

(2) When the source program 10 is completed, address resolution is performed for the intermediate object file 71 and an executable program file 37 is created.

■ Perform necessary post-processing such as closing files.

Finish the process.

The compilation results are executed as shown in FIG. The following describes the processes ① to ② shown in FIG. 14.

(2) The loader expands the P code 80 of the executable program file 37 onto memory.

■ Take out the P code 80.

■ When the P code ends or an end instruction is reached, execution ends.

■～■ Calls the execution routine corresponding to the retrieved P code 0 In the case of a normal instruction, it is executed by the basic instruction execution routine in ■, and in the case of an extended instruction.

Executed by the extended instruction execution routine (2). In the case of an extended instruction, when it is called for the first time, it is loaded from the extended instruction library 21. After execution.

Returning to process (2), processing for the primary P code is performed.

〔Effect of the invention〕

As explained above, the present invention has the following effects.

) When the number of commands increases rapidly due to functional upgrades, supporting them all as basic commands will place a burden on users who do not need new commands.

According to the present invention, there is no burden on users who only need existing basic commands.

11) Users who use extended instructions can install the extended instruction analysis information storage unit and extended instruction library externally.
High-level languages can be used in an optimal environment, that is, a user-customized environment. Extended command analysis information is provided by two grammar definition statements.

Since it is prepared separately from the extended instruction library, errors can be detected in advance through syntax checks, etc. Therefore, runaway programs can be prevented, and execution routines can be created more easily.

1ii) Even if a user does not have specialized knowledge of computer languages, if he or she has some experience in creating programs, it becomes possible for the user to create extended instructions by himself/herself.

[Brief explanation of drawings]

FIG. 1 is a diagram showing the principle configuration of the present invention. FIG. 2 shows an example of a system to which the present invention is applied. FIG. 3 is an explanatory diagram of analysis by an interpreter. FIG. 4 is an explanatory diagram of translation by the compiler. FIG. 5 is an explanatory diagram of execution after compilation. FIG. 6 is an example of a grammar definition sentence according to an embodiment of the present invention. FIG. 7 is an example of extended instruction analysis information according to an embodiment of the present invention. FIG. 8 is an example of a syntax analysis table according to an embodiment of the present invention. FIG. 9 is an example of a token code and a P code of an extended instruction according to an embodiment of the present invention. FIG. 10 is a processing flow of a grammar definition sentence converter according to an embodiment of the present invention. FIG. 11 is a processing flow of an interpreter according to an embodiment of the present invention. FIG. 12 is a processing flow of load token conversion processing. Compiler 7 (7) Processing Flow According to Embodiment FIG. 14 shows a processing flow when executing a compilation result according to an embodiment of the present invention. In the figure, 10 is a source program, 11 is a high-level language processing main unit, 12 is an extended instruction analysis processing unit, 13 is an intermediate code,
14 is a grammar definition sentence, 15 is a grammar definition sentence converter, 16
is an extended instruction analysis information storage unit. 17 is an initialization routine, 18 is an analysis table, 19 is a basic instruction library, 20 is a basic instruction execution routine, 21
2 represents an extended instruction library, and 22 represents an extended instruction execution routine.

Claims (1)

[Claims] 1) A predetermined basic instruction set in a high-level language processing device equipped with an interpreter that interprets and executes a source program (10) written in a high-level language or a compiler that translates it into a low-level language. an extension instruction library (21) that stores execution routines related to exchangeable extension instructions other than the above; and an extension instruction analysis information storage unit (16) that stores extension instruction analysis information prepared outside the interpreter body or the compiler body; When a statement other than a reserved word of the basic instruction set appears in a source program, the statement is analyzed by referring to the extended instruction analysis information storage unit, and intermediate code or machine language code corresponding to the extended instruction is output. Extended instruction analysis processing unit (1
2), and dynamically calls a corresponding execution routine in the extended instruction library in response to an intermediate code or machine language code indicating an extended instruction during execution in an interpreter or during execution after compilation. A high-level language processing device characterized by: 2) The high-level language processing device according to claim 1, further comprising a grammar definition sentence converter (15) that receives a grammar definition sentence (14) regarding an extended instruction and automatically generates the extended instruction analysis information based on the grammar definition sentence. A high-level language processing device characterized by: 3) The high-level language processing device according to claim 1 or 2, wherein the extended instruction analysis information storage unit (16) includes an initialization routine (17) for a table necessary for analysis, and the extended instruction analysis information storage unit (16) includes an initialization routine (17) for a table necessary for analysis, and the extended instruction analysis information storage unit (16) includes an initialization routine (17) for a table necessary for analysis, and the extended instruction analysis information storage unit (16) includes an initialization routine (17) for a table necessary for analysis, and the extended instruction analysis information storage unit (16) includes an initialization routine (17) for a table necessary for analysis, and the extended instruction analysis information storage unit (16) includes an initialization routine (17) for a table necessary for analysis. A high-level language processing device characterized in that it is created in a dynamic link library format that is dynamically coupled to a main body.