- ansi C fixes

git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@16761 f25d12d1-65f4-0310-ae8a-bbce733d8d8e

Compiler/runtime/systemimpl.c

@@ -1864,9 +1864,9 @@ void SystemImpl__gettextInit(const char *locale)
   int locale_len = strlen(locale);
   char *locale2 = alloc_locale_str(locale, locale_len, ".utf8", 5);
   char *locale3 = alloc_locale_str(locale, locale_len, ".UTF-8", 6);
-  char *old_ctype_default = "UTF-8";
-  if (setlocale(LC_CTYPE, ""))
-    old_ctype_default = setlocale(LC_CTYPE, "");
+  char *old_ctype_default = setlocale(LC_CTYPE, "");
+  if (!old_ctype_default)
+    old_ctype_default = "UTF-8";
   char *old_ctype = strdup(old_ctype_default);
   int old_ctype_is_utf8 = strcmp(nl_langinfo(CODESET), "UTF-8") == 0;
 

SimulationRuntime/c/simulation/simulation_runtime.cpp

@@ -88,12 +88,12 @@
 
 using namespace std;
 
-int interactiveSimulation = 0; /* This variable signals if an simulation session is interactive or non-interactive (by default) */
+static int interactiveSimulation = 0; /* This variable signals if an simulation session is interactive or non-interactive (by default) */
 
 /* This variable is used to get the step size value during the simulation. */
-double stepSize = 0.0;
-double currentTime = 0.0;
-int initTime = 0;
+static double stepSize = 0.0;
+static double currentTime = 0.0;
+static int initTime = 0;
 
 double getSimulationStepSize(double time, int *takeStep)
 {
@@ -136,10 +136,7 @@ int sim_noemit = 0;           /* Flag for not emitting data */
 
 const std::string *init_method = NULL; /* method for  initialization. */
 
-/* function for start simulation */
-int callSolver(DATA*, string, string, string, string, double, int, string, int cpuTime);
-
-int isInteractiveSimulation();
+int isInteractiveSimulation(void);
 
 /*! \fn void setTermMsg(const char* msg)
  *
@@ -283,7 +280,7 @@ int getNonlinearSolverMethod(int argc, char**argv)
   for(i=1; i<NLS_MAX; ++i)
     WARNING2(LOG_STDOUT, "%-18s [%s]", NLS_NAME[i], NLS_DESC[i]);
   THROW("see last warning");
-  
+
   return NLS_NONE;
 }
 
@@ -310,7 +307,7 @@ int getlinearSolverMethod(int argc, char**argv)
  * Signals the type of the simulation
  * retuns true for interactive and false for non-interactive
  */
-int isInteractiveSimulation()
+int isInteractiveSimulation(void)
 {
   return interactiveSimulation;
 }
@@ -319,8 +316,7 @@ int isInteractiveSimulation()
  * Starts an Interactive simulation session
  * the runtime waits until a user shuts down the simulation
  */
-int
-startInteractiveSimulation(int argc, char**argv, void* data)
+int startInteractiveSimulation(int argc, char**argv, void* data)
 {
   int retVal = -1;
 
@@ -692,7 +688,7 @@ int callSolver(DATA* simData, string result_file_cstr, string init_initMethod,
       if(std::string(SOLVER_METHOD_NAME[i]) == simData->simulationInfo.solverMethod)
         solverID = i;
   }
-  
+
   if(S_UNKNOWN == solverID)
   {
     WARNING1(LOG_STDOUT, "unrecognized option -s %s", simData->simulationInfo.solverMethod);
@@ -774,17 +770,17 @@ int initRuntimeAndSimulation(int argc, char**argv, DATA *data)
           for(j=firstOMCErrorStream; j<LOG_MAX; ++j)
             INFO2(LOG_STDOUT, "%-18s [%s]", LOG_STREAM_NAME[j], LOG_STREAM_DESC[j]);
           break;
-          
+
         case FLAG_IIM:
           for(j=1; j<IIM_MAX; ++j)
             INFO2(LOG_STDOUT, "%-18s [%s]", INIT_METHOD_NAME[j], INIT_METHOD_DESC[j]);
           break;
-          
+
         case FLAG_IOM:
           for(j=1; j<IOM_MAX; ++j)
             INFO2(LOG_STDOUT, "%-18s [%s]", OPTI_METHOD_NAME[j], OPTI_METHOD_DESC[j]);
           break;
-          
+
         case FLAG_S:
           for(j=1; j<S_MAX; ++j)
             INFO2(LOG_STDOUT, "| %-18s [%s]", SOLVER_METHOD_NAME[j], SOLVER_METHOD_DESC[j]);

SimulationRuntime/c/simulation/simulation_runtime.h

@@ -60,10 +60,10 @@ extern Socket sim_communication_port;
 
 extern "C" {
 
-int callSolver(DATA* simData, std::string result_file_cstr, std::string init_initMethod,
+extern int callSolver(DATA* simData, std::string result_file_cstr, std::string init_initMethod,
     std::string init_optiMethod, std::string init_file, double init_time, int lambda_steps, std::string outputVariablesAtEnd, int cpuTime);
 
-int initializeResultData(DATA* simData, std::string result_file_cstr, int cpuTime);
+extern int initializeResultData(DATA* simData, std::string result_file_cstr, int cpuTime);
 
 #endif /* cplusplus */
 
@@ -80,29 +80,29 @@ extern FILE_INFO TermInfo; /* message for termination. */
 extern char* TermMsg; /* message for termination. */
 
 /* defined in model code. Used to get name of variable by investigating its pointer in the state or alg vectors. */
-const char* getNameReal(double* ptr);
-const char* getNameInt(modelica_integer* ptr);
-const char* getNameBool(modelica_boolean* ptr);
-const char* getNameString(const char** ptr);
+extern const char* getNameReal(double* ptr);
+extern const char* getNameInt(modelica_integer* ptr);
+extern const char* getNameBool(modelica_boolean* ptr);
+extern const char* getNameString(const char** ptr);
 
 
 /* function for calculating state values on residual form */
 /*used in DDASRT fortran function*/
-int functionODE_residual(double *t, double *x, double *xprime, double *delta, fortran_integer *ires, double *rpar, fortran_integer* ipar);
+extern int functionODE_residual(double *t, double *x, double *xprime, double *delta, fortran_integer *ires, double *rpar, fortran_integer* ipar);
 
 /* function for calculating zeroCrossings */
 /*used in DDASRT fortran function*/
-int function_ZeroCrossingsDASSL(fortran_integer *neqm, double *t, double *y,
+extern int function_ZeroCrossingsDASSL(fortran_integer *neqm, double *t, double *y,
         fortran_integer *ng, double *gout, double *rpar, fortran_integer* ipar);
 
-double getSimulationStepSize(double time, int *takeStep);
-void printSimulationStepSize(double in_stepSize, double time, int takeStep);
+extern double getSimulationStepSize(double time, int *takeStep);
+extern void printSimulationStepSize(double in_stepSize, double time, int takeStep);
 
 /* the main function of the simulation runtime!
  * simulation runtime no longer has main, is defined by the generated model code which calls this function.
  */
 extern int _main_SimulationRuntime(int argc, char**argv, DATA *data);
-void communicateStatus(const char *phase, double completionPercent);
+extern void communicateStatus(const char *phase, double completionPercent);
 
 #ifdef __cplusplus
 }

SimulationRuntime/c/simulation/solver/initialization/initialization.c

@@ -143,7 +143,7 @@ double leastSquareWithLambda(INIT_DATA *initData, double lambda)
 
           funcValue += (1.0-lambda)*((data->modelData.realParameterData[i].attribute.start-data->simulationInfo.realParameter[i])/scalingCoefficient)*((data->modelData.realParameterData[i].attribute.start-data->simulationInfo.realParameter[i])/scalingCoefficient);
         }
-      
+
       /* for real discrete */
       for(i=data->modelData.nVariablesReal-data->modelData.nDiscreteReal; i<data->modelData.nDiscreteReal; ++i)
           if(data->modelData.realVarsData[i].attribute.useStart && !data->modelData.realVarsData[i].attribute.fixed)
@@ -152,7 +152,7 @@ double leastSquareWithLambda(INIT_DATA *initData, double lambda)
                   scalingCoefficient = initData->startValueResidualScalingCoefficients[ix++]; /* use scaling coefficients */
               else
                   scalingCoefficient = 1.0; /* no scaling coefficients given */
-              
+
               funcValue += (1.0-lambda)*((data->modelData.realVarsData[i].attribute.start-data->simulationInfo.realParameter[i])/scalingCoefficient)*((data->modelData.realVarsData[i].attribute.start-data->simulationInfo.realParameter[i])/scalingCoefficient);
           }
   }
@@ -195,7 +195,7 @@ void dumpInitialization(INIT_DATA *initData)
       INFO4(LOG_INIT, "[%ld] [%15g] := %s (parameter) [scaling coefficient: %g]", i+1, initData->vars[i], initData->name[i], initData->nominal[i]);
     else
       INFO3(LOG_INIT, "[%ld] [%15g] := %s (parameter)", i+1, initData->vars[i], initData->name[i]);
-  
+
   for(; i<initData->nVars; ++i)
     if(initData->nominal)
       INFO4(LOG_INIT, "[%ld] [%15g] := %s (discrete) [scaling coefficient: %g]", i+1, initData->vars[i], initData->name[i], initData->nominal[i]);
@@ -359,13 +359,13 @@ static int initialize2(INIT_DATA *initData, int optiMethod, int useScaling, int
     else
       THROW("unsupported option -iom");
 
-    /*storePreValues(data);                       /* save pre-values */
+    /*storePreValues(data);*/                       /* save pre-values */
     overwriteOldSimulationData(data);           /* if there are non-linear equations */
     updateDiscreteSystem(data);                 /* evaluate discrete variables */
 
     /* valid system for the first time! */
     saveZeroCrossings(data);
-    /*storePreValues(data);                       /* save pre-values */
+    /*storePreValues(data);*/                       /* save pre-values */
     overwriteOldSimulationData(data);
 
     funcValue = leastSquareWithLambda(initData, 1.0);
@@ -622,13 +622,13 @@ static int numeric_initialization(DATA *data, int optiMethod, int lambda_steps)
 
   retVal = initialize(data, optiMethod, lambda_steps);
 
-  /*storePreValues(data);                 /* save pre-values */
+  /*storePreValues(data);*/                 /* save pre-values */
   overwriteOldSimulationData(data);     /* if there are non-linear equations */
   updateDiscreteSystem(data);           /* evaluate discrete variables */
 
   /* valid system for the first time! */
   saveZeroCrossings(data);
-  /*storePreValues(data);                 /* save pre-values */
+  /*storePreValues(data);*/                 /* save pre-values */
   overwriteOldSimulationData(data);     /* if there are non-linear equations */
 
   return retVal;
@@ -659,13 +659,13 @@ static int symbolic_initialization(DATA *data, long numLambdaSteps)
     long i;
     char buffer[4096];
     FILE *pFile = NULL;
-    
+
     modelica_real* realVars = (modelica_real*)calloc(data->modelData.nVariablesReal, sizeof(modelica_real));
     modelica_integer* integerVars = (modelica_integer*)calloc(data->modelData.nVariablesInteger, sizeof(modelica_integer));
     modelica_boolean* booleanVars = (modelica_boolean*)calloc(data->modelData.nVariablesBoolean, sizeof(modelica_boolean));
     modelica_string* stringVars = (modelica_string*)calloc(data->modelData.nVariablesString, sizeof(modelica_string));
     MODEL_DATA *mData = &(data->modelData);
-    
+
     ASSERT(realVars, "out of memory");
     ASSERT(integerVars, "out of memory");
     ASSERT(booleanVars, "out of memory");
@@ -679,7 +679,7 @@ static int symbolic_initialization(DATA *data, long numLambdaSteps)
       booleanVars[i] = mData->booleanVarsData[i].attribute.start;
     for(i=0; i<mData->nVariablesString; ++i)
       stringVars[i] = mData->stringVarsData[i].attribute.start;
-    
+
     if(ACTIVE_STREAM(LOG_INIT))
     {
       sprintf(buffer, "%s_homotopy.csv", mData->modelFilePrefix);
@@ -689,7 +689,7 @@ static int symbolic_initialization(DATA *data, long numLambdaSteps)
         fprintf(pFile, "%s,", mData->realVarsData[i].info.name);
       fprintf(pFile, "\n");
     }
-    
+
     INFO(LOG_INIT, "homotopy process");
     INDENT(LOG_INIT);
     for(step=0; step<numLambdaSteps; ++step)
@@ -702,27 +702,27 @@ static int symbolic_initialization(DATA *data, long numLambdaSteps)
       functionInitialEquations(data);
 
       INFO1(LOG_INIT, "lambda = %g done", data->simulationInfo.lambda);
-      
+
       if(ACTIVE_STREAM(LOG_INIT))
       {
         fprintf(pFile, "%.16g,", data->simulationInfo.lambda);
         for(i=0; i<mData->nVariablesReal; ++i)
           fprintf(pFile, "%.16g,", data->localData[0]->realVars[i]);
         fprintf(pFile, "\n");
       }
-      
-      if(check_nonlinear_solutions(data, 0) || 
-         check_linear_solutions(data, 0) || 
+
+      if(check_nonlinear_solutions(data, 0) ||
+         check_linear_solutions(data, 0) ||
          check_mixed_solutions(data, 0))
         break;
 
       setAllStartToVars(data);
     }
     RELEASE(LOG_INIT);
-    
+
     if(ACTIVE_STREAM(LOG_INIT))
       fclose(pFile);
-    
+
     for(i=0; i<mData->nVariablesReal; ++i)
       mData->realVarsData[i].attribute.start = realVars[i];
     for(i=0; i<mData->nVariablesInteger; ++i)
@@ -731,7 +731,7 @@ static int symbolic_initialization(DATA *data, long numLambdaSteps)
       mData->booleanVarsData[i].attribute.start = booleanVars[i];
     for(i=0; i<mData->nVariablesString; ++i)
       mData->stringVarsData[i].attribute.start = stringVars[i];
-      
+
     free(realVars);
     free(integerVars);
     free(booleanVars);
@@ -757,7 +757,7 @@ static int symbolic_initialization(DATA *data, long numLambdaSteps)
     if(stateSelection(data, 1, 1) == 1)
       WARNING(LOG_STDOUT, "Cannot initialize unique the dynamic state selection. Use -lv LOG_DSS to see the switching state set.");
   }
-    
+
   return 0;
 }
 
@@ -898,19 +898,19 @@ static int importStartValues(DATA *data, const char *pInitFile, double initTime)
       else
         WARNING1(LOG_INIT, "unable to import real parameter %s from given file", mData->realParameterData[i].info.name);
     }
-      
+
     INFO(LOG_INIT, "import real discrete");
     for(i=mData->nVariablesReal-mData->nDiscreteReal; i<mData->nDiscreteReal; ++i)
     {
       pVar = omc_matlab4_find_var(&reader, mData->realParameterData[i].info.name);
-          
+
       if(!pVar)
       {
         newVarname = mapToDymolaVars(mData->realParameterData[i].info.name);
         pVar = omc_matlab4_find_var(&reader, newVarname);
         free(newVarname);
       }
-          
+
       if(pVar)
       {
         omc_matlab4_val(&(mData->realParameterData[i].attribute.start), &reader, pVar, initTime);
@@ -1063,7 +1063,7 @@ int initialization(DATA *data, const char* pInitMethod, const char* pOptiMethod,
   for(i=0; i<data->modelData.nMixedSystems; ++i)
     data->simulationInfo.mixedSystemData[i].solved = 1;
   /* end workaround */
-  
+
   /* select the right initialization-method */
   if(initMethod == IIM_NONE)
     retVal = 0;
@@ -1073,10 +1073,10 @@ int initialization(DATA *data, const char* pInitMethod, const char* pOptiMethod,
     retVal = symbolic_initialization(data, lambda_steps);
   else
     THROW("unsupported option -iim");
-    
+
   /* check for unsolved (nonlinear|linear|mixed) systems
    * This is a workaround and should be removed as soon as possible.
-   */   
+   */
   if(check_nonlinear_solutions(data, 1))
     retVal = -2;
   else if(check_linear_solutions(data, 1))

SimulationRuntime/c/util/OldModelicaTables.c

@@ -32,6 +32,7 @@
 #include <string.h>
 #include <stdlib.h>
 #include <math.h>
+#include <ctype.h>
 
 #include "omc_inline.h"
 #include "ModelicaUtilities.h"

SimulationRuntime/c/util/memory_pool.c

@@ -103,8 +103,9 @@ void restore_memory_state(state restore_state)
 
 void clear_current_state(void)
 {
-  current_states[get_thread_index()].current_state.buffer = 0;
-  current_states[get_thread_index()].current_state.offset = 0;
+  int ix = get_thread_index();
+  current_states[ix].current_state.buffer = 0;
+  current_states[ix].current_state.offset = 0;
 }
 
 void* alloc_elements(int n, int sz)