1) handles hdf5 and adf transparently through new cgns_io interface

2) added PYRA_13 and NFACE_n element types

3) element data is no longer read into memory when the file is opened,
   only when requested. John Bussoletti fix (also in 2.5 under CVS) 

4) Robert Magnum correction for cg_model_read(). (also in 2.5 under CVS)

5) added to cgnslib:

/* file_type defines */
#define CG_FILE_NONE 0
#define CG_FILE_ADF  1
#define CG_FILE_HDF5 2
#define CG_FILE_XML  3

int cg_save_as(int fn, const char *filename, int file_type, int follow_links);
cg_save_as_f(fn, filename, file_type, follow_links, ier)

int cg_set_file_type(int file_type);
int cg_get_file_type(int fn, int *file_type);
cg_set_file_type_f(file_type, ier)
cg_get_file_type_f(fn, file_type, ier)

/* these are wrappers on cg_configure() */

int cg_error_handler(void (*)(int, char *));

int cg_set_compress(int compress);
int cg_get_compress(int *compress);
cg_set_compress_f(compress, ier);
cg_get_compress_f(compress, ier);

int cg_set_path(const char *path);
int cg_add_path(const char *path);
cg_set_path_f(path, ier);
cg_add_path_f(path, ier);


6) changed in cgnslib

int cg_is_cgns(const char *filename);
cg_is_cgns_f(filename, ier)

   to

int cg_is_cgns(const char *filename, int *file_type);
cg_is_cgns_f(filename, file_type, ier)


7) removed from cgnslib:

MODE_READ, MODE_WRITE, MODE_MODIFY, Null, UserDefined and Celcius defines


8) low-level file access should now be made through the cgio interface
   rather than ADF (or ADFH) directly. Include cgns_io.h for the function
   prototypes. The ADF and ADFH functions are still available by including
   the appropiate ADF.h header file.

These are some of the defines, the CGIO_MODE_xxx and CGIO_FILE_xxx are the
same as the cgns counterparts. The CGIO_MAX_xxx defines are the same as
for the ADF library. There are also some configure defines, and error
code returns for the cgio routines. The specific implementation (ADF, HDF5)
can return additional error codes not defined there.

#define CGIO_MODE_READ   0
#define CGIO_MODE_WRITE  1
#define CGIO_MODE_MODIFY 2

#define CGIO_FILE_NONE   0
#define CGIO_FILE_ADF    1
#define CGIO_FILE_HDF5   2
#define CGIO_FILE_XML    3

#define CGIO_MAX_DATATYPE_LENGTH  2
#define CGIO_MAX_DIMENSIONS      12
#define CGIO_MAX_NAME_LENGTH     32
#define CGIO_MAX_LABEL_LENGTH    32
#define CGIO_MAX_VERSION_LENGTH  32
#define CGIO_MAX_ERROR_LENGTH    80
#define CGIO_MAX_LINK_DEPTH     100
#define CGIO_MAX_FILE_LENGTH   1024
#define CGIO_MAX_LINK_LENGTH   4096

The following lists the cgio functions. They are similar to the ADF routines
in terms of srgument list. Maybe I'll find some time to document them.

int cgio_path_add(const char *path);
cgio_path_add_f(ier, path)

int cgio_path_delete(const char *path);
cgio_path_delete_f(ier, path)

int cgio_find_file(const char *filename, int file_type,
                   int max_path_len, char *pathname);
cgio_find_file_f(ier, filename, file_type, pathname)

int cgio_is_supported(int file_type);
cgio_is_supported_f(ier, file_type);

int cgio_configure(int what, void *value);

void cgio_cleanup();
cgio_cleanup_f(ier)

int cgio_check_file(const char *filename, int *file_type);
cgio_check_file_f(ier, filename, file_type)

int cgio_compute_data_size(const char *data_type, int num_dims,
                           const int *dim_vals, unsigned long *count);
cgio_compute_data_size_f(ier, data_type, num_dims, dim_vals, count, size)

int cgio_open_file(const char *filename, int file_mode,
                   int file_type, int *cgio_num);
cgio_open_file_f(ier, filename, file_mode, file_type, cgio_num)

int cgio_close_file(int cgio_num);
cgio_close_file_f(ier, cgio_num);

int cgio_compress_file(int cgio_num, const char *filename);

int cgio_copy_file(int cgio_num_inp, int cgio_num_out, int follow_links);

int cgio_flush_to_disk(int cgio_num);
cgio_flush_to_disk_f(ier, cgio_num)

int cgio_library_version(int cgio_num, char *version);
cgio_library_version_f(ier, cgio_num, version)

int cgio_file_version(int cgio_num, char *file_version,
                      char *creation_date, char *modified_date);
cgio_file_version_f(ier, cgio_num, file_version, creation_date, modified_date)

int cgio_get_root_id(int cgio_num, double *rootid);
cgio_get_root_id_f(ier, cgio_num, rootid)

int cgio_get_file_type(int cgio_num, int *file_type);
cgio_get_file_type_f(ier, cgio_num, file_type)

void cgio_error_code(int *errcode, int *file_type);
cgio_error_code_f(errcode, file_type)

int cgio_error_message(int max_len, char *error_msg);
cgio_error_message_f(ier, error_msg)

void cgio_error_exit(const char *msg);
cgio_error_exit_f(msg)

int cgio_create_node(int cgio_num, double pid, const char *name, double *id);
cgio_create_node_f(ier, cgio_num, pid, name, id)

int cgio_new_node(int cgio_num, double pid, const char *name,
                  const char *label, const char *data_type, int ndims,
                  const int *dims, const void *data, double *id);

int cgio_delete_node(int cgio_num, double pid, double id);
cgio_delete_node_f(ier, cgio_num, pid, id)

int cgio_move_node(int cgio_num, double pid, double id, double new_pid);
cgio_move_node_f(ier, cgio_num, pid, id, new_pid)

int cgio_copy_node(int cgio_num_inp, double id_inp, int cgio_num_out,
                   double id_out);

int cgio_release_id(int cgio_num, double id);
cgio_release_id_f(ier, cgio_num, id)

int cgio_is_link(int cgio_num, double id, int *link_len);
cgio_is_link_f(ier, cgio_num, id, link_len)

int cgio_link_size(int cgio_num, double id, int *file_len, int *name_len);
cgio_link_size_f(ier, cgio_num, id, file_len, name_len)

int cgio_create_link(int cgio_num, double pid, const char *name,
                     const char *filename, const char *name_in_file,
                     double *id);
cgio_create_link_f(ier, cgio_num, pid, name, filename, name_in_file, id)

int cgio_get_link(int cgio_num, double id, char *filename,
                  char *name_in_file);
cgio_get_link_f(ier, cgio_num, id, filename, name_in_file)

int cgio_number_children(int cgio_num, double id, int *num_children);
cgio_number_children_f(ier, cgio_num, id, num_children)

int cgio_children_ids(int cgio_num, double pid, int start, int max_ret,
                      int *num_ret, double *ids);
cgio_children_ids_f(ier, cgio_num, pid, start, max_ret, num_ret, ids)

int cgio_children_names(int cgio_num, double pid, int start, int max_ret,
                        int name_len, int *num_ret, char *names);
cgio_children_names_f(ier, cgio_num, pid, start, max_ret, name_len,
                      num_ret, names)

int cgio_get_node_id(int cgio_num, double pid, const char *name, double *id);
cgio_get_node_id_f(ier, cgio_num, pid, name, id)

int cgio_get_name(int cgio_num, double id, char *name);
cgio_get_name_f(ier, cgio_num, id, name)

int cgio_get_label(int cgio_num, double id, char *label);
cgio_get_label_f(ier, cgio_num, id, label)

int cgio_get_data_type(int cgio_num, double id, char *data_type);
cgio_get_data_type_f(ier, cgio_num, id, data_type)

int cgio_get_data_size(int cgio_num, double id, unsigned long *data_size);
cgio_get_data_size_f(ier, cgio_num, id, data_size)

int cgio_get_dimensions(int cgio_num, double id, int *num_dims, int *dims);
cgio_get_dimensions_f(ier, cgio_num, id, num_dims, dims)

int cgio_read_all_data(int cgio_num, double id, void *data);
cgio_read_all_data_f(ier, cgio_num, id, data)

int cgio_read_data(int cgio_num, double id, const int *s_start,
                   const int *s_end, const int *s_stride, int m_num_dims,
                   const int *m_dims, const int *m_start, const int *m_end,
                   const int *m_stride, void *data);
cgio_read_data_f(ier, cgio_num, id, s_start, s_end, s_stride, m_num_dims,
                 m_dims, m_start, m_end, m_stride, data)

int cgio_set_name(int cgio_num, double pid, double id, const char *name);
cgio_set_name_f(ier, cgio_num, pid, id, name)

int cgio_set_label(int cgio_num, double id, const char *label);
cgio_set_label_f(ier, cgio_num, id, label)

int cgio_set_dimensions(int cgio_num, double id, const char *data_type,
                        int num_dims, const int *dims);
cgio_set_dimensions_f(ier, cgio_num, id, data_type, num_dims, dims)

int cgio_write_all_data(int cgio_num, double id, const void *data);
cgio_write_all_data_f(ier, cgio_num, id, data)

int cgio_write_data(int cgio_num, double id, const int *s_start,
                    const int *s_end, const int *s_stride, int m_num_dims,
                    const int *m_dims, const int *m_start, const int *m_end,
                    const int *m_stride, const void *data);
cgio_write_data_f(ier, cgio_num, id, s_start, s_end, s_stride, m_num_dims,
                  m_dims, m_start, m_end, m_stride, data)


9) changes to ADF

removed ADF_Search_Add() and ADF_Search_Delete() (now handled in cgio)
added   ADF_Link_Size()
implemented Paul Edwards fix for reading blocks (also in 2.5 under CVS)


10) changes to ADFH

removed ADFH_Search_Add() and ADFH_Search_Delete() (now handled in cgio)
added   ADFH_Link_Size()

updated with Marc's link file changes. The index swapping from Fortran to C
is implemented. (also in 2.5 under CVS)

