Click above to get retro games delivered to your door ever month!

   Injection points are special areas in the source programs in which the
   programmer can insert custom code. The position of the injection points is
   defined in the Templates.

   Injection points can be of two types:

     . Block type

     . Inj type

   The main difference between the two types of injection points is that the
   Block type points consist of two parts (blocks), one put before a
   specific event is verified and one after the event has been verified (ex.
   opening of the database's files). Inj type injection points consist of
   only one part and can be positioned in any point of the source.

   The two blocks that form a block injection point are called Code
   before and Code after, respectively. Inside the Code before, it is
   possible to use the

     
     * #JMP
     

   statement, acronym of jump. If the code generator encounters this
   statement, its jumps directly to the first instruction following the Code
   after marker, thus skipping everything in between.

   All the injection points can be accessed from within the development
   environment even before that the program is generated. In this case, the
   available points are displayed for each object defined and, during the
   generation of the code, the custom code entered will be automatically
   added.

   The code inserted in the injection points is written to the generated
   sources. This allows to edit the same injection points even from outside
   of the development environment. Please note that the injection points
   contained in the functions that are necessary for the correct functioning
   of the application will be generated no matter if these functions contain
   source code. For functions of secondary importance, if within the
   available points nothing has been entered, neither the function nor the
   relative injection points will be generated.
    For instance, the functions that perform transactions (ptt/rtt/ltt)
   are not generated at all if no transaction has been defined.

   If the code has been entered manually into the sources, in order to make a
   modification permanent so that it is not lost in the successive
   generations, the added part must be integrated into the Project
   Repository. The operation consists of reading the modified source,
   identifying the corrections and saving it in a definitive way. This
   process is called Reverse Engineering and the module that executes
   this process is called dBUp.

   Each injection point has a code that allows it to be uniquely identified
   within the object. The identifying code together with the name of the
   object that it belongs to make the injection point unique in the entire
   application.

   The definition of the injection points is done at the Template level. This
   allows the programmer to add new points to the standard or custom
   templates, or to remove (or simply move) the points already existing.

   --------------------------------------------------------------------------
   If the source code generated by dBsee is manually modified in points
   different from the injection points, these modification will be
   lost in the regenerated program.
   --------------------------------------------------------------------------