"expert function calls are not allowed" (?)

#1
First Post: Jan 8, 2008 7:54pm Jan 8, 2008 7:54pm

137
| Joined Jun 2005 | Status: Trader | 280 Posts

when running my EAs i often get this error message in the experts tab of the terminal:

"expert function calls are not allowed; 'stdlib'-'ErrorDescription'"

followed by "expert stopped"

just wondering if anyone can help me with this

thanks

change the future, not the past

#2
Jan 8, 2008 11:40pm Jan 8, 2008 11:40pm

WHTenn
Joined Nov 2006 | Status: Trader | 1,758 Posts

www.metaquotes.net. Also check the search feature on this forum. You will find your answer quicker if this has been discussed previously.

#3
Jan 9, 2008 3:17am Jan 9, 2008 3:17am

137
| Joined Jun 2005 | Status: Trader | 280 Posts

Quoting WHTenn

Disliked

www.metaquotes.net. Also check the search feature on this forum. You will find your answer quicker if this has been discussed previously.

Ignored

thank you WHTenn, much appreciated

change the future, not the past

#4
Jan 21, 2008 1:30am Jan 21, 2008 1:30am

137
| Joined Jun 2005 | Status: Trader | 280 Posts

i still havent found the answer. perhaps someone can take a look at the code below. maybe the problem has something to do with the TrailingStop function trying to modify the order too much...

Inserted Code

 
#include <stdlib.mqh>

extern int myMagic = 1;

extern double TakeProfit =75;
extern bool   PartialClosing = True;
extern int    TPDivide = 1;
extern double StopLoss =25;  
extern int    TrailingStop =25;
extern double BreakEvenStop =25;  

extern int    slippage=2;       
extern int    shift=0;            

extern double Lots = 0.01;
extern double MaximumRisk = 2.0; // 
extern bool   FixedLot = false;

extern int TimeStart1=0000;
extern int TimeStop1=2359;

extern int TimeStart2=0000;
extern int TimeStop2=0000;

extern int TimeStart3=0000;
extern int TimeStop3=0000;

extern int TimeStart4=0000;
extern int TimeStop4=0000;

extern int       OrderTriesNumber=25;

bool buysig,sellsig,closebuy,closesell; int lastsig,tries;


double LotsRisk(int StopLoss)  { 
   double lot=Lots;
//---- select lot size
   if (!FixedLot && (StopLoss > 0))
      lot=NormalizeDouble(AccountFreeMargin()*MaximumRisk*0.001/StopLoss,2);
   else
      lot=Lots;
//---- return lot size
   if(lot<0.01) lot=0.01;
   return(lot);
}

//+------------------------------------------------------------------+
//| Calculate open positions                                         |
//+------------------------------------------------------------------+
int CalculateCurrentOrders(string symbol)
  {
   int buys=0,sells=0;
//----
   for(int i=0;i<OrdersTotal();i++)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false) continue;
      if(OrderSymbol()==Symbol() && OrderMagicNumber()==myMagic)
        {
         if(OrderType()==OP_BUY)  buys++;
         if(OrderType()==OP_SELL) sells++;
        }
     }
//---- return orders volume
   if(buys>0) return(buys);
   else       return(-sells);
  }
//+------------------------------------------------------------------+
//| Check for open order conditions                                  |
//+------------------------------------------------------------------+
void CheckForSignals(datetime tradeopenbar) {
      
      double iMA10current=iMA(NULL,0,10,0,MODE_SMA,PRICE_CLOSE,+1);
      double iMA10previous=iMA(NULL,0,10,0,MODE_SMA,PRICE_CLOSE,+2);
      double iMA50current=iMA(NULL,0,50,0,MODE_SMA,PRICE_CLOSE,+1);
      double iMA50previous=iMA(NULL,0,50,0,MODE_SMA,PRICE_CLOSE,+2);
      

      
      iMA10current=NormalizeDouble(iMA10current,Digits);
      iMA10previous=NormalizeDouble(iMA10previous,Digits);
      iMA50current=NormalizeDouble(iMA50current,Digits);
      iMA50previous=NormalizeDouble(iMA50previous,Digits);

     
      sellsig=false;
      buysig=false;
       
       if(tradeopenbar<Time[0]){
       if 
            
    
                     (iMA10previous<iMA50previous && iMA10current>iMA50current)
                     
                     
                     {
          buysig=true;
      }
      if             
                     (iMA10previous>iMA50previous && iMA10current<iMA50current)                   

                     
                     {
          sellsig=true;
      }
      
}      
      closebuy=false;
      closesell=false;
      
      if (Close[1]<iMA50current)                                          {   
         closebuy=true;
      }
      if (Close[1]>iMA50current)                                          {
         closesell=true;
      }
}

datetime CheckForOpen(datetime orderopenbar) {
   int    res,ct;
   datetime result = orderopenbar;
   ct=Hour()*100+Minute();
   if 
   
   ( !((ct>=TimeStart1 && ct<TimeStop1) || (ct>=TimeStart2 && ct<TimeStop2) || 
   
       (ct>=TimeStart3 && ct<TimeStop3) || (ct>=TimeStart4 && ct<TimeStop4)) ) return(result);
       
   double takeProfit;
   double SetLots=0;
   string EAComment='';
//---- sell conditions
   if(sellsig && lastsig!=-1)  {
       res=0;
       tries=0;
        while (res<=0 && tries<OrderTriesNumber) {
          while(!IsTradeAllowed()) Sleep(5000);
            RefreshRates();
            if(TakeProfit > MarketInfo(Symbol(), MODE_STOPLEVEL))
              takeProfit = Bid-TakeProfit*Point;
            else
              takeProfit = 0;
            SetLots=LotsRisk(StopLoss);
            EAComment="TimeWave EURUSD M15";  
          res=OrderSend(Symbol(),OP_SELL,SetLots,Bid,slippage,Bid+StopLoss*Point,
                  takeProfit,EAComment,myMagic,0,DeepPink);
            if (res<0) 
              Print("Error opening SELL order : ",ErrorDescription(GetLastError()));
            else
              result = Time[0]; // return this bar open time.
            tries++;
        }
      lastsig= 0;
      return(result);
   }
//---- buy conditions
   if(buysig && lastsig!=1)  {
       res=0;
       tries=0;
        while (res<=0 && tries<OrderTriesNumber) {
          while(!IsTradeAllowed()) Sleep(5000);
            RefreshRates();
            if(TakeProfit > MarketInfo(Symbol(), MODE_STOPLEVEL))
              takeProfit = Ask+TakeProfit*Point;
            else
              takeProfit = 0;
            SetLots=LotsRisk(StopLoss);
            EAComment="TimeWave EURUSD M15";  
          res=OrderSend(Symbol(),OP_BUY,LotsRisk(StopLoss),Ask,slippage,Ask-StopLoss*Point,
                  takeProfit,EAComment,myMagic,0,Yellow);
          if (res<0) 
            Print("Error opening BUY order : ",ErrorDescription(GetLastError()));
          else
            result = Time[0]; // return this bar open Time
          tries++;
        }
      lastsig = 0;
      return(result);
   }
   return(result);
}
  
  
//+------------------------------------------------------------------+
//| Check for close order conditions                                 |
//+------------------------------------------------------------------+
void CheckForClose()  {
   bool bres; int tr;
   for(int i=0;i<OrdersTotal();i++)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false)  break;
      if(OrderMagicNumber()!=myMagic || OrderSymbol()!=Symbol()) continue;
      //---- check order type 
      if(OrderType()==OP_BUY)
        {
         if (closebuy) {
            bres=false;
             tries=0;
              while (!bres && tries<OrderTriesNumber) {
               while(tr<7 && !IsTradeAllowed()) { tr++; Sleep(5000); }
               RefreshRates();
               bres=OrderClose(OrderTicket(),OrderLots(),Bid,slippage,White);
               Sleep(3000);
                  if (!bres) Print("Error closing order : ",ErrorDescription(GetLastError()));
                  tries++;
               }
           }
           else
              if(PartialClosing) PartialClosingExe();
         break;
        }
      if(OrderType()==OP_SELL)
        {
         if (closesell) {
            bres=false;
             tries=0;
              while (!bres && tries<OrderTriesNumber) {
               while(tr<7 && !IsTradeAllowed()) { tr++; Sleep(5000); }
               RefreshRates();
               bres=OrderClose(OrderTicket(),OrderLots(),Ask,slippage,White);
               Sleep(3000);
                  if (!bres) Print("Error closing order : ",ErrorDescription(GetLastError()));
                  tries++;
               }
           }
           else
              if(PartialClosing) PartialClosingExe();
         break;
        }
     }
}


void BreakEvenStop() {
   bool bres;
   double StopLoss;
   if ( BreakEvenStop > 2 ) {
      for (int i = 0; i < OrdersTotal(); i++) {
         if ( OrderSelect (i, SELECT_BY_POS) == false )  continue;
         if ( OrderSymbol() != Symbol() || OrderMagicNumber() != myMagic )  continue;
         if ( OrderType() == OP_BUY ) {
            if ( (Bid < OrderOpenPrice()+BreakEvenStop*Point) )  return;
            StopLoss = OrderOpenPrice();
            if ( StopLoss > OrderStopLoss() ) {
                  bres=OrderModify (OrderTicket(), OrderOpenPrice(), StopLoss+2*Point, OrderTakeProfit(), 0, White);
                  Sleep(3000);
                       if (!bres) Print("Error Modifying BUY order : ",ErrorDescription(GetLastError()));
            }
         }
   
         if ( OrderType() == OP_SELL ) {
            if ( (Ask > OrderOpenPrice()-BreakEvenStop*Point) )  return;
            StopLoss = OrderOpenPrice();
            if ( StopLoss < OrderStopLoss() ) {
                  bres=OrderModify (OrderTicket(), OrderOpenPrice(), StopLoss-2*Point, OrderTakeProfit(), 0, White);
                  Sleep(3000);
                       if (!bres) Print("Error Modifying SELL order : ",ErrorDescription(GetLastError()));
            }
         }
      }
   }
   return;
}

void TrailingStop() {
   bool bres;
   double StopLoss;
   if ( TrailingStop > MarketInfo(Symbol(), MODE_STOPLEVEL)) {
      for (int i = 0; i < OrdersTotal(); i++) {
         if ( OrderSelect (i, SELECT_BY_POS) == false )  continue;
         if ( OrderSymbol() != Symbol() || OrderMagicNumber() != myMagic )  continue;
         if ( OrderType() == OP_BUY ) {
            if ( (Bid < OrderStopLoss()+TrailingStop*Point) )  return;
            StopLoss = Bid-TrailingStop*Point;
            if ( StopLoss > OrderStopLoss() ) {
                  bres=OrderModify (OrderTicket(), OrderOpenPrice(), StopLoss, OrderTakeProfit(), 0, White);
                  Sleep(3000);
                       if (!bres) Print("Error Modifying BUY order : ",ErrorDescription(GetLastError()));
            }
         }
   
         if ( OrderType() == OP_SELL ) {
            if ( (Ask > OrderStopLoss()-TrailingStop*Point) )  return;
            StopLoss = Ask+TrailingStop*Point;
            if ( StopLoss < OrderStopLoss() ) {
                  bres=OrderModify (OrderTicket(), OrderOpenPrice(), StopLoss, OrderTakeProfit(), 0, White);
                  Sleep(3000);
                       if (!bres) Print("Error Modifying SELL order : ",ErrorDescription(GetLastError()));
            }
         }
      }
   }
   return;
}

double RoundLots(string S, double P)
{
   double value=P;
   double MinimalLot=0;
   MinimalLot=MarketInfo(S,MODE_MINLOT);
   if(MinimalLot<=0)
      {
         RefreshRates();
         return(-1);
      }
   value=MathFloor(P/MinimalLot)*MinimalLot;
   return(value);
}

//+------------------------------------------------------------------+
//| Linear closing of position                                       |
//+------------------------------------------------------------------+
void PartialClosingExe()
{
   int Profit=0; 
   if(OrderType()==OP_BUY) Profit=MathRound((Bid-OrderOpenPrice())/Point);
   if(OrderType()==OP_SELL) Profit=MathRound((OrderOpenPrice()-Ask)/Point);
   if(Profit<=0) return;
   int PipStep=MathFloor(TakeProfit/TPDivide);
   if(PipStep<1) PipStep=1;
   if(PipStep>TakeProfit) PipStep=TakeProfit;
   double LotPercent=1.00/TPDivide;
   if(LotPercent>1.00) LotPercent=1.00;
   if(TPDivide>TakeProfit && TakeProfit>0) LotPercent=1.00/TakeProfit;
   double FirstPosition=LotsRisk(StopLoss);
   double CutLots=FirstPosition*LotPercent*MathFloor(Profit/PipStep);
   CutLots=RoundLots(Symbol(),CutLots);
   if(CutLots<=0) return;
   CutLots=CutLots-(FirstPosition-OrderLots());
   if(CutLots<=0) return;
   if(OrderLots()<CutLots) CutLots=OrderLots();
   if(OrderType()==OP_BUY) 
      OrderClose(OrderTicket(),CutLots,Bid,slippage,White);
   if(OrderType()==OP_SELL) 
      OrderClose(OrderTicket(),CutLots,Ask,slippage,White);
      
   return;
}

void start()  {
  static datetime TradeOpenBar;

   //---- check for history and trading
   if(Bars<100 || IsTradeAllowed()==false) return;

   //---- check for signals
   CheckForSignals(TradeOpenBar);
   
   //---- calculate open orders by current symbol
   if (CalculateCurrentOrders(Symbol())==0)
      TradeOpenBar = CheckForOpen(TradeOpenBar);
   else
      CheckForClose();
      
   BreakEvenStop();
   TrailingStop();
}
//+------------------------------------------------------------------+

change the future, not the past

#5
Jan 21, 2008 1:36am Jan 21, 2008 1:36am

Craig
Joined Feb 2006 | Status: Blah blah blah | 1,410 Posts

Did you try posting on http://forum.mql4.com/ ?

The breaking of a wave cannot explain the whole sea.

#6
Jan 21, 2008 2:12am Jan 21, 2008 2:12am

137
| Joined Jun 2005 | Status: Trader | 280 Posts

Quoting Craig

Disliked

Did you try posting on http://forum.mql4.com/ ?

Ignored

i just did

thanks for your suggestion Craig

change the future, not the past

#7
Last Post: Jan 21, 2008 11:46am Jan 21, 2008 11:46am

Craig
Joined Feb 2006 | Status: Blah blah blah | 1,410 Posts

I see you got your grumpy reply from 'rosh'.
He's a real charmer that one

The breaking of a wave cannot explain the whole sea.

Platform Tech
/
"expert function calls are not allowed" (?)
Reply to Thread

0 traders viewing now

Options

Similar Threads

"expert function calls are not allowed" (?)