We are designing software for small space borne control systems of scientific
experiments on spacecrafts. Because of the radiation environment, one
main goal is to keep the amount of memory needed, especially the ROM
memory, as small as possible.
  One possible contribution to small code is to group data from several
modules with the same functional semantics together in memory and let
another, centralized, module use the data. Examples for such data groups
are address lists of initialization functions, error counters,
configuration data.
  Whereas the data defining modules know the inidividual meaning of each
data item in a group, a system module may only know the structure and
basic semantics of each item and know nothing about the individual
meaning. I.e. the system initialization code would run through the list
of initialization function addresses and call each initialization
function. Or a reconfiguration module would take the block of
configuration data and store it in a permanent powered RAM (without knowing
about each individual item).
An error checking module could cyclically browse through the block
of error counters and notify any changes in the outgoing datastream.

  So far for the basic concept. To be efficient, all items of a group
should be allocated an undivided space in memory. It is usually very
easy to define such GROUPS in assembler language and have the linker
taking care of grouping the data together. So each data item can be defined
in the source code file of the module it belongs to. No extra source
file, where all data items of a group would be defined together, is
needed and this serves the aspects of modularization and independance
very well.

  Is there any language construct in C,C++,PASCAL,Modula or ADA to
support such data groups ?
  I haven't found any. If not : why didn't anybody invent such things ?

Comments to this are welcome.

   Andreas Hestermeyer
   internet : hestermeyer@ida.ing.tu-bs.de