FR2535487A1 - METHOD FOR INTEGRATION OF SOFTWARE IN ADVANCED LANGUAGE TO EQUIPMENT AND DEVICE FOR ITS IMPLEMENTATION - Google Patents

Abstract

THE INVENTION CONCERNS A PROCESS AND A DEVICE FOR INTEGRATING AN EVOLVED LANGUAGE PROGRAM WITH THE LIMITATIONS OF THE HARDWARE OF A SELECTED PROTOTYPE PROCESSOR. THE TECHNICAL PROBLEM IS TO REALIZE IN A VERY REDUCED TIME THE INTERFACE LINK BETWEEN THE SOFTWARE AND THE HARDWARE. IN ACCORDANCE WITH THE INVENTION, A SOURCE 6 FILE CONTAINING THE SPECIFICATIONS OF THE SOFTWARE CONFIGURATION OF THE HARDWARE AND THE INTERRUPTIONS OF THE PROCESSOR PROTOTYPE SELECTED ACCORDING TO THE DATA ENTERED BY THE DESIGNER, IS PREPARED IN DIALOGUE MODE AND THESE SOURCE FILE 6 IS PROCESSED, IN ORDER. ON THE ONE HAND, AN INSTRUCTION FILE 12 OF THE LINKS EDITOR, AND ON THE OTHER HAND, A FILE SUBJECT TO CONFIGURATIONS. THE INVENTION APPLIES IN PARTICULAR TO THE ADAPTATION OF A PASCAL PROGRAM TO DATA PROCESSING DEVICES USING A MICROPROCESSOR OF THE TYPE 8086, 80868087, 8088 AND 80888087.

Description

"Method of integrating software in advanced language to

  a material and device for its implementation ".

  The present invention relates to the link

  interface between software and hardware, and more specifically

  A method and apparatus for translating the hardware / software interface specifications simultaneously into code that can be executed by a specific microprocessor and specific instructions for the link / load editing system of a chosen configuration.

of material.

  Computerized devices are in fact

  mechanical and electronic component systems co-operating with the computer program stored in

  these hardware components The problem of the correct connection

  interface between hardware and software has always

  been a fairly complex and time consuming problem.

  The method and the device according to the invention allow the device designer to specify the hardware / software interface in an advanced language according to a dialogue mode. These specifications are then translated into an executable code.

  the device-related computer and other instruc-

  tions to be executed by the link-editing / program-loading systems This therefore reduces to a few minutes a development process that could

  otherwise take several days or even weeks.

  When using advanced language such

  Pascal, the program is not linked to a type of machine.

  particular because of the nature of language.

  source grams in Pascal do not change, regardless of the industrial calculator or main computer on which

  they must be used However, with classical Pascal

  that there is no way of specifying the requirements

  required, depending on the implementation, such as

  interrupt vectors, subroutines

  this or a memory configuration.

2 2535487

  It would be possible to develop a sub-

  assembly language program (to link the Pascal program to the prototype hardware) and an instruction file

  the linker (to specify the configuration of the

  concerned for this purpose it would be necessary to have detailed knowledge of the requirements

  the assembler, the linker and the Pascal interface.

  This task takes time, and with such a large number

  so many minor details to be taken into account, errors are inevitable There is no known prior art device for automatically generating the instructions of the linker and the object files

configurations.

  It would be desirable to have a

  Positive to provide a list of elements that are necessary to specify to conform a program to a prototype any element from the name of the object program

  compiled to the address where the program starts the

  Then, on the basis of the replies formulated, this system

  produces me the object file of the configurations and the instruc-

  linker requirements necessary to comply with the

prototype considered.

  If such a device uses pseudo-

  instructions in advanced language, it is possible to describe the prototype in a more convenient way and with a smaller

  number of errors Similarly, the device can also verify

  the validity of the instructions formulated, thereby eliminating errors that could not be detected for some time. It is believed that the present invention

provides such a device.

  In accordance with the embodiment

  presented, the integration control system (I <S) described.

  clears the designer of the computerized devices from the

  to design and eliminate errors of hundreds or thousands of lines of a machine language code as well as _ 3 _ t 53548? -3- that having to become familiar with increasingly complex systems of link / load

  dozens of specific instructions in a spe-

  instructions from the linker.

  The present invention provides a method

  and a device for integrating a program into

  pledge, to the material limitations of a

  selected prototype processor This is done automatically

  in collaboration with the designer to prepare a source file that includes the specifications of the

  configuration for software, hardware and interrup-

  for a selected prototype processor This process

  also includes the processing of the source file produced

  above to generate an instruction file of

  the linker and a configuration object file.

  The linker instruction file controls the concatenation process of the advanced language program with the configuration object file to produce a load module executable by the process

  prototype During the sequence, sub-programs-selec-

  from the Execution Times Library.

  for the particular advanced language must also be

  inserted if necessary.

  Cooperating with the designer includes the

  requests the latter to make the necessary entries in order to

  identifies the specifications of the software, process equipment,

  prototype and interruptions, following which,

  in response to these entries, a source file is created.

  The object file of configurations men-

  mentioned above includes interrupt vectors

  interrupt processing programs, a subsystem

  reset program and a subprogram

  initialization of the program for the prototype processor.

  -4 - Other features and benefits

  of the present invention emerge from the description given

  Hereinafter, reference is made to the accompanying drawings, in which FIG. 1 represents a flowchart of FIG.

  integration control system according to the present invention.

and,

  FIG. 2 represents a simple block diagram.

  from an interconnected terminal to a mainframe computer.

  pal, implementing the embodiment according to the present invention.

this invention.

  When using an advanced language, such as Pascal, to produce a program independent of the machine type, the code produced by the compiler can not

  be executed directly The specific codes in the bi-

  library of execution times, must be chained together with the compiled code Depending on the hardware and software needs of the prototype processor system, the latter must

  be initialized for the program.

  linker o memorize the product code in the memory

of the prototype processor system.

  The logical integration control method

  The sky / material according to the present invention generally functions as shown in the flowchart of FIG. 1. Block 2 represents the specifications, established in FIG.

  collaboration with the designer, configurations of the

  hardware, software and prototype interrupts

  response to questions from the guided program

  block 4 operator These specifications are then used

  The source file of block 6 is processed by the processor (block 8) to provide the linker instruction file.

  (block 12) and the object file of the configurations (block 10).

  253548 i -5- The Pascal object file (block 14), the software to be implemented on the prototype processor system as well as the time support library

  execution of Pascal (block 16), the object file for confi-

  gurations (block 10) and the linker instruction file (block 12) are linked to the linker 18 In the linker 18, the configuration object file is chained to the file Pascal object and library runtime support under the

  command of the linker instruction file, the

  linker 18 provides a load file (block 20), which can be executed by the prototype processor system

  specified in response to the prompt 4.

  The configuration object file (block 10) includes interrupt vectors, interrupt processing routines, a subprogram of

  the initial state and an initialization subroutine of the

  gram for the specified prototype processor system

  delete linker instructions (block 12) produced for the particular prototype processor system associates the Pascal object file (block 14), the configuration object file (block 10), and appropriate libraries

  of support for the execution time The file of instructions

  linker (block 12) also arranges the resulting code in accordance with the memory layout of the

  prototype processor system, as specified in

  response to the guide-operator program 4.

  In order for the control device

  If the grading function works, it is necessary that the basic elements of the different prototype processor systems are included as working parameters.

  include information such as maximum capacity

  mux and memory configurations,

  stoppage etc. Regarding the description that

  will follow, examples of a control device will be

  integration program that can interfere with a Pascal program in any of the microprocessors

  8086, 8086/8087, 8088 and 8088/8087.

  Before the object file of the Pascal (block 14) produced by a compiler can be executed, it must be completed by the configuration object file (block) produced by the integration control device If the designer-programmer already knows the details of the prototype processor system, it can create and process a file

  integration source (block 6) of the control system of inte-

  before actually starting programming in Pascal In reality, the integration source file (block 6)

  of the integration control system provides a description

  concise user-readable interface of the hardware / software interface, and can be used as a document

Design.

  However, it is likely that the software will be developed in parallel with the hardware and that parts of the program will be tested before the entire program is developed For testing parts of the program in emulation mode, the implicit object file of the integration control system configurations and the linker instructions file can

  To be used Since subprogrammes

  interrupts are added to the program and that the program is transferred to the prototype processor system, the integration source file (block 6) of the integration control system will be created and modified to fit

  to the variable environment of the program.

  When the integration control system

  is launched, Operator Guide 4 queries

  the user to obtain information about the configuration

  Prototype Processor System Table 1 represents

  a typical game of questioning, answers from the use of

  the user and a comment box forming a source file.

  this typical integration (block 6), each comment being

preceded by the sign (;) -

7 2535487

  Queries Answers Remarks

  : This first directive is just a title.

  PASCALCON'FIGURATION BETITER MOUSETRA These directives describe the processor configuration; and meamry layout. HARDWAREC O NFIGURATICON 80) 86-8087; 8086 CPU with 8087 NDP INSTRUCTIONSROM (0040 OH, 0 07 FFFH); 31 K for executable code CONSTANTS ROM (08000 H, 08 FFFH); 4K for RO Mable data GLOBALVARRAM (Y 9,000H, OCFFFH); 16 K for variable data HEAPSTACKRAM (ODOOOH, OEFFFH); 8 K for heap and stack RESET IMEMORY YES; also memoury at FFFFO

  This directive provides guidance for OS / 40 SV Cs.

CALLS NONE SERVICE

  These guidelines specify the abject and library files

up the progran.

  SOFTWARECONFIGURATION / usr / thomase / mno, etrap / main po MODULE / usr / those / mosssetrap / cheesemod in MODUXLE / usr / thcmse / mousetrap / firstaid in LIBRARY / usr / boratioa / m K 1 uselib

FILE SUPPORT NONE

  These directives describe the switch ccnfiguration, if any.

  ITR ERRUPTCONFIRURATION ROM; Set up interrupt vectors

  INTERRUPTTYPESUSED 2,4 l 32,39 J in ROM for types 2,4,32-39.

  SAVEFLOATINGPOINT NO; Generate 8087 save and re-

  EXCEPT FOR 32.34; store code for types 32,34.

  FAULTNOTIFICATION BADINTERRUPT; List interrupt VECTIOR NMv I, INLINE, 2; service routines

VECTOR OVERFLJDW, 4;

  VECTOR ADJUSTCHEESE, 32;

  VECDTOR ADJ UST SPRING, 34 BAD INTERRUPT

  VEX 2 TOR TIMER, OWNCODEJ 36.39 l handies 33.35

  This directive tells whiere pr'ogram execution begins.

RESTARTLABEL PASCAL BEGIN

END

Table i

  The integration control system operator program (block 4) is a dialog program that creates the integrating control system integration source file. The operator guide program 4 asks questions about the integration control system. the prototype processor system, object files and interrupt configuration,

  and builds the file-according to the answers.

  When the switch control system

  tion is called, processor 8 introduces itself and displays

  a menu of options to choose from. In the "interrogation mode"

  "the guide-operator program 4 initiates

  questions and produce the source file of integration Aus-

  soon after the integration control system has been called, the processor 8 first creates an implicit integration source file, as shown in Table 3,

  then codify it according to the specifications of the

  tor. As stated above, the source file

  integration is sent to the processor 8 to generate the

  linker instruction le (block 12) and configuration object file (block 10) Table 2 is a typical linker statement file, which would be produced from the source file of integration of

table 1.

  When the processor 8 of the communication system

  Integration command stops reading the source file of in-

  tegration (block 10), it calls the computer assembler

  to form the configuration file.

  (block 10) and the listing from the source file of integration

  (block 6) is automatically cleared once the

seems finished.

  If the processor 8 of the integration control system detects any error in the Integration Control System integration source file, it does not produce the linker instruction file or the object file of the integration control system. configurations, and the listing

  only the pseudo-instructions of the control system of in-

  tegration and associated error messages.

9 - Inquiries

PASCAL CONFIGURATION

HARDWARE CONFIGURATION

ROM INSTRUCTIONS

CONSTANTS ROM

GLOBAL VAR RAM

HEAP STACK RAM

RESET MEMORY

CALLS SERVICE

SOFTWARE CONFIGURATION

MODULE

LIBRARY

FILE SUPPORT

CONFIGURATION INTERRUPT

RESTART LABEL

  END Uncomplete integration source file Default Configuration l 00060 H, 07 FFFHl l 08000 H, 08 FFFHl l 09000 H, OD 7 FFHIl lOD 800 H, OFFFFHl NO

DEFAULT

NONE NONE NEW

DEFAULT

NOE -

PASCAL BEGIN

Table 3

  - Linker Instructions

-O moxuse io-

-D STKEBASEQQ = -OEFFFH

-D HOEAPBASWQQ = -ODOOOH

  -m INSTRQQ ROM = 0040 H-07 FFFH -mn CONSTQQ RO Vi = 08000 H-08 FFFH mn DATAQQ RAM = 09000 H-OCFFFH -L class = INSTRQQ range INSTR (Q ROM 1 -L class = CONST (Q range CONSTQQ ROM -L class = DATAQQ range DATAQQ RAM -0 / usr / thomrase / rmcusetrap / mfain po -0 / usr / thomase / rmousetrap / cheesemod po -0 / usr / thomase / mousetrap / firstaid, oo -0 / usr / horatioa / mouisel ib

-D CODEBASEQQ = -0400 H

-D DATABASEQQ = -08000 H

-0 / lib / 8086 / not fp 87 scsd

-0 / lib / 8086 / not rts scsd.

  -o / lib / 8086 / not err scsd -0 / lib / 8086 / not noio scsd -0 / lib / 8086 / not conv scsd -x PASCAL BEGIN added items

Link in ICS object file.

Define boundaries for

stack and heap.

Define mewrry areas.

Assign programn sections

to their merroryv areas.

Link in user 'S object

files and library.

Define code segment and

data segment -

Link in Pascal runtime

support libraries.

Define transfer acddress.

  Typical linker statement file listing The configuration object file (block 10

  the integration control system performs the following tasks:

  he sets the interrupt vectors; it establishes the subprograms for processing interrupts; it establishes a reset subprogram;

  it establishes the subprogrammes of initia-

program.

  The integration control system provides two types of code to perform these interrupts processing code tasks

  interrupt vectors and the sub-

  registers backup / regeneration programs that can be used

  for handling interrupts.

  initialization and reset code

  initial code that initializes the regis-

  segment (CS, DS, SS, ES), the indi-

  stack indicator, group flags the BP register, the 8087 and the floating point status word variable This code may also include a subroutine

  called COPYVECTORS which copies the

  interruptors of a read-only memory in a RAM and also a RESET carrier which creates the reset code (a JMPS instruction) to

* FFFFO location.

  Most of the code in a configuration object file can be used for interrupt processing A set of 256 types of interrupts

  are possible and each type may have a subprogram

  me different from interrupt processing Each type 12 -

  interrupt may require backup and regeneration

  8086 and 8087 Registers The actual code produced by the integration control system depends on the choices

the integration source file.

  Two sections are produced simultaneously

  for the interrupt processing code; a section

  containing the interrupt sectors (ICS-VROM) and a

  section intended to contain the executable code (ICS INSTR).

  (The assembler pseudo-instruction "SUMMARY" acts on the

  of a switch by first announcing a certain

code in the other section).

  Each interrupt processing routine has a portion of the code assigned to its

  processing The assembly code for the treatment of

  1-5 that interrupt follows a general configuration.

  The general configuration shown below

  represents a part of the listing of the control system of

  The words in capital letters are either pseudo-ins-

  tructions, or actual assembly instructions

  lowercase words are a description of the function of the

  assembly code and represent one or more lines

from the listing.

VECTOR INTSERVE, m

SUMMARY ICS INSTR

VECTOR $ SET $

  Safeguarding certain registers and preserving

  recording return return Interrupt processing subroutine call Reset IRET registers

SUMMARY ICS VROM

  Creation of the interrupt vector in the memory. On the first listing line,; VECTOR

  is the pseudo-instruction of the integration control system

  which announced the subprogramme for the treatment of

  rashes and the type (s) handled by this subroutine.

  INTSERVE represents the subroutine that processes the number

interrupt type "m".

  The pseudo statement SET causes VECTOR% to become an indicator V / f RP $ indicates the beginning of

  interrupt processing code for this type of interrup-

tions.

  The code "backup of certain registers

  and retention of the return of registration "shall assume two functions

  it saves the selected registers and allows

  subprograms for checking errors in execution time

  to identify the source of errors in execution time.

  The call code of the treatment sub-program

  interrupts "calls the subroutine that processes

the type of interruption.

  Regeneration code registers

  registers that have been saved (see Table 4 for a list of the integration control system subroutines that are used to save

and regenerate the registers.

  The IRET instruction returns the command to

subroutine interrupted.

  The pseudo-instruction RESUME ICS VROM has

  effect that any line of the code, which follows the pseudo-ins-

  truction, is placed in the ICS VROM section.

  Then, ('"Creating the interrupt vector

  in the memory ') a vector is created in the memory

  to indicate the start of the interrupt processing code

  This is done using pseudo-assembly instructions. 14 25354 t 7 Nane t Functicon SAV 86 $ t Saves 8086 registers on stack SA.V 87 $ i Saves f loating point status word (global variable FPSWQQ) and î 94-byte state of 8087 on stack RES 86 $ i Restores 8086 registers frorr stack RES 87 $ t Restores FPS Vfl QQ and 8087 state: from stack COPYVECTORS $ Copies interrupt vectors f rom RONM tto RP 1 v,

Table 4

  - The first pseudo-instruction defines the location where the interrupt vector must be placed The second creates the

  value of the interrupt vector at this location.

  A particular code is generated for each of the types of interrupts in a source file of the typical interrupt system. Table 4 lists the subroutines that may be included in the object code of the system of interrupts.

integration command.

  The types of interrupts specified with

  INTERRUPTSTYPESUSED pseudoinformation, but not

  in a VECTOR pseudo-instruction, are designated

  as types of indefinite interruptions The pseu-

  do-instruction FAULTNOTIFICATION is used to specify

  Prove the interrupt processing routine for these indefinite types The RESTARTLABEL pseudo-statement produces interrupt vectors for these indefinite interrupts.

  If the INTERRUPTCONFIGURATION is a half-

  the trap vectors must be created in a constants ROM (CONSTANTS_ROM), then transferred to the interrupt vectors area.

  RAM (ICS VRAM) at the time of execution The pseu-

  do-instruction FAULT_NOTIFICATION reserves the appropriate fields

  in the ICS VRAM for interrupt vectors and establishes the code to transfer the vectors in these

  zones during program initialization.

  The array created in the ICS ROM.

  VROM has the form shown in Table 5.

  16 - A.ddress relative to, begjirwing of

ICS VROM

Contents 0-1 2-5 6-7 8-8

Table 5

Interrupt vectors in

ICS VROM

  address where first vector is tc, be stored first interrupt vector where second vector is stored second interrupt vector address i, \ bere last vc-ctor is to be stored last interrupt vector end-of-vectors flag (400 H) 17 - The initialization code of the program is created by the pseudo-statement RESTART LABEL starting at the location PASCALBEGIN The initialization code is

  executed at the time of execution and assume the following tasks:

  : position the DS, SS and ES registers on the basis of the data segment (DATABASEQQ); set the value of the battery indicator to STKABASEQQ minus DATABASEQQ; -Initialize the group indicators into

HEAPBASEQQ;

  if necessary call COPYVECTOR $ for the copying of interrupt vectors from ICS VROM in ICS VRAM; if necessary, initialize the 8087 by performing a FINIT and initializing the command word;

  -clear the floating point status word

  the global variable; erase the BP register so that the registration return subprogram knows that it is the main program; and

  jump to the MAINQQ entry point of the

main gram.

  The reset code is a JMPS instruction, set at FFFFOH, indicating the initialization code. Once the microprocessor is reset, this JMPS instruction causes

  the execution of the initialization code.

  The RESTARTLABEL pseudo-statement also includes code for all subroutines related to,

  interruptions (as listed in Table 4).

  If the configuration object code issued by the integration control system is not suitable for the application of the prototype processor system, the code is -18

  the integration control system can be modified

fied.

  When the integration control system

  If the -l (listing) or -O (object code) option is specified, and the integration source file of the integration control system contains no errors, the command is called.

  system produces a temporary source language file of as-

  If the O option is included, the integration control system calls the 8086 assembler to create the object file

  (filename io) and the assembler listing (filename il)

  The assembler's pel, which the integration control system uses, looks like this: asm filename io filename il / lib / 8086 / ics mc / tmp / xxxxx Tnnnn Tnn

  file file Definition file my tem-

  listing (if not macros of the language portal system

necessary) assembly ICS.

  The entry in the assembler consists of two files that are treated as if they were chained as a single file The first file / lib / 8086 / ics mc consists for the most part of the macro instructions definitions of assembler, which are used by the second file The second file is the temporary source file of assembly language that the integration control system has just created Once the assembler has

  finished, the temporary file is automatically deleted.

  If the -O option is omitted, the source file of the temporary assembly language is saved as

  list file (filename il) If the designer

  re modify the code that the integration system produces, it can edit this source file or create a modified version

  of the macro-instructions file of the control system of in-

  tegration however; modification of the code that the integration system produced can cause a sequence, a

  loading or incorrect execution of the program.

  19 - For example, it is assumed that the designer

  wants to modify the code that saves and regenerates

  8086 code is found in ics mc, in the

  macro-instructions SAV-86-INLINE $, RES-86-INLINE $, and SAVE-

  RESTOR Er 86% He creates his own copy of ics mc and modifies these three macro-instructions:

  cp / lib / 8086 / ics mc mymacros (make a copy of the macro-

  instructions of the integration control system).

ed mymacros (edit copy).

  Whenever he calls the integration control system, he can create the assembly language source file but jumps to the assembly phase: ics -l myprog is (production of the language source file) appears in myprog it) Then it assembles the source file using its own macro-instructions: asm myprog io myprogolist (production of the mymacros myprog myprog file and the listing file

myprog list).

  This assembly command line effectively encodes the macro-instruction definitions (mymacro with the myprog it produces by the inté command system).

gration, then assemble this file.

  Table 6 lists the macro-instructions

  assembly language in the icsoms file and their functions. An integration control system listing file (not shown) is generated by the integration control system from an integration control system integration source file by examining the listing file. of the integration control system, it is possible to understand the object code of ocnfigurations which is chained in the executable loading module which is

  rolls into the prototype processor system.

(Name

$ COPYVECTORS

INITIALIZE_ $ 87

$ JUMPTOPASCAL

REPORT FAULT $ '

$ RESETVECTOR

$ RESTOREPSW

RES 86 INLINE $

RES_ 87 _INLINE $

$ SAVEPSW

SAVERESTORE_ $ 86

SAVE RESTORE_ $ 87

SA-V_ 86 _-N-I-E $

SAV 87 INLINE $

$ StartProgram

- Fixcticn

Code for subroutine COPYVECTORS $.

  Initializes 8087 _ Catpletes prograrm initialization

and jurps to main progran.

Calls runtime error routine to

report undefined interrupt.

_

Sets up vector reset at FFFFO.

F Restores FPSVJQQ from stack.

  In-lne code for restoring 8086 registers. to Irn-line code for restoring FPSWQQ

iand 8087 state.

Saves FPSWQQ on stack.

Code for subroutines SAV 86 $ and

RES $ 86.

Code for subroutines SAV 87 $ and

RES $ 87.

In-lne code for saving 8086

registers on stack.

In-lne code for saving FPSWQQ

and 8087 state on stack.

Begins program initialization.

Table 6

25354 E 7

  21- The integration control system creates a temporary file from the integration source file of this system This file is assembled and produces an object file of integration control system configurations and a designated assembly listing under the term list file

  of the integration control system.

  (During assembly, the assembler uses macroinstructions definitions from the / lib / 8086 / ics mc file)

  To create an executable load file

  the linker is implemented, specifying only the linker instruction file that the integration control system has created and the

loading to be created.

  Referring now to FIG. 2, there is shown a computer terminal 40 and a main computer 30. The terminal 40 comprises a cathode ray tube 42, a

  keyboard 43, a processor 41, a memory 44 and a circuit

  In addition, the terminal 40 comprises

  an input / output system 46 making it possible to validate

  bi-directional communications between the terminal and the computer

principal 30.

  The main computer 30 contains a central processing unit 32 which operates under the control of the timing and control circuit 36. In addition, the computer

  main memory 30 includes a memory 34 and an input / output circuit

  38 The input / output circuit 38 is the link for

  communications between the main computer 30 and the peripherals, that is to say the terminal 40, a printer / plotter of curves

  39 and a PROM ROM programmer 37.

  In operation, the operator guide subroutine and the processor subprogramm are

  memorized in the memories 34 When the designer puts into

  With the integration control system via the keyboard 43 of the terminal 40, the operator-guide routine is called by the central processing unit 32 from the memory 34. The particular interrogations are then transmitted. to the cathode ray tube of the terminal 40 via

  input / output systems 3 and 46.

22 2535487

  The designer, introduced by means of keyboard 43, his

  which are then retransmitted back to the central unit

  32, o the operator-guide subroutine

  formulates the integration source file <fig 1, block 6).

  Then, the processor routine is called by the CPU 32 in order to

  convert the integration source file to an installation file

  tructions of the linker and as an object file for confi-

  gurations, as described above.

  When these operating phases are completed the independent program of any type of machine, which must

  be conditioned by the use in the system of pro-

  prototype, is loaded into the main computer

  as well as the support library of the execution times

  For the language with which the program is written, if the main computer 30 includes a compiler for the language, the program of the machine type can be introduced either in the source form or in the form of the program.

  object form In the example above, the program language

I desire is the Pascal.

  With the four files identified above

  above, the subprogram of the linker of the computer

  main controller 30 goes on, under the command of the

  tructions of the linker, the object file for confi-

  gurations, the fic yesterday object in Pascal, and chooses, as necessary, the sou-prograrmes of the library of the times

  execution of the Pascal to create the loading module ex-

  cutable (FIG. 1, block 20) The executable loading module includes, in machine language, information and positions in the ROMs of the prototype processor system, for this system to operate according to the program

  contained in the object file en'Pascal.

  With the appropriate peripherals, the computer

  main unit 30 can list the load module

  table via a printer / plotter 39, or programmatically test dead reads <PROM), by

  via a PROM programmer 37.

23 -

Claims (7)

CLAIMS) A method for integrating a program into an advanced language into the hardware limitations of a selected prototype processor, characterized in that a source file (6) containing the specifications is prepared in dialogue mode. a configuration of the hardware software and interrupts of the selected prototype processor according to the data input by the designer and in that said source file (6) is processed to obtain, on the one hand, an instruction file (12) of the linker and, secondly, an object file (10) of configurations.   The process according to claim 1 further characterized in that the program is chained   in advanced language with the object file (10) of configura-   under the command of the instruction file (12) of   the linker to obtain a load module-   ment (20) executable by the prototype processor.   Method according to claim 1, characterized in that for preparing the source file (6),   we ask the designer to enter the specifi-   prototype software and hardware and interrupts, and that a file is produced   source (6) containing these specifications.   4) Method according to claim 1, characterized in that in addition, one chaines the program in advanced language, the object file (10) configurations   and the subprogrammes (16) selected from a bibliographic   Execution time library for the advanced language under the command of the instruction file of the link editor (12) to produce an executable loading module (20) by the prototype processor.    Method according to claim 1,   characterized in that the object file (10) for configuring   contains interrupt vectors, subprograms   interrupt processing programs, subroutines 24 -   reset and initialization subroutine.   the program for the prototype processor.   Method according to claim 1, characterized in that said linker instruction file (12) contains subprograms for the   the program in advanced language, the file ob-   jet (10) configurations and subroutines   requested (16) from a library of support execution.   7) Control device for the inte-   of a program in advanced lagging with the limitations   hardware of a selected prototype processor, characterized in that it compasses means (8, 30, 40) for preparing in a dialog mode a source file (6) containing   specifications of hardware software configurations   and processor interrupts selected   born according to the data entered by the designer and means (8, 30, 40) for processing said source file (6) of   way to obtain an instruction file (12) from the   linker and an object file (10) of configurations.   8) Device according to claim 7, characterized in that it further comprises means (12) for linking the program in advanced language and object file (10) configurations to produce a module   loading (20) executable by the prototype processor.   9) Device according to claim 7, characterized in that the means of preparation in dialogue mode comprise means (34,32,38, 46,41,42,43) to query the designer so that it enters the specifications of the software and prototype processor hardware and interrupts, and ways to produce a source file (6) containing these specifications. 5 47    ) Device according to claim 7, characterized in that it further comprises means for linking the program in advanced language, the object file   (10> configurations and subroutines (16) selec-   from a run time library   for advanced language, under the command of the   tructions (12) of the linker, in order to produce a   loading module (20) executable by the processor   totype. 11) Device according to claim 7,   characterized in that said object file (10) for configuring   rations includes interrupt vectors,   interrupts, a subprogram   reset program and a subprogram of i-   nitialization of the program for the prototype processor.   12) Device according to claim 7, characterized in that said file (12) of instructions of   the linker has subroutines for linking   the advanced language program, the appropriate object (10) configuration file and subroutines (16)   a library of support run times.