case STRING:           if ((expectedType != UNKNOWN_VALUE) &&               (expectedType != STRING) &&               (expectedType != SYMBOL_OR_STRING)) error = TRUE;           constantParsed = TRUE;           break;         case SYMBOL:           if ((expectedType != UNKNOWN_VALUE) &&               (expectedType != SYMBOL) &&               (expectedType != SYMBOL_OR_STRING)) error = TRUE;           constantParsed = TRUE;           break;#if OBJECT_SYSTEM         case INSTANCE_NAME:           if ((expectedType != UNKNOWN_VALUE) &&               (expectedType != INSTANCE_NAME)) error = TRUE;           constantParsed = TRUE;           break;#endif         case SF_VARIABLE:           if (strcmp(inputToken.printForm,"?VARIABLE") == 0)             { variableParsed = TRUE; }           else             {              char tempBuffer[120];              gensprintf(tempBuffer,"%s attribute",constraintName);              SyntaxErrorMessage(theEnv,tempBuffer);              return(FALSE);             }           break;         default:           {            char tempBuffer[120];            gensprintf(tempBuffer,"%s attribute",constraintName);            SyntaxErrorMessage(theEnv,tempBuffer);           }           return(FALSE);        }      /*=====================================*/      /* Signal an error if an inappropriate */      /* value was found.                    */      /*=====================================*/      if (error)        {         PrintErrorID(theEnv,"CSTRNPSR",4,TRUE);         EnvPrintRouter(theEnv,WERROR,"Value does not match the expected type for the ");         EnvPrintRouter(theEnv,WERROR,constraintName);         EnvPrintRouter(theEnv,WERROR," attribute\n");         return(FALSE);        }      /*======================================*/      /* The ?VARIABLE argument can't be used */      /* in conjunction with constants.       */      /*======================================*/      if (constantParsed && variableParsed)        {         char tempBuffer[120];         gensprintf(tempBuffer,"%s attribute",constraintName);         SyntaxErrorMessage(theEnv,tempBuffer);         return(FALSE);        }      /*===========================================*/      /* Add the constant to the restriction list. */      /*===========================================*/      newValue = GenConstant(theEnv,inputToken.type,inputToken.value);      if (lastValue == NULL)        {          if (strcmp(constraintName,"allowed-classes") == 0)           { constraints->classList = newValue; }         else           { constraints->restrictionList = newValue; }        }      else        { lastValue->nextArg = newValue; }      lastValue = newValue;      /*=======================================*/      /* Begin parsing the next allowed value. */      /*=======================================*/      GetToken(theEnv,readSource,&inputToken);     }   /*======================================================*/   /* There must be at least one value for this attribute. */   /*======================================================*/   if ((! constantParsed) && (! variableParsed))     {      char tempBuffer[120];      gensprintf(tempBuffer,"%s attribute",constraintName);      SyntaxErrorMessage(theEnv,tempBuffer);      return(FALSE);     }   /*======================================*/   /* If ?VARIABLE was parsed, then remove */   /* the restrictions for the type being  */   /* restricted.                          */   /*======================================*/   if (variableParsed)     {      switch(restrictionType)        {         case UNKNOWN_VALUE:           constraints->anyRestriction = FALSE;           break;         case SYMBOL:           constraints->symbolRestriction = FALSE;           break;         case STRING:           constraints->stringRestriction = FALSE;           break;         case INTEGER:           constraints->integerRestriction = FALSE;           break;         case FLOAT:           constraints->floatRestriction = FALSE;           break;         case INTEGER_OR_FLOAT:           constraints->floatRestriction = FALSE;           constraints->integerRestriction = FALSE;           break;         case SYMBOL_OR_STRING:           constraints->symbolRestriction = FALSE;           constraints->stringRestriction = FALSE;           break;         case INSTANCE_NAME:           constraints->instanceNameRestriction = FALSE;           break;         case INSTANCE_OR_INSTANCE_NAME:           constraints->classRestriction = FALSE;           break;        }     }   /*=====================================*/   /* Fix up pretty print representation. */   /*=====================================*/   PPBackup(theEnv);   PPBackup(theEnv);   SavePPBuffer(theEnv,")");   /*=======================================*/   /* Return TRUE to indicate the attribute */   /* was successfully parsed.              */   /*=======================================*/   return(TRUE);  }/***********************************************************//* NoConjunctiveUseError: Generic error message indicating *//*   that two attributes can't be used in conjunction.     *//***********************************************************/static void NoConjunctiveUseError(  void *theEnv,  char *attribute1,  char *attribute2)  {   PrintErrorID(theEnv,"CSTRNPSR",3,TRUE);   EnvPrintRouter(theEnv,WERROR,"The ");   EnvPrintRouter(theEnv,WERROR,attribute1);   EnvPrintRouter(theEnv,WERROR," attribute cannot be used\n");   EnvPrintRouter(theEnv,WERROR,"in conjunction with the ");   EnvPrintRouter(theEnv,WERROR,attribute2);   EnvPrintRouter(theEnv,WERROR," attribute.\n");  }/**************************************************//* ParseTypeAttribute: Parses the type attribute. *//**************************************************/static intBool ParseTypeAttribute(  void *theEnv,  char *readSource,  CONSTRAINT_RECORD *constraints)  {   int typeParsed = FALSE;   int variableParsed = FALSE;   int theType;   struct token inputToken;   /*======================================*/   /* Continue parsing types until a right */   /* parenthesis is encountered.          */   /*======================================*/   SavePPBuffer(theEnv," ");   for (GetToken(theEnv,readSource,&inputToken);        inputToken.type != RPAREN;        GetToken(theEnv,readSource,&inputToken))     {      SavePPBuffer(theEnv," ");      /*==================================*/      /* If the token is a symbol then... */      /*==================================*/      if (inputToken.type == SYMBOL)        {         /*==============================================*/         /* ?VARIABLE can't be used with type constants. */         /*==============================================*/         if (variableParsed == TRUE)           {            SyntaxErrorMessage(theEnv,"type attribute");            return(FALSE);           }         /*========================================*/         /* Check for an appropriate type constant */         /* (e.g. SYMBOL, FLOAT, INTEGER, etc.).   */         /*========================================*/         theType = GetConstraintTypeFromTypeName(ValueToString(inputToken.value));         if (theType < 0)           {            SyntaxErrorMessage(theEnv,"type attribute");            return(FALSE);           }         /*==================================================*/         /* Change the type restriction flags to reflect the */         /* type restriction. If the type restriction was    */         /* already specified, then a error is generated.    */         /*==================================================*/         if (SetConstraintType(theType,constraints))           {            SyntaxErrorMessage(theEnv,"type attribute");            return(FALSE);           }         constraints->anyAllowed = FALSE;         /*===========================================*/         /* Remember that a type constant was parsed. */         /*===========================================*/         typeParsed = TRUE;        }      /*==============================================*/      /* Otherwise if the token is a variable then... */      /*==============================================*/      else if (inputToken.type == SF_VARIABLE)        {         /*========================================*/         /* The only variable allowd is ?VARIABLE. */         /*========================================*/         if (strcmp(inputToken.printForm,"?VARIABLE") != 0)           {            SyntaxErrorMessage(theEnv,"type attribute");            return(FALSE);           }         /*===================================*/         /* ?VARIABLE can't be used more than */         /* once or with type constants.      */         /*===================================*/         if (typeParsed || variableParsed)           {            SyntaxErrorMessage(theEnv,"type attribute");            return(FALSE);           }         /*======================================*/         /* Remember that a variable was parsed. */         /*======================================*/         variableParsed = TRUE;        }      /*====================================*/      /* Otherwise this is an invalid value */      /* for the type attribute.            */      /*====================================*/       else        {         SyntaxErrorMessage(theEnv,"type attribute");         return(FALSE);        }     }   /*=====================================*/   /* Fix up pretty print representation. */   /*=====================================*/   PPBackup(theEnv);   PPBackup(theEnv);   SavePPBuffer(theEnv,")");   /*=======================================*/   /* The type attribute must have a value. */   /*=======================================*/   if ((! typeParsed) && (! variableParsed))     {      SyntaxErrorMessage(theEnv,"type attribute");      return(FALSE);     }   /*===========================================*/   /* Return TRUE indicating the type attibuted */   /* was successfully parsed.                  */   /*===========================================*/   return(TRUE);  }