}   /*=====================================================*/   /* Loop through each of the arguments dividing it into */   /* a running product. Floats are converted to integers */   /* and each argument is checked to prevent a divide by */   /* zero error.                                         */   /*=====================================================*/   while (theExpression != NULL)     {      if (! GetNumericArgument(theEnv,theExpression,"div",&theArgument,FALSE,pos)) theExpression = NULL;      else theExpression = GetNextArgument(theExpression);      if (theArgument.type == INTEGER) theNumber = ValueToLong(theArgument.value);      else if (theArgument.type == FLOAT) theNumber = (long long) ValueToDouble(theArgument.value);      else theNumber = 1;      if (theNumber == 0LL)        {         DivideByZeroErrorMessage(theEnv,"div");         SetHaltExecution(theEnv,TRUE);         SetEvaluationError(theEnv,TRUE);         return(1L);        }      if (theArgument.type == INTEGER)        { total /= ValueToLong(theArgument.value); }      else        { total = total / (long long) ValueToDouble(theArgument.value); }      pos++;     }   /*======================================================*/   /* The result of the div function is always an integer. */   /*======================================================*/   return(total);  }/*****************************************************//* SetAutoFloatDividendCommand: H/L access routine   *//*   for the set-auto-float-dividend command.        *//*****************************************************/globle int SetAutoFloatDividendCommand(  void *theEnv)  {   int oldValue;   DATA_OBJECT theArgument;   /*===============================*/   /* Remember the present setting. */   /*===============================*/   oldValue = BasicMathFunctionData(theEnv)->AutoFloatDividend;   /*============================================*/   /* Check for the correct number of arguments. */   /*============================================*/   if (EnvArgCountCheck(theEnv,"set-auto-float-dividend",EXACTLY,1) == -1)     { return(oldValue); }   EnvRtnUnknown(theEnv,1,&theArgument);   /*============================================================*/   /* The symbol FALSE disables the auto float dividend feature. */   /*============================================================*/   if ((theArgument.value == EnvFalseSymbol(theEnv)) && (theArgument.type == SYMBOL))     { BasicMathFunctionData(theEnv)->AutoFloatDividend = FALSE; }   else     { BasicMathFunctionData(theEnv)->AutoFloatDividend = TRUE; }   /*======================================*/   /* Return the old value of the feature. */   /*======================================*/   return(oldValue);  }/*****************************************************//* GetAutoFloatDividendCommand: H/L access routine   *//*   for the get-auto-float-dividend command.        *//*****************************************************/globle int GetAutoFloatDividendCommand(  void *theEnv)  {   /*============================================*/   /* Check for the correct number of arguments. */   /*============================================*/   EnvArgCountCheck(theEnv,"get-auto-float-dividend",EXACTLY,0);   /*=============================*/   /* Return the current setting. */   /*=============================*/   return(BasicMathFunctionData(theEnv)->AutoFloatDividend);  }/*************************************************//* EnvGetAutoFloatDividend: C access routine for *//*   the get-auto-float-dividend command.        *//*************************************************/globle intBool EnvGetAutoFloatDividend(  void *theEnv)  {   return(BasicMathFunctionData(theEnv)->AutoFloatDividend);  }/*************************************************//* EnvSetAutoFloatDividend: C access routine for *//*   the set-auto-float-dividend command.        *//*************************************************/globle intBool EnvSetAutoFloatDividend(  void *theEnv,  int value)  {   int ov;   ov = BasicMathFunctionData(theEnv)->AutoFloatDividend;   BasicMathFunctionData(theEnv)->AutoFloatDividend = value;   return(ov);  }/*****************************************//* IntegerFunction: H/L access routine   *//*   for the integer function.           *//*****************************************/globle long long IntegerFunction(  void *theEnv)  {   DATA_OBJECT valstruct;   /*============================================*/   /* Check for the correct number of arguments. */   /*============================================*/   if (EnvArgCountCheck(theEnv,"integer",EXACTLY,1) == -1) return(0LL);   /*================================================================*/   /* Check for the correct type of argument. Note that ArgTypeCheck */   /* will convert floats to integers when an integer is requested   */   /* (which is the purpose of the integer function).                */   /*================================================================*/   if (EnvArgTypeCheck(theEnv,"integer",1,INTEGER,&valstruct) == FALSE) return(0LL);   /*===================================================*/   /* Return the numeric value converted to an integer. */   /*===================================================*/   return(ValueToLong(valstruct.value));  }/***************************************//* FloatFunction: H/L access routine   *//*   for the float function.           *//***************************************/globle double FloatFunction(  void *theEnv)  {   DATA_OBJECT valstruct;   /*============================================*/   /* Check for the correct number of arguments. */   /*============================================*/   if (EnvArgCountCheck(theEnv,"float",EXACTLY,1) == -1) return(0.0);   /*================================================================*/   /* Check for the correct type of argument. Note that ArgTypeCheck */   /* will convert integers to floats when a float is requested      */   /* (which is the purpose of the float function).                  */   /*================================================================*/   if (EnvArgTypeCheck(theEnv,"float",1,FLOAT,&valstruct) == FALSE) return(0.0);   /*================================================*/   /* Return the numeric value converted to a float. */   /*================================================*/   return(ValueToDouble(valstruct.value));  }/*************************************//* AbsFunction: H/L access routine   *//*   for the abs function.           *//*************************************/globle void AbsFunction(  void *theEnv,  DATA_OBJECT_PTR returnValue)  {   /*============================================*/   /* Check for the correct number of arguments. */   /*============================================*/   if (EnvArgCountCheck(theEnv,"abs",EXACTLY,1) == -1)     {      returnValue->type = INTEGER;      returnValue->value = (void *) EnvAddLong(theEnv,0L);      return;     }   /*======================================*/   /* Check that the argument is a number. */   /*======================================*/   if (EnvArgTypeCheck(theEnv,"abs",1,INTEGER_OR_FLOAT,returnValue) == FALSE)     {      returnValue->type = INTEGER;      returnValue->value = (void *) EnvAddLong(theEnv,0L);      return;     }   /*==========================================*/   /* Return the absolute value of the number. */   /*==========================================*/   if (returnValue->type == INTEGER)     {      if (ValueToLong(returnValue->value) < 0L)        { returnValue->value = (void *) EnvAddLong(theEnv,- ValueToLong(returnValue->value)); }     }   else if (ValueToDouble(returnValue->value) < 0.0)     { returnValue->value = (void *) EnvAddDouble(theEnv,- ValueToDouble(returnValue->value)); }  }/*************************************//* MinFunction: H/L access routine   *//*   for the min function.           *//*************************************/globle void MinFunction(  void *theEnv,  DATA_OBJECT_PTR returnValue)  {   DATA_OBJECT argValue;   int numberOfArguments, i;   /*============================================*/   /* Check for the correct number of arguments. */   /*============================================*/   if ((numberOfArguments = EnvArgCountCheck(theEnv,"min",AT_LEAST,1)) == -1)     {      returnValue->type = INTEGER;      returnValue->value = (void *) EnvAddLong(theEnv,0L);      return;     }   /*============================================*/   /* Check that the first argument is a number. */   /*============================================*/   if (EnvArgTypeCheck(theEnv,"min",1,INTEGER_OR_FLOAT,returnValue) == FALSE)     {      returnValue->type = INTEGER;      returnValue->value = (void *) EnvAddLong(theEnv,0L);      return;     }   /*===========================================================*/   /* Loop through the remaining arguments, first checking each */   /* argument to see that it is a number, and then determining */   /* if the argument is less than the previous arguments and   */   /* is thus the minimum value.                                */   /*===========================================================*/   for (i = 2 ; i <= numberOfArguments ; i++)     {      if (EnvArgTypeCheck(theEnv,"min",i,INTEGER_OR_FLOAT,&argValue) == FALSE) return;      if (returnValue->type == INTEGER)        {         if (argValue.type == INTEGER)           {            if (ValueToLong(returnValue->value) > ValueToLong(argValue.value))              {               returnValue->type = argValue.type;               returnValue->value = argValue.value;              }           }         else           {            if ((double) ValueToLong(returnValue->value) >                         ValueToDouble(argValue.value))              {               returnValue->type = argValue.type;               returnValue->value = argValue.value;              }           }        }      else        {         if (argValue.type == INTEGER)           {            if (ValueToDouble(returnValue->value) >                (double) ValueToLong(argValue.value))              {               returnValue->type = argValue.type;               returnValue->value = argValue.value;              }           }         else           {            if (ValueToDouble(returnValue->value) > ValueToDouble(argValue.value))              {               returnValue->type = argValue.type;               returnValue->value = argValue.value;              }           }        }     }   return;  }/*************************************//* MaxFunction: H/L access routine   *//*   for the max function.           *//*************************************/globle void MaxFunction(  void *theEnv,  DATA_OBJECT_PTR returnValue)  {   DATA_OBJECT argValue;   int numberOfArguments, i;   /*============================================*/   /* Check for the correct number of arguments. */   /*============================================*/   if ((numberOfArguments = EnvArgCountCheck(theEnv,"max",AT_LEAST,1)) == -1)     {      returnValue->type = INTEGER;      returnValue->value = (void *) EnvAddLong(theEnv,0L);      return;     }   /*============================================*/   /* Check that the first argument is a number. */   /*============================================*/   if (EnvArgTypeCheck(theEnv,"max",1,INTEGER_OR_FLOAT,returnValue) == FALSE)     {      returnValue->type = INTEGER;      returnValue->value = (void *) EnvAddLong(theEnv,0L);      return;     }   /*===========================================================*/   /* Loop through the remaining arguments, first checking each */   /* argument to see that it is a number, and then determining */   /* if the argument is greater than the previous arguments    */   /* and is thus the maximum value.                            */   /*===========================================================*/   for (i = 2 ; i <= numberOfArguments ; i++)     {      if (EnvArgTypeCheck(theEnv,"max",i,INTEGER_OR_FLOAT,&argValue) == FALSE) return;      if (returnValue->type == INTEGER)        {         if (argValue.type == INTEGER)           {            if (ValueToLong(returnValue->value) < ValueToLong(argValue.value))              {               returnValue->type = argValue.type;               returnValue->value = argValue.value;              }           }         else           {            if ((double) ValueToLong(returnValue->value) <                         ValueToDouble(argValue.value))              {               returnValue->type = argValue.type;               returnValue->value = argValue.value;              }           }        }      else        {         if (argValue.type == INTEGER)           {            if (ValueToDouble(returnValue->value) <                (double) ValueToLong(argValue.value))              {               returnValue->type = argValue.type;               returnValue->value = argValue.value;              }           }         else           {            if (ValueToDouble(returnValue->value) < ValueToDouble(argValue.value))              {               returnValue->type = argValue.type;               returnValue->value = argValue.value;              }           }        }     }   return;  }