[svn-r1341]

Changes since 19990611
----------------------

./doc/html/H5.format.html
	Added documentation for opaque data types (bitfield types were
	already documented but they were out of order).

./src/H5E.c
	Fixed a bug with glibc2 on linux systems where `stdout' is an
	extern and can't be used to initialize static data.

./src/H5T.c
./src/H5Tpkg.h
./src/H5Tpublic.h
./src/H5detect.c
	Removed the `_T' from the new C9x types I just added so the
	names are consistent with existing types. Besides, the fact
	that something is a datatype is obvious because it starts with
	H5T_NATIVE_.

./tools/h5ls.c
	Added the new C9x data types. H5ls prints one of these types
	only if it doesn't match one of the builtin C types.

	Prints the OID for shared data types.

	Fixed a formatting bug with symbolic links which was
	introduced a few changes ago.

	The commandline has been changed so that objects from multiple
	files can be listed with a single command. Instead of
	specifying a file name and an optional list of objects, each
	thing to print is a file name and object concatenated. H5ls
	figures out how to devide the name into a file name and object
	name even when the file name part doesn't correspond to an
	actual Unix file.

	   Old syntax: h5ls [OPTIONS] FILE [OBJECTS]
	   New syntax: h5ls [OPTIONS] FILE[/OBJECT] [FILE[/OBJECT]]...

	   Example ({X,Y} is expanded by the shell)

	   Old command: h5ls -d ../test/x.data dir1 dir2
	   New command: h5ls -d ../test/x.data/{dir1,dir2}

	The filename is printed as part of the object name when full
	names are requested (--full or --recursive). If people really
	don't like this they can undefine a constant at the top of
	h5ls.

	Errors from the hdf5 library are turned off.

	Commandline switches of the form `--width 80' are accepted in
	addition to `--width=80'. This is more symmetric with
	single-letter switches that take two forms: `-w 80' and
	`-w80'.

./src/H5D.c
	Added tracing instrumentation for H5Dvlen_reclaim().

./src/H5private.h
	Added casts to int for the isalpha() et al macros to shut up
	solaris warnings about char subscripts.

1 files changed, 40 insertions, 40 deletions

diff --git a/src/H5detect.c b/src/H5detect.c
index 1d07df8..5930c54 100644
--- a/src/H5detect.c
+++ b/src/H5detect.c
@@ -995,106 +995,106 @@ main(void)
     print_header();
 
     /* C89 integer types */
-    DETECT_I(signed char,	  SCHAR,          d[nd]); nd++;
-    DETECT_I(unsigned char,	  UCHAR,          d[nd]); nd++;
-    DETECT_I(short,		  SHORT,          d[nd]); nd++;
-    DETECT_I(unsigned short,	  USHORT,         d[nd]); nd++;
-    DETECT_I(int,		  INT,	          d[nd]); nd++;
-    DETECT_I(unsigned int,	  UINT,	          d[nd]); nd++;
-    DETECT_I(long,		  LONG,	          d[nd]); nd++;
-    DETECT_I(unsigned long,	  ULONG,          d[nd]); nd++;
+    DETECT_I(signed char,	  SCHAR,        d[nd]); nd++;
+    DETECT_I(unsigned char,	  UCHAR,        d[nd]); nd++;
+    DETECT_I(short,		  SHORT,        d[nd]); nd++;
+    DETECT_I(unsigned short,	  USHORT,       d[nd]); nd++;
+    DETECT_I(int,		  INT,	        d[nd]); nd++;
+    DETECT_I(unsigned int,	  UINT,	        d[nd]); nd++;
+    DETECT_I(long,		  LONG,	        d[nd]); nd++;
+    DETECT_I(unsigned long,	  ULONG,        d[nd]); nd++;
 
     /*
      * C9x integer types.
      */
 #if SIZEOF_INT8_T>0
-    DETECT_I(int8_t, 		  INT8_T,         d[nd]); nd++;
+    DETECT_I(int8_t, 		  INT8,         d[nd]); nd++;
 #endif
 #if SIZEOF_UINT8_T>0
-    DETECT_I(uint8_t, 		  UINT8_T,        d[nd]); nd++;
+    DETECT_I(uint8_t, 		  UINT8,        d[nd]); nd++;
 #endif
 #if SIZEOF_INT_LEAST8_T>0
-    DETECT_I(int_least8_t, 	  INT_LEAST8_T,   d[nd]); nd++;
+    DETECT_I(int_least8_t, 	  INT_LEAST8,   d[nd]); nd++;
 #endif
 #if SIZEOF_UINT_LEAST8_T>0
-    DETECT_I(uint_least8_t, 	  UINT_LEAST8_T,  d[nd]); nd++;
+    DETECT_I(uint_least8_t, 	  UINT_LEAST8,  d[nd]); nd++;
 #endif
 #if SIZEOF_INT_FAST8_T>0
-    DETECT_I(int_fast8_t, 	  INT_FAST8_T,    d[nd]); nd++;
+    DETECT_I(int_fast8_t, 	  INT_FAST8,    d[nd]); nd++;
 #endif
 #if SIZEOF_UINT_FAST8_T>0
-    DETECT_I(uint_fast8_t, 	  UINT_FAST8_T,   d[nd]); nd++;
+    DETECT_I(uint_fast8_t, 	  UINT_FAST8,   d[nd]); nd++;
 #endif
 #if SIZEOF_INT16_T>0
-    DETECT_I(int16_t, 		  INT16_T,        d[nd]); nd++;
+    DETECT_I(int16_t, 		  INT16,        d[nd]); nd++;
 #endif
 #if SIZEOF_UINT16_T>0
-    DETECT_I(uint16_t, 		  UINT16_T,       d[nd]); nd++;
+    DETECT_I(uint16_t, 		  UINT16,       d[nd]); nd++;
 #endif
 #if SIZEOF_INT_LEAST16_T>0
-    DETECT_I(int_least16_t, 	  INT_LEAST16_T,  d[nd]); nd++;
+    DETECT_I(int_least16_t, 	  INT_LEAST16,  d[nd]); nd++;
 #endif
 #if SIZEOF_UINT_LEAST16_T>0
-    DETECT_I(uint_least16_t, 	  UINT_LEAST16_T, d[nd]); nd++;
+    DETECT_I(uint_least16_t, 	  UINT_LEAST16, d[nd]); nd++;
 #endif
 #if SIZEOF_INT_FAST16_T>0
-    DETECT_I(int_fast16_t, 	  INT_FAST16_T,   d[nd]); nd++;
+    DETECT_I(int_fast16_t, 	  INT_FAST16,   d[nd]); nd++;
 #endif
 #if SIZEOF_UINT_FAST16_T>0
-    DETECT_I(uint_fast16_t, 	  UINT_FAST16_T,  d[nd]); nd++;
+    DETECT_I(uint_fast16_t, 	  UINT_FAST16,  d[nd]); nd++;
 #endif
 #if SIZEOF_INT32_T>0
-    DETECT_I(int32_t, 		  INT32_T,        d[nd]); nd++;
+    DETECT_I(int32_t, 		  INT32,        d[nd]); nd++;
 #endif
 #if SIZEOF_UINT32_T>0
-    DETECT_I(uint32_t, 		  UINT32_T,       d[nd]); nd++;
+    DETECT_I(uint32_t, 		  UINT32,       d[nd]); nd++;
 #endif
 #if SIZEOF_INT_LEAST32_T>0
-    DETECT_I(int_least32_t, 	  INT_LEAST32_T,  d[nd]); nd++;
+    DETECT_I(int_least32_t, 	  INT_LEAST32,  d[nd]); nd++;
 #endif
 #if SIZEOF_UINT_LEAST32_T>0
-    DETECT_I(uint_least32_t, 	  UINT_LEAST32_T, d[nd]); nd++;
+    DETECT_I(uint_least32_t, 	  UINT_LEAST32, d[nd]); nd++;
 #endif
 #if SIZEOF_INT_FAST32_T>0
-    DETECT_I(int_fast32_t, 	  INT_FAST32_T,   d[nd]); nd++;
+    DETECT_I(int_fast32_t, 	  INT_FAST32,   d[nd]); nd++;
 #endif
 #if SIZEOF_UINT_FAST32_T>0
-    DETECT_I(uint_fast32_t, 	  UINT_FAST32_T,  d[nd]); nd++;
+    DETECT_I(uint_fast32_t, 	  UINT_FAST32,  d[nd]); nd++;
 #endif
 #if SIZEOF_INT64_T>0
-    DETECT_I(int64_t, 		  INT64_T,        d[nd]); nd++;
+    DETECT_I(int64_t, 		  INT64,        d[nd]); nd++;
 #endif
 #if SIZEOF_UINT64_T>0
-    DETECT_I(uint64_t, 		  UINT64_T,       d[nd]); nd++;
+    DETECT_I(uint64_t, 		  UINT64,       d[nd]); nd++;
 #endif
 #if SIZEOF_INT_LEAST64_T>0
-    DETECT_I(int_least64_t, 	  INT_LEAST64_T,  d[nd]); nd++;
+    DETECT_I(int_least64_t, 	  INT_LEAST64,  d[nd]); nd++;
 #endif
 #if SIZEOF_UINT_LEAST64_T>0
-    DETECT_I(uint_least64_t, 	  UINT_LEAST64_T, d[nd]); nd++;
+    DETECT_I(uint_least64_t, 	  UINT_LEAST64, d[nd]); nd++;
 #endif
 #if SIZEOF_INT_FAST64_T>0
-    DETECT_I(int_fast64_t, 	  INT_FAST64_T,   d[nd]); nd++;
+    DETECT_I(int_fast64_t, 	  INT_FAST64,   d[nd]); nd++;
 #endif
 #if SIZEOF_UINT_FAST64_T>0
-    DETECT_I(uint_fast64_t, 	  UINT_FAST64_T,  d[nd]); nd++;
+    DETECT_I(uint_fast64_t, 	  UINT_FAST64,  d[nd]); nd++;
 #endif
     
 #if SIZEOF_LONG_LONG>0
-    DETECT_I(long_long,		  LLONG,          d[nd]); nd++;
-    DETECT_I(unsigned long_long,  ULLONG,         d[nd]); nd++;
+    DETECT_I(long_long,		  LLONG,        d[nd]); nd++;
+    DETECT_I(unsigned long_long,  ULLONG,       d[nd]); nd++;
 #else
     /*
      * This architecture doesn't support an integer type larger than `long'
      * so we'll just make H5T_NATIVE_LLONG the same as H5T_NATIVE_LONG since
      * `long long' is probably equivalent to `long' here anyway.
      */
-    DETECT_I(long,		  LLONG,          d[nd]); nd++;
-    DETECT_I(unsigned long,	  ULLONG,         d[nd]); nd++;
+    DETECT_I(long,		  LLONG,        d[nd]); nd++;
+    DETECT_I(unsigned long,	  ULLONG,       d[nd]); nd++;
 #endif
 
-    DETECT_F(float,		  FLOAT,          d[nd]); nd++;
-    DETECT_F(double,		  DOUBLE,         d[nd]); nd++;
+    DETECT_F(float,		  FLOAT,        d[nd]); nd++;
+    DETECT_F(double,		  DOUBLE,       d[nd]); nd++;
 
 #if SIZEOF_DOUBLE == SIZEOF_LONG_DOUBLE
     /*
@@ -1103,9 +1103,9 @@ main(void)
      * some systems and `long double' is probably the same as `double' here
      * anyway.
      */
-    DETECT_F(double,		  LDOUBLE,        d[nd]); nd++;
+    DETECT_F(double,		  LDOUBLE,      d[nd]); nd++;
 #else
-    DETECT_F(long double,	  LDOUBLE,        d[nd]); nd++;
+    DETECT_F(long double,	  LDOUBLE,      d[nd]); nd++;
 #endif
 
     print_results (nd, d);