the * and the prefixes "P", "LP", "PC", "LPC" are managed by WinApiOverride. That means your "MSG.txt" file will be automatically loaded for "MSG", "MSG*", "PMSG", "LPMSG", "PCMSG", "LPCMSG"

You don't have to touch your api monitoring file : when your monitoring file is parsed, WinApiOverride will automatically search the associated type file

Specific cases : As file name can't have ":", "<" or ">" symbols, user type file name must follow the following replacement rules - for "Class::Type" type, a "Class..Type.txt" file will be searched ( ":" replaced by ".") - for "TemplateType<MyType>", "TemplateType(MyType).txt" file will be searched ( "<" replaced by "(" and ">" by ")") Notice : You still can let "Class::Type" or "TemplateType<MyType>" type in your monitoring file, the translation is done by WinApiOverride. Only text file name needs to be affected

Using the module name as subdirectory is better to avoid confusion. Example : two modules using the same struct name for different struct content. So you should put in the "UserTypes" folder only types shared by different modules.

typedef struct tagMSG {
    HWND        hwnd;
    UINT        message;
    WPARAM      wParam;
    LPARAM       lParam;
    DWORD        time;
    POINT       pt;
}MSG,*PMSG,*NPMSG,*LPMSG; 

typedef union 
{
    DWORD u1;
    BYTE  u2; 
    BYTE  u3; 
}UNION_1;
 
typedef struct
{
    UNION_1 u;
    DWORD* pdw;
    BYTE  bArray[5]; 
    char* str;
    DWORD dwArray[2][2];
    DWORD dw;
}STRUCT_1;
typedef STRUCT_1* PSTRUCT_1;
 
enum enum1
{
    FOO_1 = 0x123,
    FOO_2,
    FOO_3 = 2*FOO_1
};
enum enum2
{
    FOO_21 = 0x123,
    FOO_22,
    FOO_23 = 0x456
};
 
typedef struct
{
    STRUCT_1 S[2];
    DWORD dw1, dw2; 
    /* some comment
    *
    */
    union _u
    {
        DWORD LSB:1,
              b2:1,
              b3:1,
              b4:1,
              unused:27,
              MSB:1;
        DWORD RawValue;
        // 0x8000000A = 1000 0000 0000 0000 0000 0000 0000 1010
    }U;
    DWORD dw4;
 
 
    struct Date {
        DWORD nWeekDay  : 3;    // 0..7   (3 bits)
        DWORD nMonthDay : 6;    // 0..31  (6 bits)
        DWORD           : 0;    // Force alignment to next boundary.
        DWORD nMonth    : 5;    // 0..12  (5 bits)
        DWORD nYear     : 8;    // 0..100 (8 bits)
        DWORD Foo       : 30; // just to force another DWORD
    }d;
 
    enum1 e1[2];
    enum2 e2;
}STRUCT_2,*PSTRUCT_2; 

    #pragma pack(push)
    #pragma pack(1)  
    typedef struct
    {
        BYTE b;
        WORD w;
        DWORD dw;
    }STRUCT1;
    #pragma pack(pop)

        struct __tagVARIANT
        {
            #pragma next_field_define_values_file("VARTYPE_Defines.txt")
            VARTYPE vt;
            WORD wReserved1;
            WORD wReserved2;
            WORD wReserved3;
            ...
        }
    

        #pragma next_enum_size(1)
        typedef enum
        {
            E1_value0=0,
            E1_value1,
            E1_value2,
        }ENUM1;
    
        #pragma next_enum_size(2)
        typedef enum
        {
            E2_value0=0,
            E2_value1,
            E2_value2,
        }ENUM2; 
    

        typedef struct
        {
            WORD w;
            DWORD dw;
            STRUCT2 Struct2; // in this case, Struct2 will be parsed as a big endian struct
        }STRUCT1;    
    

        #pragma next_struct_endianness(big_endian,true)
        typedef struct
        {
            WORD w;
            DWORD dw;
            STRUCT2 Struct2; // in this case, Struct2 will be parsed as a big endian struct
        }STRUCT1;
        All the fields and nested structs of the previous struct will be parsed as big endian
    
        #pragma next_struct_endianness(big_endian,false)
        typedef struct
        {
            WORD w;
            DWORD dw;
            STRUCT2 Struct2; // in this case, Struct2 will be parsed as a little endian struct, 
                             // even if all other fields are parsed as big endian fields
        }STRUCT3; 
    

        typedef struct
        {
            WORD w;
            
            #pragma next_field_must_match(2)
            DWORD dw;
            
            STRUCT2 Struct2;
        }STRUCT1;
    

        typedef struct
        {
            ...
            #pragma next_field_must_match(2)
            DWORD dw;       
            
            #pragma next_field_must_match("Some String")
            LPCSTR String;
            
            #pragma next_field_must_match("Some String")
            LPWCSTR wString;
            ...
        };  
    

        typedef struct
        {
            ...
            #pragma next_field_must_match_one_of(1,8,64,128,256,512,1024,2048)
            DWORD dw;
            
            #pragma next_field_must_match_one_of("AnsiString1","AnsiString2","AnsiString3")
            CHAR String[256];
    
            #pragma next_field_must_match_one_of("UnicodeString1","UnicodeString2","UnicodeString3")
            WCHAR wString[256];
            ...
        };  
    

        typedef struct
        {
            ...
            #pragma next_field_must_be_less_or_equal(80)
            DWORD dw;
            
            #pragma next_field_must_be_less_or_equal(0x28)
            DWORD dw2;           
            ...
        };
    

        typedef struct
        {
            ...
            #pragma next_field_must_be_greater_or_equal(3)
            DWORD dw;
            
            #pragma next_field_must_be_greater_or_equal(0x28)
            DWORD dw2;        
            ...
        };
    

        typedef struct
        {
            ...
            #pragma next_field_must_be_between_inclusive(10,56)
            DWORD dw;
            
            #pragma next_field_must_be_between_inclusive(2.7,2.95)
            double dbl; 
    
            #pragma next_field_must_be_between_inclusive(2.5,4.5)
            float f;        
            ...
        };