generic/compiler/instance_types.h

/**< 
 *  Real Ascend Instance Types
 *  by Tom Epperly
 *  Version: $Revision: 1.29 $
 *  Version control file: $RCSfile: instance_types.h,v $
 *  Date last modified: $Date: 1998/02/05 16:36:22 $
 *  Last modified by: $Author: ballan $
 *
 *  This file is part of the Ascend Language Interpreter.
 *
 *  Copyright (C) 1990, 1993, 1994 Thomas Guthrie Epperly
 *  Copyright (C) 1996 Benjamin Andrew Allan
 *
 *  The Ascend Language Interpreter is free software; you can redistribute
 *  it and/or modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of the
 *  License, or (at your option) any later version.
 *
 *  The Ascend Language Interpreter is distributed in hope that it will be
 *  useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with the program; if not, write to the Free Software Foundation,
 *  Inc., 675 Mass Ave, Cambridge, MA 02139 USA.  Check the file named
 *  COPYING.
 *
 *  Fields not to be accessed by any client program
 *  except by the read-only functions in headers.
 *  The write functions in atomvalue.h are also reasonable for
 *  clients to use.
 *  Clients should never have to include much beyond instance_enum.h.
 */

#ifndef __INSTANCE_TYPES_H_SEEN__
#define __INSTANCE_TYPES_H_SEEN__


/**< 
 *  All of the following structures should be a multiple of *8*;
 *  being a multiple of 4 is not sufficient. Pad if necessary.
 *      RealInstance
 *  IntegerInstance
 *  BooleanInstance
 *  SymbolInstance
 *  SetInstance
 *  and in fact any new instances that will be atom children.
 *  Remember that these get *packed* in together and the order of
 *  packing is not predictable in any way. If each is a multiple
 *  of 8, then everybody will be properly aligned.
 *  *AtomInstance and  *Rel*Instance also need to be 8 byte
 *  aligned so that we
 *  start children in an 8 byte.
 *
 *  This has to hold for both 4 and 8 byte ptr/long machines.
 */

#if SIZEOF_VOID_P == 8
#define LONGCHILDREN 1
#else
#define LONGCHILDREN 0
#endif
/**< if LONGCHILDREN, then pointers are 8 bytes */

/**< at present, I don't believe the following define is needed */
/**< # if defined(_HPUX_SOURCE) || defined(_SGI_SOURCE) */
/**< # define ALIGNSTUPID 1 */
/**< # endif */
/**< if ALIGNSTUPID, then 4 byte ptrs must fall on 8 byte boundaries */
/**< any architecture with such a restrict should be summarily torched */


/**< FUNDAMENTAL INSTANCES */

/**< this aligns to 8 bytes with 4 or 8 byte pointers. size 32/40 */
struct RealInstance {
  enum inst_t t;        /**< must always be first */
  unsigned assigned;        /**< the number of times it has been assigned */
  struct Instance *parent_offset;
  CONST dim_type *dimen;
  double value;
  unsigned depth;       /**< the depth of the assignment */
  int padding;  /**< required for either type of pointer */
};

/**< this aligns to 8 bytes with 4 or 8 byte pointers. size 24/32 */
struct IntegerInstance {
  enum inst_t t;        /**< must always be first */
  unsigned assigned;        /**< the number of times it has been assigned */
  struct Instance *parent_offset;
  long value;
  unsigned depth;       /**< the depth of the last assignment */
  int padding;  /**< required for either type of pointer */
};

/**< size 24/24 */
struct BooleanInstance {
  enum inst_t t;
  unsigned assigned;        /**< the number of times it has been assigned */
  struct Instance *parent_offset;
  unsigned value;       /**< 0 false, 1 true */
  unsigned depth;       /**< the depth of the last assignment */
#if (LONGCHILDREN == 0)
  int padding;
#endif
};

/**< this aligns to 8 bytes with 4 or 8 byte pointers. size 16/24 */
struct SetInstance {
  enum inst_t t;
  unsigned int_set;     /**< 0 indicates string set, 1 indicates an */
    /**< integer set */
  struct Instance *parent_offset;
  struct set_t *list;       /**< list of enumerated values, NULL */
    /**< indicates that it has not been assigned */
  /**< 
   * if HP_sUX 9/10 or SGI is stupid enough to misalign this structure,
   * we will have to pad it with an int on both sides of *list
   */
};

/**< this aligns to 8 bytes with 4 or 8 byte pointers. size 16/24 */
struct SymbolInstance {
  enum inst_t t;
  unsigned assigned;        /**< the number of times it has been assigned */
  struct Instance *parent_offset;
  symchar *value;       /**< NULL indicates unassigned */
};


/**< TRUE ATOM INSTANCES */
/**<  the first one is a dummy of some importance. All the atomic
 *  variable types should be conformable to this structure. It
 *  is not by itself a structure that should ever exist.
 */
struct CommonAtomInstance {
  enum inst_t t;
  VOIDPTR interface_ptr;
  struct gl_list_t *parents;    /**< link to parents */
  struct Instance *alike_ptr;   /**< circular linked list of clique members */
  struct TypeDescription *desc; /**< list of children pointers */
  unsigned long visited;    /**< visited counter */
  unsigned long tmp_num;    /**< used when an instance tree is being copied*/
  unsigned int anon_flags;  /**< anonymous field to be manipulated */
};

/**< 
 * The RealAtomInstance should be reimplemented with a number of
 * supported attributes (bounds, nominal, several boolean flags)
 * and then an explicit pointer to the child space since children
 * are expected to be rare. Making this pointer explicit will allow
 * the real atoms (of which there are a lot) to be pooled and save
 * a fair amount of memory on large problems.
 */
/**< aligns to 8 byte boundaries on 4 or 8 byte machines. size 56/96 */
struct RealAtomInstance {
  enum inst_t t;
  VOIDPTR interface_ptr;
  struct gl_list_t *parents;    /**< link to parents */
  struct Instance *alike_ptr;   /**< circular linked list of clique members */
  struct TypeDescription *desc; /**< list of children pointers */
  unsigned long visited;    /**< visited counter */
  unsigned long tmp_num;    /**< used when an instance tree is being copied*/
  unsigned int anon_flags;  /**< anonymous field to be manipulated */
  /**< above should match with CommonAtomInstance */
  /**< atom value part */
  double value;         /**< value of real variable */
  CONST dim_type *dimen;    /**< dimensions */
  struct gl_list_t *relations;  /**< relations where this real appears */
  unsigned int assigned;    /**< the number of times it has been assigned */
  unsigned int depth;       /**< the depth of the last assignment */
  /**< 
   * An even number of child pointers are packed here, the last of which
   * may not be valid because the number of children may be odd.
   * This extra should be eliminated for LONG pointer machines.
   */
  /**< After the child pointers comes the data space for the actual
   * children.
   */
};

/**< future work. needs parser and interpretter support. Not yet used. */
struct SolverAtomInstance {
  enum inst_t t;
  VOIDPTR interface_ptr;
  struct gl_list_t *parents;    /**< link to parents */
  struct Instance *alike_ptr;   /**< circular linked list of clique members */
  struct TypeDescription *desc; /**< list of slow children pointers, by name */
  unsigned long visited;    /**< visited counter */
  unsigned long tmp_num;    /**< used when an instance tree is being copied*/
  /**< above should match with CommonAtomInstance */
  /**< atom value part */
  struct gl_list_t *relations;  /**< relations where this real appears */
  double value;         /**< value of variable */
  /**< fast children, all sharing dimens */
  double nominal;       /**< value of variable scaling */
  double lower;         /**< value of variable lower bound */
  double upper;         /**< value of variable upper bound */
  CONST dim_type *dimen;    /**< dimensions */
  struct Instance **carray; /**< array of pointers to slow children.
    Keep slow children in pools by type.
    This should be NULL most of the time. */
  unsigned int flags;       /**< boolean flags of the variable, both
    internal and external. must be at least
    32 bit int */
  unsigned int depth;       /**< the depth of the last assignment */
  /**< 
   * An even number of child pointers are packed here, the last of which
   * may not be real because the number of children may be odd.
   * This extra should be eliminated for LONG pointer machines.
   */
  /**< After the child pointers comes the data space for the actual
   * children.
   */
};
/**< 
 * Bit field definition for boolean attributes. room to grow.
 * Define all these fields so that a default value of (0,OFF,FALSE)
 * is the appropriate setting for 'typical' uses of ASCEND.
 */
/**< internal flags (compiler use) for solveratominstances: */
#define SOL_ASSIGNED    0x1 /**< atom value ever assigned */
/**< external flags (user interface/solver use) for solveratominstances: */
#define SOL_FIXED   0x2 /**< variable fixed for solvers */
#define SOL_INACTIVELB  0x4 /**< lower bound to be ignored in solving */
#define SOL_INACTIVEUB  0x8 /**< upper bound to be ignored in solving */
#define SOL_ODESTATE    0x10    /**< variable state for ivp solver */
#define SOL_ODEOBSERVE  0x20    /**< variable recording for ivp */
#define SOL_ISZERO  0x40    /**< semicontinuous set 0 for sciconic */
#define SOL_INTEGER 0x80    /**< integer variable */
#define SOL_RELAXEDINT  0x100   /**< integer variable treat as relaxed */
#define SOL_INTERVAL    0x200   /**< interval real variable */
#define SOL_COMPLEX 0x400   /**< complex variable. lower -> imaginary part
       upper -> magnitude bound. ASCEND -> pot */
#define SOL_DOMAIN  0x800   /**< continuous variable defines domain */
#define SOL_ODEINDEP    0x1000  /**< independent variable in ODE/BVP */
#define SOL_NODOF   0x2000  /**< user doesn't want to see var in DOF */
#define SOL_PARAMETRIC  0x4000  /**< whatever that means to a solver */
#define SOL_INTENSIVE   0x8000  /**< physics/che intensive property variable */
#define SOL_NONBASIC    0x10000 /**< in DOF of optimization problem */
/**< 2,4,8-0000 reserved for future */
/**< external flags (solver/interface tool use) for solveratominstances: */
#define SOL_TIGHTLB 0x100000    /**< value at or near lower */
#define SOL_TIGHTUB 0x200000    /**< value at or near upper */
#define SOL_NOELIG  0x400000 /**< variable not eligible to be fixed in DOF */
/**< note that the above bit positions need to be settled on still. */

/**< aligns to 8 on 4 and 8 byte compilers with compiler pad after t, depth */
struct IntegerAtomInstance {
  enum inst_t t;
  VOIDPTR interface_ptr;
  struct gl_list_t *parents;    /**< link to parents */
  struct Instance *alike_ptr;
  struct TypeDescription *desc; /**< usefull type description information */
  unsigned long visited;
  unsigned long tmp_num;    /**< used when an instance tree is being copied*/
  unsigned int anon_flags;  /**< anonymous field to be manipulated */
  /**< above should match with CommonAtomInstance  */
  /**< atom value part */
  unsigned int assigned;    /**< the number of times it has been assigned */
  struct gl_list_t *whens;  /**< link to whens on which it appears */
  unsigned int depth;       /**< the depth of the last assignment */
  long value;           /**< integer value */
  /**< 
   * An even number of child pointers are packed here, the last of which
   * may not be real because the number of children may be odd.
   * This extra should be eliminated for LONG pointer machines.
   */
  /**< After the child pointers comes the data space for the actual
   * children.
   */
};

/**< this structure aligns (with compiler generated pad after t and flags
 * on 4 or 8 byte ptr machines.
 */
struct BooleanAtomInstance {
  enum inst_t t;
  VOIDPTR interface_ptr;
  struct gl_list_t *parents;    /**< link to parent instances */
  struct Instance *alike_ptr;
  struct TypeDescription *desc; /**< description of name,children, and size */
  unsigned long visited;
  unsigned long tmp_num;    /**< used when an instance tree is being copied*/
  unsigned int anon_flags;  /**< anonymous field to be manipulated */
  /**< above should match with CommonAtomInstance  */
  /**< atom value part */
  struct gl_list_t *logrelations; /**< logrelations where this boolean appears */
  struct gl_list_t *whens;      /**< whens where this boolean appears*/
  unsigned assigned;        /**< the number of times it has been assigned */
  unsigned depth;       /**< the depth of the assignment */
  unsigned value;       /**< 0 false, 1 true */
  int padding;      /**< so that children have a square address */
  /**< 
   * An even number of child pointers are packed here, the last of which
   * may not be real because the number of children may be odd.
   * This extra should be eliminated for LONG pointer machines.
   */
  /**< After the child pointers comes the data space for the actual
   * children.
   */
};

/**< this aligns to 8 on 4 or 8 byte compilers with compiler pad after t */
struct SetAtomInstance {
  enum inst_t t;        /**< type */
  VOIDPTR interface_ptr;
  struct gl_list_t *parents;    /**< link to parents instances */
  struct Instance *alike_ptr;
  struct TypeDescription *desc; /**< description of name,children, and size */
  unsigned long visited;
  unsigned long tmp_num;    /**< used when an instance tree is being copied*/
  unsigned int anon_flags;  /**< anonymous field to be manipulated */
  /**< above should match with CommonAtomInstance  */
  /**< atom value part */
  unsigned int_set;     /**< 0 indicates string set, 1 indicates */
  struct set_t *list;       /**< list of enumerated values NULL indicates */
    /**< that is has not been assigned */
    /**< integer set */
  /**< 
   * An even number of child pointers are packed here, the last of which
   * may not be real because the number of children may be odd.
   * This extra should be eliminated for LONG pointer machines.
   */
  /**< After the child pointers comes the data space for the actual
   * children.
   */
};

/**< this aligns to 8 on 4 or 8 byte compilers with compiler pad after t, flags*/
struct SymbolAtomInstance {
  enum inst_t t;        /**< type */
  VOIDPTR interface_ptr;
  struct gl_list_t *parents;    /**< link to parent instances */
  struct Instance *alike_ptr;   /**< ALIKE clique link */
  struct TypeDescription *desc; /**< description of name, children, and size */
  unsigned long visited;
  unsigned long tmp_num;    /**< used when an instance  is being copied */
  unsigned int anon_flags;  /**< anonymous field to be manipulated */
  /**< above should match with CommonAtomInstance  */
  struct gl_list_t *whens;  /**< link to whens on which it appears */
  /**< atom value part */
  symchar *value;       /**< NULL indicates unassigned */
  /**< 
   * An even number of child pointers are packed here, the last of which
   * may not be real because the number of children may be odd.
   * This extra should be eliminated for LONG pointer machines.
   */
  /**< After the child pointers comes the data space for the actual
   * children.
   */
};

/**< CONSTANT INSTANCES */
/**< The first one is a dummy of some importance. All the Constant
 * types should be conformable to this structure. It
 * is not by itself a structure that should ever exist.
 */
struct CommonConstantInstance {
  enum inst_t t;
  unsigned int vflag;
  unsigned long visited;    /**< visited counter */
  unsigned long tmp_num;    /**< used when an instance tree is being copied*/
  VOIDPTR interface_ptr;
  unsigned int anon_flags;  /**< anonymous field to be manipulated */
/**< vflag is 32 bits with particular meanings: */
#define ci_ASSIGNED 0x1     /**< instance assigned yet? */
#define ci_BVAL 0x2     /**< boolean const instance value, reserved */
/**< other binary flags constants need to be added here. */
};

/**< RealConstantInstance should probably be pooled, but isn't yet */
struct RealConstantInstance {
  enum inst_t t;
  unsigned vflag;       /**< assigned? */
  unsigned long visited;    /**< visited counter */
  unsigned long tmp_num;    /**< used when an instance tree is being copied*/
  VOIDPTR interface_ptr;
  unsigned int anon_flags;  /**< anonymous field to be manipulated */
  /**< above should match with CommonConstantInstance */
  double value;
  struct gl_list_t *parents;    /**< link to parents */
  struct Instance *alike_ptr;   /**< circular linked list of clique members?*/
  struct TypeDescription *desc; /**< description of name, size */
  CONST dim_type *dimen;
};

struct IntegerConstantInstance {
  enum inst_t t;
  unsigned vflag;       /**< assigned? */
  unsigned long visited;    /**< visited counter */
  unsigned long tmp_num;    /**< used when an instance tree is being copied*/
  VOIDPTR interface_ptr;
  unsigned int anon_flags;  /**< anonymous field to be manipulated */
  /**< above should match with CommonConstantInstance */
  long value;
  struct gl_list_t *parents;    /**< link to parents */
  struct gl_list_t *whens;      /**< whens where this integer appears*/
  struct Instance *alike_ptr;   /**< circular linked list of clique members?*/
  struct TypeDescription *desc; /**< description of name, size */
};

struct BooleanConstantInstance {
  enum inst_t t;
  unsigned vflag;       /**< assigned? */
  unsigned long visited;    /**< visited counter */
  unsigned long tmp_num;    /**< used when an instance tree is being copied*/
  VOIDPTR interface_ptr;
  /**< above should match with CommonConstantInstance */
  unsigned int anon_flags;  /**< anonymous field to be manipulated */
  struct gl_list_t *parents;    /**< link to parents */
  struct gl_list_t *whens;      /**< whens where this boolean appears*/
  struct Instance *alike_ptr;   /**< circular linked list of clique members?*/
  struct TypeDescription *desc; /**< description of name, size */
};

struct SymbolConstantInstance {
  enum inst_t t;
  unsigned vflag;       /**< assigned */
  unsigned long visited;    /**< visited counter */
  unsigned long tmp_num;    /**< used when an instance tree is being copied*/
  VOIDPTR interface_ptr;
  unsigned int anon_flags;  /**< anonymous field to be manipulated */
  /**< above should match with CommonConstantInstance */
  struct gl_list_t *parents;    /**< link to parents */
  struct gl_list_t *whens;      /**< whens where this symbol appears*/
  struct Instance *alike_ptr;   /**< circular linked list of clique members?*/
  struct TypeDescription *desc; /**< description of name, size */
  symchar *value;
};

/**< RelationInstance should probably be pooled, as RealAtomInstance,
 * but isn't yet for the same reasons.
 */
/**< aligns on 4 or 8 byte ptr machines. size 48/88 */
struct RelationInstance {
  enum inst_t t;
  /**< on long pointer machines, we expect C compiler to pad 4 bytes here */
  VOIDPTR interface_ptr;
  struct Instance *parent[2];   /**< relations can have only two parents and */
    /**< normally they only have one.  They have */
    /**< two only during an ARE_THE_SAME */
  struct TypeDescription *desc; /**< holds the child list stuff */
  unsigned long visited;
  unsigned long tmp_num;    /**< used when an instance tree is being copied*/
  unsigned int anon_flags;  /**< anonymous field to be manipulated */
  enum Expr_enum type;      /**< what kind of the 5 possible types of reln */
                                /**< type should be down in union RelationUnion*/
  struct relation *ptr;     /**< pointer to an instance relation */
  struct gl_list_t *whens;  /**< link to whens on which the rel appears */
  struct gl_list_t *logrels;    /**< link to satified's on which rel appears */
  /**< So child insts start packing on 8byte address after child ptrs, of
   * which there are (currently, 2/97) always an even number.
   */
  /**< Not required anymore:
   *
   * #if (LONGCHILDREN == 0)
   * int padding;
   * #endif
   *
   * Not valid anymore:
   *
   * An even number of child pointers are packed here, the last of which
   * may not be real because the number of children may be odd.
   * This extra should be eliminated for LONG pointer machines.
   */

  /**< After the child pointers comes the data space for the actual
   * children.
   */
};


/**< this aligns to 8 bytes with 4 or 8 byte pointers. size 48/88 */
struct LogRelInstance {
  enum inst_t t;
  /**< on long pointer machines, we expect C compiler to pad 4 bytes here */
  VOIDPTR interface_ptr;
  struct Instance *parent[2];   /**< log relations can have only two parents */
    /**< and normally they only have one.They have */
    /**< two only during an ARE_THE_SAME */
  struct TypeDescription *desc; /**< holds the child list stuff */
  unsigned long visited;
  unsigned long tmp_num;    /**< used when an instance tree is being copied*/
  struct logrelation *ptr;  /**< pointer to an instance logical relation */
  struct gl_list_t *whens;  /**< link to whens on which the logrel appears */
  struct gl_list_t *logrels;    /**< link to satified's on which lrel appears */
  unsigned int anon_flags;  /**< anonymous field to be manipulated */
  int padding;
  /**< so child insts start packing on 8byte address after child ptrs */
  /**< 
   * All logrelations are the same type/size, because we require
   * exactly 1 refinement of the base definition.
   */
  /**< After the child pointers comes the data space for the actual
   * children. This space must start on an 8 byte address.
   */
};

/**< Never, ever, allocate either one of these types. it's a dummy for the
 * instantiator.
 */
struct PendInstance {
  enum inst_t t;
  VOIDPTR p;
};


/**< COMPOUND INSTANCES */
/**<   Note: All the compound instance structs, except ArrayChild,
 *   and Automatic should have
  enum inst_t t;
  VOIDPTR pending_entry;
 *   as the first two lines to match PendInstance above.
 * Relations of any type are NOT compound, other errors in
 * this file not withstanding.
 */
/**< this structure doesn't have to align on 4 byte ptr machines. size 48/88 */
struct ModelInstance {
  enum inst_t t;
  VOIDPTR pending_entry;    /**< hold a word only pending.c can touch */
  VOIDPTR interface_ptr;
  struct gl_list_t *parents;    /**< link to parent instances */
  struct gl_list_t *whens;  /**< link to whens on which the model appears */
  struct TypeDescription *desc;
  struct Instance *alike_ptr;
  struct BitList *executed; /**< bit list to keep track of which */
    /**< statements have been executed */
  unsigned long visited;
  unsigned long tmp_num;    /**< used when an instance tree is being copied*/
  unsigned int anon_flags;  /**< anonymous field to be manipulated */
#if (LONGCHILDREN == 1)
  int padding;          /**< so ptrs start packing on 8byte address */
#endif
  /**< The child pointers of model instances are packed here, but each is
   * different and there may not even be children. They are not
   * accessible through the struct, but only through InstanceChild.
   *
   */
};

/**< This struct not in use anywhere yet, pending more semantics */
struct AutomaticInstance {
  enum inst_t t;
  /**< this object never pending since it has no statements */
  VOIDPTR interface_ptr;
  struct Instance *sim_parent;  /**< exactly one of these */
  struct TypeDescription *desc; /**< UNIVERSAL and made at startup */
  unsigned long visited;
  unsigned long tmp_num;    /**< used when an instance tree is being copied*/
  unsigned int anon_flags;  /**< anonymous field to be manipulated */

  struct gl_list_t *children;  /**< unique unsorted list of child insts */

  /**< struct hashtable *childdata;
   * hash lookup of children.
   */
  /**< note that in table there may be multiple names for a child that
   * occurs once in childdata.
   */
  /**< HANDS OFF!  --Ben */
};

/**< First try of a WhenInstance needs to migrate toward the relations */
/**< would be nice to have a commoneqninstance type (CE_INST)
 * for rel,log,when.
 */
/**< doesn't align as never has children. */
struct WhenInstance {
  enum inst_t t;
  VOIDPTR interface_ptr;
  struct Instance *parent[2];   /**< relations can have only two parents and */
    /**< normally they only have one.  They have */
    /**< two only during an ARE_THE_SAME */
  struct gl_list_t *whens;      /**< used in case of nested whens */
  struct gl_list_t *cases;      /**< list of cases */
  struct gl_list_t *bvar ;      /**< list of references to boolean variables  */
  struct TypeDescription *desc; /**< holds the child list stuff */
  unsigned long visited;
  unsigned long tmp_num;    /**< used when an instance tree is being copied*/
  unsigned int anon_flags;  /**< anonymous field to be manipulated */
};

/**< are pooled, and therefore must align, but does so on its own */
struct ArrayChild {
  /**< this object never pending, but member inst may be */
  struct Instance *inst;
  union {
    symchar *str;
    long index;
  } name;
};

/**< never has packed children. see gllist instead. */
struct ArrayInstance {
  enum inst_t t;
  VOIDPTR pending_entry;    /**< hold a word only pending.c can touch */
  VOIDPTR interface_ptr;
  struct TypeDescription *desc; /**< holds the child list stuff */
  struct gl_list_t *parents;    /**< link to parent instances */
  struct gl_list_t *children;   /**< link to children */
  unsigned long indirected; /**< number of times of indirected */
  unsigned long visited;
  unsigned long tmp_num;    /**< used when an instance tree is being copied*/
  unsigned int anon_flags;  /**< anonymous field to be manipulated */
};

/**< CONTAINER INSTANCE for interfaces. never pending. */
/**< no packed children, so never need align */
struct SimulationInstance {   /**< these have *no* parents, yet */
  enum inst_t t;
  VOIDPTR interface_ptr;
  struct TypeDescription *desc; /**< copy of the typedesc of its lone child */
  symchar *name;        /**< name of its lone child */
  struct Instance **extvars;    /**< external variables handles hack */
  unsigned long tmp_num;    /**< used when an instance tree is being copied*/
  unsigned int anon_flags;  /**< anonymous field to be manipulated */
  /**< add other interesting stuff here */
};

/**< dummy instance for unselected children of models */
/**< no alignment issue */
struct GlobalDummyInstance {
  enum inst_t t;
  /**< never pending */
  VOIDPTR interface_ptr;
  /**< no link to parent instances */
  /**< when instances should ignore dummy completely */
  struct TypeDescription *desc;
  /**< all dummies are alike -- and the same */
  /**< dummy has not statements */
  unsigned long visited;
  unsigned long ref_count;  /**< mainly for debugging purposes */
  unsigned long tmp_num;    /**< used when an instance tree is being copied*/
  /**< but CopyDummy==dummy always */
  unsigned int anon_flags;  /**< anonymous field to be manipulated */
  /**< why make life hell for the unsuspecting client? */
  /**< 
   * In particular, the DUMMY_INST doesn't look like any category
   * (EQN,Compound,Atom,Constant)  because a single statically allocated
   * instance of it stands in for all UNSELECTED_INSTANCEs that are
   * not compiled.
   * (This has nothing to do with the DummyIndexType.)
   */
};

#endif /**< __INSTANCE_TYPES_H_SEEN__ */