예제 #1
0
파일: constrnt.c 프로젝트: DrItanium/maya
void SDCCommand(
  Environment *theEnv,
  UDFContext *context,
  UDFValue *returnValue)
  {
   UDFValue theArg;

   returnValue->lexemeValue = CreateBoolean(theEnv,GetDynamicConstraintChecking(theEnv));

   if (! UDFFirstArgument(context,ANY_TYPE_BITS,&theArg))
     { return; }

   SetDynamicConstraintChecking(theEnv,theArg.value != FalseSymbol(theEnv));
  }
예제 #2
0
BOOL FAR PASCAL ExecDlg (
   HWND       hDlg,
   unsigned   message,
   WORD       wParam,
   LONG       lParam)

{  switch (message)
   {  case WM_INITDIALOG:
      {  WPARAM item;
	 SetWindowText ( hDlg, (LPSTR)"Execution Options" );

	 /*-----------------------------+
	 | Initalize Strategy Combo Box |
	 +-----------------------------*/
#if CONFLICT_RESOLUTION_STRATEGIES
	 SendDlgItemMessage (hDlg, IDC_EXE_STRATEGY, CB_ADDSTRING,0,(LPARAM)((LPSTR) "Depth"));
	 SendDlgItemMessage (hDlg, IDC_EXE_STRATEGY, CB_ADDSTRING,0,(LPARAM)((LPSTR) "Breadth"));
	 SendDlgItemMessage (hDlg, IDC_EXE_STRATEGY, CB_ADDSTRING,0,(LPARAM)((LPSTR) "LEX"));
	 SendDlgItemMessage (hDlg, IDC_EXE_STRATEGY, CB_ADDSTRING,0,(LPARAM)((LPSTR) "MEA"));
	 SendDlgItemMessage (hDlg, IDC_EXE_STRATEGY, CB_ADDSTRING,0,(LPARAM)((LPSTR) "Complexity"));
	 SendDlgItemMessage (hDlg, IDC_EXE_STRATEGY, CB_ADDSTRING,0,(LPARAM)((LPSTR) "Simplicity"));
	 SendDlgItemMessage (hDlg, IDC_EXE_STRATEGY, CB_ADDSTRING,0,(LPARAM)((LPSTR) "Random"));

	 switch (  GetStrategy())
	 {   case DEPTH_STRATEGY:
		  item = (int) SendDlgItemMessage(hDlg,IDC_EXE_STRATEGY,CB_FINDSTRING,0,(LPARAM)((LPSTR)"Depth"));
		  break;
	     case BREADTH_STRATEGY:
		  item = (int) SendDlgItemMessage(hDlg,IDC_EXE_STRATEGY,CB_FINDSTRING,0,(LPARAM)((LPSTR)"Breadth"));
		  break;
	     case LEX_STRATEGY:
		  item = (int) SendDlgItemMessage(hDlg,IDC_EXE_STRATEGY,CB_FINDSTRING,0,(LPARAM)((LPSTR)"LEX"));
		  break;
	     case MEA_STRATEGY:
		  item = (int) SendDlgItemMessage(hDlg,IDC_EXE_STRATEGY,CB_FINDSTRING,0,(LPARAM)((LPSTR)"MEA"));
		  break;
	     case COMPLEXITY_STRATEGY:
		  item = (int) SendDlgItemMessage(hDlg,IDC_EXE_STRATEGY,CB_FINDSTRING,0,(LPARAM)((LPSTR)"Complexity"));
		  break;
	     case SIMPLICITY_STRATEGY:
		  item = (int) SendDlgItemMessage(hDlg,IDC_EXE_STRATEGY,CB_FINDSTRING,0,(LPARAM)((LPSTR)"Simplicity"));
		  break;
	     case RANDOM_STRATEGY:
		  item = (int) SendDlgItemMessage(hDlg,IDC_EXE_STRATEGY,CB_FINDSTRING,0,(LPARAM)((LPSTR)"Random"));
		  break;
	 }
#else
	 SendDlgItemMessage (hDlg, IDC_EXE_STRATEGY, CB_ADDSTRING,0,(LPARAM)((LPSTR) "Depth"));
	 item = (int) SendDlgItemMessage(hDlg,IDC_EXE_STRATEGY,CB_FINDSTRING,0,(LPARAM)((LPSTR)"Depth"));
#endif
	 SendDlgItemMessage (hDlg, IDC_EXE_STRATEGY, CB_SETCURSEL, item, 0);

	 /*-----------------------------+
	 | Initalize Salience Combo Box |
	 +-----------------------------*/
#if DYNAMIC_SALIENCE
	 SendDlgItemMessage (hDlg, IDC_EXE_SALIENCE, CB_ADDSTRING,0,(LPARAM)((LPSTR) "When Defined"));
	 SendDlgItemMessage (hDlg, IDC_EXE_SALIENCE, CB_ADDSTRING,0,(LPARAM)((LPSTR) "When Activated"));
	 SendDlgItemMessage (hDlg, IDC_EXE_SALIENCE, CB_ADDSTRING,0,(LPARAM)((LPSTR) "Every Cycle"));

	 switch (GetSalienceEvaluation())
	 {   case WHEN_DEFINED:
		item = (int) SendDlgItemMessage (hDlg, IDC_EXE_SALIENCE, CB_FINDSTRING,0,(LPARAM)((LPSTR) "When Defined"));
		break;
	     case WHEN_ACTIVATED:
		item = (int) SendDlgItemMessage (hDlg, IDC_EXE_SALIENCE, CB_FINDSTRING,0,(LPARAM)((LPSTR) "When Activated"));
		break;
	     case EVERY_CYCLE:
		item = (int) SendDlgItemMessage (hDlg, IDC_EXE_SALIENCE, CB_FINDSTRING,0,(LPARAM)((LPSTR) "Every Cycle"));
		break;
	 }
#else
	 SendDlgItemMessage (hDlg, IDC_EXE_SALIENCE, CB_ADDSTRING,0,(LPARAM)((LPSTR) "When Defined"));
	 item = SendDlgItemMessage (hDlg, IDC_EXE_SALIENCE, CB_FINDSTRING,0,(LPARAM)((LPSTR) "When Defined"));
#endif
	 SendDlgItemMessage (hDlg, IDC_EXE_SALIENCE, CB_SETCURSEL, item, 0);

	  /*-----------------------------------+
	 | Disable Incremental reset check box |
	 | if any rules are in the system.     |
	 +------------------------------------*/
	 if ( GetNextDefrule (NULL) != NULL )
	 {  EnableWindow(GetDlgItem(hDlg, IDC_WATCH_ALL ), TRUE);
	 }

	 /*----------------------------+
	 | Initalize Other Check Boxes |
	 +----------------------------*/
	 SetCheckBox(hDlg, IDC_EXE_STATIC, GetStaticConstraintChecking());
	 SetCheckBox(hDlg, IDC_EXE_DYNAMIC, GetDynamicConstraintChecking());
	 SetCheckBox(hDlg, IDC_EXE_AUTO, GetAutoFloatDividend());
#if DEFGLOBAL_CONSTRUCT
	 SetCheckBox(hDlg, IDC_EXE_GLOBAL, GetResetGlobals());
#endif
#if DEFTEMPLATE_CONSTRUCT
	 SetCheckBox(hDlg, IDC_EXE_FACT, GetFactDuplication());
#endif
#if INCREMENTAL_RESET & (! RUN_TIME)
	 SetCheckBox(hDlg, IDC_EXE_RESET, GetIncrementalReset());
#endif
#if (!RUN_TIME)
	 SetCheckBox(hDlg, IDC_EXE_SEQUENCE, GetSequenceOperatorRecognition());
#endif
	 return (TRUE);
      }

      case WM_COMMAND:
      {  switch ( wParam )
	 {  case IDC_OK:
	    {  int value;
			 char Msg[40];

#if DYNAMIC_SALIENCE
	       /*--------------------------+
	       | Decode Salience Combo Box |
	       +--------------------------*/
	       value = (int) SendDlgItemMessage (hDlg, IDC_EXE_SALIENCE, CB_GETCURSEL, 0, 0);

			 SendDlgItemMessage (hDlg, IDC_EXE_SALIENCE, CB_GETLBTEXT, value, (LONG)Msg );

			 if ( strcmp (Msg, "When Defined"  ) == 0 )
		  SetSalienceEvaluation(WHEN_DEFINED);
			 else if (strcmp(Msg, "When Activated" ) == 0)
		  SetSalienceEvaluation(WHEN_ACTIVATED);
	       else
		  SetSalienceEvaluation(EVERY_CYCLE);
#endif

#if CONFLICT_RESOLUTION_STRATEGIES
	       /*--------------------------+
	       | Decode Strategy Combo Box |
	       +--------------------------*/
	       value = (int) SendDlgItemMessage (hDlg, IDC_EXE_STRATEGY, CB_GETCURSEL, 0, 0);
	       SendDlgItemMessage (hDlg, IDC_EXE_STRATEGY, CB_GETLBTEXT, value, (LONG)Msg );

			 if ( strcmp (Msg, "Depth"  ) == 0 )
		  SetStrategy(DEPTH_STRATEGY);
			 else if (strcmp(Msg, "Breadth" ) == 0)
		  SetStrategy(BREADTH_STRATEGY);
			 else if (strcmp(Msg, "LEX") == 0 )
		  SetStrategy(LEX_STRATEGY);
			 else if (strcmp(Msg, "MEA") == 0 )
		  SetStrategy(MEA_STRATEGY);
			 else if (strcmp(Msg, "Complexity") == 0 )
		  SetStrategy(COMPLEXITY_STRATEGY);
			 else if (strcmp(Msg, "Simplicity") == 0 )
		  SetStrategy(SIMPLICITY_STRATEGY);
	       else
		  SetStrategy(RANDOM_STRATEGY);
#endif

			 /*-------------------------+
	       | Decode Other Check Boxes |
	       +-------------------------*/
	       SetStaticConstraintChecking ( IsDlgButtonChecked(hDlg, IDC_EXE_STATIC));
	       SetDynamicConstraintChecking ( IsDlgButtonChecked(hDlg, IDC_EXE_DYNAMIC));
			 SetAutoFloatDividend ( IsDlgButtonChecked(hDlg, IDC_EXE_AUTO));

#if DEFGLOBAL_CONSTRUCT
	       SetResetGlobals ( IsDlgButtonChecked(hDlg, IDC_EXE_GLOBAL));
#endif
#if DEFTEMPLATE_CONSTRUCT
	       SetFactDuplication( IsDlgButtonChecked(hDlg, IDC_EXE_FACT));
#endif
#if INCREMENTAL_RESET & (! RUN_TIME )
	       SetIncrementalReset ( IsDlgButtonChecked(hDlg, IDC_EXE_RESET));
#endif
#if ( ! RUN_TIME )
	       SetSequenceOperatorRecognition ( IsDlgButtonChecked(hDlg, IDC_EXE_SEQUENCE));
#endif
		 }

	    case IDC_CANCEL:
		 {  EndDialog( hDlg, IDOK);
			 return (TRUE);
	    }

	    /*-------------------+
	    | Toggle Check Boxes |
	    +-------------------*/
	    case IDC_EXE_RESET:
	    case IDC_EXE_STATIC:
	    case IDC_EXE_DYNAMIC:
	    case IDC_EXE_GLOBAL:
	    case IDC_EXE_FACT:
	    case IDC_EXE_AUTO:
	    case IDC_EXE_SEQUENCE:
	    {  SetCheckBox ( hDlg, wParam, !IsDlgButtonChecked (hDlg, wParam));
	       return (TRUE);
	    }

	 }
      }
   }
   return (FALSE);
}
예제 #3
0
파일: clsltpsr.c 프로젝트: DrItanium/maya
/********************************************************************
  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 bool EvaluateSlotDefaultValue(
  Environment *theEnv,
  SlotDescriptor *sd,
  const char *specbits)
  {
   UDFValue temp;
   bool oldce,olddcc, vPass;
   ConstraintViolationType 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))
     sd->dynamicDefault = 0;

   if (sd->noDefault)
     return true;

   if (sd->dynamicDefault == 0)
     {
      if (TestBitMap(specbits,DEFAULT_BIT))
        {
         oldce = ExecutingConstruct(theEnv);
         SetExecutingConstruct(theEnv,true);
         olddcc = SetDynamicConstraintChecking(theEnv,true);
         vPass = EvaluateAndStoreInDataObject(theEnv,sd->multiple,
                  (Expression *) sd->defaultValue,&temp,true);
         if (vPass != false)
           vPass = (ValidSlotValue(theEnv,&temp,sd,NULL,"the 'default' facet") == PSE_NO_ERROR);
         SetDynamicConstraintChecking(theEnv,olddcc);
         SetExecutingConstruct(theEnv,oldce);
         if (vPass)
           {
            ExpressionDeinstall(theEnv,(Expression *) sd->defaultValue);
            ReturnPackedExpression(theEnv,(Expression *) sd->defaultValue);
            sd->defaultValue = get_struct(theEnv,udfValue);
            GenCopyMemory(UDFValue,1,sd->defaultValue,&temp);
            RetainUDFV(theEnv,(UDFValue *) sd->defaultValue);
           }
         else
           {
            sd->dynamicDefault = 1;
            return false;
           }
        }
      else if (sd->defaultSpecified == 0)
        {
         sd->defaultValue = get_struct(theEnv,udfValue);
         DeriveDefaultFromConstraints(theEnv,sd->constraint,
                                      (UDFValue *) sd->defaultValue,sd->multiple,true);
         RetainUDFV(theEnv,(UDFValue *) sd->defaultValue);
        }
     }
   else
     {
      vCode = ConstraintCheckExpressionChain(theEnv,(Expression *) sd->defaultValue,sd->constraint);
      if (vCode != NO_VIOLATION)
        {
         PrintErrorID(theEnv,"CSTRNCHK",1,false);
         WriteString(theEnv,STDERR,"Expression for ");
         PrintSlot(theEnv,STDERR,sd,NULL,"dynamic default value");
         ConstraintViolationErrorMessage(theEnv,NULL,NULL,0,0,NULL,0,
                                         vCode,sd->constraint,false);
         return false;
        }
     }
   return true;
  }