GB2262368A - Generating databases. - Google Patents
Generating databases. Download PDFInfo
- Publication number
- GB2262368A GB2262368A GB9126482A GB9126482A GB2262368A GB 2262368 A GB2262368 A GB 2262368A GB 9126482 A GB9126482 A GB 9126482A GB 9126482 A GB9126482 A GB 9126482A GB 2262368 A GB2262368 A GB 2262368A
- Authority
- GB
- United Kingdom
- Prior art keywords
- text
- database
- source code
- code
- generating
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Withdrawn
Links
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/07—Responding to the occurrence of a fault, e.g. fault tolerance
- G06F11/08—Error detection or correction by redundancy in data representation, e.g. by using checking codes
- G06F11/10—Adding special bits or symbols to the coded information, e.g. parity check, casting out 9's or 11's
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
Abstract
A reference database storage structure is generated from a plurality of data field memory structures. The process involves generation of a general source code module into which text in the desired language is inserted before the source code is subsequently compiled. Insertion of text in the desired language involves retrieving a text code and using it to access a translation database. In parallel with generation of source code modules, the method involves generation of error detection code which automatically generates a breakpoint data file indicating program pointers and memory contents when a non-serious error occurs. A modified reference storage structure may be compared with the previous reference structure and the differences automatically used to update existing databases based on the previous reference structure. <IMAGE>
Description
"Processes for qeneration and operation of database systems"
The invention relates to processes for generation and operation of database systems including storage structures for data, and processors for storing, retrieving and processing the data and interfacing with a user.
Some of the most important requirements for a database system include the following:
1. There should be no program faults which would cause
disruption of operation of the system or corruption
of data.
2. If faults do occur, for example, because of
incorrect use of the system, these faults should be
easily detected and repaired.
3. It should be possible to easily update the system to
include newly developed hardware and software.
4. Text displayed during operation should be clear to
a user and generation of database systems for use in
countries having different languages should be
efficiently and accurately carried out.
Processes for generation of a database system must satisfy these requirements while at the same time make efficient use of engineer's development time.
Heretofore, database systems have been developed by mapping a storage device structure and assigning portions of the structure for storage of different databases. Programs were then written to store, retrieve and process data by accessing the storage devices. If, subsequently, a new database system was developed which was an improvement on the original one, updating of the original system involved downloading of all data to a separate storage device and re-configuring the data for storage according to the new storage device structure.
This may lead to corruption of data. Regarding programs, these are generally simply replaced by the new set of programs. This is a time-consuming exercise and often results in a system which does not look familiar to the user and a certain amount of re-training is necessary. Because of these difficulties updating of database systems is often not carried out. Accordingly, a user often does not gain the full benefit of enhancements.
If a fault occurs due to a poorly manufactured circuit or a program error, an error detection system such as that described in European Patent Specification No. 180299B (ICL) may be used. However, by the time engineers check the fault it is very difficult to identify exactly where the fault occurred so that it may be repaired. If, for example, a display apparatus is tested using a method as described in
European Patent Specification Number 52,684B (IBM), it would be time-consuming to identify the fault.
Database systems are usually generated for display and printing of text in the language of a particular country, and for effective use of the database system in a different country the text must be translated. If the displayed text is translated by machine, very often the true meaning of the original text is not replicated. If the text is translated manually, inconsistencies may occur and such a manual translation process is extremely time consuming. While displayed text does not directly affect operation of a database system, it is extremely important because it enables users (many of whom would not be familiar with electronics) to instruct the carrying out of the range of available functions using the database system. if the displayed text is not clear the database system will be grossly underutilised.
The invention is directed towards providing processes for generation and operation of updating database systems which overcome at least some of these problems.
According to the invention, there is provided a process for generating and operating a database system comprising the steps of: determining the database system requirements; designing a database storage structure, and using the design to generate a reference database storage structure by carrying out the steps of:
generating and storing a structure of empty memory
cells for each of a plurality of data fields and
storing a pointer indicating allowed character types
for storage of data in the cells;
generating and storing an address file for the field
structures;
displaying a representation of a database storage
structure comprising a plurality of data field
structures and verifying it after alteration if
necessary; and
storing the verified database structure as a
reference database structure in a non-volatile
memory device; duplicating the reference database structure to obtain an active database storage structure; generating a list of database functions for storing, retrieving and processing data in the reference database storage structure; recording authorised conditions governing storing, retrieving and processing operations; recording required events for shut-down of the system in the event of a serious fault as determined by the set of authorised conditions; generating code for mapping a breakpoint structure for processing status and memory contents; generating code for storage of a file of breakpoint data; according to the list of functions, generating a plurality of modules of general source code without text; inserting text in the language of the destination country in the general source code to generate final source code; compiling the final source code; integrating the modules; testing the machine code; and
after usage of the database system, modifying it to
improve performance utilising available hardware and
software.
Preferably, the step of modifying the system comprises the sub-steps of:
modifying the reference database storage structure;
comparing the modified reference structure with the
active structure;
generating difference data; and
automatically altering the active structure to bring it
into conformity with the modified reference structure.
In one embodiment, the step of generating the general source code modules comprises the sub-steps of:
inserting an indicator in source code indicating presence
of text;
inserting a flag indicating text not to be translated;
sequentially displaying each piece of text to be
translated;
optimising the text layout;
testing the text layout;
carrying out the following operations on each of the
lines of source code:
monitoring for presence of a text flag;
according to the monitoring, extracting the text to
be translated, if any;
comparing the text with all previously extracted
text;
if not already extracted, assigning a new text code;
if already extracted, retrieving an associated text
code; and
inserting the retrieved or assigned text code in the
line of source code;
In another embodiment, the step of inserting the text in the general source code module comprises the sub-steps of:
generating a translation database having a translated
text record for each text code, there being one
translation database for each language;
generating a set of machine codes for a program in a
language by carrying out the steps of:
filtering each line of source code and extracting a
text code, if present;
using the text code to retrieve, for the relevant
translation database, the associated translated
text;
inserting the translated text in the source code
line in the place of the text code; and
compiling the source code.
The invention will be more clearly understood from the following description of some preferred embodiments thereof, given by way of example only with reference to the accompanying drawings in which:
Fig. 1 is a flow diagram illustrating a process of
generating and operating a database system;
Fig. 2 is a flow chart illustrating portion of the
process in more detail;
Fig. 3 is a flow chart illustrating processes for
operating, namely, updating the generated system;
Figs. 4(a) and 4(b) show a flow chart for portion of the
process of generating the system in more detail; and
Figs. 5fa), 5(b) and 5(c) show examples of preliminary,
general and final source code lines generated by a
process of the invention.
Referring to Fig. 1 there is illustrated a process for generation of a database system. The process is indicated generally by the reference numeral 1 and includes an initial step 2 of determining requirements for the database system.
In detail, this step involves determining what data is to be stored in the system and the indices for which searches are to be carried out for retrieval and sorting of the data. This leads in step 3 to the designing of a database storage structure which accommodates all of the requirements. The design of storage structure incorporates fixed disk, memory circuit, bus width, and microprocessor specifications.
Subsequent to step 3, in step 4 a reference database storage structure is generated which includes parameter values defining structures of fields of data for storage in a storage device. Step 4 is described in more detail below. In step 5, error detection code is generated which is embedded with signals which relate to the reference database storage structure. Again, step 5 is described in more detail below.
In parallel with step 5, step 8 involving generation of general source code modules is carried out. A module is a group of related source code lines which are not specific to the text/language of any particular country. In general, each module relates to one particular process such as data retrieval, data storage, sorting, displaying or some other process. After both steps 5 and 8, in step 9 text for the language of the particular country is inserted into the general source code modules. In step 10 the source code of each module is compiled to generate machine code. In step 11, the modules are integrated together by storage in locations of a storage device so that they may be cross-referenced and interlinked both in hardware and in software. In step 12 the compiled machine code is tested and the system is then ready for use.At some later date, in step 13 the system is modified to incorporate improved software and hardware.
In Fig. 1, sub-steps 20 to 24 describe the step 5 involving generation of error detection code in more detail. In step 20, a set of authorised conditions for operation of the database system are recorded. These authorised conditions include sizes of memory registers, a range of processing speeds, desired memory capacities and other conditions. These conditions are generated according to the parameters of the reference structure generated in step 4. In step 21 prespecified shut-down events are recorded, these events being those in response to which the database system should shut down.An example of such an event is a parity error indicating corruption of data or repeated failure to access a particular storage device. in step 22, breakpoint mapping code is generated to instruct a processor in recording the contents of the memory circuit and the location of the program pointer when an error occurs. The code generated in step 22 comes into operation only upon occurrence of a non-serious error which would not, for example, lead to data corruption.
In step 23, a breakpoint file handler is generated to allow storage of the breakpoint mapping data in a unique file stored in non-volatile memory. Step 24 involves generation of shut down instructions for a processor for shutting down of the system when an event recorded in step 21 is detected. The error detection code generated in steps 20 to 24 is embedded with one or more of the general source code modules.
The effect of the code generated in step 5 is that if an error occurs which is serious and leads to data corruption, the database system is shut down automatically in a controlled manner (using the code of steps 21 and 24) which does not lead to loss of any more data than has already been lost. The code generated in step 22 instructs a processor in storing all contents of memory and registers of a microprocessor in a storage device so that it may be retrieved at a later stage.
These instructions are implemented before shutting down of the system. However, if a non-serious error occurs such as the storage of data in a non-authorised storage device, the processor of the database system will be instructed to generate breakpoint data which gives a picture of the memory contents and of the program operation at the time when the error occurred. This breakpoint data is stored in a unique file (using the code of step 23) in non-volatile memory so that it may be easily retrieved at a later stage for examination by engineers. In this way, the source of an error may be immediately identified without carrying out lengthy analysis procedures.This is an extremely important aspect of the invention as it allows both immediate identification of relatively non-serious errors so that they may be corrected with little interruption in operation of the database system, while at the same time providing for shutting down of the system in a controlled manner if a serious fault occurs.
Referring now to Fig. 2, step 4 is illustrated in more detail for generation of the reference database storage structure.
In step 30 a memory structure of empty memory cells for each field of data is stored. The memory structure includes memory bytes for each data field, the desired address of the bytes and the location of the bytes in relation to other fields of a database structure. In step 31, an indication is stored on the storage device of allowed data characters which may be inputted into the field memory structure. In most cases, this is alpha-numeric. In step 32, an address file is generated which is also stored on the storage device and indicates the addresses of all groups of related fields in a database. In step 33, the database structure is verified by both manual testing for consistency and correct crossreferences and for suitability for storage of the particular type of data which is required.In step 4, all of the memory structures are stored together as a reference database structure indicated by the numeral 35. The database structure is then duplicated so that one structure is stored for future reference and the other is used as an active structure for the system being currently generated. In step 36, which is carried out in parallel with step 34, a function list is generated which indicates the functions of programs which would be required for storage, retrieval and processing of data stored within the reference database structure. It is from the function list that the general source code modules are generated in step 8.
The active database storage structure which has been generated is that which is used for the database system being generated.
By recording each field memory structure in turn and subsequently interlinking the field structures and verifying the resultant database structure, the database structure generally ideally suits the user's requirements and makes most efficient use of memory. This approach has been found to be particularly suitable for utilising efficiently all of the memory space because allowances may be made for recording of additional field memory structures without the need for storage of a database structure in more than one storage device.
In Fig. 3, the step 13 of modifying the developed system is illustrated in more detail. Modification would be carried out after a considerable amount of use of the system. As described above, when generated the reference database structure was duplicated, one structure being provided for use as an active database structure of the system, and another as a reference database structure.
In step 40, the reference database storage structure is modified to cater for new user requirements, and newly available hardware and programs. In step 41, when an instruction is received for system updating the active and reference database stored structures are automatically compared by a processor. This involves comparing the parameters which have been used for setting up of the database structures, including memory space and the types of allowed characters. In step 43 a file indicating differences between the active and reference database storage structures is generated. In parallel with step 43, in step 42 data within the active database storage structure is downloaded to a separate disk drive. The processor temporarily stores the difference file and automatically alters the active database storage structure so that it is similar to the reference structure.In step 45, the function lists are compared and in step 46 the data which had been previously downloaded is now stored in the altered active database storage structure. Any required changes to the programs are also made according to the comparison between the function lists.
It will be appreciated that while modifying the database system in this manner, a single reference database storage structure may be maintained at a host location while identical active storage structures are in use by different users at different locations. When the system is modified, this is carried out at the host location by modification of the reference structure. Subsequently the new reference database storage structure is compared with all of the active structures and alterations are automatically made. In this way, one may ensure that all active database structures may be automatically updated and brought into conformity with the latest version. It has been found that the database storage structure is an essential and key element in modification of the database system and by automatically comparing and regenerating a new active storage structure, faults are eliminated.It is, of course, also important to ensure that programs are modified automatically in parallel with this. In practice, if an error occurs in an active database system, the system is automatically updated if this has not already been done so that the testing equipment is applicable to that particular system. This avoids the need for having a large number of testing systems, and for re-configuring them.
Referring now to Figs. 4(a) and 4(b) together, steps 8 and 9 of the process illustrated in Fig. 3 are shown in more detail.
These steps involve generation of general source code modules and insertion of the text of the particular country in the modules. In step 50, instructions for a source code line are written. These instructions may relate to retrieval of data or some other process which is carried out as indicated by the function list generated in step 36. In step 51, a decision is made as to whether or not text is required for the source code line and if not the instructions are stored in step 57 as a preliminary source code line and the process is repeated for the next source code line. However, if text is required, in step 53 the text is inserted into the source code line together with an indicator which indicates that text is present in the line. In step 54, a decision is made as to whether or not the text is for use in a display panel in a database system, i.e., if it will be viewed by a user.In the majority of cases, the text will be viewed by a user and in those cases step 5 of optimising the source code line and testing is carried out. Optimising the line involves displaying the text within the context of the other data which will be displayed on the screen. This allows a developer to ensure that the text will be displayed clearly and will be consistent with the remainder of a display screen regardless of the language of the text. However, if the text is not to be displayed, in step 56 a flag is inserted in the source code line to indicate this fact. For each line of source code which is required for each module, the steps 50 to 57 are repeated.
In Fig. 5(a) an example of some preliminary source code lines now developed is shown. The text is in the English language because the system is being generated in an English-speaking country. The text indicators are < TEXT > and < ENDTEXT > and the flag indicating that translation is not required is < [ SYSTEXT ] > . The flag is in the "comment" section of the line, whereas the text indicators are programming instructions in the main part of the line.
At this stage, a set of preliminary source code lines is stored and in step 60 the first of these lines is loaded into memory, is automatically monitored for presence of text, and, in step 61, a decision is made as to whether or not the text, if present, is for translation. This involves monitoring whether or not there is a text indicator. If present, a check is made if there is a flag. If there is no flag, then the text is for translation. However, if there is a flag, the text is not for translation and is ready for use by development engineers. In step 62 the source code line is stored as a general source code line and the process is repeated subsequent to the decision step 63. If the text is for translation, in step 64 a processor automatically extracts the text by detecting the text indicators and writing to a separate file all bytes within the indicators.In step 65 the processor generates a code for that piece of text. Step 65 is quite complex as it involves comparing the present line of text with all previously extracted lines of text. If it has not previously been extracted a new code is assigned to it.
If it has previously been extracted, the code which was previously used is again used. In step 66, the newly generated or the retrieved text code is inserted in the source code line, to generate a general source code line which is stored in step 62. Again, this procedure is repeated for each of the preliminary source code lines. At the end of these steps, there is a set of general source code lines which do not include any text which is for display but merely a series of codes associated with such text. Examples are shown in
Fig. 5(b) in which the text code is {001415}, the text indicators remain and the translation flag also remains in the comment column. It will be noted that empty lines are treated by the processor as text and are assigned a text code.
Referring now to Fig. 4(b), when all lines have been monitored in this way, in step 70 a list of all of the text codes is generated. In step 71, the text associated with each text code is displayed together with other data which would be displayed together with it on the same screen. A translator then inputs a translation into a particular language and in step 72 the processor cross-references the text code with a storage location in a translation database for that language.
The translation database is indicated by the numeral 73.
These steps are repeated for each general source code line until a complete translation database is generated. The process is then again repeated for each language so that there is a translation database for each desired language.
In step 74, a general source code line is loaded into memory and in step 75 it is monitored to check if there is a text code inserted in the line. If so, in step 76, the text code is extracted and, in step 77, is used to retrieve the associated text from the translation database 73. In step 78, the processor automatically writes the translated text retrieved from the translation database 73 into the general source code line to generate a final source code line which is stored in step 79. Examples of final source code lines are given in Fig. 5(c), in which it will be noted that the text code has been replaced by text from a German language database. General source code lines which do not include a text code are also stored in step 79 as final source code lines. Depending on monitoring in step 80, this process is repeated for each general source code line.Finally, the step of compiling all of the final source code lines is again indicated by step 10 in Fig. 4cub).
It will be appreciated that by generating source code modules in this way with the text in the desired language, the database system may be generated for many different languages in a simple, economical, accurate and consistent way. It is quite labour intensive to generate the translation databases, however, once this has been done database systems for different countries may be very quickly developed. The text which is displayed using the database system is generally clear and fits in well with other data being displayed and there is complete consistency between translations of different pieces of text. What has been achieved by the invention is the optimisation of both human input in translation text according to the context of a screen, while at the same time eliminating inconsistencies between translations which would otherwise be caused if the text code were not automatically generated.
It will thus be appreciated that the invention provides for generation of a database system in an efficient manner which is generally error free and for which errors may be easily detected.
The invention is not limited to the embodiments hereinbefore described, but may be varied in both construction and detail.
Claims (5)
1. A process for generating and operating a database system
comprising the steps of:
determining the database system requirements;
designing a database storage structure, and using
the design to generate a reference database storage
structure by carrying out the steps of:
generating and storing a structure of empty
memory cells for each of a plurality of data
fields and storing a pointer indicating allowed
character types for storage of data in the
cells;
generating and storing an address file for the
field structures;
displaying a representation of a database
storage structure comprising a plurality of
data field structures and verifying it after
alteration if necessary; and
storing the verified database structure as a
reference database structure in a non-volatile
memory device; duplicating the reference database structure to obtain an active database storage structure; generating a list of database functions for storing, retrieving and processing data in the reference database storage structure; recording authorised conditions governing storing, retrieving and processing operations; recording required events for shut-down of the system in the event of a serious fault as determined by the set of authorised conditions; generating code for mapping a breakpoint structure for processing status and memory contents; generating code for storage of a file of breakpoint data; according to the list of functions, generating a plurality of modules of general source code without text;
inserting text in the language of the destination
country in the general source code to generate final
source code;
compiling the final source code;
integrating the modules;
testing the machine code; and
after usage of the database system, modifying it to
improve performance utilising available hardware and
software.
2. A process as claimed in claim 1, wherein the step of
modifying the system comprises the sub-steps of:
modifying the reference database storage structure;
comparing the modified reference structure with the
active structure;
generating difference data; and
automatically altering the active structure to bring
it into conformity with the modified reference
structure.
3. A process as claimed in claims 1 or 2 wherein the step of
generating the general source code modules comprises the
sub-steps of:
inserting an indicator in source code indicating
presence of text;
inserting a flag indicating text not to be
translated;
sequentially displaying each piece of text to be
translated;
optimising the text layout;
testing the text layout;
carrying out the following operations on each of the
lines of source code:
monitoring for presence of a text flag;
according to the monitoring, extracting the
text to be translated, if any;
comparing the text with all previously
extracted text;
if not already extracted, assigning a new text
code;
if already extracted, retrieving an associated
text code; and
inserting the retrieved or assigned text code
in the line of source code;
4. A process as claimed in claim 3, wherein the step of
inserting text in the general source code module
comprises the sub-steps of:
generating a translation database having a
translated text record for each text code, there
being one translation database for each language;
generating a set of machine codes for a program in
a language by carrying out the steps of:
filtering each line of source code and
extracting a text code, if present;
using the text code to retrieve, for the
relevant translation database, the associated
translated text;
inserting the translated text in the source
code line in the place of the text code; and
compiling the source code.
5. A process substantially as hereinbefore described with
reference to, and as illustrated in the accompanying
drawings.
Priority Applications (2)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| GB9126482A GB2262368A (en) | 1991-12-13 | 1991-12-13 | Generating databases. |
| BE9101153A BE1003613A6 (en) | 1991-12-13 | 1991-12-19 | Method for producing and operating systems databases. |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| GB9126482A GB2262368A (en) | 1991-12-13 | 1991-12-13 | Generating databases. |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| GB9126482D0 GB9126482D0 (en) | 1992-02-12 |
| GB2262368A true GB2262368A (en) | 1993-06-16 |
Family
ID=10706202
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| GB9126482A Withdrawn GB2262368A (en) | 1991-12-13 | 1991-12-13 | Generating databases. |
Country Status (2)
| Country | Link |
|---|---|
| BE (1) | BE1003613A6 (en) |
| GB (1) | GB2262368A (en) |
Families Citing this family (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| SG80592A1 (en) * | 1998-05-07 | 2001-05-22 | Panasonic Singapore Lab Pte Lt | Graphical microcontroller software development system flow chart engine |
| CN109829010B (en) * | 2017-08-28 | 2023-11-14 | 西安中兴新软件有限责任公司 | Entry modification method and entry modification device |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| EP0333612A2 (en) * | 1988-03-17 | 1989-09-20 | International Business Machines Corporation | Multi-language program |
| EP0335139A2 (en) * | 1988-03-30 | 1989-10-04 | International Business Machines Corporation | National language support system without external files |
| GB2243005A (en) * | 1990-04-11 | 1991-10-16 | P I Programmers International | Generating a database system |
-
1991
- 1991-12-13 GB GB9126482A patent/GB2262368A/en not_active Withdrawn
- 1991-12-19 BE BE9101153A patent/BE1003613A6/en not_active IP Right Cessation
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| EP0333612A2 (en) * | 1988-03-17 | 1989-09-20 | International Business Machines Corporation | Multi-language program |
| EP0335139A2 (en) * | 1988-03-30 | 1989-10-04 | International Business Machines Corporation | National language support system without external files |
| GB2243005A (en) * | 1990-04-11 | 1991-10-16 | P I Programmers International | Generating a database system |
Also Published As
| Publication number | Publication date |
|---|---|
| BE1003613A6 (en) | 1992-05-05 |
| GB9126482D0 (en) | 1992-02-12 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US7401322B1 (en) | Software debugging tool | |
| EP0785510B1 (en) | Program debugging system for debugging a program having a graphical user interface | |
| US5528753A (en) | System and method for enabling stripped object software monitoring in a computer system | |
| US5513315A (en) | System and method for automatic testing of computer software | |
| EP1130518B1 (en) | Software analysis system having an apparatus for selectively collecting analysis data from a target system executing software instrumented with tag statements and method for use thereof | |
| US4910663A (en) | System for measuring program execution by replacing an executable instruction with interrupt causing instruction | |
| US8087005B2 (en) | Software testing by groups | |
| US5418954A (en) | Method for preparing and dynamically loading context files | |
| US20070204261A1 (en) | Robust software library wrapper method and apparatus | |
| JP3699154B2 (en) | Method and apparatus for self-describing encoding of data | |
| EP0111952B1 (en) | Verification of a processor architecture having a partial instruction set | |
| US20030088810A1 (en) | Methods and apparatus for determining software component sizes associated with errors | |
| US6591389B1 (en) | Testing system for circuit board self-test | |
| CN113742215B (en) | Method and system for automatically configuring and calling test tool to perform test analysis | |
| US4108360A (en) | Method of error analysis and diagnosis in electronic data processing systems | |
| US20070226471A1 (en) | Data processing apparatus | |
| US20020129336A1 (en) | Automatic symbol table selection in a multi-cell environment | |
| US20030177471A1 (en) | System and method for graphically developing a program | |
| US6611924B1 (en) | Reducing code size of debug output statements | |
| GB2262368A (en) | Generating databases. | |
| CN108304330B (en) | Content extraction method and device and computer equipment | |
| IE914227A1 (en) | Processes for generation and operation of database systems | |
| US20040205704A1 (en) | Transparent monitoring system and method for examining an executing program in real time | |
| EP0526055B1 (en) | Monitoring execution of a computer program to provide profile analysis | |
| JP3077627B2 (en) | Debugging method and recording medium for recording debug program |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| WAP | Application withdrawn, taken to be withdrawn or refused ** after publication under section 16(1) |