First of all, check MQL4 (MQL5) specifications about special functions:
http://docs.mql4.com/basis/functions/special
http://www.mql5.com/en/docs/runtime/running
Let's take MQL4 for example. There are 3 basic special functions: Init(), Start() and DeInit(). The basic structure of MQL4 expert advisor looks like this:
//+------------------------------------------------------------------+
//| MQL4file.mq4 |
//| Copyright © 2011, MetaQuotes Software Corp. |
//| "http://www.metaquotes.net" |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2011, MetaQuotes Software Corp."
#property link "http://www.metaquotes.net"
//+------------------------------------------------------------------+
//| expert initialization function |
//+------------------------------------------------------------------+
int init()
{
//----
//----
return(0);
}
//+------------------------------------------------------------------+
//| expert deinitialization function |
//+------------------------------------------------------------------+
int deinit()
{
//----
//----
return(0);
}
//+------------------------------------------------------------------+
//| expert start function |
//+------------------------------------------------------------------+
int start()
{
//----
//----
return(0);
}
//+------------------------------------------------------------------+
As you can see the three special functions are placed one after another.
Init() is called only once when expert advisor starts, Start() is called at each tick, and DeInit is called only once when you shut down the expert advisor.
In FXDreema each library (block) is represented in output code with it's own function.
Not connected blocks will not appear in output code
First blocks in logic trees will be called first
Logic trees can be as many as you want
Logic trees may be as bigger as you need
One independend logic tree may have more than one first blocks
Let's see some examples. First we'll see what happens with only one logic tree.
http://i41.tinypic.com/1z4fi50.png
This will output something like this
/////////////////////////////////////////////////////////////////////////////
//+-----------------------------------------------------------------------+//
//| EXPERT INITIALIZATION SECTOR |//
//| Runs only once when expert loads |//
//+-----------------------------------------------------------------------+//
/////////////////////////////////////////////////////////////////////////////
int init()
{
return(0);
}
/////////////////////////////////////////////////////////////////////////////
//+-----------------------------------------------------------------------+//
//| EXPERT START SECTOR |//
//| Runs at every new tick (begins with "start()" function) |//
//+-----------------------------------------------------------------------+//
/////////////////////////////////////////////////////////////////////////////
int start()
{
start1(); // The only first block in the only logic tree
return(0);
}
//////////////////////////////////
// Define block 1 (Empty block) //
void start1()
{
start2(); start4();
}
//////////////////////////////////
// Define block 2 (Empty block) //
void start2()
{
start3();
}
//////////////////////////////////
// Define block 3 (Empty block) //
void start3()
{
/* Nothing here */
}
//////////////////////////////////
// Define block 4 (Empty block) //
void start4()
{
/* Nothing here */
}
/////////////////////////////////////////////////////////////////////////////
//+-----------------------------------------------------------------------+//
//| EXPERT DEINITIALIZATION SECTOR |//
//| Runs only once when expert unloads |//
//+-----------------------------------------------------------------------+//
/////////////////////////////////////////////////////////////////////////////
int deinit()
{
return(0);
}
The logic is:
At each tick block 1 is runned
If block 1 passes -> Run block 2 and block 4
If block 2 passes -> Run block 3
Ok, there's two logic trees:
http://i41.tinypic.com/zunnl4.png
And the output code is:
/////////////////////////////////////////////////////////////////////////////
//+-----------------------------------------------------------------------+//
//| EXPERT INITIALIZATION SECTOR |//
//| Runs only once when expert loads |//
//+-----------------------------------------------------------------------+//
/////////////////////////////////////////////////////////////////////////////
int init()
{
return(0);
}
/////////////////////////////////////////////////////////////////////////////
//+-----------------------------------------------------------------------+//
//| EXPERT START SECTOR |//
//| Runs at every new tick (begins with "start()" function) |//
//+-----------------------------------------------------------------------+//
/////////////////////////////////////////////////////////////////////////////
int start()
{
start1(); start5(); // The first blocks in logic trees called one after another
return(0);
}
//////////////////////////////////
// Define block 1 (Empty block) //
void start1()
{
start2(); start4();
}
//////////////////////////////////
// Define block 2 (Empty block) //
void start2()
{
start3();
}
//////////////////////////////////
// Define block 3 (Empty block) //
void start3()
{
/* Nothing here */
}
//////////////////////////////////
// Define block 4 (Empty block) //
void start4()
{
/* Nothing here */
}
//////////////////////////////////
// Define block 5 (Empty block) //
void start5()
{
start6(); start7();
}
//////////////////////////////////
// Define block 6 (Empty block) //
void start6()
{
/* Nothing here */
}
//////////////////////////////////
// Define block 7 (Empty block) //
void start7()
{
start8();
}
//////////////////////////////////
// Define block 8 (Empty block) //
void start8()
{
/* Nothing here */
}
/////////////////////////////////////////////////////////////////////////////
//+-----------------------------------------------------------------------+//
//| EXPERT DEINITIALIZATION SECTOR |//
//| Runs only once when expert unloads |//
//+-----------------------------------------------------------------------+//
/////////////////////////////////////////////////////////////////////////////
int deinit()
{
return(0);
}
The logic is:
At each tick block 1 is runned
If block 1 passes -> Run block 2 and block 4
If block 2 passes -> Run block 3
At each tick block 5 is runned
If block 5 passes -> Run block 6 and block 7
If block 7 passes -> Run block 8
In Init() and DeInit() rules are the same. Only names for functions starts with "init" and deinit".
ID's of blocks are unique in global scope. So you can have only one block with ID #3 for example, no matter if it is in Init(), Start() or DeInit().
