Калькулятор с парсингом ввода

TNode *Find(TNode *Root, int Data)
{
 TNode Temp;
 if (Root==NULL)
 {
  return NULL;
 }
 if (Root->Data==Data)
 {
  return Root;
 }
 Temp=Find(Root->Left, Data);
 if (Temp!=NULL)
 {
  return TEMP;
 }
 return Find(Root->Right, Data);
}

void Out(TTree *Root)
{
 if (Root!=NULL)
 {
  Out(Root->Left);
  std::cout<<Root->Data;
  Out(Root->Right);
 }
}

unsigned long int factorial(unsigned short int n)
{
 if (n==0)
 {
  return 1;
 }
 return n*factorial(n-1);
}

unsigned long int factorial(unsigned short int n)
{
 unsigned short int r;
 for (r=0; n>0; --n)
 {
  r*=n;
 }
 return n;
}

double det(dpuble *a, int n)
{
 double ***minors;
 double result;
 int m;
 int i;
 int j;
 if (n==2)
 {
   return (a[0][0]*a[1][1]-a[1][0]*a[0][1];
 }
 minors=new double**[n];
 for (result=0.0, m=0; m<n; ++m)
 {
  minors[m]=new double*[n-1];
  for (i=0, i<(n-1); i++)
  {
   minors[m][i]=new double[n-1];
   for (j=0, j<(n-1); j++)
   {
    if (i<m)
    {
     minors[m][i][j]=a[i][j+1];
    }
    else
    {
     minors[m][i][j]=a[i-1][j+1];
    }
   }
   if (i%2==0)
   {
    result+=det(minors[m], n-1);
   }
   else
   {
    result-=det(minors[m], n-1);
   }
   delete [] minors[m][i];
  }
  delete [] minors[m];
 }
 delete [] minors;
 return result;
}
void kramer(double **a, int n, double *b, double *x)
{
 double **ax;
 double d;
 double dx;
 int i;
 int j;
 int k;
 d=det(a, n);
 ax=new double*[n];
 for (i=0; i<n; ++i)
 {
  ax=new double [n];  
  for (j=0; j<n; ++j)
  {
   ax[j]=new double [n];  
   for (k=0; k<n; ++k)
   {
    if (i==j)
    {
     ax[j][k]=b[k];
    }
    else
    {
     ax[j][k]=a[j][k];
    }
   }
   dx=det(ax,n);
   x[i]=dx/d;
  }
  for (j=0; j<n; ++j)
  {  
   delete [] ax[j];
  }
 }
 delete [] ax;
}

double det(double **a, int n)
{
 int i;
 int j;
 int k;
 double r;
 for (i=0; i<n; ++i)
 {
   for (j=i+1; j<n; ++j)
   {
    for (k=i+1; k<n; ++k)
    {
     a[j][k]-=a[i][k]*a[j][i]/a[i][i];
    }
    a[j][i]=0.0;  
   }
 }
 for (r=1.0, i=0; i<n; ++i)
 {
  r*=a[i][i];
 }
 return r;
}

void Searhc(TDirrectrory *Dirrectrory, TDirrectroryArray &Array, std::string Name)
{
 Dirrectrory *Child;
 if (Dirrectrory!=NULL)
 {
  if (Dirrectory->Name==Name)
  {
   Array+=Dirrectory;
   if (Dirrectory->ChildrenCount>0)
   {
    for (Child=Dirrectory->Children+Dirrectory->ChildrenCount-1; Child>=Dirrectory->Children; --Child)
    {
     Search(Child, Array, Name);
    }
   }
  }
 }
}