}/*************************************************************  NAME         : ParseDefaultFacet  DESCRIPTION  : Parses the facet for a slot  INPUTS       : 1) The input logical name                 2) The bitmap indicating which facets have                    already been parsed                 3) The slot descriptor to set  RETURNS      : TRUE if all OK, FALSE otherwise  SIDE EFFECTS : Slot  set and parsed facet bitmap set  NOTES        : Syntax: (default ?NONE|<expression>*)                         (default-dynamic <expression>*) *************************************************************/static intBool ParseDefaultFacet(  void *theEnv,  char *readSource,  char *specbits,  SLOT_DESC *slot)  {   EXPRESSION *tmp;   int error,noneSpecified,deriveSpecified;   if (TestBitMap(specbits,DEFAULT_BIT))     {      PrintErrorID(theEnv,"CLSLTPSR",2,FALSE);      EnvPrintRouter(theEnv,WERROR,"default facet already specified.\n");      return(FALSE);     }   SetBitMap(specbits,DEFAULT_BIT);   error = FALSE;   tmp = ParseDefault(theEnv,readSource,1,(int) TestBitMap(specbits,DEFAULT_DYNAMIC_BIT),                      0,&noneSpecified,&deriveSpecified,&error);   if (error == TRUE)     return(FALSE);   if (noneSpecified || deriveSpecified)     {     if (noneSpecified)       {        slot->noDefault = 1;        slot->defaultSpecified = 1;       }      else        ClearBitMap(specbits,DEFAULT_BIT);     }   else     {      slot->defaultValue = (void *) PackExpression(theEnv,tmp);      ReturnExpression(theEnv,tmp);      ExpressionInstall(theEnv,(EXPRESSION *) slot->defaultValue);      slot->defaultSpecified = 1;     }   return(TRUE);  }/**************************************************************************  NAME         : BuildCompositeFacets  DESCRIPTION  : Composite slots are ones that get their facets                   from more than one class.  By default, the most                   specific class in object's precedence list specifies                   the complete set of facets for a slot.  The composite                   facet in a slot allows facets that are not overridden                   by the most specific class to be obtained from other                   classes.                 Since all superclasses are predetermined before creating                   a new class based on them, this routine need only                   examine the immediately next most specific class for                   extra facets.  Even if that slot is also composite, the                   other facets have already been filtered down.  If the                   slot is no-inherit, the next most specific class must                   be examined.  INPUTS       : 1) The slot descriptor                 2) The class precedence list                 3) The bitmap marking which facets were specified in                    the original slot definition  RETURNS      : Nothing useful  SIDE EFFECTS : Composite slot is updated to reflect facets from                   a less specific class  NOTES        : Assumes slot is composite *************************************************************************/static void BuildCompositeFacets(  void *theEnv,  SLOT_DESC *sd,  PACKED_CLASS_LINKS *preclist,  char *specbits,  CONSTRAINT_PARSE_RECORD *parsedConstraint)  {   SLOT_DESC *compslot = NULL;   long i;   for (i = 1 ; i < preclist->classCount ; i++)     {      compslot = FindClassSlot(preclist->classArray[i],sd->slotName->name);      if ((compslot != NULL) ? (compslot->noInherit == 0) : FALSE)        break;     }   if (compslot != NULL)     {      if ((sd->defaultSpecified == 0) && (compslot->defaultSpecified == 1))        {         sd->dynamicDefault = compslot->dynamicDefault;         sd->noDefault = compslot->noDefault;         sd->defaultSpecified = 1;         if (compslot->defaultValue != NULL)           {            if (sd->dynamicDefault)              {               sd->defaultValue = (void *) PackExpression(theEnv,(EXPRESSION *) compslot->defaultValue);               ExpressionInstall(theEnv,(EXPRESSION *) sd->defaultValue);              }            else              {               sd->defaultValue = (void *) get_struct(theEnv,dataObject);               GenCopyMemory(DATA_OBJECT,1,sd->defaultValue,compslot->defaultValue);               ValueInstall(theEnv,(DATA_OBJECT *) sd->defaultValue);              }           }        }      if (TestBitMap(specbits,FIELD_BIT) == 0)        sd->multiple = compslot->multiple;      if (TestBitMap(specbits,STORAGE_BIT) == 0)        sd->shared = compslot->shared;      if (TestBitMap(specbits,ACCESS_BIT) == 0)        {         sd->noWrite = compslot->noWrite;         sd->initializeOnly = compslot->initializeOnly;        }#if DEFRULE_CONSTRUCT      if (TestBitMap(specbits,MATCH_BIT) == 0)        sd->reactive = compslot->reactive;#endif      if (TestBitMap(specbits,VISIBILITY_BIT) == 0)        sd->publicVisibility = compslot->publicVisibility;      if (TestBitMap(specbits,CREATE_ACCESSOR_BIT) == 0)        {         sd->createReadAccessor = compslot->createReadAccessor;         sd->createWriteAccessor = compslot->createWriteAccessor;        }      if ((TestBitMap(specbits,OVERRIDE_MSG_BIT) == 0) &&          compslot->overrideMessageSpecified)        {         DecrementSymbolCount(theEnv,sd->overrideMessage);         sd->overrideMessage = compslot->overrideMessage;         IncrementSymbolCount(sd->overrideMessage);         sd->overrideMessageSpecified = TRUE;        }      OverlayConstraint(theEnv,parsedConstraint,sd->constraint,compslot->constraint);     }  }/***************************************************  NAME         : CheckForFacetConflicts  DESCRIPTION  : Determines if all facets specified                 (and inherited) for a slot are                 consistent  INPUTS       : 1) The slot descriptor                 2) The parse record for the                    type constraints on the slot  RETURNS      : TRUE if all OK,                 FALSE otherwise  SIDE EFFECTS : Min and Max fields replaced in                 constraint for single-field slot  NOTES        : None ***************************************************/static intBool CheckForFacetConflicts(  void *theEnv,  SLOT_DESC *sd,  CONSTRAINT_PARSE_RECORD *parsedConstraint)  {   if (sd->multiple == 0)     {      if (parsedConstraint->cardinality)        {         PrintErrorID(theEnv,"CLSLTPSR",3,TRUE);         EnvPrintRouter(theEnv,WERROR,"Cardinality facet can only be used with multifield slots\n");         return(FALSE);        }      else        {         ReturnExpression(theEnv,sd->constraint->minFields);         ReturnExpression(theEnv,sd->constraint->maxFields);         sd->constraint->minFields = GenConstant(theEnv,INTEGER,EnvAddLong(theEnv,1LL));         sd->constraint->maxFields = GenConstant(theEnv,INTEGER,EnvAddLong(theEnv,1LL));        }     }   if (sd->noDefault && sd->noWrite)     {      PrintErrorID(theEnv,"CLSLTPSR",4,TRUE);      EnvPrintRouter(theEnv,WERROR,"read-only slots must have a default value\n");      return(FALSE);     }   if (sd->noWrite && (sd->createWriteAccessor || sd->overrideMessageSpecified))     {      PrintErrorID(theEnv,"CLSLTPSR",5,TRUE);      EnvPrintRouter(theEnv,WERROR,"read-only slots cannot have a write accessor\n");      return(FALSE);     }   if (sd->noInherit && sd->publicVisibility)     {      PrintErrorID(theEnv,"CLSLTPSR",6,TRUE);      EnvPrintRouter(theEnv,WERROR,"no-inherit slots cannot also be public\n");      return(FALSE);     }   return(TRUE);  }/********************************************************************  NAME         : EvaluateSlotDefaultValue  DESCRIPTION  : Checks the default value against the slot                 constraints and evaluates static default values  INPUTS       : 1) The slot descriptor                 2) The bitmap marking which facets were specified in                    the original slot definition  RETURNS      : TRUE if all OK, FALSE otherwise  SIDE EFFECTS : Static default value expressions deleted and                 replaced with data object evaluation  NOTES        : On errors, slot is marked as dynamix so that                 DeleteSlots() will erase the slot expression ********************************************************************/static intBool EvaluateSlotDefaultValue(  void *theEnv,  SLOT_DESC *sd,  char *specbits)  {   DATA_OBJECT temp;   int oldce,olddcc,vCode;   /* ===================================================================      Slot default value expression is marked as dynamic until now so      that DeleteSlots() would erase in the event of an error.  The delay      was so that the evaluation of a static default value could be      delayed until all the constraints were parsed.      =================================================================== */   if (TestBitMap(specbits,DEFAULT_DYNAMIC_BIT) == 0)     sd->dynamicDefault = 0;   if (sd->noDefault)     return(TRUE);   if (sd->dynamicDefault == 0)     {      if (TestBitMap(specbits,DEFAULT_BIT))        {         oldce = ExecutingConstruct(theEnv);         SetExecutingConstruct(theEnv,TRUE);         olddcc = EnvSetDynamicConstraintChecking(theEnv,EnvGetStaticConstraintChecking(theEnv));         vCode = EvaluateAndStoreInDataObject(theEnv,(int) sd->multiple,                  (EXPRESSION *) sd->defaultValue,&temp,TRUE);         if (vCode != FALSE)           vCode = ValidSlotValue(theEnv,&temp,sd,NULL,"slot default value");         EnvSetDynamicConstraintChecking(theEnv,olddcc);         SetExecutingConstruct(theEnv,oldce);         if (vCode)           {            ExpressionDeinstall(theEnv,(EXPRESSION *) sd->defaultValue);            ReturnPackedExpression(theEnv,(EXPRESSION *) sd->defaultValue);            sd->defaultValue = (void *) get_struct(theEnv,dataObject);            GenCopyMemory(DATA_OBJECT,1,sd->defaultValue,&temp);            ValueInstall(theEnv,(DATA_OBJECT *) sd->defaultValue);           }         else           {            sd->dynamicDefault = 1;            return(FALSE);           }        }      else if (sd->defaultSpecified == 0)        {         sd->defaultValue = (void *) get_struct(theEnv,dataObject);         DeriveDefaultFromConstraints(theEnv,sd->constraint,                                      (DATA_OBJECT *) sd->defaultValue,(int) sd->multiple,TRUE);         ValueInstall(theEnv,(DATA_OBJECT *) sd->defaultValue);        }     }   else if (EnvGetStaticConstraintChecking(theEnv))     {      vCode = ConstraintCheckExpressionChain(theEnv,(EXPRESSION *) sd->defaultValue,sd->constraint);      if (vCode != NO_VIOLATION)        {         PrintErrorID(theEnv,"CSTRNCHK",1,FALSE);         EnvPrintRouter(theEnv,WERROR,"Expression for ");         PrintSlot(theEnv,WERROR,sd,NULL,"dynamic default value");         ConstraintViolationErrorMessage(theEnv,NULL,NULL,0,0,NULL,0,                                         vCode,sd->constraint,FALSE);         return(FALSE);        }     }   return(TRUE);  }#endif