Added rudimentary boolean functions to c_runtime.

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

c_runtime/boolean_array.c

@@ -20,3 +20,56 @@
 */
 
 #include "boolean_array.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <stdarg.h>
+
+int boolean_array_ok(boolean_array_t* a)
+{
+    int i;
+	if (!a) return 0;
+    if (a->ndims < 0) return 0;
+    if (!a->dim_size) return 0;
+    for (i = 0; i < a->ndims; ++i) 
+    {
+	if (a->dim_size[i] < 0) return 0;
+    }  
+    return 1;
+}
+
+size_t boolean_array_nr_of_elements(boolean_array_t* a)
+{
+    int i;
+    size_t nr_of_elements = 1;
+    for (i = 0; i < a->ndims; ++i)
+    {
+	nr_of_elements *= a->dim_size[i];
+    }
+    return nr_of_elements;
+
+}
+
+void alloc_boolean_array_data(boolean_array_t* a)
+{
+  size_t array_size;
+
+  array_size = boolean_array_nr_of_elements(a);
+  a->data = boolean_alloc(array_size);
+}
+
+void clone_boolean_array_spec(boolean_array_t* source, boolean_array_t* dest)
+{
+  int i;
+  assert(boolean_array_ok(source));
+
+  dest->ndims = source->ndims;
+  dest->dim_size = size_alloc(dest->ndims*sizeof(int));
+  assert(dest->dim_size);
+
+  for (i = 0; i < dest->ndims; ++i)
+    {
+      dest->dim_size[i] = source->dim_size[i];
+    }
+}

c_runtime/boolean_array.h

@@ -22,6 +22,12 @@
 #ifndef BOOLEAN_ARRAY_H_
 #define BOOLEAN_ARRAT_H_
 
+#include "index_spec.h"
+#include "memory_pool.h"
+#include <stdio.h>
+#include <stdarg.h>
+#include <math.h>
+
 typedef double modelica_boolean;
 
 struct boolean_array_s
@@ -33,4 +39,10 @@ struct boolean_array_s
 
 typedef struct boolean_array_s boolean_array_t;
 
+size_t boolean_array_nr_of_elements(boolean_array_t* a);
+
+void alloc_boolean_array_data(boolean_array_t* a);
+
+void clone_boolean_array_spec(boolean_array_t* source, boolean_array_t* dest);
+
 #endif

c_runtime/integer_array.c

@@ -165,16 +165,6 @@ void alloc_integer_array_data(integer_array_t* a)
 
   array_size = integer_array_nr_of_elements(a);
   a->data = integer_alloc(array_size);
-
-  /*  size_t array_size;
-  void* ptr;
-
-  assert(integer_array_ok(a));
-  array_size = integer_array_nr_of_elements(a) * sizeof(modelica_integer);
-  ptr = malloc(array_size);
-  assert(ptr);
-  a->data = ptr;*/
-
 }
 
 void free_integer_array_data(integer_array_t* a)
@@ -185,8 +175,6 @@ void free_integer_array_data(integer_array_t* a)
 
   array_size = integer_array_nr_of_elements(a) * sizeof(modelica_integer);
   integer_free(array_size);
-  /*  free(a->data);
-      a->data = 0;*/
 }
 
 void clone_integer_array_spec(integer_array_t* source, integer_array_t* dest)

c_runtime/memory_pool.h

@@ -34,7 +34,7 @@
 typedef double m_real;
 typedef int m_integer;
 typedef const char* m_string;
-typedef int m_boolean;
+typedef double m_boolean;
 typedef int _index_t; 
 
 extern m_real real_buffer[NR_REAL_ELEMENTS];

c_runtime/read_write.c

@@ -126,6 +126,18 @@ int read_modelica_integer(FILE* file, modelica_integer* data)
   return 0;
 }
 
+int read_modelica_boolean(FILE* file, modelica_boolean* data)
+{
+  type_description desc;
+  if (read_type_description(file,&desc)) { in_report("is type_desc"); return 1; }
+  if (desc.type != 'b') { cleanup_description(&desc); in_report("is type"); return 1; }
+  if (desc.ndims != 0) { cleanup_description(&desc); in_report("is ndims"); return 1; }
+  if (fscanf(file,"%e",(float*)data) != 1) { cleanup_description(&desc); in_report("is parse"); return 1; }
+  read_to_eol(file);
+  cleanup_description(&desc);
+  return 0;
+}
+
 int read_real_array(FILE* file, real_array_t* arr)
 {
   int nr_elements;
@@ -183,13 +195,48 @@ int read_integer_array(FILE* file, integer_array_t* arr)
   return 0;
 }
 
+int read_boolean_array(FILE* file, boolean_array_t* arr)
+{
+
+  int nr_elements;
+  int i;
+  float f;
+  boolean_array_t tmp;
+  type_description desc;
+
+  if (read_type_description(file,&desc)) { in_report("ia type_desc"); return 1; }
+  if ((desc.type != 'b')) { in_report("ia type"); return 1; }
+  if (desc.ndims <= 0) { in_report("a ndims"); return 1; }
+
+  tmp.ndims = desc.ndims;
+  tmp.dim_size = desc.dim_size;
+  clone_boolean_array_spec(&tmp,arr);
+  alloc_boolean_array_data(arr);
+  cleanup_description(&desc);
+
+  nr_elements = boolean_array_nr_of_elements(arr);
+  for (i = 0; i < nr_elements; ++i)
+    {
+      if (fscanf(file,"%e",&f) != 1) { in_report("ia parse"); return 1; }
+      arr->data[i] = f;
+    }
+  read_to_eol(file);
+  return 0;
+}
+
 int write_modelica_real(FILE* file, modelica_real* data)
 {
   fprintf(file,"# r!\n");
   fprintf(file,"%e\n",*data);
   return 0;
 }
 
+int write_modelica_boolean(FILE* file, modelica_boolean* data)
+{
+  fprintf(file,"# b!\n");
+  fprintf(file,"%e\n",*data);
+  return 0;
+}
 int write_modelica_integer(FILE* file, modelica_integer* data)
 {
   fprintf(file,"# i!\n");
@@ -211,8 +258,23 @@ int write_real_array(FILE* file, real_array_t* arr)
     }
   return 0;
 }
-/*
-void write_integer_array(FILE* file, integer_array_t* arr)
+
+int write_boolean_array(FILE* file, boolean_array_t* arr)
+{
+  int nr_elements;
+  int i;
+  fprintf(file,"# b[ %d",arr->ndims);
+  for (i = 0; i < arr->ndims; ++i) fprintf(file," %d",arr->dim_size[i]);
+  fprintf(file,"\n");
+  nr_elements = boolean_array_nr_of_elements(arr);
+  for (i = 0; i < nr_elements; ++i)
+    {
+      fprintf(file,"%e\n",arr->data[i]);
+    }
+  return 0;
+}
+
+int write_integer_array(FILE* file, integer_array_t* arr)
 {
   int nr_elements;
   int i;
@@ -226,7 +288,7 @@ void write_integer_array(FILE* file, integer_array_t* arr)
     }
     return 0;
 }
-*/
+
 
 int read_modelica_string(FILE* file, modelica_string_t* str)
 {

c_runtime/read_write.h

@@ -55,6 +55,11 @@ int read_integer_array(FILE*,integer_array_t*);
 int write_modelica_integer(FILE*,modelica_integer*);
 int write_integer_array(FILE*,integer_array_t*);
 
+int read_modelica_boolean(FILE*,modelica_boolean*);
+int read_boolean_array(FILE*,boolean_array_t*);
+int write_modelica_boolean(FILE*,modelica_boolean*);
+int write_boolean_array(FILE*,boolean_array_t*);
+
 int read_modelica_string(FILE*,modelica_string_t*);
 int write_modelica_string(FILE*,modelica_string_t*);
 int read_type_description(FILE*, type_description*);

c_runtime/real_array.c

@@ -193,8 +193,8 @@ size_t real_array_nr_of_elements(real_array_t* a)
 	nr_of_elements *= a->dim_size[i];
     }
     return nr_of_elements;
-
 }
+
 void simple_alloc_1d_real_array(real_array_t* dest, int n)
 {
   dest->ndims = 1;
@@ -240,16 +240,7 @@ void alloc_real_array_data(real_array_t* a)
 
   array_size = real_array_nr_of_elements(a);
   a->data = real_alloc(array_size);
-
-  /*  size_t array_size;
-  void* ptr;
-
-  assert(real_array_ok(a));
-  array_size = real_array_nr_of_elements(a) * sizeof(modelica_real);
-  ptr = malloc(array_size);
-  assert(ptr);
-  a->data = ptr;*/
-
+
 }
 
 void free_real_array_data(real_array_t* a)