sToken

//+------------------------------------------------------------------+
//|                                                       sToken.mq4 |
//|                                                                * |
//|                                                                * |
//+------------------------------------------------------------------+
#property copyright "http://dmffx.com"
#property link      "http://dmffx.com"
#property show_inputs
// âûðàæåíèå

extern string Expression=""; //(a+b+c+d+f[0]+f[1]+f[2]+f[3]+1)*2/4*10

/*   
   Ôóíêöèè: abs, arccos, arcsin, arctan, ceil, cos, exp, floor, log, max, min, mod, pow, rand, round, sin, sqrt, tan
   Äåéñòâèÿ: /, %, *, +, -, >, <, >=, <=, ==, !=, &&, ||
*/

//===============================================================================================================================
//===============================================================================================================================

// ïîëüçîâàòåëüñêèå ïåðåìåííûå. Äëÿ êàæäîé ïåðåìåííîé â êîäå äîëæíà ñóùåñòâîâàòü 
// ôóíêöèÿ è äîëæíà áûòü îáùàÿ ôóíêöèÿ äëÿ ïîëó÷åíèÿ çíà÷åíèÿ ïî èìåíè ôóíêöèè

string un[]={"a","b","c","d"};

string a(){
   return("1");
}
string b(){
   return("2");
}
string c(){
   return("3");
}
string d(){
   return("4");
}

string UserFunc(string FuncName){
   if(FuncName=="a")return(a());
   if(FuncName=="b")return(b());
   if(FuncName=="c")return(c());
   if(FuncName=="d")return(d());
   Alert("Ôóíêöèÿ äëÿ ïåðåìåííîé "+FuncName+" íå îïðåäåëåíà");
}

// ïîëüçîâàòåëüñêèå ìàññèâû. Äëÿ êàæäîé ìàññèâà â êîäå äîëæíà ñóùåñòâîâàòü ôóíêöèÿè 
// è äîëæíà áûòü îáùàÿ ôóíêöèÿ äëÿ ïîëó÷åíèÿ çíà÷åíèÿ ïî èìåíè ôóíêöèè

string uan[]={"e","f"};

string e(int Index){
   string v[]={"1","2","3","4","5","6","7","8","9"};
   return(v[Index]);
}

string f(int Index){
   string v[]={"10","20","30","40","50","60","70","80","90"};
   return(v[Index]);
}

string UserArray(string ArrName,int aIndex){
   if(ArrName=="e")return(e(aIndex));
   if(ArrName=="f")return(f(aIndex));
   Alert("Ôóíêöèÿ äëÿ ìàññèâà "+ArrName+" íå îïðåäåëåíà");
}

//===============================================================================================================================
//===============================================================================================================================

int init(){
   Prepare();
}

int start(){
   double Result=SolveExpression();
   Alert("Result="+Result);
   return(0);
}

//===============================================================================================================================
//===============================================================================================================================

// êîíñòàíòû:
// ìàññèâ ôóíêöèé
string a[]={"abs","arccos","arcsin","arctan","ceil","cos","exp","floor","log","max","min","mod","pow","rand","round","sin","sqrt","tan"};
// ìàññèâ àðèôìåòè÷åñêèõ äåéñòâèé
string b[]={"/","%","*","+","-",">","<",">=","<=","==","!=","&&","||"};
// ñêîáêè
string c[]={",","(",")"};

// âñïîìîãàòåëüíûå ïåðåìåííûå:
// îáùèé ìàññèâ
string all[];
// ìàññèâ âûðàæåíèÿ
string r[];

string e; // âûðàæåíèå
string uv[]; // çíà÷åíèÿ ïîëüçîâàòåëüñêèõ ïåðåìåííûõ
int uri[]; // èíäåêñ â ìàññèâå âûðàæåíèÿ
int uvi[]; // èíäåêñ â ìàññèâå çíà÷åíèé
string fn[]; // ïîëíûé òåêñò: èìÿ, ñêîáêè, èíäåêñ. Äëÿ áûñòðîé çàìåíû
string an[]; // èìÿ ìàññèâà  
int ai[]; // èíäåêñ ýëåìåíòà
string av[]; // çíà÷åíèå
int uari[]; // èíäåêñ â ìàññèâå âûðàæåíèÿ
int uavi[]; // èíäåêñ â ìàññèâå çíà÷åíèé

double SolveExpression(){

   string t[];
   ArrayResize(t,ArraySize(r));
   ArrayCopy(t,r);
   

   
   // à òåïåðü äèñêîòåêà!!!
   
   // 1. çàïîëíèòü ìàññèâ ïîëüçîâàòåëüñêèõ ïåðåìåííûõ àêòóàëüíûìè çíà÷åíèÿìè
   
      FillUserVariables(un,uv);
     
   // 2. çàïîëíèòü ìàññèâ ýëåìåíòîâ ïîëüçîâàòåëëüñêèõ ìàññèâîâ àêòóàëüíûìè çíà÷åíèÿìè 

      FillUserArraysElements(fn,an,ai,av);
   
   // 3. Çàìåíèòü ïîëüçîâàòåëüñêèå ïåðåìåííûå íà çíà÷åíèÿ
   
      ReplaceVarsToValues(r,uv,uri,uvi);

   // 4. Çàìåíèòü ýëåìåíòû ïîëüçîâàòåëüñêèõ ìàññèâîâ íà çíà÷åíèÿ
   
      ReplaceVarsToValues(r,av,uari,uavi);

   // Òàíöóåì! 

   // 1. Íàéòè âíóòðåííåå âûðàæåíèå
         
      string Result;
      string Res[];         
      bool solved=true;
      int cnt=ArraySize(t);
      
      int cn=0;
         
         while(solved){
            cn++;
            solved=false;
            int lb=-1;
            
               for(int i=0;i<cnt;i++){
                  if(r[i]=="("){
                     lb=i;
                  }
                  if(r[i]==")"){
                        if(lb!=-1){
                           SolveArguments(r,lb+1,i-1,Res); // âûðàæåíèÿ ìåæäó çàïÿòûìè, åñëè åñòü çàïÿòûå, èëè ñàìî âûðàæåíèå
                           int func=SolveFunc(r[lb-1],Res);
                           r[lb-func]=Res[0];
                           ArrayCopy(r,r,lb+1-func,i+1,cnt-i-1);
                           cnt=cnt-(i+1-(lb+1-func));
                           solved=true;
                        }
                     lb=-1;
                  }
               }
         }   

   // Áåëûé òàíåö ;-)

      return(StrToDouble(SolveSimple(r,0,cnt-1)));
      
      

   // Íàøè ïîáåäèëè   
   
}

/*
void AA(string aTag,string & aAr[],int aStart,int aCnt){
   string str=aTag+"::: ";
   //for(int i=aStart;i<aCnt;i++)str=str+i+"->"+aAr[i]+", ";
   for(int i=aStart;i<aCnt;i++)str=str+" "+aAr[i];
   Alert(str);
}
*/

void SolveArguments(string aExp[],int aFrom,int aTo,string & aRes[]){
   ArrayResize(aRes,0);
   string ex[];
   int cnt=aTo-aFrom+1;
   ArrayResize(ex,cnt);
   ArrayCopy(ex,aExp,0,aFrom,cnt);
   int strt=0;
      for(int i=0;i<ArraySize(ex);i++){
         if(ex[i]==","){
            ArrayResize(aRes,ArraySize(aRes)+1);
            aRes[ArraySize(aRes)-1]=SolveSimple(ex,strt,i-1);
            strt=i+1;
         }
      }
   ArrayResize(aRes,ArraySize(aRes)+1);
   aRes[ArraySize(aRes)-1]=SolveSimple(ex,strt,i-1);
   
}

string SolveSimple(string aExp[],int aFrom,int aTo){
   string ex[];
   int cnt=aTo-aFrom+1;
   ArrayResize(ex,cnt);
   ArrayCopy(ex,aExp,0,aFrom,cnt);

   int i,j;
   bool exist;


   // %
   exist=true;
      while(exist){
         exist=false;
            for(i=0;i<cnt;i++){
               if(ex[i]=="%"){
                  ex[i-1]=StrToInteger(ex[i-1])%StrToInteger(ex[i+1]);
                     for(j=i;j<cnt-2;j++){
                        ex[j]=ex[j+2];
                     }
                  cnt--;
                  cnt--;
                  exist=true;
                  break;
               }
            }
      } 

   //===
   
   // /
   exist=true;
      while(exist){
         exist=false;
            for(i=0;i<cnt;i++){
               if(ex[i]=="/"){
                     if(StrToDouble(ex[i+1])!=0){
                        ex[i-1]=StrToDouble(ex[i-1])/StrToDouble(ex[i+1]);
                     }
                     else{
                        ex[i-1]=StrToDouble(ex[i-1])/0.00000001;
                     }
                     for(j=i;j<cnt-2;j++){
                        ex[j]=ex[j+2];
                     }
                  cnt--;
                  cnt--;
                  exist=true;
                  break;
               }
            }
      }  
      
   // *
   exist=true;
      while(exist){
         exist=false;
            for(i=0;i<cnt;i++){
               if(ex[i]=="*"){
                  ex[i-1]=StrToDouble(ex[i-1])*StrToDouble(ex[i+1]);
                     for(j=i;j<cnt-2;j++){
                        ex[j]=ex[j+2];
                     }
                  cnt--;
                  cnt--;
                  exist=true;
                  break;
               }
            }
      }   
      
   // +-
   exist=true;
      while(exist){
         exist=false;
            for(i=0;i<cnt;i++){
               if(ex[i]=="+"){
                  ex[i-1]=StrToDouble(ex[i-1])+StrToDouble(ex[i+1]);
                     for(j=i;j<cnt-2;j++){
                        ex[j]=ex[j+2];
                     }
                  cnt--;
                  cnt--;
                  exist=true;
                  break;
               }
               if(ex[i]=="-"){
                  ex[i-1]=StrToDouble(ex[i-1])-StrToDouble(ex[i+1]);
                     for(j=i;j<cnt-2;j++){
                        ex[j]=ex[j+2];
                     }
                  cnt--;
                  cnt--;
                  exist=true;
                  break;
               }               
            }
      }             
   
      
   //===
   
   // >
   exist=true;
      while(exist){
         exist=false;
            for(i=0;i<cnt;i++){
               if(ex[i]==">"){
                  ex[i-1]=StrToDouble(ex[i-1])>StrToDouble(ex[i+1]);
                     for(j=i;j<cnt-2;j++){
                        ex[j]=ex[j+2];
                     }
                  cnt--;
                  cnt--;
                  exist=true;
                  break;
               }
            }
      }  
      
   // <
   exist=true;
      while(exist){
         exist=false;
            for(i=0;i<cnt;i++){
               if(ex[i]=="<"){
                  ex[i-1]=StrToDouble(ex[i-1])<StrToDouble(ex[i+1]);
                     for(j=i;j<cnt-2;j++){
                        ex[j]=ex[j+2];
                     }
                  cnt--;
                  cnt--;
                  exist=true;
                  break;
               }
            }
      }                

   // >=
   exist=true;
      while(exist){
         exist=false;
            for(i=0;i<cnt;i++){
               if(ex[i]==">="){
                  ex[i-1]=StrToDouble(ex[i-1])>=StrToDouble(ex[i+1]);
                     for(j=i;j<cnt-2;j++){
                        ex[j]=ex[j+2];
                     }
                  cnt--;
                  cnt--;
                  exist=true;
                  break;
               }
            }
      } 
      
   // <=
   exist=true;
      while(exist){
         exist=false;
            for(i=0;i<cnt;i++){
               if(ex[i]=="<="){
                  ex[i-1]=StrToDouble(ex[i-1])<=StrToDouble(ex[i+1]);
                     for(j=i;j<cnt-2;j++){
                        ex[j]=ex[j+2];
                     }
                  cnt--;
                  cnt--;
                  exist=true;
                  break;
               }
            }
      }  
      
   // ==
   exist=true;
      while(exist){
         exist=false;
            for(i=0;i<cnt;i++){
               if(ex[i]=="=="){
                  ex[i-1]=StrToDouble(ex[i-1])==StrToDouble(ex[i+1]);
                     for(j=i;j<cnt-2;j++){
                        ex[j]=ex[j+2];
                     }
                  cnt--;
                  cnt--;
                  exist=true;
                  break;
               }
            }
      }  
       
   // ==
   exist=true;
      while(exist){
         exist=false;
            for(i=0;i<cnt;i++){
               if(ex[i]=="!="){
                  ex[i-1]=StrToDouble(ex[i-1])!=StrToDouble(ex[i+1]);
                     for(j=i;j<cnt-2;j++){
                        ex[j]=ex[j+2];
                     }
                  cnt--;
                  cnt--;
                  exist=true;
                  break;
               }
            }
      }   
   //===
   
   // ||
   exist=true;
      while(exist){
         exist=false;
            for(i=0;i<cnt;i++){
               if(ex[i]=="||"){
                  ex[i-1]=StrToDouble(ex[i-1])||StrToDouble(ex[i+1]);
                     for(j=i;j<cnt-2;j++){
                        ex[j]=ex[j+2];
                     }
                  cnt--;
                  cnt--;
                  exist=true;
                  break;
               }
            }
      }      
         
   // &&
   exist=true;
      while(exist){
         exist=false;
            for(i=0;i<cnt;i++){
               if(ex[i]=="&&"){
                  ex[i-1]=StrToDouble(ex[i-1])&&StrToDouble(ex[i+1]);
                     for(j=i;j<cnt-2;j++){
                        ex[j]=ex[j+2];
                     }
                  cnt--;
                  cnt--;
                  exist=true;
                  break;
               }
            }
      }                   
   
   return(ex[0]);
}

int SolveFunc(string Func,string & aRes[]){
      if(Func=="abs"){
         aRes[0]=MathAbs(StrToDouble(aRes[0]));
         return(1);
      }
      if(Func=="arccos"){
         aRes[0]=MathArccos(StrToDouble(aRes[0]));
         return(1);
      }
      if(Func=="arcsin"){
         aRes[0]=MathArcsin(StrToDouble(aRes[0]));   
         return(1);
      }
      if(Func=="arctan"){
         aRes[0]=MathArctan(StrToDouble(aRes[0]));   
         return(1);
      }
      if(Func=="ceil"){
         aRes[0]=MathCeil(StrToDouble(aRes[0]));   
         return(1);
      }
      if(Func=="cos"){
         aRes[0]=MathCos(StrToDouble(aRes[0]));   
         return(1);
      }
      if(Func=="exp"){
         aRes[0]=MathExp(StrToDouble(aRes[0]));   
         return(1);
      }
      if(Func=="floor"){
         aRes[0]=MathFloor(StrToDouble(aRes[0]));   
         return(1);
      }
      if(Func=="log"){
         aRes[0]=MathLog(StrToDouble(aRes[0]));   
         return(1);
      }
      if(Func=="max"){
         aRes[0]=MathMax(StrToDouble(StrToDouble(aRes[0])),StrToDouble(aRes[1]));   
         return(1);
      }
      if(Func=="min"){
         aRes[0]=MathMin(StrToDouble(aRes[0]),StrToDouble(aRes[1]));    
         return;
      }
      if(Func=="mod"){
         aRes[0]=MathMod(StrToInteger(aRes[0]),StrToInteger(aRes[1]));   
         return(1);
      }
      if(Func=="pow"){
         aRes[0]=MathPow(StrToDouble(aRes[0]),StrToDouble(aRes[1]));   
         return(1);
      }
      if(Func=="rand"){
         aRes[0]=MathRand();   
         return(1);
      }
      if(Func=="round"){
         aRes[0]=MathRound(StrToDouble(aRes[0]));   
         return(1);
      }
      if(Func=="sin"){
         aRes[0]=MathSin(StrToDouble(aRes[0]));   
         return(1);
      }
      if(Func=="sqrt"){
         aRes[0]=MathSqrt(StrToDouble(aRes[0]));   
         return(1);
      }
      if(Func=="tan"){
         aRes[0]=MathTan(StrToDouble(aRes[0]));   
         return(1);
      }
   return(0);   
   
}

void ReplaceVarsToValues(string & aExp[],string & aValues[],int & aExpIndexes[],int & aValIndexes[]){
   for(int i=0;i<ArraySize(aExpIndexes);i++){
      aExp[aExpIndexes[i]]=aValues[aValIndexes[i]];
   }
}   

void FillUserVariables(string & aNames[],string & aValues[]){    
   for(int i=0;i<ArraySize(aNames);i++){
      aValues[i]=UserFunc(aNames[i]);
   }
} 

void FillUserArraysElements(string & aFullNames[],string & aNames[],int & aIndexes[],string & aValues[]){
   for(int i=0;i<ArraySize(aFullNames);i++){ 
      aValues[i]=UserArray(aNames[i],aIndexes[i]);
   }
}

void Prepare(){

   // Ïîäãîòîâêà. Ïðåîáðàçîâàíèå ñòðîêè ñ âûðàæåíèåì â ìàññèâ. Ðåâèçèÿ ìàññèâà ñ ôóíêöèÿìè

   e=StringTrimLeft(StringTrimRight(Expression));
   
   if(e==""){
      Alert("Âûðàæåíèå íå çàäàíî");
      e="0";
   }

   // 1. Ïîëó÷èòü îáùèé ìàññèâ   
   AddArrays(all,a);
   AddArrays(all,b);
   AddArrays(all,c);
   
   // 2. Îòñîðòèðîâàòü îáùèé ìàññèâ ïî ïîðÿäêó óìåíüøåíèÿ äëèíû   
   SortByLen(all);
   
   // 3. ïðèâåäåíèå âûðàæåíèÿ ê íèæíåìó ðåãèñòðó
   e=StrLCase(e);
   
   // 4. óáðàòü âñå ïðîáåëû
   e=DelSpaces(e);
   
   // 5. ðàçáèâêà âûðàæåíèÿ â ìàññèâ
   
   SplitExprToArray(e,all,r);
   
   // 6. îñòàâèòü â ìàññèâå ôóíêöèé òîëüêî èñïîëüçóåìûå ôóíêöèè
   
   RemUnUsed(a,r);
   
   // 7. îñòàâèòü â ìàññèâå ïîëüçîâàòåëüñêèõ ïåðåìåííûõ òîëüêî èñïîëüçóåìûå ïåðåìåííûå
   
   RemUnUsed(un,r);
   ArrayResize(uv,ArraySize(un));
   
   // 8. ñïèñêè ñ èíäåêñàìè çàìåíû ïîëüçîâàòåëüñêèõ ïåðåìåííûõ
   
   CreateReplaceLists(r,un,uri,uvi);
   
   // 9. ñîñòàâèòü ìàññèâ èñïîëüçóåìûõ ýëåìåíòîâ ïîëüçîâàòåëüñêèõ ìàññèâîâ

   CreateElementsList(r,uan,fn,an,ai,av);
   ArrayResize(av,ArraySize(fn));
   
   // 10. ñîñòàâèòü ñïèñîê çàìåíû äëÿ ïîëüçîâàòåëüñêèõ ìàññèâîâ: èíäåêñ â ìàññèâå âûðàæåíèÿ - èíäåêñ â ñïèñêå ýëåìíîòîâ
   
   CreateReplaceLists(r,fn,uari,uavi);
   //ArrayResize(av,ArraySize(fn));
}

void CreateReplaceLists(string & aExp[],string & aNames[],int & aInExpIndex[],int & aInNamesIndex[]){
   ArrayResize(aInExpIndex,0);
   ArrayResize(aInNamesIndex,0);
      for(int i=0;i<ArraySize(aExp);i++){
         for(int j=0;j<ArraySize(aNames);j++){
            if(aExp[i]==aNames[j]){
               AddToArrayI(i,aInExpIndex);
               AddToArrayI(j,aInNamesIndex);               
            }
         }
      }
}

void CreateElementsList(string & aExp[],string & aUserArrays[],string & aFull[],string & aName[],int & aIndex[],string & aValues[]){
   ArrayResize(aFull,0);
   ArrayResize(aName,0);
   ArrayResize(aIndex,0);      
      for(int i=0;i<ArraySize(aUserArrays);i++){
         string search=aUserArrays[i]+"[";
         int slen=StringLen(search);
            for(int j=0;j<ArraySize(aExp);j++){
               if(StringSubstr(aExp[j],0,slen)==search){
                  int Index=StrToInteger(StringSubstr(r[j],slen,StringLen(r[j])-slen-1));
                     if(!ExistInArray(aExp[j],aFull)){
                        AddToArrayS(aExp[j],aFull);
                        AddToArrayS(uan[i],aName);
                        AddToArrayI(Index,aIndex);
                     }                        
               }
            }
      }
   ArrayResize(aValues,ArraySize(aFull)); 
}

void RemUnUsed(string & aAr[],string & aEAr[]){
   string tAr[];
   ArrayResize(tAr,0);
      for(int i=0;i<ArraySize(aAr);i++){
         if(ExistInArray(aAr[i],aEAr)){
            AddIfNotExist(aAr[i],tAr);
         }
      }
   ArrayResize(aAr,ArraySize(tAr));
      if(ArraySize(tAr)!=0){
         ArrayCopy(aAr,tAr);
      }
}

bool ExistInArray(string aVal,string & aAr[]){
      for(int i=0;i<ArraySize(aAr);i++){
         if(aVal==aAr[i])return(true);
      }
   return(false);
}

void AddIfNotExist(string aVal,string & aAr[]){
   if(!ExistInArray(aVal,aAr)){
      ArrayResize(aAr,ArraySize(aAr)+1);
      aAr[ArraySize(aAr)-1]=aVal;
   }
}

void AddToArrayS(string aVal,string & aAr[]){
   ArrayResize(aAr,ArraySize(aAr)+1);
   aAr[ArraySize(aAr)-1]=aVal;
}

void AddToArrayI(int aVal,int & aAr[]){
   ArrayResize(aAr,ArraySize(aAr)+1);
   aAr[ArraySize(aAr)-1]=aVal;
}


void SplitExprToArray(string aExp,string aSplitBy[],string & aAr[]){
   string t=aExp;
   string p="";
   ArrayResize(aAr,0);
      while(t!=""){
         bool exist=false;
            for(int j=0;j<ArraySize(aSplitBy);j++){
               if(StringSubstr(t,0,StringLen(aSplitBy[j]))==aSplitBy[j]){
                     if(p!=""){
                        ArrayResize(aAr,ArraySize(aAr)+1);
                        aAr[ArraySize(aAr)-1]=p;
                     }
                  ArrayResize(aAr,ArraySize(aAr)+1);
                  aAr[ArraySize(aAr)-1]=aSplitBy[j];
                  p="";
                  t=StringSubstr(t,StringLen(aSplitBy[j]),StringLen(t)-StringLen(aSplitBy[j]));
                  exist=true;
                  break;            
               }
            }
            if(!exist){
               p=p+StringSubstr(t,0,1);
               t=StringSubstr(t,1,StringLen(t)-1);
            }
      }
      if(p!=""){
         ArrayResize(aAr,ArraySize(aAr)+1);
         aAr[ArraySize(aAr)-1]=p;
      } 
}

void SortByLen(string & aAr[]){
   for(int i=ArraySize(aAr)-1;i>0;i--){
      for(int j=0;j<i;j++){
         if(StringLen(aAr[j])<StringLen(aAr[j+1])){
            string tmp=aAr[j];
            aAr[j]=aAr[j+1];
            aAr[j+1]=tmp;
         }
      }
   }
}

string DelSpaces(string aStr){
   string rs="";
      for(int i=0;i<StringLen(aStr);i++){
         string chr=StringSubstr(aStr,i,1);
         if(chr!=" ")rs=rs+chr;
      }
   return(rs);      
}

void AddArrays(string & aAr1[],string & aAr2[]){
   int from=ArraySize(aAr1);
   int cnt=ArraySize(aAr2);
   ArrayResize(aAr1,from+cnt);
   ArrayCopy(aAr1,aAr2,from,0,cnt);
}

string StrLCase(string aString){
      for(int i=0;i<StringLen(aString);i++){
         int char=StringGetChar(aString,i);
            if(char>64 && char<91){
                aString=StringSetChar(aString,i,char+32);
                continue;
            }      
            if(char>191 && char<224){
               aString=StringSetChar(aString,i,char+32);
               continue;
            }
            if(char==168){
               aString=StringSetChar(aString,i,184);
               continue;
            }               
      }
   return(aString);
}