Logger: fix intel compilation

logger/logger_header.c

@@ -93,7 +93,7 @@ void header_change_offset_direction(struct header *h,
   /* Skip file format and version numbers. */
   size_t offset = LOGGER_VERSION_SIZE + 2 * sizeof(int);
 
-  logger_loader_io_write_data(h->log->log.map + offset, sizeof(unsigned int),
+  logger_loader_io_write_data((char *) h->log->log.map + offset, sizeof(unsigned int),
                               &new_value);
 }
 
@@ -183,9 +183,9 @@ void header_read(struct header *h, struct logger_logfile *log) {
   }
 
   /* Check the logfile header's size. */
-  if (map != log->log.map + h->offset_first_record) {
+  if (map != (char *) log->log.map + h->offset_first_record) {
     header_print(h);
-    size_t offset = map - log->log.map;
+    size_t offset = (char *) map - (char *) log->log.map;
     error("Wrong header size (in header %zi, current %zi).",
           h->offset_first_record, offset);
   }

logger/logger_index.c

@@ -64,18 +64,18 @@ void logger_index_read_header(struct logger_index *index,
   logger_index_map_file(index, filename, 0);
 
   /* Read times */
-  memcpy(&index->time, index->index.map + logger_index_time_offset,
+  memcpy(&index->time, (char *) index->index.map + logger_index_time_offset,
          logger_index_time_size);
   memcpy(&index->integer_time,
-         index->index.map + logger_index_integer_time_offset,
+         (char *) index->index.map + logger_index_integer_time_offset,
          logger_index_integer_time_size);
 
   /* Read the number of particles */
-  memcpy(index->nparts, index->index.map + logger_index_npart_offset,
+  memcpy(index->nparts, (char *) index->index.map + logger_index_npart_offset,
          logger_index_npart_size);
 
   /* Read if the file is sorted */
-  memcpy(&index->is_sorted, index->index.map + logger_index_is_sorted_offset,
+  memcpy(&index->is_sorted, (char *) index->index.map + logger_index_is_sorted_offset,
          logger_index_is_sorted_size);
 
   /* Close the file */
@@ -94,7 +94,7 @@ void logger_index_write_sorted(struct logger_index *index) {
   const char is_sorted = 1;
 
   /* Write the value */
-  memcpy(index->index.map + logger_index_is_sorted_offset, &is_sorted,
+  memcpy((char *) index->index.map + logger_index_is_sorted_offset, &is_sorted,
          logger_index_is_sorted_size);
 }
 
@@ -113,7 +113,8 @@ struct index_data *logger_index_get_data(struct logger_index *index, int type) {
   }
   const size_t type_offset = count * sizeof(struct index_data);
 
-  return index->index.map + logger_index_data_offset + type_offset;
+  const char * ret = (char *) index->index.map + logger_index_data_offset + type_offset;
+  return (struct index_data *) ret;
 }
 
 /**

logger/logger_loader_io.h

@@ -61,14 +61,14 @@ __attribute__((always_inline)) INLINE static void *logger_loader_io_read_mask(
     *mask = 0;
     memcpy(mask, data, LOGGER_MASK_SIZE);
   }
-  data += LOGGER_MASK_SIZE;
+  data = (char *) data + LOGGER_MASK_SIZE;
 
   /* read offset */
   if (diff_offset) {
     *diff_offset = 0;
     memcpy(diff_offset, data, LOGGER_OFFSET_SIZE);
   }
-  data += LOGGER_OFFSET_SIZE;
+  data = (char *) data + LOGGER_OFFSET_SIZE;
 
   return data;
 }
@@ -85,7 +85,7 @@ __attribute__((always_inline)) INLINE static void *logger_loader_io_read_mask(
 __attribute__((always_inline)) INLINE static void *logger_loader_io_read_data(
     void *data, const size_t size, void *p) {
   memcpy(p, data, size);
-  return data + size;
+  return (char *) data + size;
 };
 
 /**
@@ -101,7 +101,7 @@ __attribute__((always_inline)) INLINE static void *logger_loader_io_write_data(
     void *data, const size_t size, const void *p) {
   memcpy(data, p, size);
 
-  return data + size;
+  return (char *) data + size;
 };
 
 #endif  // LOGGER_LOGGER_LOADER_IO_H

logger/logger_particle.c

@@ -109,9 +109,9 @@ void *logger_particle_read_field(struct logger_particle *part, void *map,
     part->mass = 0;
     part->id = 0;
     memcpy(&part->mass, p, sizeof(float));
-    p += sizeof(float);
+    p = (char *) p + sizeof(float);
     memcpy(&part->id, p, sizeof(size_t));
-    p -= sizeof(float);
+    p = (char *) p - sizeof(float);
     free(p);
   }
 
@@ -149,7 +149,7 @@ size_t logger_particle_read(struct logger_particle *part,
   logger_particle_init(part);
 
   /* Read the record's mask. */
-  map = logger_loader_io_read_mask(h, map + offset, &mask, &h_offset);
+  map = logger_loader_io_read_mask(h, (char *) map + offset, &mask, &h_offset);
 
   /* Check that the mask is meaningful */
   if (mask > (unsigned int)(1 << h->masks_count)) {
@@ -178,7 +178,7 @@ size_t logger_particle_read(struct logger_particle *part,
     part->time = -1;
 
   /* update the offset. */
-  offset = (size_t)(map - reader->log.log.map);
+  offset = (size_t)((char *) map - (char *) reader->log.log.map);
 
   /* Check if an interpolation is required. */
   if (reader_type == logger_reader_const) return offset;
@@ -192,7 +192,7 @@ size_t logger_particle_read(struct logger_particle *part,
   }
 
   /* No next particle. */
-  if (h_offset == 0) return (size_t)(map - reader->log.log.map);
+  if (h_offset == 0) return (size_t)((char *) map - (char *) reader->log.log.map);
 
   /* get absolute offset of next particle. */
   h_offset += offset - header_get_record_size_from_mask(h, mask) -

logger/logger_reader.c

@@ -142,7 +142,7 @@ size_t reader_read_record(struct logger_reader *reader,
 
   /* Read mask to find out if timestamp or particle. */
   size_t mask = 0;
-  logger_loader_io_read_mask(&log->header, log->log.map + offset, &mask, NULL);
+  logger_loader_io_read_mask(&log->header, (char *) log->log.map + offset, &mask, NULL);
 
   /* Check if timestamp or not. */
   int ind = header_get_field_index(&log->header, "timestamp");
@@ -280,7 +280,7 @@ void logger_reader_read_all_particles_mapper(void *map_data, int num_elements,
       if (test == -1) {
         size_t mask = 0;
         logger_loader_io_read_mask(&reader->log.header,
-                                   reader->log.log.map + prev_offset, &mask,
+                                   (char *) reader->log.log.map + prev_offset, &mask,
                                    &next_offset);
         error(
             "Trying to get a particle without next record (mask: %zi, diff "
@@ -412,7 +412,7 @@ void logger_reader_get_next_particle(struct logger_reader *reader,
   while (1) {
     /* Read the offset to the next particle */
     size_t mask = 0;
-    logger_loader_io_read_mask(&reader->log.header, map + prev_offset, &mask,
+    logger_loader_io_read_mask(&reader->log.header, (char *) map + prev_offset, &mask,
                                &next_offset);
 
     /* Check if something special happened */

logger/logger_time.c

@@ -92,7 +92,7 @@ size_t time_read(integertime_t *int_time, double *time,
   *time = 0;
 
   /* read record header. */
-  map = logger_loader_io_read_mask(h, map + offset, &mask, &prev_offset);
+  map = logger_loader_io_read_mask(h, (char *) map + offset, &mask, &prev_offset);
 
 #ifdef SWIFT_DEBUG_CHECKS
 
@@ -109,7 +109,7 @@ size_t time_read(integertime_t *int_time, double *time,
       logger_loader_io_read_data(map, sizeof(unsigned long long int), int_time);
   map = logger_loader_io_read_data(map, sizeof(double), time);
 
-  return map - h->log->log.map;
+  return (char *) map - (char *) h->log->log.map;
 }
 
 /**
@@ -131,7 +131,7 @@ size_t time_offset_first_record(const struct header *h) {
   if (i == -1) error("Time mask not present in the log file header.");
 
   size_t mask = 0;
-  logger_loader_io_read_mask(h, map + offset, &mask, NULL);
+  logger_loader_io_read_mask(h, (char *) map + offset, &mask, NULL);
 
   if (mask != h->masks[i].mask) error("Log file should begin by timestep.");
 

logger/logger_tools.c

@@ -60,7 +60,7 @@ int _tools_get_next_record_forward(const struct header *h, void *map,
   size_t diff_offset = 0;
 
   /* Read the offset. */
-  map = logger_loader_io_read_mask(h, map + *offset, NULL, &diff_offset);
+  map = logger_loader_io_read_mask(h, (char *) map + *offset, NULL, &diff_offset);
 
   if (diff_offset == 0) return -1;
 
@@ -91,7 +91,7 @@ int _tools_get_next_record_backward(const struct header *h, void *map,
   while (current_offset < file_size) {
     size_t mask = 0;
     size_t prev_offset;
-    logger_loader_io_read_mask(h, map + current_offset, &mask, &prev_offset);
+    logger_loader_io_read_mask(h, (char *) map + current_offset, &mask, &prev_offset);
 
     prev_offset = current_offset - prev_offset - record_header;
     if (*offset == prev_offset) {
@@ -123,16 +123,16 @@ size_t tools_reverse_offset(const struct header *h, void *file_map,
   void *map = file_map;
 
   /* read mask + offset. */
-  map = logger_loader_io_read_mask(h, map + offset, &mask, &prev_offset);
+  map = logger_loader_io_read_mask(h, (char *) map + offset, &mask, &prev_offset);
 
   /* write offset of zero (in case it is the last record). */
   const size_t zero = 0;
-  map -= LOGGER_OFFSET_SIZE;
+  map = (char *) map - LOGGER_OFFSET_SIZE;
   map = logger_loader_io_write_data(map, LOGGER_OFFSET_SIZE, &zero);
 
   /* set offset after current record. */
-  map += header_get_record_size_from_mask(h, mask);
-  size_t after_current_record = (size_t)(map - file_map);
+  map = (char *) map + header_get_record_size_from_mask(h, mask);
+  size_t after_current_record = (size_t)((char *) map - (char *)file_map);
 
   /* first records do not have a previous partner. */
   if (prev_offset == cur_offset) return after_current_record;
@@ -142,12 +142,12 @@ size_t tools_reverse_offset(const struct header *h, void *file_map,
           cur_offset);
 
   /* modify previous offset. */
-  map = file_map + cur_offset - prev_offset + LOGGER_MASK_SIZE;
+  map = (char *) file_map + cur_offset - prev_offset + LOGGER_MASK_SIZE;
   map = logger_loader_io_write_data(map, LOGGER_OFFSET_SIZE, &prev_offset);
 
 #ifdef SWIFT_DEBUG_CHECKS
   size_t prev_mask = 0;
-  map -= LOGGER_MASK_SIZE + LOGGER_OFFSET_SIZE;
+  map = (char *) map - LOGGER_MASK_SIZE + LOGGER_OFFSET_SIZE;
   logger_loader_io_read_mask(h, map, &prev_mask, NULL);
 
   /* Check if we are not mixing timestamp and particles */
@@ -179,7 +179,7 @@ size_t tools_check_record_consistency(const struct logger_reader *reader,
 
   const struct header *h = &reader->log.header;
   void *file_init = reader->log.log.map;
-  void *map = file_init + offset;
+  void *map = (char *) file_init + offset;
 
   size_t mask;
   size_t pointed_offset;
@@ -200,14 +200,14 @@ size_t tools_check_record_consistency(const struct logger_reader *reader,
   }
 
   /* set offset after current record. */
-  map += header_get_record_size_from_mask(h, mask);
+  map = (char *) + header_get_record_size_from_mask(h, mask);
 
   if (pointed_offset == offset || pointed_offset == 0)
-    return (size_t)(map - file_init);
+    return (size_t)((char *) map - (char *) file_init);
 
   /* read mask of the pointed record. */
   size_t pointed_mask = 0;
-  logger_loader_io_read_mask(h, file_init + pointed_offset, &pointed_mask,
+  logger_loader_io_read_mask(h, (char *) file_init + pointed_offset, &pointed_mask,
                              NULL);
 
   /* check if not mixing timestamp and particles. */
@@ -216,7 +216,7 @@ size_t tools_check_record_consistency(const struct logger_reader *reader,
     error("Error in the offset (mask %lu at %lu != %lu at %lu).", mask, offset,
           pointed_mask, pointed_offset);
 
-  if (pointed_mask == h->timestamp_mask) return (size_t)(map - file_init);
+  if (pointed_mask == h->timestamp_mask) return (size_t)((char *) map - (char *) file_init);
 
   struct logger_particle part;
   logger_particle_read(&part, reader, offset, 0, logger_reader_const);
@@ -229,5 +229,5 @@ size_t tools_check_record_consistency(const struct logger_reader *reader,
           pointed_offset);
   }
 
-  return (size_t)(map - file_init);
+  return (size_t)((char *) map - (char *) file_init);
 }

src/logger.h

@@ -186,7 +186,7 @@ void logger_struct_restore(struct logger_writer *log, FILE *stream);
  */
 INLINE static void logger_part_data_init(struct logger_part_data *logger) {
   logger->last_offset = 0;
-  logger->steps_since_last_output = INT_MAX;
+  logger->steps_since_last_output = 0; //INT_MAX;
 }
 
 /**