JPH01300342A - Program development system - Google Patents

Abstract

PURPOSE:To facilitate the maintenance of a program development system by referring to a table which contains the address information decided in response to a logic number and to receive an access and the information on the length, etc. CONSTITUTION:The stored addresses of a variable and a constant are shown in the logic numbers and a logic number corresponds to an argument which is delivered to a function. Then the reference is given to a table which stores the address information decided in response to a logic number and to receive an access. Thus it is possible to know the store place for the data to be processed within the function. Then the argument can be described by using a logic number that points the object data on the table storing the related data to be processed. As a result, the careless mistakes are decreased together with reduction of the description value when a source program is coded. At the same time, the data are retrieved with a logic number used as a key. Thus the capacity of an execution program is also reduced and the maintenance is easily attained just with the change of the table.

Description

DETAILED DESCRIPTION OF THE INVENTION [Field of Industrial Application] The present invention relates to a program development system that facilitates program development.

[Conventional technology]

With the remarkable development of semiconductor technology in recent years, microcomputer technology has been adopted in many fields, making it easier to miniaturize equipment, perform advanced control, and manage and use data. Microcomputer technology has become indispensable due to its ability to reduce costs and improve reliability.

By the way, in microcomputer-applied equipment that requires high-speed control and large-capacity data processing, the processors used are also shifting to highly functional ones such as 16-bit and 32-bit, making coding more complex, so software development languages are being used. There is also an increasing tendency to use high-level compiler languages instead of focusing on assembler. In particular, the ``0C'' language has attracted attention because it is easy to write control programs that are directly connected to the hardware configuration of the target system, and can easily perform high-level processing, and has become popular as a program development language for microcomputer application equipment. Significant.

If we look at "C" as a development language, this is usually used when writing source programs.

Pass the required input data as an argument to a program module called a function, and ask the C# compiler to implement the functionality of this function in the program you are developing. .

For example, the contents of 5 bytes of memory at address r5000H (II indicates hexadecimal notation) and 4 bytes at address 2000011.
In the case of a program that adds the contents of a byte of memory in decimal notation, the name of the library that defines the IO decimal addition program is ``Cat add'', and 5000
The address (or its pointer) indicating address 11 is A3
Assuming that the address (or its pointer) indicating addresses 00G and 2000011 is A2000G, and this is defined in the source program, the calling sequence of this function is Ca 1 add (5, A3000, 4. A
20,000), and when a "C" compiler compiles a source program with such a description, it is expanded as shown in FIG. 5(C), and an object code thereof is generated. As you can see, the first argument is "5".

rA5000J, r4J, rA200
Create a routine that sequentially stores 00J on the stack (24 bytes in this example), and then start by calling the function rcal a
Develop a program that connects the IO base addition processing routine of ddJ (5 bytes in this example). Therefore, in this example, at the object code level before link processing, 2
It can be seen that 9 bytes are required. Finally, the link process by the linker creates the function rcal ad
All the codes required to execute the lO base addition processing program defined in dJ are added, and the end result is an executable program with a considerably large capacity.

On the other hand, when considering the application system to be developed (e.g., inventory management system, payroll system, sales management system, etc.), it is expected that addition processing routines will be used throughout the application.
In this case, each time the rcal addJ function description is encountered, the previous stack storage routine and rcal add
A processing routine for executing J will be added. Therefore, even if it is possible to develop an application system aiming for advanced processing much more easily than when using an assembler, the generated executable program has a huge capacity, and it is not as compact as an assembler. It cannot be summarized into.

[Problem to be solved by the invention]

In this way, when developing a target application system using the "C" language and using a program module called a function, if you want to input data to that function, you must write it as an argument. . Conventionally, when a function with arguments is compiled, a processing routine that stores the given arguments on the stack is always added, and this has a capacity of several tens of bytes. In application systems that aim for advanced processing, cases in which data is exchanged by giving arguments inevitably appear in the source program, so the generated executable program has a huge capacity, and the assembler It cannot be summarized in such a compact manner.

On the other hand, in microcomputer-applied equipment, semiconductor memory elements have become larger in capacity and lower in cost. Since the program is large, the data area that can be secured on the main memory is ultimately limited, and even if the amount of data that needs to be processed increases, it cannot be accommodated. Program development using the "°C" language is a trend of the times, and it is not only possible to develop high-quality software in a short period of time, but also improves productivity in that the accumulated software assets can be effectively utilized in the future. Because you can't miss it
It is desirable to be able to suppress the increase in the capacity of generated programs as described above.

In addition, when creating a source program using the C language, arguments generally include addresses, lengths, the nature of the data (whether the data is numerical or character, etc.).
It is necessary to write at least the first two of the hexadecimal numbers, IO base numbers, octal numbers, etc.), but the first I
As you can see from the example of O-adic addition, there are a large number of arguments written, and if this is used frequently, the amount of work for the programmer becomes significant, and careless mistakes in coding are likely to occur, making debugging difficult. It is also difficult. Also, if conditions are changed for improvement or the target system is changed, it will be necessary to change the "arguments" in the source program and recompile it, but to do so, the source program must be thoroughly checked. Therefore, it is difficult to maintain the system.

Therefore, the purpose of this invention is to provide a program development system that can reduce careless mistakes in source program coding and the amount of description, reduce the size of the executable program, and facilitate maintenance. .

[Means to solve the problem]

In order to achieve the above object, the present invention is configured as follows. That is, in a program development system using the C language, there is a table that stores storage address information and data length information for data that corresponds to each logical number and is exchanged by the logical number allocation argument, and a table that stores the data length information that is allocated corresponding to each logical number. Receives a data file function that defines a data area for storing exchanged data using an argument and a single argument for taking in a logical number, and from this receives the data storage address and data length information pointed to by the logical number data storage means having a library function having a procedure for searching from the table, fetching data within the address area for the data length starting from the storage address, and providing the data for processing defined within the function; specific logical number assigning means for assigning a specific logical number to each argument given to the
Receives a source program written in C language including an instruction to import the data file function, compiles the same, and converts each argument in the source program into a logical number obtained by the specific logical number assigning means. A compile processing function that generates a compiled first file by incorporating it into the program as a constant, and an executable format that links this first file and adds a data file defined by the data file function. and a link processing function for generating a program.

[For production]

In such a configuration, the library function receives a single argument for reading a logical number, searches the table for the data storage address and data length information pointed to by the logical number, and retrieves the data storage address and data length information pointed to by the logical number. It has a procedure for importing data and processing it as defined within the function, and when using this library function, multiple arguments such as data length, address, and data characteristics must be passed when passing one address or data. Even if it is actually necessary, write it using a single argument such as a variable name for assigning a logical number. When a source program written in C language including an instruction to import a function for a data file is given, the arithmetic processing means executes the compilation process, and each argument in the source program is assigned a logic value obtained by the specific logical number assigning means. It converts it into a number and incorporates it into the program as a constant to generate a compiled first file. Next, when link processing is instructed, the arithmetic processing means performs link processing on this first file, and at this time generates an executable program to which the data file defined by the data file function is added.

In this way, the storage addresses of variables and constants are represented by logical numbers, and the arguments passed to functions are structured to correspond to logical numbers, and information such as address information to be accessed and length determined in correspondence with the logical numbers is stored. By preparing a table and referring to it, the storage location of the data to be processed in the function is known.
Arguments can be described using logical numbers that point to target data in a table that stores related data to be processed. Therefore, according to the present invention, careless mistakes and the amount of description in source program coding can be reduced, and
Since data is searched and processed using a logical number as a key, the capacity of an execution program can be reduced, and maintenance can be performed only by changing tables, making it possible to provide a program development system that is easy to maintain.

〔Example〕

An embodiment of the present invention will be described below with reference to the drawings.

Figure 1 is a block diagram showing the configuration of this device.
2 is the central processing unit, which is responsible for controlling the entire system and executing arithmetic processing, and 2 is the memory, in addition to the operation system, the "C" compiler, linker, editor, etc. that are executed by the central processing unit 1. It is used to store various programs that need to be executed, and as a working area, text area, etc. 3 is an external storage device that stores various standard and user-defined library functions used in the "C" language, various header files, source program lists, etc., and is controlled by the central processing unit 1 and is connected to the memory 2. Data can be exchanged between the two. 4 is a keyboard, which is used to give data and commands to the central processing unit 1; 5 is a display that displays input from the keyboard 4, various messages and execution contents from the central processing unit 1, and 6 is a printer for outputting hard copies.

FIG. 2 is a diagram showing an example of the structure of a data management table necessary for implementing the present invention and the relationship between logical numbers.

The data management table has a multilayer structure as shown in the figure.
e Table) and the data file (■). ■
After the link processing, the data file is prepared for each user-defined function used in the executable program.

■Data file table (Data Full T
able) stores data file first segment information in which each target data file exists and the maximum value of the logical number managed in each data file. For example, there is one per application system. are doing. The start address of the target data file can be known from the data file start segment information.

■The data file has a file header (Filellc).
adcr), maximum area number (MAX area No.)
, end address of logical number table ■, logical number table ■, length, address table (Length
.

Address Table) ■, and a data area ■.

Among these, the file header stores information such as the file name and small mode and large mode. This is 16 if the target processor (MPU, microprocessor used) is from the Intel family, for example.
Bit i 808B, i 8028 [i etc. 6
4. In order to manage memory addresses in byte units as segments, addresses are handled differently depending on the model, such as a large model where the program spans multiple segments and a small model where the program can be completed within a single segment. This is to provide information so that the number of bytes required for programming for address operations to be used varies widely, so that the number of bytes required for programming can vary widely depending on the model. This is not necessary when the target MPU is an MPU that does not have such a model type.

The maximum area number (MAXNll) has the same value as the maximum area number of the data file table■, so that you do not have to check the maximum area number information of the data file table every time you access the data file. This is for the purpose of Here, an MPU that performs segment management is assumed, and the purpose is to provide convenience when a data file and a data file table are arranged in memory areas of different segments. Therefore, it is not necessary when targeting an MPU that does not take this format.

The end address of the logical table is used to check the end when searching the logical table. That is, it stores the end address occupied by this logical number table, and is used to prevent a program using this logical number table from picking up data beyond the area of the table.

The logical number table ■ is used to search and find a specified logical number from this table, and this logical number table ■ stores the logical numbers to be used, and the stored logical numbers are 1- They must be arranged in the order of small to large (ascending order; however, it is not necessary to do this if search time is not an issue). It is possible to improve the speed when searching for data that is managed in a data file.

The length and address table is paired with the logical number table, and the real address (Address) of the data memory indicated by the logical number, the data length (Len),
The characteristics of the data are stored. Actual data is stored in the data area.

Such a data file table is created as a user-defined function and registered in the library in advance.

In the present invention, by using the above-mentioned various tables, by providing an argument in the form of a logical number, which would normally have to be set as an argument in the calling case, this logical number can also be used in a user-defined function. Create a data file table that allows you to obtain actual data by referring to the above table, and in the executable program generated by link processing, you can refer to this data file table and proceed with calculation processing. It is something that makes it possible. When developing a full-scale application system, the library functions that come standard with the "C" language are often insufficient in terms of content as is, so it is up to the user to create functions that suit their purposes. Since there is a strong tendency to develop and use it, by writing the processing procedure that uses the above-mentioned table in this user-developed function, you can import the above data file table and data file into the executable program, and use this data file. Achieve the desired calculation control by referring to .

Next, the user function rcal addJ for decimal addition calculation processing is written including such a table usage processing procedure.
The present invention will be explained using an example. In the present invention, considering the case where calculation is performed in the same manner as the conventional example shown in FIG.
The calling sequence of l addJ is shown in (b) in Figure 3.
), rCal a d d (A5000
, A20000) is written as J. Here, A30
00 and A20000 are variable names or labels that indicate the storage addresses of the two data to be added.
“C” indicates which logical number each of these corresponds to.
Define it in the source program using the language's preprocessor.

In this example, the variable name rA5000 J is the logical number "10"
.

r A20000J is defined in the preprocessor to use logical number "12". Also, the data management table shown in Figure 2 used in this addition processing function is created as a user-defined library function before compilation, but the logical number table ■ is based on the length and address of the stored data. It is associated with the position within the table in the data stored in table ■. however,
The address corresponding to the logical number in the data stored in the address table ■ is written with a label in the library, and the area corresponding to the logical number in the data area ■ is also written with a corresponding label. When the real address is determined, the logical number corresponding address in the data stored in the address table (2) is stored as data.

Therefore, in an executable program, it is actual data.

Start the editor, operate the keyboard 4 to create the above-mentioned function, and store it in the external storage device 3. Also, manually input the source program including the above-mentioned pre-processor and calling sequence into the memory. 2 and stored in the external storage device 3. and,
When the central processing unit 1 is instructed to compile the source program, the central processing unit 1 activates the C° compiler in the memory 2, executes the compilation, and generates relocatable object code.

As shown in FIG. 3(b), in the calling sequence example according to the present invention, the number of arguments to the function rcal addJ is reduced to two compared to the conventional one. Further, an example of the expansion of the compilation result is shown in Fig. 3(e), where the two arguments are expressed in the form of storing data indicating the logical number from the length of the data management table and the address information on the stack. The number of bytes for expansion logic has also decreased.

When the central processing unit 1 is instructed to link the object code after this compilation processing, the central processing unit 1 starts the linker in the memory 2, executes the linking, and sends rcal addJ to the stack processing routine.
An executable program is generated by adding the decimal addition execution routine defined in , and further adding the data management table shown in FIG. 2 as a data file.

Here, in the executable program, the expanded data file is added as shown in Figure 4, but the function rcal
In the program using addJ, the data file table ■'' is accessed as follows to obtain the desired data.

First, the logical number '10' of the argument is compared with the maximum area number of the data file table {circle over (2)} to search for a block that satisfies 'logical number≦maximum area number' and obtain the nl segment. In other words, since the function rcal addJ uses the logical number table ■'', the maximum area number WAX &! in this logical number table ■''! r
Loo J Te is present, therefore the logical number "10' is 10
Since it is less than 0, we know the start address of the data file ■'' of MAX No, r 100 J. Next, the function rc
The al addJ program searches the logical number table ■゛, which is a sequential file located at a predetermined position in the data file ■゛ of MAX No. rlooo J distributed below this calculated start address, and searches the logical number table ■゛, which is a sequential file, with the data stored in the stack. It is known that a certain logical number "lO" matches the third one in the logical number table {circle around (2)}.

Therefore, the length and address of this third correspondence are obtained from the length and address table ■'. This is a logical number”
Since "IO" matches the third position in the logical number table ■', the leading gram of the sequential file length and address table ■' is MAX NIILr.
Take in the data stored at the 5-byte address corresponding to the logical number '10' in the data area ■'' in the data file ■'' of too J. Similarly, read the data stored at the 5-byte address corresponding to the logical number '12' stored in the stack. , but this time the maximum area number of the data file ■- is MAX k rlooo
Since it satisfies the above conditions, it searches the logical number table ■' and finds that it matches the fourth position in the logical number table ■''.Then, the length and address corresponding to this fourth position are set as Length and Address. This is obtained from the table ``.'' This is because the logical number "12" matches the fourth position in the logical number table ``.'' From this, the function rcal
addJ's program is MAX 1llO, rlooo
The data stored in the 4-byte address corresponding to the logical number "12" in the data area ■- in the data file ■'' of J is read. Then, both data are added in lO base to obtain a result.

In addition, by programming to allocate this logical number as a storage area for variables, constants, etc. to addresses corresponding to each logical number of a predetermined byte in the data area ``'', the allocated variables, constants, etc. This data is stored as actual data by program execution, and is used in the manner described above.

In this way, this system is a program development system using the "C" language, and includes a table that stores storage address information and data length information for data that corresponds to each logical number and is exchanged using the logical number assignment argument, as well as a table that stores data length information for each logical number. A data file function that defines a data area that is allocated in accordance with the number and stores the data exchanged by the argument, and a single argument to take in the logical number, and then the data pointed to by the logical number. A library function that has a procedure for searching the table for a storage address and data length information, fetching data within an address area for the data length starting from the storage address, and providing it for processing defined within the function. including a data storage means to have, a specific logical number assigning means to assign a specific logical number to each argument given to the function, and importing a data file function,
Receiving a source program written in C language, compiling it, converting each argument in the source program into a logical number obtained by the specific logical number assigning means, incorporating it into the program as a constant, and compiling it. a data execution format that includes a compile processing function that generates a completed first file, a compile process for this first file, and a data file based on the data file function that has a storage area for data exchanged using arguments; The system is constructed by providing a link processing means for generating a program.

Then, the library function receives a single argument to take in a logical number, searches for the data storage address and data length information pointed to by the logical number, takes in the data at the storage address, and defines it within the function. By providing a procedure for processing this library function, when passing a single address or data, it is logically possible to pass a single address or data even when multiple arguments are originally required, such as data length, address, data characteristics, etc. It is sufficient to write the program using one argument such as a variable name to assign the number i, and when a source program written in C language including an instruction to import a function for a data file is given, the arithmetic processing means executes the compilation process, converts each argument in the source program into a logical number obtained by the specific logical number assigning means, and incorporates it into the program as a constant to generate a compiled first file. Therefore, when link processing is next commanded, the arithmetic processing means links this first file, and at that time generates an executable program with the data file defined by the data file function added. Since the number of arguments to be passed and received is significantly reduced compared to the conventional method, the procedure for passing arguments to the main processing body of the program is simplified, and since the target data is passed by referring to a table, it is easier to use functions that involve passing and receiving arguments. For application systems that appear frequently, the capacity of executable programs can be compressed. In addition, as mentioned above, the storage addresses of variables and constants are represented by logical numbers, and the arguments passed to functions are structured to correspond to logical numbers, and the address information to be accessed, length, etc. By preparing a table that stores information and referring to it, the storage location of the data to be processed within the function is known, and the data is searched and processed using a logical number as a key. Maintenance can be done by simply changing the table, making maintenance easier.

In this way, when developing a target application system using the "C" language and using a program module called a function, if you want to input data to that function, you must write it as an argument. However, even if the frequency of occurrence of functions that require description of arguments is high, according to the present invention, the number can be reduced, and the workload of the programmer can be reduced compared to the conventional method. Also,
By reducing the amount of arguments to be written and reducing the burden, careless mistakes in coding are less likely to occur, and debugging becomes easier. Furthermore, since it is a format that refers to a data table, it is easy to deal with changes in conditions or target systems for improvement, and therefore, maintenance becomes easier. Additionally, in the past, when a function with arguments was compiled, a processing routine was always added to store the given arguments on the stack, which resulted in a capacity of several tens of bytes. In the system, it is unavoidable that cases where data is exchanged by giving arguments appear in many places in the source program, so the generated execution program has a huge capacity. By using a data table that allows you to search for specific data and sharing this in one application system, it becomes possible to compile executable programs in a compact manner. Therefore, productivity is improved and program development costs are reduced.

〔Effect of the invention〕

As described in detail above, according to the present invention, storage addresses of variables and constants are represented by logical numbers, arguments passed to functions are structured to correspond to logical numbers, and access points are defined corresponding to the logical numbers. By preparing a table that stores information such as address information and length, it is possible to know the storage location of the data to be processed within the function, so the argument description is as follows. It is sufficient to use a logical number that points to the target data in a table that stores related data to be processed. Therefore, according to the present invention, careless mistakes and the amount of description in source program coding can be reduced, and the logical number can be used as a key. Since data is searched and processed, the capacity of the execution program can be reduced, and maintenance can be done only by changing tables, making it possible to provide a program development system that is easy to maintain.

[Brief explanation of the drawing]

FIG. 1 is a system configuration block diagram showing an embodiment of the present invention, FIG. 2 is a diagram for explaining the configuration of a data management table used in the present invention, and FIG. 3 is an example of a calling sequence according to the present invention. FIG. 4 is a diagram for explaining a specific example of the structure of a generated data file in the example shown in FIG. 3, and FIG. 5 is a diagram for explaining a conventional example. DESCRIPTION OF SYMBOLS 1...Central processing unit, 2...Memory, 3...External storage device, 4...Keyboard, 5...Display, 6...Printer. Applicant's agent Patent attorney Takehiko Suzue Figure 1 Figure 3 Figure 5

Claims (1)

[Claims] In a program development system using the C language, a table that stores storage address information and data length information of data corresponding to each logical number and exchanged by the logical number assignment argument, and corresponding to each logical number. A data file function that defines a data area that is allocated as a data area and stores data exchanged by an argument, and a single argument for taking in a logical number, from which the data storage address pointed to by the logical number is defined. A data storage that has data length information and a library function that has a procedure for searching data length information from the table, fetching data within the address area for the data length starting from the storage address, and providing it for processing defined within the function. means for assigning a specific logical number to each argument given to the function; and receiving a source program written in C language including an instruction to import the data file function, and compiling the source program. A compile processing function that converts each argument in the source program into a logical number obtained by the specific logical number assigning means and incorporates it into the program as a constant to generate a compiled first file; A program development system comprising: arithmetic processing means having a link processing function for linking files of the above file and generating an executable program to which a data file defined by the data file function is added. .