diff -upr speech_tools/base_class/EST_TMatrix.cc /tmp/speech_tools/base_class/EST_TMatrix.cc
--- speech_tools/base_class/EST_TMatrix.cc	2001-07-25 12:02:35.000000000 +0100
+++ /tmp/speech_tools/base_class/EST_TMatrix.cc	2004-05-07 04:02:14.324407638 +0100
@@ -101,7 +101,7 @@ T &EST_TMatrix<T>::a_check(int row, int 
 {
 
   if (!EST_matrix_bounds_check(row, col, num_rows(), num_columns(), FALSE))
-    return *error_return;
+    return *this->error_return;
     
   return a_no_check(row,col);
 }
@@ -212,9 +212,9 @@ void EST_TMatrix<T>::just_resize(int new
 {
     T *new_m;
 
-    if (num_rows() != new_rows || num_columns() != new_cols || p_memory == NULL )
+    if (num_rows() != new_rows || num_columns() != new_cols || this->p_memory == NULL )
       {
-	if (p_sub_matrix)
+	if (this->p_sub_matrix)
 	  EST_error("Attempt to resize Sub-Matrix");
 
 	if (new_cols < 0 || new_rows < 0)
@@ -225,22 +225,22 @@ void EST_TMatrix<T>::just_resize(int new
 	
 	new_m = new T[new_rows*new_cols];
 
-	if (p_memory != NULL)
+	if (this->p_memory != NULL)
 	  if (old_vals != NULL)
-	    *old_vals = p_memory;
-	  else  if (!p_sub_matrix)
-	    delete [] (p_memory-p_offset);
+	    *old_vals = this->p_memory;
+	  else  if (!this->p_sub_matrix)
+	    delete [] (this->p_memory-this->p_offset);
     
 	p_num_rows = new_rows;
-	p_num_columns = new_cols;
-	p_offset=0;
-	p_row_step=p_num_columns; 
-	p_column_step=1;
+	this->p_num_columns = new_cols;
+	this->p_offset=0;
+	p_row_step=this->p_num_columns; 
+	this->p_column_step=1;
 	
-	p_memory = new_m;
+	this->p_memory = new_m;
       }
     else
-      *old_vals = p_memory;
+      *old_vals = this->p_memory;
 	
 }
 
@@ -248,12 +248,12 @@ template<class T>
 void EST_TMatrix<T>::resize(int new_rows, int new_cols, int set)
 {
   int i,j;
-  T * old_vals = p_memory;
+  T * old_vals = this->p_memory;
   int old_rows = num_rows();
   int old_cols = num_columns();
   int old_row_step = p_row_step;
-  int old_offset = p_offset;
-  int old_column_step = p_column_step;
+  int old_offset = this->p_offset;
+  int old_column_step = this->p_column_step;
 
   if (new_rows<0)
     new_rows = old_rows;
@@ -285,27 +285,27 @@ void EST_TMatrix<T>::resize(int new_rows
       
       for(i=0; i<copy_r; i++)
 	for(j=copy_c; j<new_cols; j++)
-	  a_no_check(i,j) =  *def_val;
+	  a_no_check(i,j) =  *this->def_val;
       
       for(i=copy_r; i<new_rows; i++)
 	for(j=0; j<new_cols; j++)
-	  a_no_check(i,j) =  *def_val;
+	  a_no_check(i,j) =  *this->def_val;
     }
 
-  if (old_vals && old_vals != p_memory && !p_sub_matrix)
+  if (old_vals && old_vals != this->p_memory && !this->p_sub_matrix)
     delete [] (old_vals-old_offset);
 }
 
 template<class T>
 bool EST_TMatrix<T>::have_rows_before(int n) const
 {
-  return p_offset >= n*p_row_step;
+  return this->p_offset >= n*p_row_step;
 }
 
 template<class T>
 bool EST_TMatrix<T>::have_columns_before(int n) const
 {
-  return p_offset >= n*p_column_step;
+  return this->p_offset >= n*this->p_column_step;
 }
 
 template<class T>
@@ -506,12 +506,12 @@ void EST_TMatrix<T>::row(EST_TVector<T> 
 
   rv.p_sub_matrix = TRUE;
   rv.p_num_columns = len;
-  rv.p_offset = p_offset + start_c*p_column_step + r*p_row_step;
-  rv.p_memory = p_memory - p_offset + rv.p_offset;
+  rv.p_offset = this->p_offset + start_c*this->p_column_step + r*p_row_step;
+  rv.p_memory = this->p_memory - this->p_offset + rv.p_offset;
 //  cout << "mrow: mem: " << rv.p_memory << " (" << (int)rv.p_memory << ")\n";
 //  cout << "mrow: ofset: " << rv.p_offset << " (" << (int)rv.p_offset << ")\n";
 
-  rv.p_column_step=p_column_step;
+  rv.p_column_step=this->p_column_step;
 }
 
 template<class T>
@@ -528,8 +528,8 @@ void EST_TMatrix<T>::column(EST_TVector<
 
   cv.p_sub_matrix = TRUE;
   cv.p_num_columns = len;
-  cv.p_offset = p_offset + c*p_column_step + start_r*p_row_step;
-  cv.p_memory = p_memory -p_offset + cv.p_offset;
+  cv.p_offset = this->p_offset + c*this->p_column_step + start_r*p_row_step;
+  cv.p_memory = this->p_memory -this->p_offset + cv.p_offset;
 //  cout << "mcol: mem: " << cv.p_memory << " (" << (int)cv.p_memory << ")\n";
 //  cout << "mcol: offset: " << cv.p_offset << " (" << (int)cv.p_offset << ")\n";
 
@@ -552,10 +552,10 @@ void EST_TMatrix<T>::sub_matrix(EST_TMat
     delete [] (sm.p_memory - sm.p_offset);
 
   sm.p_sub_matrix = TRUE;
-  sm.p_offset =  p_offset + c*p_column_step + r*p_row_step;
-  sm.p_memory = p_memory - p_offset + sm.p_offset;
+  sm.p_offset =  this->p_offset + c*this->p_column_step + r*p_row_step;
+  sm.p_memory = this->p_memory - this->p_offset + sm.p_offset;
   sm.p_row_step=p_row_step;
-  sm.p_column_step=p_column_step;
+  sm.p_column_step=this->p_column_step;
   sm.p_num_rows = len_r;
   sm.p_num_columns = len_c;
   
diff -upr speech_tools/base_class/EST_TNamedEnum.cc /tmp/speech_tools/base_class/EST_TNamedEnum.cc
--- speech_tools/base_class/EST_TNamedEnum.cc	2001-04-04 14:11:27.000000000 +0100
+++ /tmp/speech_tools/base_class/EST_TNamedEnum.cc	2004-05-07 02:47:03.000000000 +0100
@@ -186,11 +186,11 @@ EST_read_status EST_TNamedEnum<ENUM>::pr
   if ((file=fopen(name, "rb"))==NULL)
     return misc_read_error;
 
-  if (definitions)
-    delete[] definitions;
+  if (this->definitions)
+    delete[] this->definitions;
 
-  ndefinitions= -1;
-  definitions=NULL;
+  this->ndefinitions= -1;
+  this->definitions=NULL;
 
   buffer[LINE_LENGTH-1] = 'x';
 
@@ -202,27 +202,27 @@ EST_read_status EST_TNamedEnum<ENUM>::pr
 	  return wrong_format;
 	}
 
-      if (ndefinitions>=0 && quote != '\0' && buffer[0] == '=')
+      if (this->ndefinitions>=0 && quote != '\0' && buffer[0] == '=')
 	{
 	  // definition by number
 
-	  if ( n>= ndefinitions)
+	  if ( n>= this->ndefinitions)
 	    {
 	      cerr << "too many definitions\n";
 	      return wrong_format;
 	    }
 
 	  int ntokens = split(line, tokens, NAMED_ENUM_MAX_SYNONYMS+2, RXwhite, '"');
-	  definitions[n].token = (ENUM)atoi(tokens[0].after(0,1));
+	  this->definitions[n].token = (ENUM)atoi(tokens[0].after(0,1));
 
 	  for(int i=1; i<ntokens; i++)
-	      definitions[n].values[i-1] = wstrdup(tokens[i].unquote_if_needed(quote));
+	      this->definitions[n].values[i-1] = wstrdup(tokens[i].unquote_if_needed(quote));
 	  for(int j=ntokens-1 ; j< NAMED_ENUM_MAX_SYNONYMS; j++)
-	    definitions[n].values[j]=NULL;
+	    this->definitions[n].values[j]=NULL;
 
 	  n++;
 	}
-      else if (have_unknown && ndefinitions>=0 && quote != '\0' && buffer[0] == quote)
+      else if (have_unknown && this->ndefinitions>=0 && quote != '\0' && buffer[0] == quote)
 	{
 	  // definition by standard name
 	  if (!definitive)
@@ -230,7 +230,7 @@ EST_read_status EST_TNamedEnum<ENUM>::pr
 	      cerr << "can't use names in this definition\n";
 	      return wrong_format;
 	    }
-	  if ( n>= ndefinitions)
+	  if ( n>= this->ndefinitions)
 	    {
 	      cerr << "too many definitions\n";
 	      return wrong_format;
@@ -238,12 +238,12 @@ EST_read_status EST_TNamedEnum<ENUM>::pr
 
 	  int ntokens = split(line, tokens, NAMED_ENUM_MAX_SYNONYMS+2, RXwhite, quote);
 
-	  definitions[n].token = definitive->token(tokens[0].unquote(quote));
+	  this->definitions[n].token = definitive->token(tokens[0].unquote(quote));
 
 	  for(int i=1; i<ntokens; i++)
-	    definitions[n].values[i-1] = wstrdup(tokens[i].unquote_if_needed(quote));
+	    this->definitions[n].values[i-1] = wstrdup(tokens[i].unquote_if_needed(quote));
 	  for(int j=ntokens-1 ; j< NAMED_ENUM_MAX_SYNONYMS; j++)
-	    definitions[n].values[j]=NULL;
+	    this->definitions[n].values[j]=NULL;
 
 	  n++;
 	}
@@ -269,16 +269,16 @@ EST_read_status EST_TNamedEnum<ENUM>::pr
 	    }
 	  else if (key == "number")
 	    {
-	      ndefinitions=atoi(line.after(eq,1));
+	      this->ndefinitions=atoi(line.after(eq,1));
 	      // cout << "n = '" << ndefinitions << "'\n";
-	      definitions = new Defn[ndefinitions];
-	      for(int i=0; i<ndefinitions; i++)
-		definitions[i].values[0] =NULL;
+	      this->definitions = new Defn[this->ndefinitions];
+	      for(int i=0; i<this->ndefinitions; i++)
+		this->definitions[i].values[0] =NULL;
 	      n=0;
 	    }
 	  else if (key == "unknown")
 	    {
-	      p_unknown_enum=(ENUM)atoi(line.after(eq,1));
+	      this->p_unknown_enum=(ENUM)atoi(line.after(eq,1));
 	      // cout << "unknown = '" << p_unknown_enum << "'\n";
 	      have_unknown=1;
 	    }
@@ -305,20 +305,20 @@ EST_write_status EST_TNamedEnum<ENUM>::p
   if ((file=fopen(name, "wb"))==NULL)
     return write_fail;
 
-  fprintf(file, "unknown=%d\n", p_unknown_enum);
+  fprintf(file, "unknown=%d\n", this->p_unknown_enum);
   fprintf(file, "quote=%c\n", quote);
-  fprintf(file, "number=%d\n", ndefinitions);
+  fprintf(file, "number=%d\n", this->ndefinitions);
 
-  for(int i=0; i<ndefinitions; i++)
-    if (definitions[i].values[0])
+  for(int i=0; i<this->ndefinitions; i++)
+    if (this->definitions[i].values[0])
       {
 	if (definitive)
-	  fprintf(file, "%s ", (const char *)EST_String(definitive->name(definitions[i].token)).quote(quote));
+	  fprintf(file, "%s ", (const char *)EST_String(definitive->name(this->definitions[i].token)).quote(quote));
 	else
-	  fprintf(file, "=%d ", (int)definitions[i].token);
+	  fprintf(file, "=%d ", (int)this->definitions[i].token);
 
-	for(int j=0; j<NAMED_ENUM_MAX_SYNONYMS && definitions[i].values[j] != NULL; j++)
-	  fprintf(file, "%s ", (const char *) EST_String(definitions[i].values[j]).quote_if_needed(quote));
+	for(int j=0; j<NAMED_ENUM_MAX_SYNONYMS && this->definitions[i].values[j] != NULL; j++)
+	  fprintf(file, "%s ", (const char *) EST_String(this->definitions[i].values[j]).quote_if_needed(quote));
       
 	fputc('\n', file);
       }
diff -upr speech_tools/base_class/EST_TSimpleMatrix.cc /tmp/speech_tools/base_class/EST_TSimpleMatrix.cc
--- speech_tools/base_class/EST_TSimpleMatrix.cc	2001-04-04 12:55:32.000000000 +0100
+++ /tmp/speech_tools/base_class/EST_TSimpleMatrix.cc	2004-05-07 04:06:11.621966744 +0100
@@ -49,23 +49,23 @@
 template<class T> 
 void EST_TSimpleMatrix<T>::copy_data(const EST_TSimpleMatrix<T> &a)
 {
-  if (!a.p_sub_matrix && !p_sub_matrix)
-    memcpy((void *)&a_no_check(0,0),
+  if (!a.p_sub_matrix && !this->p_sub_matrix)
+    memcpy((void *)&this->a_no_check(0,0),
 	   (const void *)&a.a_no_check(0,0),
-	   num_rows()*num_columns()*sizeof(T)
+	   this->num_rows()*this->num_columns()*sizeof(T)
 	   );
   else
     {
-    for (int i = 0; i < num_rows(); ++i)
-      for (int j = 0; j < num_columns(); ++j)
-	a_no_check(i,j) = a.a_no_check(i,j);
+    for (int i = 0; i < this->num_rows(); ++i)
+      for (int j = 0; j < this->num_columns(); ++j)
+	this->a_no_check(i,j) = a.a_no_check(i,j);
     }
 }
 
 template<class T> 
 void EST_TSimpleMatrix<T>::copy(const EST_TSimpleMatrix<T> &a)
 {
-  if (num_rows() != a.num_rows() || num_columns() != a.num_columns())
+  if (this->num_rows() != a.num_rows() || this->num_columns() != a.num_columns())
     resize(a.num_rows(), a.num_columns(), 0);
   
   copy_data(a);
@@ -83,31 +83,31 @@ void EST_TSimpleMatrix<T>::resize(int ne
 				  int set)
 {
   T* old_vals=NULL;
-  int old_offset = p_offset;
+  int old_offset = this->p_offset;
 
   if (new_rows<0)
-    new_rows = num_rows();
+    new_rows = this->num_rows();
   if (new_cols<0)
-    new_cols = num_columns();
+    new_cols = this->num_columns();
 
   if (set)
     {
-      if (!p_sub_matrix && new_cols == num_columns() && new_rows != num_rows())
+      if (!this->p_sub_matrix && new_cols == this->num_columns() && new_rows != this->num_rows())
 	{
-	  int copy_r = Lof(num_rows(), new_rows);
+	  int copy_r = Lof(this->num_rows(), new_rows);
 
 	  just_resize(new_rows, new_cols, &old_vals);
 
-	  memcpy((void *)p_memory, 
+	  memcpy((void *)this->p_memory, 
 		 (const void *)old_vals,
 		 copy_r*new_cols*sizeof(T));
 	  
 	  int i,j;
 	  
 	  if (new_rows > copy_r)
-	    if (*def_val == 0)
+	    if (*this->def_val == 0)
 	      {
-		memset((void *)(p_memory + copy_r*p_row_step),
+		memset((void *)(this->p_memory + copy_r*this->p_row_step),
 		       0,
 		       (new_rows-copy_r)*new_cols*sizeof(T));
 	      }
@@ -115,15 +115,15 @@ void EST_TSimpleMatrix<T>::resize(int ne
 	      {
 		for(j=0; j<new_cols; j++)
 		  for(i=copy_r; i<new_rows; i++)
-		    a_no_check(i,j) = *def_val;
+		    this->a_no_check(i,j) = *this->def_val;
 	      }
 	}
-      else if (!p_sub_matrix)
+      else if (!this->p_sub_matrix)
 	{
-	  int old_row_step = p_row_step;
-	  int old_column_step = p_column_step;
-	  int copy_r = Lof(num_rows(), new_rows);
-	  int copy_c = Lof(num_columns(), new_cols);
+	  int old_row_step = this->p_row_step;
+	  int old_column_step = this->p_column_step;
+	  int copy_r = Lof(this->num_rows(), new_rows);
+	  int copy_c = Lof(this->num_columns(), new_cols);
 	  
 	  just_resize(new_rows, new_cols, &old_vals);
 
@@ -136,12 +136,12 @@ void EST_TSimpleMatrix<T>::resize(int ne
 	  
 	  for(i=0; i<copy_r; i++)
 	    for(j=copy_c; j<new_cols; j++)
-	      a_no_check(i,j) =  *def_val;
+	      this->a_no_check(i,j) =  *this->def_val;
 	  
 	  if (new_rows > copy_r)
-	    if (*def_val == 0)
+	    if (*this->def_val == 0)
 	      {
-		memset((void *)(p_memory + copy_r*p_row_step),
+		memset((void *)(this->p_memory + copy_r*this->p_row_step),
 		       0,
 		       (new_rows-copy_r)*new_cols*sizeof(T));
 	      }
@@ -149,7 +149,7 @@ void EST_TSimpleMatrix<T>::resize(int ne
 	      {
 		for(j=0; j<new_cols; j++)
 		  for(i=copy_r; i<new_rows; i++)
-		    a_no_check(i,j) = *def_val;
+		    this->a_no_check(i,j) = *this->def_val;
 	      }
 	}
       else
@@ -158,7 +158,7 @@ void EST_TSimpleMatrix<T>::resize(int ne
   else
     EST_TMatrix<T>::resize(new_rows, new_cols, 0);
 
-  if (old_vals && old_vals != p_memory)
+  if (old_vals && old_vals != this->p_memory)
     delete [] (old_vals-old_offset);
 }
 
diff -upr speech_tools/base_class/EST_TSimpleVector.cc /tmp/speech_tools/base_class/EST_TSimpleVector.cc
--- speech_tools/base_class/EST_TSimpleVector.cc	2001-04-04 12:55:32.000000000 +0100
+++ /tmp/speech_tools/base_class/EST_TSimpleVector.cc	2004-05-07 04:17:18.583043092 +0100
@@ -46,10 +46,10 @@
 
 template<class T> void EST_TSimpleVector<T>::copy(const EST_TSimpleVector<T> &a)
 {
-  if (p_column_step==1 && a.p_column_step==1)
+  if (this->p_column_step==1 && a.p_column_step==1)
     {
     resize(a.n(), FALSE);
-    memcpy((void *)(p_memory), (const void *)(a.p_memory), n() * sizeof(T));
+    memcpy((void *)(this->p_memory), (const void *)(a.p_memory), this->n() * sizeof(T));
     }
 else
   ((EST_TVector<T> *)this)->copy(a);
@@ -57,33 +57,33 @@ else
 
 template<class T> EST_TSimpleVector<T>::EST_TSimpleVector(const EST_TSimpleVector<T> &in)
 {
-    default_vals();    
+    this->default_vals();    
     copy(in);
 }
 
 // should copy from and delete old version first
 template<class T> void EST_TSimpleVector<T>::resize(int newn, int set)
 {
-  int oldn = n();
+  int oldn = this->n();
   T *old_vals =NULL;
-  int old_offset = p_offset;
+  int old_offset = this->p_offset;
 
   just_resize(newn, &old_vals);
 
   if (set && old_vals)
     {
       int copy_c = 0;
-      if (p_memory != NULL)
+      if (this->p_memory != NULL)
 	{
-	  copy_c = Lof(n(), oldn);
-	  memcpy((void *)p_memory, (const void *)old_vals,  copy_c* sizeof(T));
+	  copy_c = Lof(this->n(), oldn);
+	  memcpy((void *)this->p_memory, (const void *)old_vals,  copy_c* sizeof(T));
 	}
       
-      for (int i=copy_c; i < n(); ++i)
-	p_memory[i] = *def_val;
+      for (int i=copy_c; i < this->n(); ++i)
+	this->p_memory[i] = *this->def_val;
     }
   
-  if (old_vals != NULL && old_vals != p_memory && !p_sub_matrix)
+  if (old_vals != NULL && old_vals != this->p_memory && !this->p_sub_matrix)
     delete [] (old_vals - old_offset);
 
 }
@@ -92,32 +92,32 @@ template<class T>
 void EST_TSimpleVector<T>::copy_section(T* dest, int offset, int num) const
 {
   if (num<0)
-    num = num_columns()-offset;
+    num = this->num_columns()-offset;
 
-  if (!EST_vector_bounds_check(num+offset-1, num_columns(), FALSE))
+  if (!EST_vector_bounds_check(num+offset-1, this->num_columns(), FALSE))
     return;
 
-  if (!p_sub_matrix && p_column_step==1)
-    memcpy((void *)dest, (const void *)(p_memory+offset), num*sizeof(T));
+  if (!this->p_sub_matrix && this->p_column_step==1)
+    memcpy((void *)dest, (const void *)(this->p_memory+offset), num*sizeof(T));
   else
     for(int i=0; i<num; i++)
-      dest[i] = a_no_check(offset+i);
+      dest[i] = this->a_no_check(offset+i);
 }
 
 template<class T>
 void EST_TSimpleVector<T>::set_section(const T* src, int offset, int num)
 {
   if (num<0)
-    num = num_columns()-offset;
+    num = this->num_columns()-offset;
 
-  if (!EST_vector_bounds_check(num+offset-1, num_columns(), FALSE))
+  if (!EST_vector_bounds_check(num+offset-1, this->num_columns(), FALSE))
     return;
   
-  if (!p_sub_matrix && p_column_step==1)
-    memcpy((void *)(p_memory+offset), (void *)src, num*sizeof(T));
+  if (!this->p_sub_matrix && this->p_column_step==1)
+    memcpy((void *)(this->p_memory+offset), (void *)src, num*sizeof(T));
   else
     for(int i=0; i<num; i++)
-      a_no_check(offset+i) = src[i];
+      this->a_no_check(offset+i) = src[i];
 }
 
 template<class T> EST_TSimpleVector<T> &EST_TSimpleVector<T>::operator=(const EST_TSimpleVector<T> &in)
@@ -128,9 +128,9 @@ template<class T> EST_TSimpleVector<T> &
 
 template<class T> void EST_TSimpleVector<T>::zero()
 {
-  if (p_column_step==1)
-    memset((void *)(p_memory), 0, n() * sizeof(T));
+  if (this->p_column_step==1)
+    memset((void *)(this->p_memory), 0, this->n() * sizeof(T));
   else
-    ((EST_TVector<T> *)this)->fill(*def_val);
+    ((EST_TVector<T> *)this)->fill(*this->def_val);
 }
 
diff -upr speech_tools/base_class/EST_Tvectlist.cc /tmp/speech_tools/base_class/EST_Tvectlist.cc
--- speech_tools/base_class/EST_Tvectlist.cc	2001-04-04 12:55:32.000000000 +0100
+++ /tmp/speech_tools/base_class/EST_Tvectlist.cc	2004-05-07 04:09:57.405474037 +0100
@@ -39,6 +39,7 @@
 /*=======================================================================*/
 #include <fstream.h>
 #include "EST_TVector.h"
+#include "EST_TList.h"
 #include "EST_cutils.h"
 
 template<class T> 
@@ -57,6 +58,7 @@ template<class T> EST_TVector<T> &copy(E
 {
     a.resize(in.length(), FALSE);
     EST_Litem *p;
+	int i;
     for (i = 0, p = in.head(); p!= 0; p = next(p), ++i)
 	a[i] = in.item(p);
 
diff -upr speech_tools/base_class/inst_tmpl/hash_fi_t.cc /tmp/speech_tools/base_class/inst_tmpl/hash_fi_t.cc
--- speech_tools/base_class/inst_tmpl/hash_fi_t.cc	2001-04-04 12:55:32.000000000 +0100
+++ /tmp/speech_tools/base_class/inst_tmpl/hash_fi_t.cc	2004-05-07 08:46:03.658610923 +0100
@@ -38,7 +38,7 @@
 #include "EST_String.h"
 #include "EST_THash.h"
 
-Declare_THash(float, int)
+Declare_THash_Base(float, int, 0.0, 0, NULL)
 
 #if defined(INSTANTIATE_TEMPLATES)
 
diff -upr speech_tools/base_class/inst_tmpl/hash_ii_t.cc /tmp/speech_tools/base_class/inst_tmpl/hash_ii_t.cc
--- speech_tools/base_class/inst_tmpl/hash_ii_t.cc	2001-04-04 12:55:32.000000000 +0100
+++ /tmp/speech_tools/base_class/inst_tmpl/hash_ii_t.cc	2004-05-07 08:44:57.647279973 +0100
@@ -38,7 +38,7 @@
 #include "EST_String.h"
 #include "EST_THash.h"
 
-Declare_THash(int,int)
+Declare_THash_Base(int,int,0,0,NULL)
 
 #if defined(INSTANTIATE_TEMPLATES)
 
diff -upr speech_tools/base_class/inst_tmpl/hash_iv_t.cc /tmp/speech_tools/base_class/inst_tmpl/hash_iv_t.cc
--- speech_tools/base_class/inst_tmpl/hash_iv_t.cc	2001-04-04 12:55:32.000000000 +0100
+++ /tmp/speech_tools/base_class/inst_tmpl/hash_iv_t.cc	2004-05-07 08:45:15.019314215 +0100
@@ -42,7 +42,7 @@
 #include "EST_THash.h"
 #include "EST_Val.h"
 
-Declare_THash(int,EST_Val)
+Declare_THash_Base(int,EST_Val,0,EST_Val(),NULL)
 
 #if defined(INSTANTIATE_TEMPLATES)
 
diff -upr speech_tools/base_class/inst_tmpl/hash_sd_t.cc /tmp/speech_tools/base_class/inst_tmpl/hash_sd_t.cc
--- speech_tools/base_class/inst_tmpl/hash_sd_t.cc	2001-04-04 12:55:32.000000000 +0100
+++ /tmp/speech_tools/base_class/inst_tmpl/hash_sd_t.cc	2004-05-07 08:41:00.844600895 +0100
@@ -39,7 +39,7 @@
 #include "EST_String.h"
 #include "EST_THash.h"
 
-Declare_TStringHash(double)
+Declare_TStringHash_Base(double, 0.0, NULL)
 
 #if defined(INSTANTIATE_TEMPLATES)
 
diff -upr speech_tools/base_class/inst_tmpl/hash_sfmp_t.cc /tmp/speech_tools/base_class/inst_tmpl/hash_sfmp_t.cc
--- speech_tools/base_class/inst_tmpl/hash_sfmp_t.cc	2001-04-04 12:55:32.000000000 +0100
+++ /tmp/speech_tools/base_class/inst_tmpl/hash_sfmp_t.cc	2004-05-07 08:41:43.081096350 +0100
@@ -40,7 +40,7 @@
 #include "EST_FMatrix.h"
 #include "EST_THash.h"
 
-Declare_TStringHash_T(EST_FMatrix*,EST_StringFMatrixP)
+Declare_TStringHash_Base_T(EST_FMatrix*,NULL,NULL,EST_StringFMatrixP)
 
 #if defined(INSTANTIATE_TEMPLATES)
 
diff -upr speech_tools/base_class/inst_tmpl/hash_sf_t.cc /tmp/speech_tools/base_class/inst_tmpl/hash_sf_t.cc
--- speech_tools/base_class/inst_tmpl/hash_sf_t.cc	2001-04-04 12:55:32.000000000 +0100
+++ /tmp/speech_tools/base_class/inst_tmpl/hash_sf_t.cc	2004-05-07 08:41:11.281016897 +0100
@@ -38,7 +38,7 @@
 #include "EST_String.h"
 #include "EST_THash.h"
 
-Declare_TStringHash(float)
+Declare_TStringHash_Base(float, 0.0, NULL)
 
 #if defined(INSTANTIATE_TEMPLATES)
 
diff -upr speech_tools/base_class/inst_tmpl/hash_si_t.cc /tmp/speech_tools/base_class/inst_tmpl/hash_si_t.cc
--- speech_tools/base_class/inst_tmpl/hash_si_t.cc	2001-04-04 12:55:32.000000000 +0100
+++ /tmp/speech_tools/base_class/inst_tmpl/hash_si_t.cc	2004-05-07 08:41:17.868754585 +0100
@@ -38,7 +38,7 @@
 #include "EST_String.h"
 #include "EST_THash.h"
 
-Declare_TStringHash(int)
+Declare_TStringHash_Base(int, 0, NULL)
 
 #if defined(INSTANTIATE_TEMPLATES)
 
diff -upr speech_tools/base_class/inst_tmpl/hash_srp.cc /tmp/speech_tools/base_class/inst_tmpl/hash_srp.cc
--- speech_tools/base_class/inst_tmpl/hash_srp.cc	2001-04-04 12:55:32.000000000 +0100
+++ /tmp/speech_tools/base_class/inst_tmpl/hash_srp.cc	2004-05-07 08:42:04.399775250 +0100
@@ -40,7 +40,7 @@
 #include "ling_class/EST_Relation.h"
 #include "EST_THash.h"
 
-Declare_TStringHash_T(EST_Relation*,EST_StringRelationP)
+Declare_TStringHash_Base_T(EST_Relation*,NULL,NULL,EST_StringRelationP)
 
 #if defined(INSTANTIATE_TEMPLATES)
 
diff -upr speech_tools/base_class/inst_tmpl/hash_ss_t.cc /tmp/speech_tools/base_class/inst_tmpl/hash_ss_t.cc
--- speech_tools/base_class/inst_tmpl/hash_ss_t.cc	2001-04-04 12:55:32.000000000 +0100
+++ /tmp/speech_tools/base_class/inst_tmpl/hash_ss_t.cc	2004-05-07 08:41:49.145013925 +0100
@@ -41,7 +41,7 @@
 #include "EST_String.h"
 #include "EST_THash.h"
 
-Declare_TStringHash(EST_String)
+Declare_TStringHash_Base(EST_String, "", NULL)
 
 #if defined(INSTANTIATE_TEMPLATES)
 
diff -upr speech_tools/base_class/inst_tmpl/hash_sv_t.cc /tmp/speech_tools/base_class/inst_tmpl/hash_sv_t.cc
--- speech_tools/base_class/inst_tmpl/hash_sv_t.cc	2001-04-04 12:55:32.000000000 +0100
+++ /tmp/speech_tools/base_class/inst_tmpl/hash_sv_t.cc	2004-05-07 08:41:55.909690850 +0100
@@ -42,7 +42,7 @@
 #include "EST_String.h"
 #include "EST_Val.h"
 
-Declare_TStringHash(EST_Val)
+Declare_TStringHash_Base(EST_Val, EST_Val(), NULL)
 
 #if defined(INSTANTIATE_TEMPLATES)
 
diff -upr speech_tools/base_class/inst_tmpl/vector_dmatrix_t.cc /tmp/speech_tools/base_class/inst_tmpl/vector_dmatrix_t.cc
--- speech_tools/base_class/inst_tmpl/vector_dmatrix_t.cc	2001-04-04 12:55:32.000000000 +0100
+++ /tmp/speech_tools/base_class/inst_tmpl/vector_dmatrix_t.cc	2004-05-07 04:25:47.812305417 +0100
@@ -52,8 +52,8 @@ template ostream& operator << (ostream &
 #endif
 static const EST_DMatrix def_val_DMatrix;
 static EST_DMatrix error_return_DMatrix;
-const EST_DMatrix *EST_TVector<EST_DMatrix>::def_val = &def_val_DMatrix;
-EST_DMatrix *EST_TVector<EST_DMatrix>::error_return = &error_return_DMatrix;
+template <> const EST_DMatrix *EST_TVector<EST_DMatrix>::def_val = &def_val_DMatrix;
+template <> EST_DMatrix *EST_TVector<EST_DMatrix>::error_return = &error_return_DMatrix;
 
 int operator !=(const EST_DMatrix &fm1, 
 		const EST_DMatrix &fm2)
diff -upr speech_tools/base_class/inst_tmpl/vector_dvector_t.cc /tmp/speech_tools/base_class/inst_tmpl/vector_dvector_t.cc
--- speech_tools/base_class/inst_tmpl/vector_dvector_t.cc	2001-04-04 12:55:32.000000000 +0100
+++ /tmp/speech_tools/base_class/inst_tmpl/vector_dvector_t.cc	2004-05-07 04:24:39.031901237 +0100
@@ -52,8 +52,8 @@ template ostream& operator << (ostream &
 #endif
 static const EST_DVector def_val_DVector;
 static EST_DVector error_return_DVector;
-const EST_DVector *EST_TVector<EST_DVector>::def_val = &def_val_DVector;
-EST_DVector *EST_TVector<EST_DVector>::error_return = &error_return_DVector;
+template <> const EST_DVector *EST_TVector<EST_DVector>::def_val = &def_val_DVector;
+template <> EST_DVector *EST_TVector<EST_DVector>::error_return = &error_return_DVector;
 
 int operator !=(const EST_DVector &fv1, 
 		const EST_DVector &fv2)
diff -upr speech_tools/base_class/inst_tmpl/vector_fmatrix_t.cc /tmp/speech_tools/base_class/inst_tmpl/vector_fmatrix_t.cc
--- speech_tools/base_class/inst_tmpl/vector_fmatrix_t.cc	2001-04-04 12:55:32.000000000 +0100
+++ /tmp/speech_tools/base_class/inst_tmpl/vector_fmatrix_t.cc	2004-05-07 04:23:50.761461063 +0100
@@ -52,8 +52,8 @@ template ostream& operator << (ostream &
 #endif
 static const EST_FMatrix def_val_FMatrix;
 static EST_FMatrix error_return_FMatrix;
-const EST_FMatrix *EST_TVector<EST_FMatrix>::def_val = &def_val_FMatrix;
-EST_FMatrix *EST_TVector<EST_FMatrix>::error_return = &error_return_FMatrix;
+template <> const EST_FMatrix *EST_TVector<EST_FMatrix>::def_val = &def_val_FMatrix;
+template <> EST_FMatrix *EST_TVector<EST_FMatrix>::error_return = &error_return_FMatrix;
 
 int operator !=(const EST_FMatrix &fm1, 
 		const EST_FMatrix &fm2)
diff -upr speech_tools/grammar/scfg/EST_SCFG_inout.cc /tmp/speech_tools/grammar/scfg/EST_SCFG_inout.cc
--- speech_tools/grammar/scfg/EST_SCFG_inout.cc	2001-04-04 12:55:32.000000000 +0100
+++ /tmp/speech_tools/grammar/scfg/EST_SCFG_inout.cc	2004-05-07 04:37:19.286102544 +0100
@@ -54,8 +54,8 @@
 
 static const EST_bracketed_string def_val_s;
 static EST_bracketed_string error_return_s;
-const EST_bracketed_string *EST_TVector<EST_bracketed_string>::def_val=&def_val_s;
-EST_bracketed_string *EST_TVector<EST_bracketed_string>::error_return=&error_return_s;
+template <> const EST_bracketed_string *EST_TVector<EST_bracketed_string>::def_val=&def_val_s;
+template <> EST_bracketed_string *EST_TVector<EST_bracketed_string>::error_return=&error_return_s;
 
 
 #if defined(INSTANTIATE_TEMPLATES)
diff -upr speech_tools/grammar/wfst/wfst_ops.cc /tmp/speech_tools/grammar/wfst/wfst_ops.cc
--- speech_tools/grammar/wfst/wfst_ops.cc	2001-09-25 18:02:06.000000000 +0100
+++ /tmp/speech_tools/grammar/wfst/wfst_ops.cc	2004-05-07 04:38:54.305509023 +0100
@@ -57,8 +57,8 @@ Declare_TList_T(EST_WFST_MultiState *,ES
 	static EST_IList int_EST_IList_kv_def_EST_IList_s; 
 	static int int_EST_IList_kv_def_int_s; 
 	
-	EST_IList *EST_TKVL< int, EST_IList >::default_val=&int_EST_IList_kv_def_EST_IList_s; 
-	int *EST_TKVL< int, EST_IList >::default_key=&int_EST_IList_kv_def_int_s; 
+	template <> EST_IList *EST_TKVL< int, EST_IList >::default_val=&int_EST_IList_kv_def_EST_IList_s; 
+	template <> int *EST_TKVL< int, EST_IList >::default_key=&int_EST_IList_kv_def_int_s; 
 	
 	Declare_TList_N(KVI_int_EST_IList_t, 0)
 
diff -upr speech_tools/include/EST_THash.h /tmp/speech_tools/include/EST_THash.h
--- speech_tools/include/EST_THash.h	2004-05-07 08:54:04.192593423 +0100
+++ /tmp/speech_tools/include/EST_THash.h	2004-05-07 06:11:11.652145799 +0100
@@ -325,7 +325,7 @@ protected:
 
 public:
   /// Create a string hash table of <parameter>size</parameter> buckets.
-  EST_TStringHash(int size) : EST_THash<EST_String, V>(size, StringHash) {};
+  EST_TStringHash(int size) : EST_THash<EST_String, V>(size, this->StringHash) {};
 
   /// An entry returned by the iterator is a key value pair.
   typedef EST_StringHash_Pair<V> Entry;
diff -upr speech_tools/include/EST_TIterator.h /tmp/speech_tools/include/EST_TIterator.h
--- speech_tools/include/EST_TIterator.h	2002-12-26 15:48:54.000000000 +0000
+++ /tmp/speech_tools/include/EST_TIterator.h	2004-05-07 02:14:24.000000000 +0100
@@ -201,18 +201,18 @@ public:  
   typedef EST_TIterator<Container, IPointer, Entry> Iter;
 
   /// Create an iterator not associated with any specific container.
-  EST_TStructIterator() {cont=NULL;}
+  EST_TStructIterator() {this->cont=NULL;}
 
   /// Copy an iterator by assignment
   Iter &operator = (const Iter &orig)
-    { cont=orig.cont; pos=orig.pos; pointer=orig.pointer; return *this;}
+    { this->cont=orig.cont; this->pos=orig.pos; this->pointer=orig.pointer; return *this;}
 
   /// Create an iterator ready to run over the given container.
   EST_TStructIterator(const Container &over)
     { begin(over); }
 
   const Entry *operator ->() const
-    {return &current();}
+    {return &this->current();}
 };
 
 template <class Container, class IPointer, class Entry>
@@ -231,11 +231,11 @@ public:
   typedef EST_TIterator<Container, IPointer, Entry> Iter;
 
   /// Create an iterator not associated with any specific container.
-  EST_TRwIterator() {cont=NULL;}
+  EST_TRwIterator() {this->cont=NULL;}
 
   /// Copy an iterator by assignment
   Iter &operator = (const Iter &orig)
-    { cont=orig.cont; pos=orig.pos; pointer=orig.pointer; return *this;}
+    { this->cont=orig.cont; this->pos=orig.pos; this->pointer=orig.pointer; return *this;}
 
   /// Create an iterator ready to run over the given container.
   EST_TRwIterator(Container &over)
@@ -243,18 +243,18 @@ public:
 
   /// Set the iterator ready to run over this container.
   void begin(Container &over)
-    {cont=&over; beginning();}
+    {this->cont=&over; this->beginning();}
 
   /**@name Access
     */
   //@{
   /// Return the element currentl pointed to.
   Entry& current() const
-    {return cont->points_at(pointer);}
+    {return this->cont->points_at(this->pointer);}
 
   /// The * operator returns the current element. 
   Entry &operator *() const
-    {return current();}
+    {return this->current();}
 
 #if 0 
   Entry *operator ->() const
@@ -264,8 +264,8 @@ public:
   /// Return the current element and move the pointer forwards.
   Entry& next_element() 
 	{ 
-	  Entry &it = cont->points_at(pointer); 
-	  cont->move_pointer_forwards(pointer); 
+	  Entry &it = this->cont->points_at(this->pointer); 
+	  this->cont->move_pointer_forwards(this->pointer); 
 	  return it; 
 	}
 
@@ -281,18 +281,18 @@ public:
   typedef EST_TIterator<Container, IPointer, Entry> Iter;
 
   /// Create an iterator not associated with any specific container.
-  EST_TRwStructIterator() {cont=NULL;}
+  EST_TRwStructIterator() {this->cont=NULL;}
 
   /// Copy an iterator by assignment
   Iter &operator = (const Iter &orig)
-    { cont=orig.cont; pos=orig.pos; pointer=orig.pointer; return *this;}
+    { this->cont=orig.cont; this->pos=orig.pos; this->pointer=orig.pointer; return *this;}
 
   /// Create an iterator ready to run over the given container.
   EST_TRwStructIterator(Container &over)
     { begin(over); }
 
   Entry *operator ->() const
-    {return &current();}
+    {return &this->current();}
 };
 
 #endif
diff -upr speech_tools/include/EST_TMatrix.h /tmp/speech_tools/include/EST_TMatrix.h
--- speech_tools/include/EST_TMatrix.h	2004-05-07 08:54:04.197591707 +0100
+++ /tmp/speech_tools/include/EST_TMatrix.h	2004-05-07 02:15:29.000000000 +0100
@@ -105,7 +105,7 @@ protected:
     {
 
       return mcell_pos(r, c, 
-		       p_row_step, p_column_step);
+		       p_row_step, this->p_column_step);
     }
 
   INLINE unsigned int mcell_pos_1(int r, int c) const
@@ -117,14 +117,14 @@ protected:
 
   /// quick method for returning {\tt x[m][n]}
   INLINE const T &fast_a_m(int r, int c) const 
-    { return p_memory[mcell_pos(r,c)]; }
+    { return this->p_memory[mcell_pos(r,c)]; }
   INLINE T &fast_a_m(int r, int c) 
-    { return p_memory[mcell_pos(r,c)]; }
+    { return this->p_memory[mcell_pos(r,c)]; }
 
   INLINE const T &fast_a_1(int r, int c) const 
-    { return p_memory[mcell_pos_1(r,c)]; }
+    { return this->p_memory[mcell_pos_1(r,c)]; }
   INLINE T &fast_a_1(int r, int c) 
-    { return p_memory[mcell_pos_1(r,c)]; }
+    { return this->p_memory[mcell_pos_1(r,c)]; }
   
 
     /// Get and set values from array
@@ -176,7 +176,7 @@ public:
   /// return number of rows
   int num_rows() const {return p_num_rows;}
   /// return number of columns
-  int num_columns() const {return p_num_columns;}
+  int num_columns() const {return this->p_num_columns;}
 
   /// const access with no bounds check, care recommend
   INLINE const T &a_no_check(int row, int col) const 
@@ -215,7 +215,7 @@ public:
 
   /// fill matrix with value v
   void fill(const T &v);
-  void fill() { fill(*def_val); }
+  void fill() { fill(*this->def_val); }
 
   /// assignment operator
   EST_TMatrix &operator=(const EST_TMatrix &s); 
diff -upr speech_tools/include/EST_TNamedEnum.h /tmp/speech_tools/include/EST_TNamedEnum.h
--- speech_tools/include/EST_TNamedEnum.h	2001-04-04 12:55:32.000000000 +0100
+++ /tmp/speech_tools/include/EST_TNamedEnum.h	2004-05-07 02:41:52.000000000 +0100
@@ -124,9 +124,9 @@ protected:
 public:
 
   EST_TNamedEnumI(EST_TValuedEnumDefinition<ENUM,const char *,INFO> defs[])
-	{initialise((const void *)defs); };
+	{this->initialise((const void *)defs); };
   EST_TNamedEnumI(EST_TValuedEnumDefinition<const char *,const char *,INFO> defs[], ENUM (*conv)(const char *))
-	{initialise((const void *)defs, conv); };
+	{this->initialise((const void *)defs, conv); };
   const char *name(ENUM tok, int n=0) const {return value(tok,n); };
 
 };
@@ -136,9 +136,9 @@ public:
 template<class ENUM, class VAL> class EST_TValuedEnum : public EST_TValuedEnumI<ENUM,VAL,NO_INFO> { 
 public:
   EST_TValuedEnum(EST_TValuedEnumDefinition<ENUM,VAL,NO_INFO> defs[]) 
-	{initialise((const void *)defs);};
+	{this->initialise((const void *)defs);};
   EST_TValuedEnum(EST_TValuedEnumDefinition<const char *,VAL,NO_INFO> defs[], ENUM (*conv)(const char *)) 
-	{initialise((const void *)defs, conv);};
+	{this->initialise((const void *)defs, conv);};
 };
 
 
@@ -148,11 +148,11 @@ private:
   EST_write_status priv_save(EST_String name, EST_TNamedEnum *definitive, char quote) const;
 public:
   EST_TNamedEnum(ENUM undef_e, const char *undef_n = NULL) 
-	{initialise(undef_e, undef_n);};
+	{this->initialise(undef_e, undef_n);};
   EST_TNamedEnum(EST_TValuedEnumDefinition<ENUM,const char *,NO_INFO> defs[]) 
-	{initialise((const void *)defs);};
+	{this->initialise((const void *)defs);};
   EST_TNamedEnum(EST_TValuedEnumDefinition<const char *,const char *,NO_INFO> defs[], ENUM (*conv)(const char *)) 
-	{initialise((const void *)defs, conv);};
+	{this->initialise((const void *)defs, conv);};
 
   EST_read_status load(EST_String name) { return priv_load(name, NULL); };
   EST_read_status load(EST_String name, EST_TNamedEnum &definitive) { return priv_load(name, &definitive); };
diff -upr speech_tools/include/EST_TSimpleVector.h /tmp/speech_tools/include/EST_TSimpleVector.h
--- speech_tools/include/EST_TSimpleVector.h	2001-04-04 12:55:32.000000000 +0100
+++ /tmp/speech_tools/include/EST_TSimpleVector.h	2004-05-07 02:15:08.000000000 +0100
@@ -74,7 +74,7 @@ public:
     void zero(void);
 
     /// Fill vector with default value
-    void empty(void) { if (*def_val == 0) zero(); else fill(*def_val); }
+    void empty(void) { if (*this->def_val == 0) zero(); else this->fill(*this->def_val); }
 };
 
 #endif
diff -upr speech_tools/include/instantiate/EST_TDequeI.h /tmp/speech_tools/include/instantiate/EST_TDequeI.h
--- speech_tools/include/instantiate/EST_TDequeI.h	2001-04-04 14:11:27.000000000 +0100
+++ /tmp/speech_tools/include/instantiate/EST_TDequeI.h	2004-05-07 04:28:35.271857830 +0100
@@ -54,16 +54,16 @@
 #define Instantiate_TDEQ(T) Instantiate_TDEQ_T(T, T) 
 
 #define Declare_TDEQ_T(T, TAG)  \
-	const T *EST_TDeque< T >::Filler=NULL;
+	template <> const T *EST_TDeque< T >::Filler=NULL;
 
 #define Declare_TDEQ_Base_T(T, FILLER ,TAG) \
 	const T TAG ## _deq_filler=FILLER; \
-	const T *EST_TDeque< T >::Filler=& TAG ## _deq_filler;
+	template <> const T *EST_TDeque< T >::Filler=& TAG ## _deq_filler;
 	
 
 #define Declare_TDEQ_Class_T(T, FILLER,TAG) \
 	const T TAG ## _deq_filler(FILLER); \
-	const T *EST_TDeque< T >::Filler=& TAG ## _deq_filler;
+	template <> const T *EST_TDeque< T >::Filler=& TAG ## _deq_filler;
 
 #define Declare_TDEQ(T) Declare_TDEQ_T(T, T)
 
diff -upr speech_tools/include/instantiate/EST_THashI.h /tmp/speech_tools/include/instantiate/EST_THashI.h
--- speech_tools/include/instantiate/EST_THashI.h	2001-04-04 14:11:27.000000000 +0100
+++ /tmp/speech_tools/include/instantiate/EST_THashI.h	2004-05-07 08:07:46.302692176 +0100
@@ -77,17 +77,17 @@
 
 
 #define Declare_THash_T(KEY, VAL, TAG) \
-	VAL EST_THash< KEY, VAL >::Dummy_Value; \
-	KEY EST_THash< KEY, VAL >::Dummy_Key; \
+	template <> VAL EST_THash< KEY, VAL >::Dummy_Value; \
+	template <> KEY EST_THash< KEY, VAL >::Dummy_Key; \
 	EST_THash< KEY, VAL > TAG ## _hash_dummy(0);
 
 #define Declare_THash_Base_T(KEY, VAL, DEFAULTK, DEFAULT, ERROR,TAG) \
-	KEY EST_THash< KEY, VAL >::Dummy_Key=DEFAULTK; \
-	VAL EST_THash<KEY, VAL>::Dummy_Value=DEFAULT;
+	template <> KEY EST_THash< KEY, VAL >::Dummy_Key=DEFAULTK; \
+	template <> VAL EST_THash<KEY, VAL>::Dummy_Value=DEFAULT;
 
 #define Declare_THash_Class_T(KEY, VAL, DEFAULTK, DEFAULT, ERROR,TAG) \
-	KEY EST_THash< KEY, VAL >::Dummy_Key(DEFAULTK); \
-	VAL EST_THash<KEY, VAL>::Dummy_Value(DEFAULT);
+	template <> KEY EST_THash< KEY, VAL >::Dummy_Key(DEFAULTK); \
+	template <> VAL EST_THash<KEY, VAL>::Dummy_Value(DEFAULT);
 
 #define Declare_THash(KEY, VAL) Declare_THash_T(KEY, VAL, KEY ## VAL)
 
@@ -98,3 +98,4 @@
 
 #endif
 
+
diff -upr speech_tools/include/instantiate/EST_TKVLI.h /tmp/speech_tools/include/instantiate/EST_TKVLI.h
--- speech_tools/include/instantiate/EST_TKVLI.h	2001-04-04 14:11:27.000000000 +0100
+++ /tmp/speech_tools/include/instantiate/EST_TKVLI.h	2004-05-07 03:39:25.860020756 +0100
@@ -71,8 +71,8 @@
 	static VAL TAG##_kv_def_val_s; \
 	static KEY TAG##_kv_def_key_s; \
 	\
-	VAL *EST_TKVL< KEY, VAL >::default_val=&TAG##_kv_def_val_s; \
-	KEY *EST_TKVL< KEY, VAL >::default_key=&TAG##_kv_def_key_s; \
+	template <> VAL *EST_TKVL< KEY, VAL >::default_val=&TAG##_kv_def_val_s; \
+	template <> KEY *EST_TKVL< KEY, VAL >::default_key=&TAG##_kv_def_key_s; \
 	\
 	Declare_TList_N(KVI_ ## TAG ## _t, MaxFree)
 #define Declare_KVL_T(KEY, VAL, TAG) \
@@ -85,8 +85,8 @@
 	static VAL TAG##_kv_def_val_s=DEFV; \
 	static KEY TAG##_kv_def_key_s=DEFK; \
 	\
-	VAL *EST_TKVL< KEY, VAL >::default_val=&TAG##_kv_def_val_s; \
-	KEY *EST_TKVL< KEY, VAL >::default_key=&TAG##_kv_def_key_s; \
+	template <> VAL *EST_TKVL< KEY, VAL >::default_val=&TAG##_kv_def_val_s; \
+	template <> KEY *EST_TKVL< KEY, VAL >::default_key=&TAG##_kv_def_key_s; \
 	\
 	Declare_TList_N(KVI_ ## TAG ## _t, MaxFree)
 #define Declare_KVL_Base_T(KEY, VAL, DEFV, DEFK, TAG) \
@@ -99,8 +99,8 @@
 	static VAL TAG##_kv_def_val_s(DEFV); \
 	static KEY TAG##_kv_def_key_s(DEFK); \
 	\
-	VAL *EST_TKVL< KEY, VAL >::default_val=&TAG##_kv_def_val_s; \
-	KEY *EST_TKVL< KEY, VAL >::default_key=&TAG##_kv_def_key_s; \
+	template <> VAL *EST_TKVL< KEY, VAL >::default_val=&TAG##_kv_def_val_s; \
+	template <> KEY *EST_TKVL< KEY, VAL >::default_key=&TAG##_kv_def_key_s; \
 	\
 	Declare_TList_N(KVI_ ## TAG ## _t, MaxFree)
 #define Declare_KVL_Class_T(KEY, VAL, DEFV, DEFK,TAG) \
diff -upr speech_tools/include/instantiate/EST_TListI.h /tmp/speech_tools/include/instantiate/EST_TListI.h
--- speech_tools/include/instantiate/EST_TListI.h	2001-04-04 14:11:27.000000000 +0100
+++ /tmp/speech_tools/include/instantiate/EST_TListI.h	2004-05-07 03:52:57.507516308 +0100
@@ -64,9 +64,9 @@
 
 #define Declare_TList_TN(TYPE,MaxFree,TAG) \
 	typedef TYPE TLIST_ ## TAG ## _VAL; \
-	EST_TItem< TYPE > * EST_TItem< TYPE >::s_free=NULL; \
-	unsigned int EST_TItem< TYPE >::s_maxFree=MaxFree; \
-	unsigned int EST_TItem< TYPE >::s_nfree=0;
+	template <> EST_TItem< TYPE > * EST_TItem< TYPE >::s_free=NULL; \
+	template <> unsigned int EST_TItem< TYPE >::s_maxFree=MaxFree; \
+	template <> unsigned int EST_TItem< TYPE >::s_nfree=0;
 #define Declare_TList_T(TYPE,TAG) \
 	Declare_TList_TN(TYPE,0,TAG)
 
diff -upr speech_tools/include/instantiate/EST_TVectorI.h /tmp/speech_tools/include/instantiate/EST_TVectorI.h
--- speech_tools/include/instantiate/EST_TVectorI.h	2001-04-04 14:11:27.000000000 +0100
+++ /tmp/speech_tools/include/instantiate/EST_TVectorI.h	2004-05-07 04:19:44.345012309 +0100
@@ -62,22 +62,22 @@
 	static TYPE const TAG##_vec_def_val_s; \
 	static TYPE TAG##_vec_error_return_s; \
 	\
-	TYPE const *EST_TVector< TYPE >::def_val=&TAG##_vec_def_val_s; \
-	TYPE *EST_TVector< TYPE >::error_return=&TAG##_vec_error_return_s;
+	template <> TYPE const *EST_TVector< TYPE >::def_val=&TAG##_vec_def_val_s; \
+	template <> TYPE *EST_TVector< TYPE >::error_return=&TAG##_vec_error_return_s;
 
 #define Declare_TVector_Base_T(TYPE,DEFAULT,ERROR,TAG)  \
 	static TYPE const TAG##_vec_def_val_s=DEFAULT; \
 	static TYPE TAG##_vec_error_return_s=ERROR; \
 	\
-	TYPE const *EST_TVector<TYPE>::def_val=&TAG##_vec_def_val_s; \
-	TYPE *EST_TVector<TYPE>::error_return=&TAG##_vec_error_return_s;
+	template <> TYPE const *EST_TVector<TYPE>::def_val=&TAG##_vec_def_val_s; \
+	template <> TYPE *EST_TVector<TYPE>::error_return=&TAG##_vec_error_return_s;
 
 #define Declare_TVector_Class_T(TYPE,DEFAULT,ERROR,TAG)  \
 	static TYPE const TAG##_vec_def_val_s(DEFAULT); \
 	static TYPE TAG##_vec_error_return_s(ERROR); \
 	\
-	TYPE const *EST_TVector<TYPE>::def_val=&TAG##_vec_def_val_s; \
-	TYPE *EST_TVector<TYPE>::error_return=&TAG##_vec_error_return_s;
+	template <> TYPE const *EST_TVector<TYPE>::def_val=&TAG##_vec_def_val_s; \
+	template <> TYPE *EST_TVector<TYPE>::error_return=&TAG##_vec_error_return_s;
 
 #define Declare_TVector(TYPE) Declare_TVector_T(TYPE,TYPE)
 #define Declare_TVector_Base(TYPE,DEFAULT,ERROR)  Declare_TVector_Base_T(TYPE,DEFAULT,ERROR,TYPE)
diff -upr speech_tools/ling_class/EST_FeatureFunctionContext.cc /tmp/speech_tools/ling_class/EST_FeatureFunctionContext.cc
--- speech_tools/ling_class/EST_FeatureFunctionContext.cc	2001-04-04 12:55:32.000000000 +0100
+++ /tmp/speech_tools/ling_class/EST_FeatureFunctionContext.cc	2004-05-07 08:42:17.083419530 +0100
@@ -210,7 +210,7 @@ const EST_Item_featfunc EST_FeatureFunct
     return NULL;
 }
 
-Declare_TStringHash(EST_Item_featfunc)
+Declare_TStringHash_Base(EST_Item_featfunc,EST_Item_featfunc(),NULL)
 Declare_TList_T(EST_FeatureFunctionPackage *, EST_FeatureFunctionPackageP)
 
 
diff -upr speech_tools/ling_class/EST_FeatureFunctionPackage.cc /tmp/speech_tools/ling_class/EST_FeatureFunctionPackage.cc
--- speech_tools/ling_class/EST_FeatureFunctionPackage.cc	2001-04-04 12:55:32.000000000 +0100
+++ /tmp/speech_tools/ling_class/EST_FeatureFunctionPackage.cc	2004-05-07 08:42:35.373138615 +0100
@@ -41,7 +41,7 @@
 #include "ling_class/EST_FeatureFunctionPackage.h"
 
 			
-Declare_TStringHash_T(EST_FeatureFunctionPackage::Entry, EST_FeatureFunctionPackage_Entry)
+Declare_TStringHash_Base_T(EST_FeatureFunctionPackage::Entry, EST_FeatureFunctionPackage::Entry(), NULL, EST_FeatureFunctionPackage_Entry)
 
 
 #if defined(INSTANTIATE_TEMPLATES)
diff -upr speech_tools/ling_class/genxml.cc /tmp/speech_tools/ling_class/genxml.cc
--- speech_tools/ling_class/genxml.cc	2001-04-04 14:11:27.000000000 +0100
+++ /tmp/speech_tools/ling_class/genxml.cc	2004-05-07 08:42:25.215626830 +0100
@@ -736,7 +736,7 @@ void GenXML_Parser_Class::error(XML_Pars
   est_error_throw();
 }
 
-Declare_TStringHash_T(EST_Item_Content *, THash_String_ItemC_P)
+Declare_TStringHash_Base_T(EST_Item_Content *, NULL, NULL, THash_String_ItemC_P)
 
 #if defined(INSTANTIATE_TEMPLATES)
 
diff -upr speech_tools/siod/siod.cc /tmp/speech_tools/siod/siod.cc
--- speech_tools/siod/siod.cc	2001-07-21 01:30:32.000000000 +0100
+++ /tmp/speech_tools/siod/siod.cc	2004-05-07 08:27:50.492063612 +0100
@@ -38,7 +38,7 @@ Cambridge, MA 02138
 
 extern "C" const char * repl_prompt;
 
-Declare_TStringHash_T(EST_Regex *, hash_string_regex)
+Declare_TStringHash_Base_T(EST_Regex *, NULL, NULL, hash_string_regex)
 
 #if defined(INSTANTIATE_TEMPLATES)
 #include "../base_class/EST_THash.cc"
diff -upr speech_tools/stats/dynamic_program.cc /tmp/speech_tools/stats/dynamic_program.cc
--- speech_tools/stats/dynamic_program.cc	2001-04-04 12:55:32.000000000 +0100
+++ /tmp/speech_tools/stats/dynamic_program.cc	2004-05-07 04:35:21.329564579 +0100
@@ -50,10 +50,10 @@ template class EST_TVector<EST_Item*>;
 #endif
 
 static EST_Item *const def_val_item_ptr = NULL;
-EST_Item* const *EST_Item_ptr_Vector::def_val = &def_val_item_ptr;
+template <> EST_Item* const *EST_Item_ptr_Vector::def_val = &def_val_item_ptr;
 
 static EST_Item* error_return_item_ptr = NULL;
-EST_Item* *EST_Item_ptr_Vector::error_return = &error_return_item_ptr;
+template <> EST_Item* *EST_Item_ptr_Vector::error_return = &error_return_item_ptr;
 
 typedef
 float (*local_cost_function)(const EST_Item *item1,
diff -upr speech_tools/testsuite/hash_example.cc /tmp/speech_tools/testsuite/hash_example.cc
--- speech_tools/testsuite/hash_example.cc	2004-05-07 08:54:04.251573170 +0100
+++ /tmp/speech_tools/testsuite/hash_example.cc	2004-05-07 08:51:12.344606193 +0100
@@ -135,7 +135,7 @@ cout << "\n";
 }
 
 
-Declare_THash(int,float)
+Declare_THash_Base(int,float,0,0.0,NULL)
 
 #if defined(INSTANTIATE_TEMPLATES)
 #include "../base_class/EST_THash.cc"