//+------------------------------------------------------------------+ //| App.mqh | //| Copyright 2026, Niquel Mendoza. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2026, Niquel Mendoza." #property link "https://www.mql5.com" #property strict #ifndef MQLARTICLES_INDICATORSCTS_IMP_INTERNLA_APP_MQH #define MQLARTICLES_INDICATORSCTS_IMP_INTERNLA_APP_MQH //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ #include "Def.mqh" //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ class CApp : public CLoggerBase { private: TSN::CJsonParser m_json; //--- //string m_fn_out_pool; string m_fn_src_file_ind; // arhcivo de config de indicaodres (json) //--- /*uchar m_file_pool[]; int m_file_pool_s; int m_file_pool_r;*/ //--- Archivo de indicadores uchar m_file_ind_guard[256]; // Buffer del guard int m_file_ind_guard_s; // Numero de bytes ocupados guard uchar m_file_ind[]; // Buffer del archivo ind int m_file_ind_s; // Tamaño del archivo ind int m_file_ind_r; // Tamaño real (reserva) del archivo ind string m_fn_out_ind; // Name del archivo final de esctritura //--- const ulong m_hash_relative; //--- Procesar json bool ProccesConfig(); bool ProccesIndicators(); //--- Utilidades de archivos bool AssingFileWJson(const string& file); bool SaveFile(const uchar& raw[], int size, const string& file); //--- bool FileProrrogo(TSN::CJsonNode& file, uchar& raw[], int& raw_s, int& raw_r, string& out_path); //--- Utilidades de escritura void FileAddLineWC(const string& line, uchar& raw[], int& raw_s); void FileAddLineWC(const uchar& line[], int line_s, int line_len, uchar& raw[], int& raw_s); void FileAddInclude(const bool relative, uchar& raw[], int& raw_s, const uchar& include[], int inc_start, int inc_len); void AddGuardEnd(uchar& raw[], int& raw_s, const uchar& guard[], int guard_start, int guard_len); void FileAddGuardInit(uchar& raw[], int& raw_s, const uchar& guard[], int guard_start, int guard_len); //--- Utilidad para json int JsonObjStrLen(TSN::CJsonNode& node, const uchar& in[]); public: CApp(void); ~CApp(void) {} //--- bool Run(const string& fn_config); }; //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ CApp::CApp(void) : m_hash_relative(TSN::FNV1a_64("relative", StringLen("relative"))), m_fn_src_file_ind(NULL), //--- m_file_ind_s(0), m_file_ind_r(0), m_fn_out_ind(NULL), m_file_ind_guard_s(0) { } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ bool CApp::AssingFileWJson(const string &file) { //--- HANDLE handle = kernel32::CreateFileW(file, GENERIC_READ, SHARE_READ, 0, OPEN_EXISTING, 0, 0); if(handle == INVALID_HANDLE) { LogError(::StringFormat("Failed to open file = %s, last err = %d", file, kernel32::GetLastError()), FUNCION_ACTUAL); return false; } //--- long size; kernel32::GetFileSizeEx(handle, size); uint read; //--- const int isize = (int)size; m_json.m_len = isize; ::ArrayResize(m_json.m_raw, m_json.m_len); kernel32::ReadFile(handle, m_json.m_raw, (uint)isize, read, 0); kernel32::CloseHandle(handle); //--- m_json.NormalizeUft(); //--- if(!m_json.Parse()) { LogError(::StringFormat("Fallo al parsear json:\nFile: '%s'\n", file), FUNCION_ACTUAL); m_json.ErrorInfo(); return false; } //--- return true; } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ bool CApp::SaveFile(const uchar &raw[], int size, const string &file) { //--- HANDLE handle = kernel32::CreateFileW(file, GENERIC_WRITE, 0, 0, CREATE_ALWAYS, 0, 0); if(handle == INVALID_HANDLE) { LogCriticalError(::StringFormat("Failed to create file:\n'%s'\nLast err in kernel32 = %d", file, kernel32::GetLastError()), FUNCION_ACTUAL); return false; } //--- uint writen = 0; kernel32::WriteFile(handle, raw, sizeof(uchar) * size, writen, NULL); kernel32::CloseHandle(handle); return true; } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ bool CApp::Run(const string& fn_config) { //--- Parseamos la configuracion if(!AssingFileWJson(fn_config)) return false; if(!ProccesConfig()) return false; //--- Parseamos ahora si el archivo de indicadores if(!AssingFileWJson(m_fn_src_file_ind)) return false; //--- if(!ProccesIndicators()) return false; //--- Guardamos el archivo final if(!SaveFile(m_file_ind, m_file_ind_s, m_fn_out_ind)) return false; //--- LogInfo("Se termino", FUNCION_ACTUAL); //--- return true; } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ bool CApp::ProccesConfig(void) { //--- TSN::CJsonNode root = m_json.GetRoot(); //--- if(!root["src_inds_file"].ToStringSafe(m_fn_src_file_ind)) { LogError("Falta el campo 'src_inds_file' que idnica el archivo donde estan los indicadores, o esta malformado", FUNCION_ACTUAL); return false; } //--- if(!FileProrrogo(root["main_file"], m_file_ind, m_file_ind_s, m_file_ind_r, m_fn_out_ind)) return false; /* if(!FileProrrogo(root["pool_file"], m_file_pool, m_file_pool_s, m_file_pool_r, m_fn_out_pool)) return false;*/ //--- return true; } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ bool CApp::FileProrrogo(TSN::CJsonNode& file, uchar& raw[], int& raw_s, int& raw_r, string& out_path) { //--- Reserva inicial SCRIPT_RESERVE_ARR(raw, raw_s, raw_r, 2048) //--- if(!file["path"].ToStringSafe(out_path)) { LogError("No se pudo obtener el campo path", FUNCION_ACTUAL); return false; } //--- const string pure = TSN::CPathUtils::GetPureFileName(out_path); // nombre puro del archivo (sin barras y eso) //--- parte inciial header de comentarios //- primera linea SCRIPT_ADD_ONE_LINE(raw, raw_s) //- File FileAddLineWC(pure, raw, raw_s); //- (autor solo ascci puro) const int autor_start = file["autor"].StrStart(); const int autor_len = file["autor"].StrLenRaw(); if(autor_len == 0 || autor_start == 0) { LogError(::StringFormat("Falta el campo autor en file = '%s'", pure), FUNCION_ACTUAL); return false; } FileAddLineWC(m_json.m_raw, autor_start, autor_len, raw, raw_s); //- (link solo ascci puro) const int link_start = file["link"].StrStart(); const int link_len = file["link"].StrLenRaw(); if(link_len == 0 || link_start == 0) { LogError(::StringFormat("Falta el campo link en file = '%s'", pure), FUNCION_ACTUAL); return false; } FileAddLineWC(m_json.m_raw, link_start, link_len, raw, raw_s); //--- Linea de terminacion SCRIPT_ADD_ONE_LINE(raw, raw_s) //--- Ahora si parrte de props //- copryrgith SCRIPT_ADD_PROP(SCRIPT_PROP_COPYRIGHT, raw, raw_s) raw[raw_s++] = '"'; raw_s += ArrayCopy(raw, m_json.m_raw, raw_s, autor_start, autor_len); raw[raw_s++] = '"'; SCRIPT_ADD_LINETERMINATOR(raw, raw_s) //- link SCRIPT_ADD_PROP(SCRIPT_PROP_LINK, raw, raw_s) raw[raw_s++] = '"'; raw_s += ArrayCopy(raw, m_json.m_raw, raw_s, link_start, link_len); raw[raw_s++] = '"'; SCRIPT_ADD_LINETERMINATOR(raw, raw_s) //- strict SCRIPT_ADD_PROP(SCRIPT_PROP_STRICT, raw, raw_s) SCRIPT_ADD_LINETERMINATOR(raw, raw_s) //--- Espacio separador SCRIPT_ADD_LINETERMINATOR(raw, raw_s) //--- Guards (trunca a 256 el guard) const int guard_start = file["guard"].StrStart(); m_file_ind_guard_s = MathMin(file["guard"].StrLenRaw(), 256); if(guard_start != 0 && m_file_ind_guard_s > 0) { ArrayCopy(m_file_ind_guard, m_json.m_raw, 0, guard_start, m_file_ind_guard_s); // copiamos FileAddGuardInit(raw, raw_s, m_file_ind_guard, 0, m_file_ind_guard_s); // Agregamos el guard SCRIPT_ADD_LINETERMINATOR(raw, raw_s) } //--- SCRIPT_ADD_ONE_BLOCK(raw, raw_s) //--- Includes // volvemos a reservas por si acaso const int t = file["includes"].Size() * 256; SCRIPT_RESERVE_ARR(raw, raw_s, raw_r, t) //--- CJsonIteratorArray it = file["includes"].BeginArr(); while(it.IsValid()) { TSN::CJsonNode include = it.Val(); ulong key_h; if(!include.AtObjKey(0).KeyHashFVN1A64(key_h)) { LogError("Se esperaba una key en el objeto de includes, no se obutvo nada", FUNCION_ACTUAL); return false; } const bool is_rel = key_h == m_hash_relative; int start = 0, len = 0; if(is_rel) // relatvie { TSN::CJsonNode r = include["relative"]; start = r.StrStart(); len = r.StrLenRaw(); } else // <> { TSN::CJsonNode m = include["mql5"]; if(m.IsInvalid()) { LogError("Solo se permite dos tipos para los includes [relative, mql5] nada mas", FUNCION_ACTUAL); return false; } start = m.StrStart(); len = m.StrLenRaw(); } //--- truncamos si hace falta FileAddInclude(is_rel, raw, raw_s, m_json.m_raw, start, MathMin(len, 256)); //--- it.Next(); } //--- SCRIPT_ADD_LINETERMINATOR(raw, raw_s) //--- LogInfo(::StringFormat("Archivo = '%s' procesado correctamente", pure), FUNCION_ACTUAL); //--- return true; // terminamos el prologo } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ void CApp::FileAddLineWC(const string& line, uchar& raw[], int& raw_s) { //--- const int line_pure_size = SCRIPT_LINEW_PURESIZE; // espacio util const int norm_len = MathMin(line_pure_size, StringLen(line)); const int rest_len = line_pure_size - norm_len; // espacio que necesitare int to_copy_linew = 4 + rest_len; // cuanto copiar de linew //--- raw_s += ArrayCopy(raw, g_res_linew, raw_s, 0, to_copy_linew); // ws raw_s += StringToCharArray(line, raw, raw_s, norm_len, CP_UTF8); // ahora si //--- raw[raw_s++] = ' '; raw[raw_s++] = '|'; SCRIPT_ADD_LINETERMINATOR(raw, raw_s) } //+------------------------------------------------------------------+ void CApp::FileAddLineWC(const uchar& line[], int line_s, int line_len, uchar& raw[], int& raw_s) { //--- const int line_pure_size = SCRIPT_LINEW_PURESIZE; // espacio util const int norm_len = MathMin(line_pure_size, line_len); const int rest_len = line_pure_size - norm_len; // espacio que necesitare int to_copy_linew = 4 + rest_len; // cuanto copiar de linew //--- raw_s += ArrayCopy(raw, g_res_linew, raw_s, 0, to_copy_linew); // ws raw_s += ArrayCopy(raw, line, raw_s, line_s, norm_len); // ahora si //--- raw[raw_s++] = ' '; raw[raw_s++] = '|'; SCRIPT_ADD_LINETERMINATOR(raw, raw_s) } //+------------------------------------------------------------------+ void CApp::FileAddGuardInit(uchar& raw[], int& raw_s, const uchar& guard[], int guard_start, int guard_len) { //--- raw[raw_s++] = '#'; raw[raw_s++] = 'i'; raw[raw_s++] = 'f'; raw[raw_s++] = 'n'; raw[raw_s++] = 'd'; raw[raw_s++] = 'e'; raw[raw_s++] = 'f'; raw[raw_s++] = ' '; raw_s += ArrayCopy(raw, guard, raw_s, guard_start, guard_len); SCRIPT_ADD_LINETERMINATOR(raw, raw_s) //--- raw[raw_s++] = '#'; raw[raw_s++] = 'd'; raw[raw_s++] = 'e'; raw[raw_s++] = 'f'; raw[raw_s++] = 'i'; raw[raw_s++] = 'n'; raw[raw_s++] = 'e'; raw[raw_s++] = ' '; raw_s += ArrayCopy(raw, guard, raw_s, guard_start, guard_len); SCRIPT_ADD_LINETERMINATOR(raw, raw_s) } //+------------------------------------------------------------------+ void CApp::AddGuardEnd(uchar& raw[], int& raw_s, const uchar& guard[], int guard_start, int guard_len) { //--- raw[raw_s++] = '#'; raw[raw_s++] = 'e'; raw[raw_s++] = 'n'; raw[raw_s++] = 'd'; raw[raw_s++] = 'i'; raw[raw_s++] = 'f'; raw[raw_s++] = ' '; raw[raw_s++] = '/'; raw[raw_s++] = '/'; //--- raw_s += ArrayCopy(raw, guard, raw_s, guard_start, guard_len); SCRIPT_ADD_LINETERMINATOR(raw, raw_s) } //+------------------------------------------------------------------+ void CApp::FileAddInclude(const bool relative, uchar& raw[], int& raw_s, const uchar& include[], int inc_start, int inc_len) { //--- raw[raw_s++] = '#'; raw[raw_s++] = 'i'; raw[raw_s++] = 'n'; raw[raw_s++] = 'c'; raw[raw_s++] = 'l'; raw[raw_s++] = 'u'; raw[raw_s++] = 'd'; raw[raw_s++] = 'e'; raw[raw_s++] = ' '; //--- raw[raw_s++] = relative ? '"' : '<'; //--- raw_s += ArrayCopy(raw, include, raw_s, inc_start, inc_len); //--- raw[raw_s++] = relative ? '"' : '>'; //--- SCRIPT_ADD_LINETERMINATOR(raw, raw_s) } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ int CApp::JsonObjStrLen(TSN::CJsonNode& node, const uchar& in[]) { //--- if(node.Size() < 1) return 16; // Default size //--- const int li = node.AtObjKey(0).StrStart() - 2; // Start de string int read_i = li; uchar c; //--- int stack = 1; //--- while(true) { //--- Saltamos los ws while((c = in[++read_i]) < 33) {} //--- Salimos if(c == '}') break; //--- Verificamos si es string if(c != '"') continue; //--- while((c = in[++read_i]) != '"') { if(c == '\\') // backslsaw saltamos read_i++; } } //--- retornamos return (read_i - li) + 32; } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ bool CApp::ProccesIndicators(void) { //--- TSN::CJsonNode indicators = m_json.GetRoot()["indicators"]; if(indicators.IsInvalid()) { LogError("No se encontro indicators en el root", FUNCION_ACTUAL); return false; } //--- int expected_len = 0; //--- Caluclo del len CJsonIteratorArray it = indicators.BeginArr(); while(it.IsValid()) { // 32 lineas de 256 carcteras mas el len del subnodo.. (contnado todos los chars) * 3 + 128 TSN::CJsonNode params = it.Val()["parameters"]; if(params.IsInvalid()) { LogError(::StringFormat("Campo parametres no esta presente.. en pos = %d", it.m_cur), FUNCION_ACTUAL); return false; } expected_len += (256 * 8) + (JsonObjStrLen(params, m_json.m_raw) * 3) + 128; it.Next(); } //--- SCRIPT_RESERVE_ARR(m_file_ind, m_file_ind_s, m_file_ind_r, expected_len) //SCRIPT_RESERVE_ARR(m_file_pool, m_file_pool_s, m_file_pool_r, expected_len) //--- Ahora si iteramos de verdad it = indicators.BeginArr(); int curr_el = 0; while(it.IsValid()) { //--- Defoines de ayuda #define SCRIPT_APPEND_CLASSNAME m_file_ind_s += ArrayCopy(m_file_ind, m_json.m_raw, m_file_ind_s, class_name.StrStart(), class_name.StrLenRaw()); #define SCRIPT_APPEND_PADRE m_file_ind_s += ArrayCopy(m_file_ind, m_file_ind, m_file_ind_s, class_padre_start, class_padre_len); //--- TSN::CJsonNode ind = it.Val(); //--- bloque inciia SCRIPT_ADD_ONE_BLOCK(m_file_ind, m_file_ind_s) //--- class m_file_ind[m_file_ind_s++] = 'c'; m_file_ind[m_file_ind_s++] = 'l'; m_file_ind[m_file_ind_s++] = 'a'; m_file_ind[m_file_ind_s++] = 's'; m_file_ind[m_file_ind_s++] = 's'; m_file_ind[m_file_ind_s++] = ' '; //--- TSN::CJsonNode class_name = ind["class_name"]; if(class_name.IsInvalid()) { LogError(::StringFormat("No se encontro el campo class name en indicators[%d]", curr_el), FUNCION_ACTUAL); return false; } //--- SCRIPT_APPEND_CLASSNAME //--- const ulong num_buffers = ind["num_buffers"].ToUInt(0); if(num_buffers == 0) { LogError(::StringFormat("indicators[%d], Clase = %s, proporicono un numero de buffers menor a 1", curr_el, class_name.ToString("")), FUNCION_ACTUAL); return false; } //--- m_file_ind_s += ArrayCopy(m_file_ind, g_res_class_start, m_file_ind_s, 0); // public: padre //--- Name CiIndicatorSimple const int class_padre_start = m_file_ind_s; m_file_ind_s += ArrayCopy(m_file_ind, g_res_class_p, m_file_ind_s, 0); // nombre // ahora el buffer y cirrea STRCONV_VALTOBUFFER_USIGNED(num_buffers, m_file_ind, m_file_ind_s) m_file_ind[m_file_ind_s++] = ')'; m_file_ind[m_file_ind_s++] = '>'; const int class_padre_len = m_file_ind_s - class_padre_start; //--- termiansmo la linea de class SCRIPT_ADD_LINETERMINATOR(m_file_ind, m_file_ind_s) //--- SCRIPT_CTX(m_file_ind, m_file_ind_s, '{') //--- public:\r\n m_file_ind_s += ArrayCopy(m_file_ind, g_res_class_start, m_file_ind_s, RES_CLASS_START_OFF_PUBLIC, RES_CLASS_START_L_PUBLIC); m_file_ind[m_file_ind_s++] = ':'; SCRIPT_ADD_LINETERMINATOR(m_file_ind, m_file_ind_s) //--- espacios para el contructor Class() : m_file_ind_s += ArrayCopy(m_file_ind, g_res_contructor_start, m_file_ind_s, 0); SCRIPT_APPEND_CLASSNAME m_file_ind[m_file_ind_s++] = '('; m_file_ind[m_file_ind_s++] = ')'; m_file_ind[m_file_ind_s++] = ' '; m_file_ind[m_file_ind_s++] = ':'; //--- CiIndicatorSimple() SCRIPT_APPEND_PADRE m_file_ind[m_file_ind_s++] = '('; //--- Valor del contructor TSN::CJsonNode type = ind["type"]; int ts, tl; if((tl = type.StrLenRaw()) > 0 && m_json.m_raw[(ts = type.StrStart())] == '$') { ts++; // aumenta tl--; // reduce el len m_file_ind_s += ArrayCopy(m_file_ind, m_json.m_raw, m_file_ind_s, ts, tl); } else { // solo numero enteoro no negaitvo asi que uint const ulong type_n = type.ToUInt(ULONG_MAX); if(type_n == ULONG_MAX) { LogError(::StringFormat("indicators[%d]: no se encontro el campo 'type' o el tipo debe de ser string (enum y emepzar con $)o un numero unsigned valido", curr_el), FUNCION_ACTUAL); return false; } STRCONV_VALTOBUFFER_USIGNED(type_n, m_file_ind, m_file_ind_s) } //--- finalziamos la linea del contrutro m_file_ind_s += ArrayCopy(m_file_ind, g_res_fina_b, m_file_ind_s, 0); //--- Ahora destructor m_file_ind_s += ArrayCopy(m_file_ind, g_res_contructor_start, m_file_ind_s, 0); m_file_ind[m_file_ind_s++] = '~'; SCRIPT_APPEND_CLASSNAME m_file_ind[m_file_ind_s++] = '('; m_file_ind_s += ArrayCopy(m_file_ind, g_res_fina_b, m_file_ind_s, 0); //--- Funcion create (Firma) m_file_ind_s += ArrayCopy(m_file_ind, g_res_create_func, m_file_ind_s, 0); // Continuamos con la firma m_file_ind_s += ArrayCopy(m_file_ind, g_res_initial_firm, m_file_ind_s, 0); //--- TSN::CJsonNode parameters = ind["parameters"]; CJsonIteratorObj it_params = parameters.BeginObj(); while(it_params.IsValid()) { //--- TSN::CJsonNode val = it_params.Val(); TSN::CJsonNode key = it_params.Key(); //--- m_file_ind[m_file_ind_s++] = ','; m_file_ind[m_file_ind_s++] = ' '; //--- if(val.GetType() != TSN::JSON_VTYPE_STRING) { LogError(::StringFormat("indiator[%d][parameter=%s] = Solo se permite strings como valores", curr_el, it_params.Key().KeyToString()), FUNCION_ACTUAL); return false; } //--- tipo name m_file_ind_s += ArrayCopy(m_file_ind, m_json.m_raw, m_file_ind_s, val.StrStart(), val.StrLenRaw()); m_file_ind[m_file_ind_s++] = ' '; m_file_ind_s += ArrayCopy(m_file_ind, m_json.m_raw, m_file_ind_s, key.StrStart(), key.KeyLenRaw()); //--- it_params.Next(); } //--- Finalizamos m_file_ind[m_file_ind_s++] = ')'; SCRIPT_ADD_LINETERMINATOR(m_file_ind, m_file_ind_s) // apertura del body SCRIPT_CTX(m_file_ind, m_file_ind_s, '{') m_file_ind_s += ArrayCopy(m_file_ind, g_res_hide_s, m_file_ind_s, 0); // Hide start m_file_ind_s += ArrayCopy(m_file_ind, g_res_h_assing, m_file_ind_s, 0); // const int h = :: // Ahora si el handle y parametros //--- TSN::CJsonNode creator = ind["creator"]; if(creator.GetType() != TSN::JSON_VTYPE_STRING) { LogError(::StringFormat("indicator[%d][%s]: no se encontro el campo creator o este no es del tipo de string", curr_el, class_name.ToString()), FUNCION_ACTUAL); return false; } //--- m_file_ind_s += ArrayCopy(m_file_ind, m_json.m_raw, m_file_ind_s, creator.StrStart(), creator.StrLenRaw()); // const int h = :: m_file_ind_s += ArrayCopy(m_file_ind, g_res_create_h_ini, m_file_ind_s, 0); //--- parametros it_params = parameters.BeginObj(); while(it_params.IsValid()) { TSN::CJsonNode key = it_params.Key(); m_file_ind_s += ArrayCopy(m_file_ind, m_json.m_raw, m_file_ind_s, key.StrStart(), key.KeyLenRaw()); m_file_ind[m_file_ind_s++] = ','; m_file_ind[m_file_ind_s++] = ' '; it_params.Next(); } //--- if(parameters.Size()) m_file_ind_s -= 2; // pop los finales //--- m_file_ind[m_file_ind_s++] = ')'; m_file_ind[m_file_ind_s++] = ';'; SCRIPT_ADD_LINETERMINATOR(m_file_ind, m_file_ind_s) //--- m_file_ind_s += ArrayCopy(m_file_ind, g_res_body_ee, m_file_ind_s, 0); // Hide END //--- Return: m_file_ind_s += ArrayCopy(m_file_ind, g_res_return, m_file_ind_s, 0); // return SCRIPT_APPEND_PADRE m_file_ind_s += ArrayCopy(m_file_ind, g_res_ret_i_final, m_file_ind_s, 0); // return //--- SCRIPT_CTX_WCLOSE(m_file_ind, m_file_ind_s) // cuerpo de clase //--- it.Next(); curr_el++; } //--- #undef SCRIPT_APPEND_CLASSNAME #undef SCRIPT_APPEND_PADRE //--- if(m_file_ind_guard_s) AddGuardEnd(m_file_ind, m_file_ind_s, m_file_ind_guard, 0, m_file_ind_guard_s); //--- return true; } #endif // MQLARTICLES_INDICATORSCTS_IMP_INTERNLA_APP_MQH