1125 lines
46 KiB
C++
1125 lines
46 KiB
C++
//━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
//
|
|
|
|
#include "stdafx.h"
|
|
|
|
//━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
//
|
|
#include <Define.h>
|
|
#include "CPShowMSG.h"
|
|
#include <Protocol_CG.h>
|
|
#include <Protocol_CW.h>
|
|
//
|
|
//━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
//
|
|
#include "../Protocol_CG.HEAD.h"
|
|
#include "../Protocol_CG.WRAP.h"
|
|
#include "../Protocol_CW.WRAP.h"
|
|
#include "../Protocol_CG.TAIL.h"
|
|
//
|
|
//━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
|
|
|
|
//━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
#if CPSHOWLIB_VERSION == 0x0200
|
|
//━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
|
|
|
|
//───────────────────────────────────────────────────────────
|
|
// (Internal Interfaces)
|
|
struct CPShowLIB
|
|
{
|
|
static INT Init( BYTE verMAJOR, BYTE verMIDDLE, DWORD oddNOcate, DWORD oddNOproto );
|
|
static const CHAR* Query( BYTE byCategory, BYTE byProtocol, DWORD* dwOffset );
|
|
};
|
|
|
|
//───────────────────────────────────────────────────────────
|
|
// (Interfaces)
|
|
static const CPShowFNTable s_CPShowHandler = { &CPShowLIB::Init, &CPShowLIB::Query };
|
|
static const CPShowFNTable* s_CPShowMSG = NULL;
|
|
|
|
//───────────────────────────────────────────────────────────
|
|
//
|
|
const CPShowFNTable*
|
|
GetCPShowHandler()
|
|
{
|
|
if( s_CPShowMSG )
|
|
return s_CPShowMSG;
|
|
|
|
s_CPShowMSG = &s_CPShowHandler;
|
|
return s_CPShowMSG;
|
|
}
|
|
|
|
|
|
//───────────────────────────────────────────────────────────
|
|
//
|
|
INT
|
|
CPShowLIB::Init( BYTE verMAJOR, BYTE verMIDDLE, DWORD oddNOcate, DWORD oddNOproto )
|
|
{
|
|
const BOOLEAN bAccept
|
|
= (C2S_HIGH_VERSION_NO == verMAJOR)
|
|
&& (C2S_MIDDLE_VERSION_NO == verMIDDLE)
|
|
&& (CATEGORY_ODD_NUMBER == oddNOcate)
|
|
&& (PROTOCOL_ODD_NUMBER == oddNOproto)
|
|
;
|
|
|
|
return bAccept
|
|
? 0
|
|
: ERR_CPSHOW_DIFFVERSION
|
|
;
|
|
}
|
|
|
|
|
|
//───────────────────────────────────────────────────────────
|
|
//
|
|
const CHAR*
|
|
CPShowLIB::Query( BYTE byCategory, BYTE byProtocol, DWORD* dwOffset )
|
|
{
|
|
const BOOLEAN bound_over
|
|
= ((DWORD)byCategory > 256)
|
|
|| ((DWORD)byProtocol > 256)
|
|
;
|
|
|
|
if( bound_over )
|
|
return NULL;
|
|
|
|
const CHAR* pCategoryName = NULL;
|
|
const CHAR* pProtocolName = NULL;
|
|
|
|
DWORD countC = 0;
|
|
const PROTOCOL_STRUCT_CATEINDEX* const pItConst = &idxCG_CATEGORY[0];
|
|
const PROTOCOL_STRUCT_CATEINDEX* pIt = pItConst;
|
|
for( ; countC<256 ; ++countC, ++pIt )
|
|
{
|
|
if( !pIt->pProtocols )
|
|
break;
|
|
|
|
const BYTE category = (BYTE)pIt->dwIndex;
|
|
if( category != byCategory )
|
|
continue;
|
|
|
|
pCategoryName = pIt->pCategoryName;
|
|
|
|
const PROTOCOL_STRUCT* pProtocol = pIt->pProtocols;
|
|
DWORD countP = 0;
|
|
for( ; countP<256 ; ++countP, ++pProtocol )
|
|
{
|
|
if( !pProtocol->name )
|
|
break;
|
|
|
|
if( pProtocol->code != byProtocol )
|
|
continue;
|
|
|
|
pProtocolName = pProtocol->name;
|
|
break;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
return
|
|
pProtocolName ? pProtocolName
|
|
: pCategoryName ? pCategoryName
|
|
: NULL
|
|
;
|
|
}
|
|
|
|
|
|
//━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
#elif CPSHOWLIB_VERSION == 0x0100
|
|
//━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
|
|
#include <vector>
|
|
#include <list>
|
|
|
|
using namespace std;
|
|
|
|
#include <crtdbg.h>
|
|
#include <assert.h>
|
|
|
|
//───────────────────────────────────────────────────────────
|
|
// <Prototypes>
|
|
static INT Init( BYTE verMAJOR, BYTE verMIDDLE, DWORD oddNOcate, DWORD oddNOproto );
|
|
static const CHAR* Query( BYTE byCategory, BYTE byProtocol, DWORD* dwOffset );
|
|
|
|
//
|
|
//───────────────────────────────────────────────────────────
|
|
//
|
|
const static CPShowFNTable* s_CPShowMSG = NULL;
|
|
const static CPShowFNTable s_CPShowHandler = { &Init, &Query };
|
|
//
|
|
const CPShowFNTable* GetCPShowHandler()
|
|
{
|
|
if( s_CPShowMSG )
|
|
return s_CPShowMSG;
|
|
|
|
s_CPShowMSG = &s_CPShowHandler;
|
|
return s_CPShowMSG;
|
|
}
|
|
//
|
|
//========================================================
|
|
|
|
//#define INDEX_SIZE 512
|
|
#define INDEX_SIZE 2048
|
|
#define GET_KEY(wKey) ((WORD)(wKey/29) % INDEX_SIZE)
|
|
//#define GET_KEY(wKey) ((WORD)(wKey/4) % INDEX_SIZE)
|
|
|
|
#ifdef __CPSHOW_UNUSED_SECT__
|
|
static BYTE pCATEGORY_OFFSETs[256] = { 0, };
|
|
static BYTE pPROTOCOL_OFFSETs[256] = { 0, };
|
|
static BYTE pCATEGORY_BOUNDs[10] = { 0, }; // 이후 AG, DG, AW, CW 등등에 대한 보완을 고려하자.
|
|
static BYTE pPROTOCOL_BOUNDs[256] = { 0, };
|
|
#endif
|
|
|
|
//
|
|
struct SListTable
|
|
{
|
|
WORD wUKey;
|
|
CHAR* name;
|
|
};
|
|
|
|
struct SIndexTable
|
|
{
|
|
SListTable* pList;
|
|
DWORD dwCount;
|
|
};
|
|
|
|
static DWORD ListTableLength = 0;
|
|
static SListTable* pListTable = NULL;
|
|
static SIndexTable IndexTable[INDEX_SIZE] = { NULL, };
|
|
//
|
|
|
|
static VOID _Init_CategoryIndex();
|
|
static VOID _Init_ProtocolIndex();
|
|
static INT _Process();
|
|
|
|
static INT _MAKETABLE();
|
|
static INT Init( BYTE verMAJOR, BYTE verMIDDLE, DWORD oddNOcate, DWORD oddNOproto )
|
|
{
|
|
BOOL bChk = FALSE;
|
|
|
|
if( C2S_HIGH_VERSION_NO == verMAJOR )
|
|
if( C2S_MIDDLE_VERSION_NO == verMIDDLE )
|
|
if( CATEGORY_ODD_NUMBER == oddNOcate )
|
|
if( PROTOCOL_ODD_NUMBER == oddNOproto )
|
|
bChk = TRUE;
|
|
|
|
if( !bChk )
|
|
return ERR_CPSHOW_DIFFVERSION;
|
|
|
|
#ifdef __CPSHOW_UNUSED_SECT__
|
|
_Init_CategoryIndex();
|
|
_Init_ProtocolIndex();
|
|
//_Process();
|
|
#endif
|
|
return _MAKETABLE();
|
|
}
|
|
|
|
static INT _MAKETABLE()
|
|
{
|
|
typedef pair<WORD, PROTOCOL_STRUCT*> CPSHOW_PAIR;
|
|
typedef list<CPSHOW_PAIR> CPSHOW_DLIST;
|
|
typedef list<CPSHOW_PAIR>::iterator CPSHOW_DLIST_IT;
|
|
typedef vector<CPSHOW_DLIST*> CPSHOW_CLIST;
|
|
|
|
CPSHOW_CLIST cateLIST;
|
|
cateLIST.reserve( INDEX_SIZE );
|
|
|
|
for( int i=0 ; i<INDEX_SIZE ; ++i )
|
|
{
|
|
CPSHOW_DLIST* p_dLIST = new CPSHOW_DLIST;
|
|
cateLIST[i] = p_dLIST;
|
|
}
|
|
|
|
int iCount;
|
|
int iSum = 0;
|
|
|
|
const PROTOCOL_STRUCT_CATEINDEX* pPTR = &idxCG_CATEGORY[0];
|
|
for( iCount=0 ; iCount<256 ; ++iCount )
|
|
{
|
|
if( pPTR->pProtocols == NULL )
|
|
break;
|
|
|
|
BYTE byCateNo = (BYTE)pPTR->dwIndex;
|
|
const PROTOCOL_STRUCT* pProtocols = pPTR->pProtocols;
|
|
|
|
int iSubCount = 0;
|
|
for( ; iSubCount<256 ; ++iSubCount )
|
|
{
|
|
if( pProtocols->name == NULL )
|
|
break;
|
|
|
|
BYTE byProtoNo = pProtocols->code;
|
|
WORD wKey = MAKEWORD(byCateNo, byProtoNo);
|
|
|
|
WORD wUKey = GET_KEY(wKey);// (WORD)(wKey/29) % INDEX_SIZE;
|
|
CPSHOW_DLIST& dList = *cateLIST[wUKey];
|
|
|
|
cateLIST[wUKey]->insert( cateLIST[wUKey]->end(), CPSHOW_PAIR(wKey, (PROTOCOL_STRUCT*)pProtocols));
|
|
|
|
pProtocols++;
|
|
}
|
|
|
|
if( !(iSubCount < 256) )
|
|
{
|
|
printf( "Error : IndexOutOfRange Protocol Count\n" );
|
|
}
|
|
else
|
|
{
|
|
iSum += iSubCount;
|
|
}
|
|
|
|
pPTR++;
|
|
}
|
|
|
|
if( !(iCount < 256) )
|
|
{
|
|
printf( "Error : IndexOutOfRange Protocol Count\n" );
|
|
return ERR_CPSHOW_FAULT;
|
|
}
|
|
|
|
//static DWORD ListTableLength = 0;
|
|
//static SListTable* pListTable = NULL;
|
|
//static SIndexTable IndexTable[256] = { NULL, };
|
|
ListTableLength = (DWORD)iSum;
|
|
pListTable = (SListTable*)malloc( sizeof(SListTable)*ListTableLength );
|
|
|
|
#ifdef __DEBUG_TESTUNIT__
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// <test code>
|
|
BYTE bylists[INDEX_SIZE] = { 0, };
|
|
for( iCount=0 ; iCount<INDEX_SIZE ; ++iCount )
|
|
{
|
|
CPSHOW_DLIST& rDLIST = *cateLIST[iCount];
|
|
bylists[iCount] = (BYTE)rDLIST.size();
|
|
}
|
|
FILE* pFILE = fopen( "list.txt", "w+" );
|
|
CHAR strmsg[20];
|
|
for( iCount=0 ; iCount<INDEX_SIZE ; ++iCount )
|
|
{
|
|
_snprintf( strmsg, 20, "%03d\t%d\n", iCount, bylists[iCount] );
|
|
fputs( strmsg, pFILE );
|
|
}
|
|
fflush(pFILE);
|
|
fclose(pFILE);
|
|
// <test code>
|
|
////////////////////////////////////////////////////////////////////////////
|
|
#endif //__DEBUG_TESTUNIT__
|
|
|
|
SListTable* pListOffset = pListTable;
|
|
for( iCount=0 ; iCount<INDEX_SIZE ; ++iCount )
|
|
{
|
|
CPSHOW_DLIST& rDLIST = *cateLIST[iCount];
|
|
//DWORD dwSize = rDLIST.size();
|
|
|
|
IndexTable[iCount].pList = pListOffset;
|
|
|
|
CPSHOW_DLIST_IT it(rDLIST.begin()), end(rDLIST.end());
|
|
DWORD dwIdx=0;
|
|
for( ; it != end ; ++it )
|
|
{
|
|
WORD wUKey = it->first;
|
|
PROTOCOL_STRUCT* pProtocol = it->second;
|
|
pListOffset->wUKey = wUKey;
|
|
pListOffset->name = pProtocol->name;
|
|
++pListOffset;
|
|
++dwIdx;
|
|
}
|
|
IndexTable[iCount].dwCount = dwIdx;
|
|
}
|
|
|
|
for( int i=0 ; i<INDEX_SIZE ; ++i )
|
|
{
|
|
delete cateLIST[i];
|
|
}
|
|
|
|
return ListTableLength;
|
|
}
|
|
|
|
static const CHAR* Query( BYTE byCategory, BYTE byProtocol, DWORD* dwOffset )
|
|
{
|
|
if( (DWORD)byCategory > 256 || (DWORD)byProtocol > 256 )
|
|
return NULL;
|
|
|
|
WORD wKey = MAKEWORD(byCategory, byProtocol);
|
|
WORD wUKey = GET_KEY(wKey);
|
|
|
|
//static DWORD ListTableLength = 0;
|
|
//static SListTable* pListTable = NULL;
|
|
//static SIndexTable IndexTable[256] = { NULL, };
|
|
|
|
DWORD dwFind = 0;
|
|
|
|
DWORD dwSize = IndexTable[wUKey].dwCount;
|
|
SListTable* pList = IndexTable[wUKey].pList;
|
|
for( dwFind=0 ; dwFind<dwSize ; ++dwFind )
|
|
{
|
|
if( wKey == pList->wUKey )
|
|
{
|
|
if( dwOffset )
|
|
{
|
|
*dwOffset = (DWORD)( ((DWORD)(__int64)pList - (DWORD)(__int64)&IndexTable[0])/sizeof(SListTable) );
|
|
}
|
|
return pList->name;
|
|
}
|
|
|
|
++pList;
|
|
}
|
|
|
|
return NULL;
|
|
|
|
/*
|
|
if( !(byCategory < 256 && byProtocol < 256) )
|
|
{
|
|
// error
|
|
return NULL;
|
|
}
|
|
|
|
DWORD upperbound = pCATEGORY_BOUNDs[0];
|
|
DWORD dwIndex = pCATEGORY_OFFSETs[byCategory];
|
|
|
|
if( !(dwIndex < upperbound) )
|
|
return NULL;
|
|
|
|
const PROTOCOL_STRUCT_CATEINDEX* pPTR = &idxCG_CATEGORY[dwIndex];
|
|
const PROTOCOL_STRUCT* pProtocols = pPTR->pProtocols;
|
|
|
|
DWORD dwProtoIndex = pPROTOCOL_OFFSETs[byProtocol];
|
|
DWORD proto_upperbound = pPROTOCOL_BOUNDs[dwProtoIndex];
|
|
|
|
if( !(dwProtoIndex < proto_upperbound) )
|
|
return NULL;
|
|
|
|
return pProtocols[dwProtoIndex].name;
|
|
*/
|
|
|
|
/*
|
|
// 이전 버전용
|
|
if( (DWORD)byCategory > 256 || (DWORD)byProtocol > 256 )
|
|
return NULL;
|
|
|
|
int iFind = 0;
|
|
const PROTOCOL_STRUCT_CATEINDEX* pPTR = &idxCG_CATEGORY[0];
|
|
for( ; iFind<256 ; ++iFind )
|
|
{
|
|
if( pPTR->pProtocols == NULL )
|
|
{
|
|
iFind = 256;
|
|
break;
|
|
}
|
|
|
|
if( pPTR->dwIndex == byCategory )
|
|
break;
|
|
|
|
pPTR++;
|
|
}
|
|
|
|
if( iFind==256 )
|
|
{
|
|
//perror( "Can't find Category Number" );
|
|
return NULL;
|
|
}
|
|
|
|
CHAR* catename = pPTR->pCategoryName;
|
|
const PROTOCOL_STRUCT* pProtocols = pPTR->pProtocols;
|
|
|
|
for( iFind=0 ; iFind<256 ; ++iFind )
|
|
{
|
|
if( pProtocols->name == NULL )
|
|
{
|
|
iFind = 256;
|
|
break;
|
|
}
|
|
|
|
if( pProtocols->code == (BYTE)byProtocol )
|
|
break;
|
|
|
|
pProtocols++;
|
|
}
|
|
|
|
return pProtocols->name;
|
|
*/
|
|
}
|
|
|
|
#ifdef __CPSHOW_UNUSED_SECT__
|
|
|
|
static VOID _Init_CategoryIndex()
|
|
{
|
|
DWORD dwIndex = 0;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_001 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_002 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_003 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_004 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_005 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_006 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_007 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_008 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_009 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_010 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_011 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_012 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_013 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_014 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_015 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_016 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_017 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_018 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_019 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_020 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_021 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_022 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_023 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_024 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_025 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_026 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_027 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_028 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_029 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_030 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_031 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_032 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_033 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_034 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_035 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_036 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_037 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_038 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_039 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_040 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_041 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_042 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_043 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_044 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_045 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_046 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_047 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_048 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_049 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_050 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_051 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_052 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_053 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_054 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_055 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_056 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_057 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_058 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_059 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_060 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_061 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_062 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_063 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_064 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_065 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_066 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_067 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_068 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_069 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_070 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_071 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_072 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_073 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_074 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_075 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_076 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_077 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_078 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_079 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_080 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_081 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_082 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_083 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_084 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_085 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_086 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_087 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_088 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_089 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_090 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_091 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_092 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_093 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_094 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_095 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_096 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_097 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_098 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_099 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_100 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_101 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_102 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_103 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_104 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_105 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_106 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_107 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_108 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_109 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_110 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_111 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_112 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_113 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_114 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_115 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_116 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_117 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_118 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_119 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_120 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_121 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_122 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_123 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_124 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_125 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_126 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_127 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_128 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_129 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_130 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_131 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_132 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_133 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_134 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_135 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_136 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_137 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_138 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_139 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_140 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_141 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_142 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_143 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_144 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_145 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_146 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_147 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_148 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_149 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_150 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_151 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_152 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_153 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_154 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_155 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_156 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_157 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_158 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_159 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_160 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_161 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_162 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_163 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_164 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_165 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_166 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_167 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_168 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_169 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_170 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_171 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_172 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_173 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_174 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_175 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_176 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_177 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_178 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_179 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_180 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_181 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_182 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_183 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_184 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_185 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_186 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_187 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_188 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_189 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_190 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_191 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_192 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_193 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_194 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_195 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_196 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_197 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_198 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_199 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_200 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_201 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_202 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_203 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_204 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_205 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_206 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_207 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_208 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_209 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_210 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_211 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_212 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_213 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_214 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_215 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_216 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_217 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_218 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_219 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_220 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_221 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_222 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_223 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_224 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_225 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_226 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_227 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_228 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_229 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_230 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_231 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_232 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_233 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_234 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_235 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_236 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_237 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_238 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_239 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_240 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_241 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_242 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_243 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_244 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_245 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_246 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_247 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_248 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_249 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_250 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_251 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_252 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_253 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_254 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_255 ] = (BYTE)dwIndex++;
|
|
pCATEGORY_OFFSETs[ CATEGORY_GENERATOR_256 ] = (BYTE)dwIndex++;
|
|
}
|
|
|
|
static VOID _Init_ProtocolIndex()
|
|
{
|
|
DWORD dwIndex = 0;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_001 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_002 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_003 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_004 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_005 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_006 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_007 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_008 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_009 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_010 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_011 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_012 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_013 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_014 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_015 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_016 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_017 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_018 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_019 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_020 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_021 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_022 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_023 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_024 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_025 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_026 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_027 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_028 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_029 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_030 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_031 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_032 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_033 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_034 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_035 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_036 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_037 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_038 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_039 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_040 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_041 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_042 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_043 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_044 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_045 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_046 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_047 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_048 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_049 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_050 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_051 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_052 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_053 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_054 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_055 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_056 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_057 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_058 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_059 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_060 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_061 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_062 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_063 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_064 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_065 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_066 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_067 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_068 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_069 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_070 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_071 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_072 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_073 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_074 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_075 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_076 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_077 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_078 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_079 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_080 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_081 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_082 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_083 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_084 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_085 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_086 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_087 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_088 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_089 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_090 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_091 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_092 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_093 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_094 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_095 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_096 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_097 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_098 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_099 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_100 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_101 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_102 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_103 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_104 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_105 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_106 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_107 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_108 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_109 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_110 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_111 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_112 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_113 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_114 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_115 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_116 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_117 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_118 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_119 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_120 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_121 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_122 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_123 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_124 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_125 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_126 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_127 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_128 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_129 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_130 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_131 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_132 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_133 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_134 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_135 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_136 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_137 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_138 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_139 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_140 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_141 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_142 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_143 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_144 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_145 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_146 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_147 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_148 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_149 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_150 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_151 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_152 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_153 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_154 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_155 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_156 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_157 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_158 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_159 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_160 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_161 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_162 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_163 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_164 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_165 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_166 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_167 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_168 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_169 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_170 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_171 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_172 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_173 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_174 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_175 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_176 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_177 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_178 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_179 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_180 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_181 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_182 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_183 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_184 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_185 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_186 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_187 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_188 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_189 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_190 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_191 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_192 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_193 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_194 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_195 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_196 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_197 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_198 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_199 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_200 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_201 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_202 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_203 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_204 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_205 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_206 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_207 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_208 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_209 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_210 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_211 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_212 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_213 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_214 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_215 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_216 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_217 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_218 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_219 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_220 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_221 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_222 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_223 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_224 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_225 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_226 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_227 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_228 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_229 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_230 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_231 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_232 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_233 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_234 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_235 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_236 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_237 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_238 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_239 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_240 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_241 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_242 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_243 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_244 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_245 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_246 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_247 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_248 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_249 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_250 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_251 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_252 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_253 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_254 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_255 ] = (BYTE)dwIndex++;
|
|
pPROTOCOL_OFFSETs[ PROTOCOL_GENERATOR_256 ] = (BYTE)dwIndex++;
|
|
}
|
|
|
|
|
|
static INT _Process()
|
|
{
|
|
int iCount;
|
|
int iSum = 0;
|
|
const PROTOCOL_STRUCT_CATEINDEX* pPTR = &idxCG_CATEGORY[0];
|
|
for( iCount=0 ; iCount<256 ; ++iCount )
|
|
{
|
|
if( pPTR->pProtocols == NULL )
|
|
break;
|
|
|
|
BYTE byCateNo = (BYTE)pPTR->dwIndex;
|
|
const PROTOCOL_STRUCT* pProtocols = pPTR->pProtocols;
|
|
|
|
int iSubCount = 0;
|
|
for( ; iSubCount<256 ; ++iSubCount )
|
|
{
|
|
if( pProtocols->name == NULL )
|
|
break;
|
|
|
|
BYTE byProtoNo = pProtocols->code;
|
|
WORD wKey = MAKEWORD(byCateNo, byProtoNo);
|
|
|
|
pProtocols++;
|
|
}
|
|
|
|
if( !(iSubCount < 256) )
|
|
{
|
|
printf( "Error : IndexOutOfRange Protocol Count\n" );
|
|
}
|
|
else
|
|
{
|
|
pPROTOCOL_BOUNDs[iCount] = iSubCount;
|
|
iSum += iSubCount;
|
|
}
|
|
|
|
pPTR++;
|
|
}
|
|
|
|
if( !(iCount < 256) )
|
|
return -1;
|
|
|
|
pCATEGORY_BOUNDs[0] = iCount;
|
|
|
|
// count <0>,<1>의 구분은 필요하지만 여기서는 무시하기로 하자.
|
|
return iSum;
|
|
}
|
|
|
|
#endif //__CPSHOW_UNUSED_SECT__
|
|
|
|
//static VOID _MAKETABLE()
|
|
//{
|
|
// typedef pair<WORD, PROTOCOL_STRUCT*> CPSHOW_PAIR;
|
|
// typedef list<CPSHOW_PAIR> CPSHOW_DLIST;
|
|
// typedef list<CPSHOW_PAIR>::iterator CPSHOW_DLIST_IT;
|
|
// typedef vector<CPSHOW_DLIST*> CPSHOW_CLIST;
|
|
//
|
|
// CPSHOW_CLIST cateLIST;
|
|
// cateLIST.reserve( INDEX_SIZE );
|
|
//
|
|
// for( int i=0 ; i<INDEX_SIZE ; ++i )
|
|
// {
|
|
// CPSHOW_DLIST* p_dLIST = new CPSHOW_DLIST;
|
|
// cateLIST[i] = p_dLIST;
|
|
// }
|
|
//
|
|
// int iCount;
|
|
// int iSum = 0;
|
|
//
|
|
// const PROTOCOL_STRUCT_CATEINDEX* pPTR = &idxCG_CATEGORY[0];
|
|
// for( iCount=0 ; iCount<256 ; ++iCount )
|
|
// {
|
|
// if( pPTR->pProtocols == NULL )
|
|
// break;
|
|
//
|
|
// BYTE byCateNo = (BYTE)pPTR->dwIndex;
|
|
// const PROTOCOL_STRUCT* pProtocols = pPTR->pProtocols;
|
|
//
|
|
// int iSubCount = 0;
|
|
// for( ; iSubCount<256 ; ++iSubCount )
|
|
// {
|
|
// if( pProtocols->name == NULL )
|
|
// break;
|
|
//
|
|
// BYTE byProtoNo = pProtocols->code;
|
|
// WORD wKey = MAKEWORD(byCateNo, byProtoNo);
|
|
//
|
|
// WORD wUKey = GET_KEY(wKey);// (WORD)(wKey/29) % INDEX_SIZE;
|
|
// CPSHOW_DLIST& dList = *cateLIST[wUKey];
|
|
//
|
|
// cateLIST[wUKey]->insert( cateLIST[wUKey]->end(), CPSHOW_PAIR(wKey, (PROTOCOL_STRUCT*)pProtocols));
|
|
//
|
|
// pProtocols++;
|
|
// }
|
|
//
|
|
// if( !(iSubCount < 256) )
|
|
// {
|
|
// printf( "Error : IndexOutOfRange Protocol Count\n" );
|
|
// }
|
|
// else
|
|
// {
|
|
// iSum += iSubCount;
|
|
// }
|
|
//
|
|
// pPTR++;
|
|
// }
|
|
//
|
|
// if( !(iCount < 256) )
|
|
// {
|
|
// printf( "Error : IndexOutOfRange Protocol Count\n" );
|
|
// return;
|
|
// }
|
|
//
|
|
// //static DWORD ListTableLength = 0;
|
|
// //static SListTable* pListTable = NULL;
|
|
// //static SIndexTable IndexTable[256] = { NULL, };
|
|
// ListTableLength = (DWORD)iSum;
|
|
// pListTable = (SListTable*)malloc( sizeof(SListTable)*ListTableLength );
|
|
//
|
|
// // <test code>
|
|
// //BYTE bylists[256] = { 0, };
|
|
// //for( iCount=0 ; iCount<256 ; ++iCount )
|
|
// //{
|
|
// // CPSHOW_DLIST& rDLIST = *cateLIST[iCount];
|
|
// // bylists[iCount] = rDLIST.size();
|
|
// //}
|
|
//
|
|
// SListTable* pListOffset = pListTable;
|
|
// for( iCount=0 ; iCount<INDEX_SIZE ; ++iCount )
|
|
// {
|
|
// CPSHOW_DLIST& rDLIST = *cateLIST[iCount];
|
|
// //DWORD dwSize = rDLIST.size();
|
|
//
|
|
// IndexTable[iCount].pList = pListOffset;
|
|
//
|
|
// CPSHOW_DLIST_IT it(rDLIST.begin()), end(rDLIST.end());
|
|
// DWORD dwIdx=0;
|
|
// for( ; it != end ; ++it )
|
|
// {
|
|
// WORD wUKey = it->first;
|
|
// PROTOCOL_STRUCT* pProtocol = it->second;
|
|
// pListOffset->wUKey = wUKey;
|
|
// pListOffset->name = pProtocol->name;
|
|
// ++pListOffset;
|
|
// ++dwIdx;
|
|
// }
|
|
// IndexTable[iCount].dwCount = dwIdx;
|
|
// }
|
|
//
|
|
// for( int i=0 ; i<INDEX_SIZE ; ++i )
|
|
// {
|
|
// delete cateLIST[i];
|
|
// }
|
|
//}
|
|
|
|
#endif //CPSHOWLIB_VERSION
|
|
|