io_basic.h

Go to the documentation of this file.

/* ============================================================================

   Copyright (C) 1991, 2001, 2007, 2009, 2010, 2014  Konrad Bernloehr

   This file is part of the eventio/hessio library.

   The eventio/hessio library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public License
   along with this library. If not, see <http://www.gnu.org/licenses/>.

============================================================================ */

#ifndef IO_BASIC_H__LOADED

#define IO_BASIC_H__LOADED 1

#ifdef __cplusplus
extern "C" {
#endif

#ifndef INITIAL_H__LOADED
#include "initial.h"
#endif

/* #ifndef __cplusplus */
#ifndef WARNING_H__LOADED
#include "warning.h"
#endif
/* #endif */

#define MAX_IO_ITEM_LEVEL 20

#define HAVE_EVENTIO_USER_FLAG 1
#define HAVE_EVENTIO_EXTENDED_LENGTH 1
#define HAVE_EVENTIO_HEADER_LENGTH 1

/* Flag bits to be used with put_item_begin_with_flag(): */
#define EVENTIO_USER_FLAG 1
#define EVENTIO_EXTENSION_FLAG 2

typedef unsigned char BYTE;

struct _struct_IO_ITEM_HEADER
{
   unsigned long type;  
   unsigned version;    
   int can_search;      
   int level;           
   long ident;          
   int user_flag;       
   int use_extension;   
   size_t length;       
};
typedef struct _struct_IO_ITEM_HEADER IO_ITEM_HEADER;

struct _struct_IO_BUFFER
{
   unsigned char *buffer;  
   long buflen;            
   long r_remaining, w_remaining; 
   BYTE *data;             
   int is_allocated;
   int item_level;         
   long item_length[MAX_IO_ITEM_LEVEL]; 
   long sub_item_length[MAX_IO_ITEM_LEVEL]; 
   long item_start_offset[MAX_IO_ITEM_LEVEL]; 
   int item_extension[MAX_IO_ITEM_LEVEL]; 
   int input_fileno;  
   int output_fileno; 
   FILE *input_file;  
   FILE *output_file; 
   int (*user_function) (unsigned char *, long, int);
   int byte_order;    
   int data_pending;  
   long min_length;   
   long max_length;   
   int aux_count;     
   int regular;       
   int extended;      
   int sync_err_count;
   int sync_err_max;  
   int msg_ext;       
};
typedef struct _struct_IO_BUFFER IO_BUFFER;
typedef int (*IO_USER_FUNCTION) (unsigned char *, long, int);

/* ------------------ Buffer size parameters ------------------ */

#ifdef OS_MSDOS
# define IO_BUFFER_INITIAL_LENGTH 8192L
# define IO_BUFFER_LENGTH_INCREMENT 8192L
# define IO_BUFFER_MAXIMUM_LENGTH 65500L
#else
# define IO_BUFFER_INITIAL_LENGTH 32768L
# define IO_BUFFER_LENGTH_INCREMENT 65536L
# ifdef OS_OS9
#  define IO_BUFFER_MAXIMUM_LENGTH 1000000L
# else
#  define IO_BUFFER_MAXIMUM_LENGTH 3000000L
# endif
#endif

/* ------------------- Macro definitions ---------------------- */

/* ------------------------ COPY_BYTES ------------------------- */

/* Copy byte without or with switching byte orders. */
/* Using the order of arguments as with memcpy: (to,from,nbytes) */
#define COPY_BYTES(_target,_source,_num) memcpy(_target,_source,_num)
/* For reverting byte orders every two bytes, use swab() but */
/* beware that the order of arguments differs from memcpy. */
#define COPY_BYTES_SWAB(_target,_source,_num) swab(_source,_target,_num)

/* -------------------------- put_byte ------------------------- */
/*
@@ put_byte(): Write a byte to the output buffer.
 */

#define put_byte(_c,_p) (--(_p)->w_remaining>=0 ? \
   (*(_p)->data++ = (BYTE)(_c)) : \
   (BYTE)extend_io_buffer(_p,(unsigned)(_c), \
     (IO_BUFFER_LENGTH_INCREMENT)))

/* -------------------------- get_byte ------------------------- */
/*
@@ get_byte(): Read a byte from the input buffer.
 */

#define get_byte(p) (--(p)->r_remaining>=0? *(p)->data++ : -1)
#define get_bytes(p,k) (((p)->r_remaining -= k) >=0 ? (*(p)->data+=k)-k : -1)


/* ------------------ Function prototypes --------------------- */

/* I/O buffer allocation: */
IO_BUFFER *allocate_io_buffer (size_t buflen);
int extend_io_buffer (IO_BUFFER *iobuf, unsigned next_byte,
   long increment);
void free_io_buffer (IO_BUFFER *iobuf);

/* Atomic data type handling: */
/* ... 8 bits integer data types ... */
void put_vector_of_byte (const BYTE *vec, int num, IO_BUFFER *iobuf);
void get_vector_of_byte (BYTE *vec, int num, IO_BUFFER *iobuf);
#define put_vector_of_uint8 put_vector_of_byte
#define get_vector_of_uint8 get_vector_of_byte

/* Unsigned integers (counts) of unspecified length */
void put_count (uintmax_t num, IO_BUFFER *iobuf);
void put_count32 (uint32_t num, IO_BUFFER *iobuf);
void put_count16 (uint16_t num, IO_BUFFER *iobuf);
uintmax_t get_count (IO_BUFFER *iobuf);
uint32_t get_count32 (IO_BUFFER *iobuf);
uint16_t get_count16 (IO_BUFFER *iobuf);
/* Signed integers (counts) of unspecified length */
void put_scount (intmax_t num, IO_BUFFER *iobuf);
void put_scount32 (int32_t num, IO_BUFFER *iobuf);
void put_scount16 (int16_t num, IO_BUFFER *iobuf);
intmax_t get_scount (IO_BUFFER *iobuf);
int32_t get_scount32 (IO_BUFFER *iobuf);
int16_t get_scount16 (IO_BUFFER *iobuf);
void put_vector_of_int_scount (const int *vec, int num, IO_BUFFER *iobuf);
void get_vector_of_int_scount (int *vec, int num, IO_BUFFER *iobuf);
void put_vector_of_uint16_scount_differential (uint16_t *vec, int num, IO_BUFFER *iobuf);
void get_vector_of_uint16_scount_differential (uint16_t *vec, int num, IO_BUFFER *iobuf);
void put_vector_of_uint32_scount_differential (uint32_t *vec, int num, IO_BUFFER *iobuf);
void get_vector_of_uint32_scount_differential (uint32_t *vec, int num, IO_BUFFER *iobuf);

/* ... 16 bits integer data types ... */
/* ... (native) ... */
void put_vector_of_short (const short *vec, int num, IO_BUFFER *iobuf);
void get_vector_of_short (short *vec, int num, IO_BUFFER *iobuf);
#define put_vector_of_int16 put_vector_of_short
#define get_vector_of_int16 get_vector_of_short
void put_vector_of_uint16 (const uint16_t *uval, int num, IO_BUFFER *iobuf);
void get_vector_of_uint16 (uint16_t *uval, int num, IO_BUFFER *iobuf);
uint16_t get_uint16(IO_BUFFER *iobuf);
/* ... (with conversion) ... */
void put_short (int num, IO_BUFFER *iobuf);
int get_short (IO_BUFFER *iobuf);
void put_vector_of_int (const int *vec, int num, IO_BUFFER *iobuf);
void get_vector_of_int (int *vec, int num, IO_BUFFER *iobuf);

/* ... 32 bits integer data types ... */
/* ... (native) ... */
void put_int32 (int32_t num, IO_BUFFER *iobuf);
int32_t get_int32 (IO_BUFFER *iobuf);
void put_uint32 (uint32_t num, IO_BUFFER *iobuf);
uint32_t get_uint32 (IO_BUFFER *iobuf);
void put_vector_of_int32 (const int32_t *vec, int num, IO_BUFFER *iobuf);
void get_vector_of_int32 (int32_t *vec, int num, IO_BUFFER *iobuf);
void put_vector_of_uint32 (const uint32_t *vec, int num, IO_BUFFER *iobuf);
void get_vector_of_uint32 (uint32_t *vec, int num, IO_BUFFER *iobuf);
/* ... (with conversion) ... */
void put_long (long num, IO_BUFFER *iobuf);
long get_long (IO_BUFFER *iobuf);
void put_vector_of_long (const long *vec, int num, IO_BUFFER *iobuf);
void get_vector_of_long (long *vec, int num, IO_BUFFER *iobuf);

#ifdef HAVE_64BIT_INT
/* ... 64 bits integer data types (data may be non-portable!) ... */
void put_vector_of_int64 (const int64_t *vec, int num, IO_BUFFER *iobuf);
void get_vector_of_int64 (int64_t *vec, int num, IO_BUFFER *iobuf);
void put_vector_of_uint64 (const uint64_t *vec, int num, IO_BUFFER *iobuf);
void get_vector_of_uint64 (uint64_t *vec, int num, IO_BUFFER *iobuf);
#endif

/* ... run-length encoded character string ... */
int put_string (const char *s, IO_BUFFER *iobuf);
int get_string (char *s, int nmax, IO_BUFFER *iobuf);
int put_long_string (const char *s, IO_BUFFER *iobuf);
int get_long_string (char *s, int nmax, IO_BUFFER *iobuf);
int put_var_string (const char *s, IO_BUFFER *iobuf);
int get_var_string (char *s, int nmax, IO_BUFFER *iobuf);

/* ... 32 bits floating point ... */
/* ... (native) ... */
void put_vector_of_float (const float *vec, int num, IO_BUFFER *iobuf);
void get_vector_of_float (float *vec, int num, IO_BUFFER *iobuf);
/* ... (with conversion) ... */
void put_real (double d, IO_BUFFER *iobuf);
double get_real (IO_BUFFER *iobuf);
void put_vector_of_real (const double *vec, int num, IO_BUFFER *iobuf);
void get_vector_of_real (double *vec, int num, IO_BUFFER *iobuf);

/* ... 64 bits floating point ... */
void put_double (double d, IO_BUFFER *iobuf);
double get_double (IO_BUFFER *iobuf);
void put_vector_of_double (const double *vec, int num, IO_BUFFER *iobuf);
void get_vector_of_double (double *vec, int num, IO_BUFFER *iobuf);

/* ... 16 bits floating point ... */
void dbl_to_sfloat (double dnum, uint16_t *snum);
void fltp_to_sfloat (const float *fnum, uint16_t *snum);
void put_sfloat (double dnum, IO_BUFFER *iobuf);
double dbl_from_sfloat(const uint16_t *snum);
double get_sfloat (IO_BUFFER *iobuf);

/* General item management: */
int put_item_begin (IO_BUFFER *iobuf, IO_ITEM_HEADER *item_header);
int put_item_begin_with_flags (IO_BUFFER *iobuf, 
   IO_ITEM_HEADER *item_header, int user_flag, int extended);
int put_item_end (IO_BUFFER *iobuf, IO_ITEM_HEADER *item_header);
int unput_item (IO_BUFFER *iobuf, IO_ITEM_HEADER *item_header);
int get_item_begin (IO_BUFFER *iobuf, IO_ITEM_HEADER *item_header);
int get_item_end (IO_BUFFER *iobuf, IO_ITEM_HEADER *item_header);
int unget_item (IO_BUFFER *iobuf, IO_ITEM_HEADER *item_header);
int next_subitem_type (IO_BUFFER *iobuf);
long next_subitem_length (IO_BUFFER *iobuf);
long next_subitem_ident (IO_BUFFER *iobuf);
int skip_subitem (IO_BUFFER *iobuf);
int search_sub_item (IO_BUFFER *iobuf, IO_ITEM_HEADER *item_header,
    IO_ITEM_HEADER *sub_item_header);
int rewind_item (IO_BUFFER *iobuf, IO_ITEM_HEADER *item_header);
int remove_item (IO_BUFFER *iobuf, IO_ITEM_HEADER *item_header);
int list_sub_items (IO_BUFFER *iobuf, IO_ITEM_HEADER *item_header,
    int maxlevel, int verbosity);

/* File I/O: */
int reset_io_block (IO_BUFFER *iobuf);
int write_io_block (IO_BUFFER *iobuf);
int find_io_block (IO_BUFFER *iobuf, IO_ITEM_HEADER *item_header);
int read_io_block (IO_BUFFER *iobuf, IO_ITEM_HEADER *item_header);
int skip_io_block (IO_BUFFER *iobuf, IO_ITEM_HEADER *item_header);
int list_io_blocks (IO_BUFFER *iobuf, int verbosity);

int copy_item_to_io_block (IO_BUFFER *iobuf2, IO_BUFFER *iobuf,
    const IO_ITEM_HEADER *item_header);
int append_io_block_as_item (IO_BUFFER *iobuf,
    IO_ITEM_HEADER *item_header, BYTE *_buffer, long length);
    
/* Registry hook: */

struct ev_reg_entry
{
   unsigned long type; 
   char *name;         
   char *description;  
};

struct ev_reg_entry *find_ev_reg(unsigned long t);

typedef struct ev_reg_entry *(*EVREGSEARCH)(unsigned long t);

void set_eventio_registry_hook(EVREGSEARCH fptr);

const char *eventio_registered_typename(unsigned long type);
const char *eventio_registered_description(unsigned long type);


#ifdef __cplusplus
}
#endif

#endif