578 líneas
Sin EOL
13 KiB
Markdown
578 líneas
Sin EOL
13 KiB
Markdown
Recommended Project Knowledge Structure
|
|
0.66 KB •13 lines
|
|
•
|
|
Formatting may be inconsistent from source
|
|
Project Knowledge/
|
|
├── MQL5_Compliance/
|
|
│ ├── STRICT_RULES.md (Critical syntax rules)
|
|
│ ├── COMMON_FIXES.md (Error fix patterns)
|
|
│ ├── MODULE_TEMPLATE.mqh (Standard module structure)
|
|
│ └── TEST_TEMPLATE.mq5 (Module test template)
|
|
├── Development/
|
|
│ ├── CODING_STANDARDS.md (Naming conventions)
|
|
│ ├── DEPENDENCY_GRAPH.md (Module dependencies)
|
|
│ └── BUILD_CHECKLIST.md (Pre-release checks)
|
|
└── Troubleshooting/
|
|
├── COMPILATION_ERRORS.md (Common errors and fixes)
|
|
└── MIGRATION_GUIDE.md (Structure update guide)
|
|
|
|
|
|
Critical Syntax Requirement
|
|
0.90 KB •23 lines
|
|
•
|
|
Formatting may be inconsistent from source
|
|
## MQL5 CRITICAL SYNTAX REQUIREMENTS
|
|
|
|
### MANDATORY RULES:
|
|
1. NEVER use pointer syntax (`->`) - ALWAYS use dot operator (`.`)
|
|
2. When using pointers to objects, declare with `*` but access with `.`
|
|
3. Cannot use reference (`&`) for local simple type variables
|
|
4. Must work directly with array elements: `array[i].member = value`
|
|
5. All enums MUST be defined BEFORE structures that use them
|
|
|
|
### COMMON ERROR FIXES:
|
|
- Replace ALL `m_utils->` with `m_utils.`
|
|
- Replace ALL `m_tech->` with `m_tech.`
|
|
- Replace ALL `m_risk->` with `m_risk.`
|
|
- Change pointer member access from `ptr->member` to `ptr.member`
|
|
|
|
### MODULE STRUCTURE:
|
|
- DataTypes module: NO dependencies (base module)
|
|
- All structures defined in DataTypes
|
|
- All enums defined BEFORE structures
|
|
- Include order: System → Library → DataTypes → Utils → Components
|
|
|
|
### TESTING REQUIREMENT:
|
|
Every module must compile independently with zero errors and warnings
|
|
|
|
|
|
Compliance check script
|
|
0.43 KB •17 lines
|
|
•
|
|
Formatting may be inconsistent from source
|
|
#!/bin/bash
|
|
# MQL5 Compliance Quick Check
|
|
echo "Checking for non-compliant syntax..."
|
|
|
|
# Check for pointer syntax
|
|
if grep -n "\->" *.mqh *.mq5 2>/dev/null; then
|
|
echo "❌ Found pointer syntax (->)"
|
|
else
|
|
echo "✅ No pointer syntax found"
|
|
fi
|
|
|
|
# Check for correct includes
|
|
if grep -l "DataTypes_PME.mqh" *.mqh *.mq5 2>/dev/null; then
|
|
echo "⚠️ Check if should use DataTypes_PME_Fixed.mqh"
|
|
fi
|
|
|
|
echo "Compliance check complete"
|
|
|
|
|
|
MQL coding guidelines for EA development
|
|
10.58 KB •503 lines
|
|
•
|
|
Formatting may be inconsistent from source
|
|
# MQL5 Strict Compliance Guidelines for EA Development
|
|
|
|
## 1. FUNDAMENTAL MQL5 SYNTAX RULES
|
|
|
|
### 1.1 NO Pointer Syntax
|
|
|
|
❌ **NEVER USE:**
|
|
|
|
```cpp
|
|
CObject* obj;
|
|
obj->Method(); // WRONG - pointer syntax not supported
|
|
```
|
|
|
|
✅ **ALWAYS USE:**
|
|
|
|
```cpp
|
|
CObject* obj; // Declaration with * is OK
|
|
obj.Method(); // Use dot operator for access
|
|
```
|
|
|
|
### 1.2 NO Reference Parameters for Local Variables
|
|
|
|
❌ **NEVER USE:**
|
|
|
|
```cpp
|
|
void Function(int &value) { } // Reference parameters only for arrays/objects
|
|
int local = 5;
|
|
Function(local); // WRONG for simple types
|
|
```
|
|
|
|
✅ **ALWAYS USE:**
|
|
|
|
```cpp
|
|
void Function(int value) { } // Pass by value for simple types
|
|
void ArrayFunc(int &arr[]) { } // References OK for arrays
|
|
```
|
|
|
|
### 1.3 Array Element Direct Access
|
|
|
|
❌ **NEVER USE:**
|
|
|
|
```cpp
|
|
ManagedPosition* pos = &m_positions[i];
|
|
pos->member = value; // WRONG - no pointer operations
|
|
```
|
|
|
|
✅ **ALWAYS USE:**
|
|
|
|
```cpp
|
|
m_positions[i].member = value; // Direct array element access
|
|
// Or work with index:
|
|
int index = FindPosition(ticket);
|
|
m_positions[index].member = value;
|
|
```
|
|
|
|
## 2. STRUCTURE AND CLASS DEFINITIONS
|
|
|
|
### 2.1 Structure Member Naming
|
|
|
|
- Use consistent, descriptive names
|
|
- Avoid abbreviations that might change (e.g., use `magic` not `magic_number` if shorter is standard)
|
|
- Document any name changes in migration notes
|
|
|
|
### 2.2 Enum Definitions
|
|
|
|
```cpp
|
|
// ALWAYS define enums BEFORE structures that use them
|
|
enum ENUM_EXIT_REASON
|
|
{
|
|
EXIT_NONE = 0,
|
|
EXIT_STOP_LOSS = 1,
|
|
// ... more values
|
|
};
|
|
|
|
// THEN define structures
|
|
struct ManagedPosition
|
|
{
|
|
ENUM_EXIT_REASON exit_signal; // Can now use the enum
|
|
};
|
|
```
|
|
|
|
### 2.3 Structure Evolution
|
|
|
|
When modifying structures:
|
|
|
|
1. ADD new fields at the end
|
|
1. NEVER remove fields in production code
|
|
1. DOCUMENT deprecated fields
|
|
1. Use ZeroMemory() for initialization
|
|
|
|
## 3. MODULE ORGANIZATION
|
|
|
|
### 3.1 Include File Order
|
|
|
|
```cpp
|
|
// CORRECT ORDER:
|
|
#include <Object.mqh> // 1. System includes first
|
|
#include <Trade/Trade.mqh> // 2. MQL5 standard library
|
|
#include "DataTypes_PME.mqh" // 3. Project data types
|
|
#include "Utilities_PME.mqh" // 4. Utilities
|
|
#include "RiskManager_PME.mqh" // 5. Dependent modules
|
|
#include "TechnicalAnalysis_PME.mqh" // 6. Technical modules
|
|
#include "PositionManager_PME.mqh" // 7. Main logic modules
|
|
```
|
|
|
|
### 3.2 Module Dependencies
|
|
|
|
- DataTypes module should have NO dependencies (except system includes)
|
|
- Utilities should only depend on DataTypes
|
|
- Higher-level modules can depend on lower-level ones
|
|
- AVOID circular dependencies
|
|
|
|
### 3.3 Header Guards
|
|
|
|
```cpp
|
|
#ifndef MODULE_NAME_MQH
|
|
#define MODULE_NAME_MQH
|
|
// ... module content
|
|
#endif // MODULE_NAME_MQH
|
|
```
|
|
|
|
## 4. OBJECT AND MEMORY MANAGEMENT
|
|
|
|
### 4.1 Object Creation and Deletion
|
|
|
|
```cpp
|
|
// ALWAYS check allocation
|
|
CObject* obj = new CObject();
|
|
if(obj == NULL)
|
|
{
|
|
Print("ERROR: Failed to create object");
|
|
return false;
|
|
}
|
|
|
|
// ALWAYS delete in destructor or cleanup
|
|
if(obj != NULL)
|
|
{
|
|
delete obj;
|
|
obj = NULL; // Set to NULL after deletion
|
|
}
|
|
```
|
|
|
|
### 4.2 Array Management
|
|
|
|
```cpp
|
|
// Dynamic arrays
|
|
ArrayResize(m_array, new_size);
|
|
ArrayFree(m_array); // In destructor
|
|
|
|
// Check bounds
|
|
if(index >= 0 && index < ArraySize(m_array))
|
|
{
|
|
m_array[index].member = value;
|
|
}
|
|
```
|
|
|
|
## 5. COMMON PITFALLS AND SOLUTIONS
|
|
|
|
### 5.1 Enum Value Changes
|
|
|
|
```cpp
|
|
// PROBLEM: Enum values might not exist
|
|
case TRAIL_FIXED: // Might not be defined
|
|
|
|
// SOLUTION: Use defines for compatibility
|
|
#define TRAIL_FIXED TRAIL_FIXED_POINTS
|
|
```
|
|
|
|
### 5.2 Method Return Types
|
|
|
|
```cpp
|
|
// PROBLEM: Incorrect return type
|
|
ENUM_SIGNAL_TYPE CheckExitSignal(); // Returns wrong enum
|
|
|
|
// SOLUTION: Ensure return types match usage
|
|
ENUM_EXIT_REASON CheckExitSignal(); // Correct enum type
|
|
```
|
|
|
|
### 5.3 Null Pointer Checks
|
|
|
|
```cpp
|
|
// ALWAYS check before use
|
|
if(m_utils != NULL)
|
|
m_utils.Log("message", LOG_INFO);
|
|
```
|
|
|
|
## 6. COMPILATION AND TESTING
|
|
|
|
### 6.1 Compilation Checks
|
|
|
|
Before release, ensure:
|
|
|
|
- [ ] ZERO warnings with strict compilation
|
|
- [ ] All includes use correct paths
|
|
- [ ] No undefined identifiers
|
|
- [ ] All enums defined before use
|
|
- [ ] All structure members exist
|
|
|
|
### 6.2 Test Module Pattern
|
|
|
|
```cpp
|
|
// Create standalone test for each module
|
|
void TestModule()
|
|
{
|
|
CModule* module = new CModule();
|
|
if(module == NULL)
|
|
{
|
|
Print("FAILED: Module creation");
|
|
return;
|
|
}
|
|
|
|
if(!module.Initialize())
|
|
{
|
|
Print("FAILED: Module initialization");
|
|
delete module;
|
|
return;
|
|
}
|
|
|
|
// Test specific functionality
|
|
|
|
delete module;
|
|
Print("Module test PASSED");
|
|
}
|
|
```
|
|
|
|
## 7. STRING AND TYPE HANDLING
|
|
|
|
### 7.1 String Operations
|
|
|
|
```cpp
|
|
// Use StringFormat for complex strings
|
|
string message = StringFormat("Value: %d, Price: %.5f", value, price);
|
|
|
|
// String concatenation
|
|
string full = str1 + " " + str2; // OK in MQL5
|
|
```
|
|
|
|
### 7.2 Type Casting
|
|
|
|
```cpp
|
|
// Explicit casting when needed
|
|
int magic = (int)PositionGetInteger(POSITION_MAGIC);
|
|
datetime time = (datetime)PositionGetInteger(POSITION_TIME);
|
|
ENUM_ORDER_TYPE type = (ENUM_ORDER_TYPE)PositionGetInteger(POSITION_TYPE);
|
|
```
|
|
|
|
## 8. ERROR HANDLING
|
|
|
|
### 8.1 Function Return Checks
|
|
|
|
```cpp
|
|
if(!FunctionCall())
|
|
{
|
|
int error = GetLastError();
|
|
Print(StringFormat("Error %d: %s", error, ErrorDescription(error)));
|
|
return false;
|
|
}
|
|
```
|
|
|
|
### 8.2 Trade Operation Checks
|
|
|
|
```cpp
|
|
CTrade trade;
|
|
if(!trade.PositionClose(ticket))
|
|
{
|
|
Print("Failed to close position: ", trade.ResultRetcodeDescription());
|
|
return false;
|
|
}
|
|
```
|
|
|
|
## 9. NAMING CONVENTIONS
|
|
|
|
### 9.1 Class Members
|
|
|
|
```cpp
|
|
class CMyClass
|
|
{
|
|
private:
|
|
int m_member; // m_ prefix for members
|
|
static int s_static; // s_ prefix for static
|
|
|
|
public:
|
|
void Method(); // PascalCase for methods
|
|
int GetValue(); // Get/Set for properties
|
|
};
|
|
```
|
|
|
|
### 9.2 Global Variables
|
|
|
|
```cpp
|
|
CManager* g_manager = NULL; // g_ prefix for globals
|
|
int g_counter = 0;
|
|
```
|
|
|
|
### 9.3 Constants and Enums
|
|
|
|
```cpp
|
|
#define MAX_POSITIONS 100 // UPPER_CASE for defines
|
|
enum ENUM_MY_TYPE // ENUM_ prefix
|
|
{
|
|
TYPE_NONE = 0, // UPPER_CASE with underscores
|
|
TYPE_ACTIVE = 1
|
|
};
|
|
```
|
|
|
|
## 10. MODULAR DEVELOPMENT BEST PRACTICES
|
|
|
|
### 10.1 Module Structure Template
|
|
|
|
```cpp
|
|
//+------------------------------------------------------------------+
|
|
//| ModuleName.mqh |
|
|
//| Brief Description |
|
|
//+------------------------------------------------------------------+
|
|
#ifndef MODULE_NAME_MQH
|
|
#define MODULE_NAME_MQH
|
|
|
|
#include "Dependencies.mqh"
|
|
|
|
class CModuleName : public CObject
|
|
{
|
|
private:
|
|
// Private members
|
|
|
|
public:
|
|
CModuleName();
|
|
~CModuleName();
|
|
|
|
bool Initialize(/* parameters */);
|
|
void Deinitialize();
|
|
|
|
// Public methods
|
|
};
|
|
|
|
// Implementation
|
|
CModuleName::CModuleName()
|
|
{
|
|
// Initialize members
|
|
}
|
|
|
|
CModuleName::~CModuleName()
|
|
{
|
|
Deinitialize();
|
|
}
|
|
|
|
bool CModuleName::Initialize(/* parameters */)
|
|
{
|
|
// Initialization logic
|
|
return true;
|
|
}
|
|
|
|
void CModuleName::Deinitialize()
|
|
{
|
|
// Cleanup
|
|
}
|
|
|
|
#endif // MODULE_NAME_MQH
|
|
```
|
|
|
|
### 10.2 Module Testing Template
|
|
|
|
```cpp
|
|
//+------------------------------------------------------------------+
|
|
//| Test_ModuleName.mq5 |
|
|
//+------------------------------------------------------------------+
|
|
#include "ModuleName.mqh"
|
|
|
|
void OnStart()
|
|
{
|
|
Print("Testing ModuleName...");
|
|
|
|
CModuleName* module = new CModuleName();
|
|
if(module == NULL)
|
|
{
|
|
Print("FAILED: Creation");
|
|
return;
|
|
}
|
|
|
|
if(!module.Initialize())
|
|
{
|
|
Print("FAILED: Initialization");
|
|
delete module;
|
|
return;
|
|
}
|
|
|
|
// Specific tests
|
|
|
|
delete module;
|
|
Print("SUCCESS: All tests passed");
|
|
}
|
|
```
|
|
|
|
## 11. VERSION CONTROL AND DOCUMENTATION
|
|
|
|
### 11.1 Version Headers
|
|
|
|
```cpp
|
|
//+------------------------------------------------------------------+
|
|
//| ModuleName v1.0.0 |
|
|
//| [FIXED VERSION - MQL5 Compliant] |
|
|
//| Last Updated: 2024-01-01 |
|
|
//+------------------------------------------------------------------+
|
|
```
|
|
|
|
### 11.2 Change Documentation
|
|
|
|
```cpp
|
|
// CHANGELOG:
|
|
// v1.0.1 - Fixed pointer syntax for MQL5 compliance
|
|
// v1.0.0 - Initial release
|
|
```
|
|
|
|
### 11.3 Deprecation Notices
|
|
|
|
```cpp
|
|
// DEPRECATED: Use NewMethod() instead
|
|
// Will be removed in v2.0.0
|
|
void OldMethod() { NewMethod(); }
|
|
```
|
|
|
|
## 12. CRITICAL REMINDERS
|
|
|
|
### Always Remember:
|
|
|
|
1. **NO pointer operators** (`->`) - use dot notation (`.`)
|
|
1. **Check NULL** before using any object pointer
|
|
1. **Initialize structures** with ZeroMemory()
|
|
1. **Free resources** in destructors
|
|
1. **Check array bounds** before access
|
|
1. **Define enums** before use in structures
|
|
1. **Include files** in correct order
|
|
1. **Test each module** independently
|
|
1. **Document all changes** in headers
|
|
1. **Compile with strict** mode enabled
|
|
|
|
### Common Error Fixes:
|
|
|
|
- “undeclared identifier” → Check if defined in includes
|
|
- “cannot convert enum” → Check enum type matches
|
|
- “object pointer expected” → Change `->` to `.`
|
|
- “some operator expected” → Check syntax and types
|
|
- “operand expected” → Check expression syntax
|
|
|
|
## 13. BUILD AND DEPLOYMENT CHECKLIST
|
|
|
|
### Pre-Compilation:
|
|
|
|
- [ ] All modules include correct dependencies
|
|
- [ ] No circular dependencies
|
|
- [ ] All enums defined before use
|
|
- [ ] All structure members properly typed
|
|
- [ ] No pointer syntax (`->`) used
|
|
|
|
### Post-Compilation:
|
|
|
|
- [ ] Zero errors
|
|
- [ ] Zero warnings
|
|
- [ ] All modules tested individually
|
|
- [ ] Integration tests pass
|
|
- [ ] Memory leaks checked
|
|
- [ ] Performance benchmarked
|
|
|
|
### Deployment:
|
|
|
|
- [ ] Version number updated
|
|
- [ ] Changelog updated
|
|
- [ ] Backup created
|
|
- [ ] Test on demo account
|
|
- [ ] Document any breaking changes
|
|
|
|
-----
|
|
|
|
## Quick Reference Card
|
|
|
|
### ❌ AVOID
|
|
|
|
- `obj->Method()` - pointer syntax
|
|
- `int &local` - local variable references
|
|
- Undefined enums in structures
|
|
- Circular dependencies
|
|
- Memory leaks
|
|
|
|
### ✅ ALWAYS
|
|
|
|
- `obj.Method()` - dot notation
|
|
- Check NULL pointers
|
|
- Initialize with ZeroMemory()
|
|
- Delete objects in cleanup
|
|
- Define enums first
|
|
- Test each module
|
|
|
|
### 🔧 FIX PATTERNS
|
|
|
|
|Error |Solution |
|
|
|-----------------------|---------------------------|
|
|
|`->` |Change to `.` |
|
|
|undeclared identifier |Add to DataTypes or include|
|
|
|cannot convert enum |Check/fix enum type |
|
|
|object pointer expected|Remove `->`, use `.` |
|
|
|
|
-----
|
|
|
|
*This document should be included in project knowledge and referenced during all MQL5 EA development.* |