Ошибка не закрытый комментарии в файле

#define MAT_TEMPLATE template <class T>
# include <iostream.h> 
# include <string.h>

#define MAT_TEMPLATE template <class T>
 
# include <iostream> 
# include <string> 
 
# define max(a,b)    (((a) > (b)) ? (a) : (b)) 
# define min(a,b)    (((a) < (b)) ? (a) : (b)) 
 
#if !defined(_NO_TEMPLATE) 
# define MAT_TEMPLATE template <class T>
# define matrixT  matrix<T>
#else 
# define MAT_TEMPLATE 
# define matrixT  matrix 
# ifdef MATRIX_TYPE
typedef MATRIX_TYPE T; 
# else      
typedef double T; 
# endif 
#endif 
 
//template <class T>
MAT_TEMPLATE
class matrix 
{
  public:    
  // Constructors    
  matrix (size_t row = 6, size_t col = 6); 
  
  // Destructor    
  ~matrix (); 
 
  // Assignment operators
  matrixT& operator = (const matrixT& m);// _NO_THROW;
                                           
  // Value extraction method    
  size_t RowNo () const { return _m->Row; }    
  size_t ColNo () const { return _m->Col; } 
   
  // Combined assignment - calculation operators    
  matrixT& operator += (const matrixT& m);// _THROW_MATRIX_ERROR;    
  matrixT& operator -= (const matrixT& m);// _THROW_MATRIX_ERROR;    
  matrixT& operator *= (const matrixT& m) ;//_THROW_MATRIX_ERROR;    
  matrixT& operator *= (const T& c) ;//_NO_THROW;    
  matrixT& operator /= (const T& c) ;//_NO_THROW;    
  matrixT& operator ^= (const size_t& pow);// _THROW_MATRIX_ERROR; 
   
  void SetSize(size_t row, size_t col);// _NO_THROW;    
  void SetElement (size_t row, size_t col,T value); 
 
  private:     
  struct base_mat 
  {
    T** Val;  
    size_t Row, Col, RowSiz, ColSiz;  
    int Refcnt;
    
    base_mat(size_t row, size_t col, T** v) 
    {
      Row = row; 
      RowSiz = row;      
      Col = col; ColSiz = col;      
      Refcnt = 1;
        
      Val = new T * [row];      
      size_t rowlen = col * sizeof(T);
        
      for (size_t i = 0; i < row; i++) 
      {
        Val[i] = new T[col];   
        if (v) memcpy(Val[i], v[i], rowlen); 
      }
    }   ~base_mat() 
      { 
        for (size_t i = 0; i < RowSiz; i++)   
        delete[] Val[i];      
        delete[] Val; 
      }
  };     
  base_mat* _m;
   
  void clone();     
  void realloc(size_t row, size_t col);     
  int pivot(size_t row); 
};
 
#if defined(_MSC_VER) && _MSC_VER <= 1020 
# undef  _NO_THROW      // MSVC++ 4.0/4.2 does not support 
# undef  _THROW_MATRIX_ERROR     // exception specification in 
 
definition 
# define _NO_THROW 
# define _THROW_MATRIX_ERROR 
#endif
 
// constructor 
MAT_TEMPLATE inline 
matrixT::matrix (size_t row, size_t col) 
{   
  _m = new base_mat( row, col, 0); 
} 
 
// combined power and assignment operator 
MAT_TEMPLATE inline matrixT& 
matrixT::operator ^= (const size_t& pow) 
//_THROW_MATRIX_ERROR 
{  
  matrixT temp(*this); 
  for (size_t i = 2; i <= pow; i++)       
  *this = *this * temp;
  return *this; 
}
 
// binary addition operator 
MAT_TEMPLATE inline matrixT 
operator + (const matrixT& m1, const matrixT& m2) 
//HROW_MATRIX_ERROR 
{    
  matrixT temp = m1;    
  temp += m2;    
  return temp; 
} 
 
// binary subtraction operator 
MAT_TEMPLATE inline matrixT 
operator - (const matrixT& m1, const matrixT& m2) 
 
//HROW_MATRIX_ERROR 
{
  matrixT temp = m1;    
  temp -= m2;    
  return temp; 
} 
 
// binary scalar multiplication operator 
MAT_TEMPLATE inline matrixT 
operator * (const matrixT& m, const T& no) //O_THROW 
{  
  matrixT temp = m;    
  temp *= no;    
  return temp; 
} 
 
// binary scalar multiplication operator 
MAT_TEMPLATE inline matrixT 
operator * (const T& no, const matrixT& m) //O_THROW 
{    
  return (m * no); 
} 
 
// binary matrix multiplication operator 
MAT_TEMPLATE inline matrixT
operator * (const matrixT& m1, const matrixT& m2) 
//HROW_MATRIX_ERROR 
{   
  matrixT temp = m1;    
  temp *= m2;    
  return temp; 
} 
 
// binary scalar division operator 
MAT_TEMPLATE inline matrixT 
operator / (const matrixT& m, const T& no) //O_THROW 
{     
  return (m * (T(1) / no)); 
}
 
// binary scalar division operator 
MAT_TEMPLATE inline matrixT 
operator / (const T& no, const matrixT& m) 
//_THROW_MATRIX_ERROR 
{    
  return (!m * no); 
} 
 
// binary matrix division operator 
MAT_TEMPLATE inline matrixT 
operator / (const matrixT& m1, const matrixT& m2) 
//_THROW_MATRIX_ERROR 
{     
  return (m1 * !m2); 
} 
 
// binary power operator
MAT_TEMPLATE inline matrixT 
operator ^ (const matrixT& m, const size_t& pow) 
//_THROW_MATRIX_ERROR 
{    
  matrixT temp = m;    
  temp ^= pow;    
  return temp; 
} 
 
// unary transpose operator
MAT_TEMPLATE inline matrixT
operator ~ (const matrixT& m) //_NO_THROW 
{    
  matrixT temp(m.ColNo(),m.RowNo()); 
  for (size_t i = 0; i < m.RowNo(); i++)       
  for (size_t j = 0; j < m.ColNo(); j++) 
  {
    T x = m(i, j);
    temp(j, i) = x;
  }    
 return temp; 
}
 
// unary inversion operator 
MAT_TEMPLATE inline matrixT 
operator ! (const matrixT m) //_THROW_MATRIX_ERROR 
{    
  matrixT temp = m;    
  return temp.Inv(); 
} 
 
// inversion function
/**MAT_TEMPLATE inline matrixT 
matrixT::Inv () //_THROW_MATRIX_ERROR 
{    
  size_t i,j,k;    
  T a1,a2,*rowptr; 
 
  if (_m->Row != _m->Col)       
  REPORT_ERROR("matrixT::operator!: Inversion of a nonsquare matrix");
 
  matrixT temp(_m->Row, _m->Col);    
  if (_m->Refcnt > 1) clone();
 
  temp.Unit();    
  for (k = 0; k < _m->Row; k++) 
   {
     int indx = pivot(k);       
     if (indx == -1)        
     REPORT_ERROR("matrixT::operator!: Inversion of a singular matrix");
    
    if (indx != 0) 
    {
      rowptr = temp._m->Val[k];        
      temp._m->Val[k] = temp._m->Val[indx];
      temp._m->Val[indx] = rowptr;
    }       
    a1 = _m->Val[k][k];       
    for (j = 0; j < _m->Row; j++) 
    { 
      _m->Val[k][j] /= a1;        
      temp._m->Val[k][j] /= a1; 
    }       
    for (i = 0; i < _m->Row; i++)     
    if (i != k) 
    { 
      a2 = _m->Val[i][k];        
      for (j = 0; j < _m->Row; j++) 
      { 
        _m->Val[i][j] -= a2 * _m->Val[k][j];       
        temp._m->Val[i][j] -= a2 * temp._m->Val[k][j];
      }
    }
    }   
  return temp; 
} 
  Unit1.cpp – головний модуль сервера 
  Функція обробки вхідних повідомлень  
 
  void __fastcall TForm1::MyServerClientRead(TObject* Sender, TCustomWinSocket* Socket) 
  {
    AnsiString TextIn;   
    int iIndex;
    
    TextIn = Socket->ReceiveText();   
    TStringList* TMess = new TStringList();   
    TMess->Text = TextIn;
 
    iIndex = ConnectedList->IndexOfObject(Socket);   
    if (iIndex == -1)     
    return;
    if (TMess->Strings[0] == "PRO")
    {         
      LogMemo->Lines->Add("Received message from " + TMess > Strings[1]);
    
      if (TMess->Strings[2] == "_findb") 
      { 
        LogMemo->Lines->Add("b vector:");           
        GetMatrixFromMSG(3, TMess, T2);           
        LogMemo->Lines->Add(GetMatrixString(T2)); 
      }
      else           
      if (TMess->Strings[2] == "_findC2") 
      { 
        LogMemo->Lines->Add("C2 matrix:");             
        GetMatrixFromMSG(3, TMess, T1);             
        LogMemo->Lines->Add(GetMatrixString(T1)); 
      }
      else         
      if (TMess->Strings[2] == "_sum") 
      {
        switch (InputStage) 
        {
          case 6: 
          {             
            Done++;             
            if (Done == 2) 
            {  
              NextButton->Enabled = true; Done = 0;
            }
            if (TMess->Strings[1] == ConnectedList->Strings[0])
            {
              LogMemo->Lines->Add("after b1+4*c1:");              
              GetMatrixFromMSG(3, TMess, T1);             
              LogMemo->Lines->Add(GetMatrixString(T1));
            }
            else
            if (TMess->Strings[1] == ConnectedList->Strings[1])
            {
              LogMemo->Lines->Add("after B2+C2:");                
              GetMatrixFromMSG(3, TMess, T2);          
              LogMemo->Lines->Add(GetMatrixString(T2)); 
            }      
          } //case           
          break;         
        
         case 10:          
         if (TMess->Strings[1]==ConnectedList->Strings[0])
         {            
           LogMemo->Lines->Add("after Y3 x y1 + Y3^2 x y2:");             
           GetMatrixFromMSG(3,TMess, TT2);         
           LogMemo->Lines->Add(GetMatrixString (TT2));           
         }        
         break;    
 
         case 11: 
         if (TMess->Strings[1] == ConnectedList->Strings[0])
         {
           LogMemo->Lines->Add("after Y3 x y1 + Y3^2 x y2 + (y2~ x y1)(Y3 x y1):");             
           GetMatrixFromMSG(3, TMess, TT1);        
           LogMemo->Lines->Add(GetMatrixString(TT1));        
           TT1 = ~TT1;           
           LogMemo->Lines->Add("transponovana matrix");       
           LogMemo->Lines->Add(GetMatrixString(TT1)); 
         }        
         break;
         } //switch      
         }else    
         {      }//end sum       
         if (TMess->Strings[2]=="_mul")
         {        
           switch (InputStage)
           {        
             case 6:           
             if (TMess->Strings[1]==ConnectedList->Strings[2])
             {        
               LogMemo->Lines->Add("after A*b:");       
               GetMatrixFromMSG(3,TMess, T3);  
               LogMemo->Lines->Add(GetMatrixString (T3));      
             }         
             break;        
            
            case 7:           
            if (TMess->Strings[1]==ConnectedList->Strings[0])
            {       
              LogMemo->Lines->Add("after y2=A1*(5*b1-c1):");     
              GetMatrixFromMSG(3,TMess, T1);      
              LogMemo->Lines->Add(GetMatrixString (T1));       
              TTT1=T1;     
              T1=~T1;          
              LogMemo->Lines->Add("transponovana y2");      
              LogMemo->Lines->Add(GetMatrixString (T1));        
            }          
            if (TMess->Strings[1]==ConnectedList->Strings[1])
            {       
              LogMemo->Lines->Add("after Y3=A2*(B2+10*С2):");         
              GetMatrixFromMSG(3,TMess, T2);     
              LogMemo->Lines->Add(GetMatrixString (T2));       
            }        
            break;      
       
            case 8: 
            if (TMess->Strings[1] == ConnectedList->Strings[0])
            {
              LogMemo->Lines->Add("after y2~ x y1:");       
              GetMatrixFromMSG(3, TMess, TT1);     
              LogMemo->Lines->Add(GetMatrixString(TT1));
            }         
            if (TMess->Strings[1] == ConnectedList->Strings[1])
            {
              LogMemo->Lines->Add("after Y3^2");        
              GetMatrixFromMSG(3, TMess, TT2);        
              LogMemo->Lines->Add(GetMatrixString(TT2)); }     
              if (TMess->Strings[1] == ConnectedList->Strings[2])
              { 
                LogMemo->Lines->Add("after Y3 x y1:");           
                GetMatrixFromMSG(3, TMess, T3);        
                LogMemo->Lines->Add(GetMatrixString(T3));
              }        
              break;          
       
            case 9:        
            if (TMess->Strings[1] == ConnectedList->Strings[0])
            {
              LogMemo->Lines->Add("after (y2~ x y1)(Y3 x y1):");      
              etMatrixFromMSG(3, TMess, TT1);         
              LogMemo->Lines->Add(GetMatrixString(TT1));
            }         
            if (TMess->Strings[1] == ConnectedList->Strings[1])
            {
              LogMemo->Lines->Add("after Y3^2 x y2");        
              GetMatrixFromMSG(3, TMess, TT2);          
              LogMemo->Lines->Add(GetMatrixString(TT2));
            }       
            break;   
        
            case 12:         
            if (TMess->Strings[1] == ConnectedList->Strings[0])
            { 
              LogMemo->Lines->Add("Result:");         
              GetMatrixFromMSG(3, TMess, TT1);         
              LogMemo->Lines->Add(GetMatrixString(TT1)); 
            }        
            break;
 
          } //switch     
        }//case      
      } 
    }
  }

MAT_TEMPLATE inline matrixT
matrixT::Inv () //_THROW_MATRIX_ERROR

/*
 
// inversion function
MAT_TEMPLATE inline matrixT 
matrixT::Inv () //_THROW_MATRIX_ERROR

          } //switch     
        }//case      
      } 
    }
  }
 
 
*/

matrixT::Inv() //_THROW_MATRIX_ERROR
...
Unit1.cpp – головний модуль сервера
...
case 10:
...
case 11: 
...