home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 2005 June (DVD) / DPPRO0605DVD.iso / dotNETSDK / SETUP.EXE / netfxsd1.cab / FL_basehlp_hpp________.3643236F_FC70_11D3_A536_0090278A1BB8 < prev    next >
Encoding:
Text File  |  2002-05-06  |  37.0 KB  |  1,636 lines

  1. /****************************************************************************************
  2.  * Copyright (c) Microsoft Corporation.  All Rights Reserved.
  3.  *
  4.  * File:
  5.  *  basehlp.hpp
  6.  *
  7.  * Description:
  8.  *    
  9.  *
  10.  *
  11.  ***************************************************************************************/
  12.  
  13.  
  14. /***************************************************************************************
  15.  ********************                                               ********************
  16.  ********************          BaseException Implementation         ********************
  17.  ********************                                               ********************
  18.  ***************************************************************************************/
  19.  
  20. /***************************************************************************************
  21.  *    Method:
  22.  *
  23.  *
  24.  *    Purpose:
  25.  *
  26.  *
  27.  *    Parameters: 
  28.  *
  29.  *
  30.  *    Return value:
  31.  *
  32.  *
  33.  *    Notes:
  34.  *
  35.  ***************************************************************************************/
  36. DECLSPEC
  37. /* public */
  38. BaseException::BaseException( const char *reason ) :
  39.     m_reason( NULL )
  40. {
  41.     SIZE_T length = strlen( reason );
  42.     
  43.     
  44.     m_reason = new char[(length + 1)];
  45.     strcpy( m_reason, reason );
  46.  
  47. } // ctor
  48.  
  49.  
  50. /***************************************************************************************
  51.  *    Method:
  52.  *
  53.  *
  54.  *    Purpose:
  55.  *
  56.  *
  57.  *    Parameters: 
  58.  *
  59.  *
  60.  *    Return value:
  61.  *
  62.  *
  63.  *    Notes:
  64.  *
  65.  ***************************************************************************************/
  66. DECLSPEC
  67. /* virtual public */
  68. BaseException::~BaseException() 
  69. {
  70.     if ( m_reason != NULL )
  71.         delete[] m_reason;
  72.  
  73. } // dtor
  74.  
  75.  
  76. /***************************************************************************************
  77.  *    Method:
  78.  *
  79.  *
  80.  *    Purpose:
  81.  *
  82.  *
  83.  *    Parameters: 
  84.  *
  85.  *
  86.  *    Return value:
  87.  *
  88.  *
  89.  *    Notes:
  90.  *
  91.  ***************************************************************************************/
  92. DECLSPEC
  93. /* virtual public */
  94. void BaseException::ReportFailure()
  95. {
  96.        TEXT_OUTLN( m_reason );
  97.     
  98. } // BaseException::ReportFailure
  99.  
  100.  
  101. /***************************************************************************************
  102.  ********************                                               ********************
  103.  ********************            Synchronize Implementation         ********************
  104.  ********************                                               ********************
  105.  ***************************************************************************************/
  106.  
  107. /***************************************************************************************
  108.  *    Method:
  109.  *
  110.  *
  111.  *    Purpose:
  112.  *
  113.  *
  114.  *    Parameters: 
  115.  *
  116.  *
  117.  *    Return value:
  118.  *
  119.  *
  120.  *    Notes:
  121.  *
  122.  ***************************************************************************************/
  123. DECLSPEC
  124. /* public */
  125. Synchronize::Synchronize( CRITICAL_SECTION &criticalSection ) : 
  126.     m_block( criticalSection )
  127. {
  128.     EnterCriticalSection( &m_block );
  129.     
  130. } // ctor
  131.  
  132.  
  133. /***************************************************************************************
  134.  *    Method:
  135.  *
  136.  *
  137.  *    Purpose:
  138.  *
  139.  *
  140.  *    Parameters: 
  141.  *
  142.  *
  143.  *    Return value:
  144.  *
  145.  *
  146.  *    Notes:
  147.  *
  148.  ***************************************************************************************/
  149. DECLSPEC
  150. /* public */
  151. Synchronize::~Synchronize()
  152. {
  153.     LeaveCriticalSection( &m_block );
  154.  
  155. } // dtor
  156.  
  157.  
  158. /***************************************************************************************
  159.  ********************                                               ********************
  160.  ********************            BASEHELPER Implementation          ********************
  161.  ********************                                               ********************
  162.  ***************************************************************************************/
  163.  
  164. /***************************************************************************************
  165.  *    Method:
  166.  *
  167.  *
  168.  *    Purpose:
  169.  *
  170.  *
  171.  *    Parameters: 
  172.  *
  173.  *
  174.  *    Return value:
  175.  *
  176.  *
  177.  *    Notes:
  178.  *
  179.  ***************************************************************************************/
  180. DECLSPEC
  181. /* static public */
  182. DWORD BASEHELPER::FetchEnvironment( const char *environment )
  183. {
  184.     DWORD retVal = -1;
  185.     char buffer[MAX_LENGTH];
  186.     
  187.     
  188.      if ( GetEnvironmentVariableA( environment, buffer, MAX_LENGTH ) > 0 )
  189.            retVal = BASEHELPER::GetEnvVarValue( buffer );
  190.                 
  191.     
  192.     return retVal;
  193.  
  194. } // BASEHELPER::FetchEnvironemnt
  195.  
  196.  
  197. /***************************************************************************************
  198.  *    Method:
  199.  *
  200.  *
  201.  *    Purpose:
  202.  *
  203.  *
  204.  *    Parameters: 
  205.  *
  206.  *
  207.  *    Return value:
  208.  *
  209.  *
  210.  *    Notes:
  211.  *
  212.  ***************************************************************************************/
  213. DECLSPEC
  214. /* static public */
  215. void BASEHELPER::DDebug( char *format, ... )
  216. {
  217.     static DWORD debugShow = BASEHELPER::FetchEnvironment( DEBUG_ENVIRONMENT );
  218.     
  219.     
  220.      if ( (debugShow == 2) || (debugShow == 3) ) 
  221.     {
  222.         va_list args;
  223.         char buffer[1024];    // largest possible for wvsprintf
  224.    
  225.  
  226.         va_start( args, format );    
  227.         wvsprintfA( buffer, format, args );
  228.  
  229.         printf( "%s\n", buffer );
  230.        }
  231.  
  232.  
  233. } // BASEHELPER::DDebug
  234.  
  235.  
  236. /***************************************************************************************
  237.  *    Method:
  238.  *
  239.  *
  240.  *    Purpose:
  241.  *
  242.  *
  243.  *    Parameters: 
  244.  *
  245.  *
  246.  *    Return value:
  247.  *
  248.  *
  249.  *    Notes:
  250.  *
  251.  ***************************************************************************************/
  252. DECLSPEC
  253. /* static public */
  254. void BASEHELPER::Display( char *format, ... )
  255. {
  256.     va_list args;
  257.     char buffer[1024];    // largest possible for wvsprintf
  258.  
  259.  
  260.     va_start( args, format );    
  261.     wvsprintfA( buffer, format, args );
  262.  
  263.     printf( "%s\n", buffer );       
  264.    
  265. } // BASEHELPER::Display
  266.  
  267.  
  268. /***************************************************************************************
  269.  *    Method:
  270.  *
  271.  *
  272.  *    Purpose:
  273.  *
  274.  *
  275.  *    Parameters: 
  276.  *
  277.  *
  278.  *    Return value:
  279.  *
  280.  *
  281.  *    Notes:
  282.  *
  283.  ***************************************************************************************/
  284. DECLSPEC
  285. /* static public */
  286. void BASEHELPER::LogToFile( char *format, ... )
  287. {
  288.     va_list args;
  289.     static DWORD dwVarValue = BASEHELPER::FetchEnvironment( LOG_ENVIRONMENT );
  290.  
  291.  
  292.     va_start( args, format );        
  293.     switch ( dwVarValue )
  294.     {
  295.         case 0x00:
  296.         case 0xFFFFFFFF:
  297.              vprintf( format, args );
  298.              break;
  299.  
  300.  
  301.         case 0xFF:
  302.             break;
  303.  
  304.  
  305.         default:
  306.             {
  307.                 static count = 0;
  308.                 static CRITICAL_SECTION criticalSection = { 0 };
  309.                 static char logfile[MAX_LENGTH+MAX_PATH];
  310.  
  311.                 
  312.                 if ( count++ == 0 )
  313.                 {
  314.                     InitializeCriticalSection( &criticalSection );
  315.                     if ( GetEnvironmentVariableA( LOG_OUTPUT_FILE, logfile, MAX_LENGTH+MAX_PATH ) == 0 )
  316.                     {
  317.                         //
  318.                         // if var does not exist, use the defaul directory and the default name
  319.                         //
  320.                         strcpy( logfile, "output.log" );
  321.                     }
  322.                 }
  323.                 
  324.                 
  325.                 {
  326.                     FILE *stream;
  327.                     Synchronize    guard( criticalSection );
  328.                 
  329.  
  330.                     //
  331.                     // first time create otherwise append
  332.                     //
  333.                     stream = ((count == 1) ? fopen( logfile, "w" ) : fopen( logfile, "a+" ));
  334.                     if ( stream != NULL )
  335.                     {
  336.                         vfprintf( stream, format, args );
  337.                         fflush( stream );
  338.                         fclose( stream );
  339.                     }
  340.                     else
  341.                        TEXT_OUTLN( "Unable to open log file" )
  342.                 }
  343.             }            
  344.             break;
  345.             
  346.     } // switch
  347.  
  348. } // BASEHELPER::LogToFile
  349.  
  350.  
  351. /***************************************************************************************
  352.  *    Method:
  353.  *
  354.  *
  355.  *    Purpose:
  356.  *
  357.  *
  358.  *    Parameters: 
  359.  *
  360.  *
  361.  *    Return value:
  362.  *
  363.  *
  364.  *    Notes:
  365.  *
  366.  ***************************************************************************************/
  367. DECLSPEC
  368. /* static public */
  369. void BASEHELPER::PrintTheWin32Error( DWORD dwError )
  370. {
  371.     LPVOID lpMsgBuf;
  372.     static DWORD launchWindow = BASEHELPER::FetchEnvironment( DEBUG_ENVIRONMENT );
  373.  
  374.     
  375.     if ( (launchWindow >= 1) && (launchWindow != 0xFFFFFFFF) )
  376.     {        
  377.         FormatMessageA( FORMAT_MESSAGE_ALLOCATE_BUFFER | 
  378.                         FORMAT_MESSAGE_FROM_SYSTEM | 
  379.                         FORMAT_MESSAGE_IGNORE_INSERTS,
  380.                         NULL,
  381.                         dwError,
  382.                         MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
  383.                         (LPSTR) &lpMsgBuf,
  384.                         0,
  385.                         NULL );
  386.  
  387.         // Display the string.
  388.         MessageBoxA( NULL, (LPCSTR)lpMsgBuf, "Error", MB_OK | MB_ICONINFORMATION );
  389.  
  390.         // Free the buffer.
  391.         LocalFree( lpMsgBuf );
  392.     }
  393.        else
  394.     {
  395.         char strMessage[MAX_LENGTH];
  396.  
  397.         sprintf( strMessage, "GetLastError() Returned Error Code: 08%x", dwError );
  398.         TEXT_OUTLN( strMessage )
  399.     }
  400.  
  401. } // BASEHELPER::PrintTheWin32Error
  402.  
  403.  
  404. /***************************************************************************************
  405.  *    Method:
  406.  *
  407.  *
  408.  *    Purpose:
  409.  *
  410.  *
  411.  *    Parameters: 
  412.  *
  413.  *
  414.  *    Return value:
  415.  *
  416.  *
  417.  *    Notes:
  418.  *
  419.  ***************************************************************************************/
  420. DECLSPEC
  421. /* static public */
  422. void BASEHELPER::LaunchDebugger( const char *szMsg, const char *szFile, int iLine )
  423. {    
  424.     static DWORD launchDebugger = BASEHELPER::FetchEnvironment( DEBUG_ENVIRONMENT );
  425.     
  426.     
  427.     if ( (launchDebugger >= 1) && (launchDebugger != 0xFFFFFFFF) )
  428.     {        
  429.         char title[MAX_LENGTH];
  430.         char message[MAX_LENGTH];
  431.         
  432.              
  433.         sprintf( message, 
  434.                  "%s\n\n"     \
  435.                  "File: %s\n" \
  436.                  "Line: %d\n",
  437.                  ((szMsg == NULL) ? "FAILURE" : szMsg), 
  438.                  szFile, 
  439.                  iLine );
  440.              
  441.         sprintf( title, 
  442.                  "Test Failure (PID: %d/0x%08x, Thread: %d/0x%08x)      ",
  443.                  GetCurrentProcessId(), 
  444.                  GetCurrentProcessId(), 
  445.                  GetCurrentThreadId(), 
  446.                  GetCurrentThreadId() );
  447.                       
  448.         switch ( MessageBoxA( NULL, 
  449.                               message, 
  450.                               title, 
  451.                               (MB_ABORTRETRYIGNORE | MB_ICONEXCLAMATION) ) )
  452.         {
  453.             case IDABORT:
  454.                 TerminateProcess( GetCurrentProcess(), 999 /* bad exit code */ );
  455.                 break;
  456.  
  457.  
  458.             case IDRETRY:
  459.                 _DbgBreak();
  460.  
  461.  
  462.             case IDIGNORE:
  463.                 break;
  464.                                 
  465.         } // switch
  466.     }
  467.     
  468. } // BASEHELPER::LaunchDebugger
  469.  
  470.  
  471. /***************************************************************************************
  472.  *    Method:
  473.  *
  474.  *
  475.  *    Purpose:
  476.  *
  477.  *
  478.  *    Parameters: 
  479.  *
  480.  *
  481.  *    Return value:
  482.  *
  483.  *
  484.  *    Notes:
  485.  *
  486.  ***************************************************************************************/
  487. DECLSPEC
  488. /* static public */
  489. int BASEHELPER::String2Number( char *number )
  490. {
  491.     WCHAR ch;
  492.     int base; 
  493.     int iIndex = 1;
  494.     BOOL errorOccurred = FALSE;
  495.  
  496.  
  497.     // check to see if this is a valid number
  498.     // if the first digit is '0', then this is 
  499.     // a hex or octal number
  500.     if ( number[0] == '0' )
  501.     {
  502.         //
  503.         // hex
  504.         //
  505.         if ( (number[1] == 'x') || (number[1] == 'X') )
  506.         {
  507.             iIndex++;
  508.             
  509.             base = 16;
  510.             while ( (errorOccurred == FALSE) &&
  511.                     ((ch = number[iIndex++]) != '\0') )
  512.             {    
  513.                 if ( ((ch >= '0') && (ch <= '9'))  ||
  514.                      ((ch >= 'a') && (ch <= 'f'))  ||
  515.                      ((ch >= 'A') && (ch <= 'F')) )
  516.                 {
  517.                     continue;
  518.                 }
  519.                 
  520.                 errorOccurred = TRUE;
  521.             }
  522.         }
  523.         //
  524.         // octal
  525.         //
  526.         else
  527.         {
  528.             base = 8;
  529.             while ( (errorOccurred == FALSE) &&
  530.                     ((ch = number[iIndex++]) != '\0') )
  531.             {    
  532.                 if ( (ch >= '0') && (ch <= '7') )
  533.                     continue;
  534.                 
  535.                 
  536.                 errorOccurred = TRUE;
  537.             }
  538.         }
  539.     }
  540.     //
  541.     // decimal
  542.     //
  543.     else
  544.     {
  545.         base = 10;
  546.         while  ( (errorOccurred == FALSE) &&
  547.                   ((ch = number[iIndex++]) != '\0') )
  548.         {    
  549.             if ( (ch >= '0') && (ch <= '9')    )
  550.                 continue;
  551.             
  552.             
  553.             errorOccurred = TRUE;
  554.         }
  555.     }
  556.     
  557.     
  558.     return ((errorOccurred == TRUE) ? -1 : base);
  559.  
  560. } // BASEHELPER::String2Number
  561.  
  562.  
  563. /***************************************************************************************
  564.  *    Method:
  565.  *
  566.  *
  567.  *    Purpose:
  568.  *
  569.  *
  570.  *    Parameters: 
  571.  *
  572.  *
  573.  *    Return value:
  574.  *
  575.  *
  576.  *    Notes:
  577.  *
  578.  ***************************************************************************************/
  579. DECLSPEC
  580. /* static public */ 
  581. int BASEHELPER::ElementType2String( CorElementType elementType, WCHAR *buffer )
  582. {
  583.     int ret = 0; // success
  584.  
  585.  
  586.     switch ( elementType )
  587.     {
  588.         case ELEMENT_TYPE_END:
  589.              swprintf( buffer, L"ELEMENT_TYPE_END" );
  590.              break;
  591.         
  592.         
  593.         case ELEMENT_TYPE_VOID:
  594.              swprintf( buffer, L"ELEMENT_TYPE_VOID" );
  595.              break;
  596.  
  597.  
  598.         case ELEMENT_TYPE_BOOLEAN:
  599.              swprintf( buffer, L"ELEMENT_TYPE_BOOLEAN" );
  600.              break;
  601.  
  602.  
  603.         case ELEMENT_TYPE_CHAR:
  604.              swprintf( buffer, L"ELEMENT_TYPE_CHAR" );
  605.              break;
  606.  
  607.  
  608.         case ELEMENT_TYPE_I1:
  609.              swprintf( buffer, L"ELEMENT_TYPE_I1" );
  610.              break;
  611.  
  612.  
  613.         case ELEMENT_TYPE_U1:
  614.              swprintf( buffer, L"ELEMENT_TYPE_U1" );
  615.              break;
  616.  
  617.  
  618.         case ELEMENT_TYPE_I2:
  619.              swprintf( buffer, L"ELEMENT_TYPE_I2" );
  620.              break;
  621.  
  622.  
  623.         case ELEMENT_TYPE_U2:
  624.              swprintf( buffer, L"ELEMENT_TYPE_U2" );
  625.              break;
  626.  
  627.  
  628.         case ELEMENT_TYPE_I4:
  629.              swprintf( buffer, L"ELEMENT_TYPE_I4" );
  630.              break;
  631.  
  632.  
  633.         case ELEMENT_TYPE_U4:
  634.              swprintf( buffer, L"ELEMENT_TYPE_U4" );
  635.              break;
  636.  
  637.  
  638.         case ELEMENT_TYPE_I8:
  639.              swprintf( buffer, L"ELEMENT_TYPE_I8" );
  640.              break;
  641.  
  642.  
  643.         case ELEMENT_TYPE_U8:
  644.              swprintf( buffer, L"ELEMENT_TYPE_U8" );
  645.              break;
  646.  
  647.  
  648.         case ELEMENT_TYPE_R4:
  649.              swprintf( buffer, L"ELEMENT_TYPE_R4" );
  650.              break;
  651.  
  652.  
  653.         case ELEMENT_TYPE_R8:
  654.              swprintf( buffer, L"ELEMENT_TYPE_R8" );
  655.              break;
  656.  
  657.  
  658.         case ELEMENT_TYPE_STRING:
  659.              swprintf( buffer, L"ELEMENT_TYPE_STRING" );
  660.              break;
  661.  
  662.  
  663.         case ELEMENT_TYPE_PTR:
  664.              swprintf( buffer, L"ELEMENT_TYPE_PTR" );
  665.              break;
  666.  
  667.  
  668.         case ELEMENT_TYPE_BYREF:
  669.              swprintf( buffer, L"ELEMENT_TYPE_BYREF" );
  670.              break;
  671.  
  672.  
  673.         case ELEMENT_TYPE_VALUETYPE:
  674.              swprintf( buffer, L"ELEMENT_TYPE_VALUETYPE" );
  675.              break;
  676.  
  677.  
  678.         case ELEMENT_TYPE_CLASS:
  679.              swprintf( buffer, L"ELEMENT_TYPE_CLASS" );
  680.              break;
  681.  
  682.  
  683.         case ELEMENT_TYPE_ARRAY:
  684.              swprintf( buffer, L"ELEMENT_TYPE_ARRAY" );
  685.              break;
  686.  
  687.  
  688.         case ELEMENT_TYPE_TYPEDBYREF:
  689.              swprintf( buffer, L"ELEMENT_TYPE_TYPEDBYREF" );
  690.              break;
  691.  
  692.  
  693.         case ELEMENT_TYPE_I:
  694.              swprintf( buffer, L"ELEMENT_TYPE_I" );
  695.              break;
  696.  
  697.  
  698.         case ELEMENT_TYPE_U:
  699.              swprintf( buffer, L"ELEMENT_TYPE_U" );
  700.              break;
  701.  
  702.  
  703.         case ELEMENT_TYPE_FNPTR:
  704.              swprintf( buffer, L"ELEMENT_TYPE_FNPTR" );
  705.              break;
  706.  
  707.  
  708.         case ELEMENT_TYPE_OBJECT:
  709.              swprintf( buffer, L"ELEMENT_TYPE_OBJECT" );
  710.              break;
  711.  
  712.  
  713.         case ELEMENT_TYPE_SZARRAY:
  714.              swprintf( buffer, L"ELEMENT_TYPE_SZARRAY" );
  715.              break;
  716.  
  717.  
  718.         case ELEMENT_TYPE_CMOD_REQD:
  719.              swprintf( buffer, L"ELEMENT_TYPE_CMOD_REQD" );
  720.              break;
  721.  
  722.  
  723.         case ELEMENT_TYPE_CMOD_OPT:
  724.              swprintf( buffer, L"ELEMENT_TYPE_CMOD_OPT" );
  725.              break;
  726.  
  727.  
  728.         case ELEMENT_TYPE_MAX:
  729.              swprintf( buffer, L"ELEMENT_TYPE_MAX" );
  730.              break;
  731.  
  732.  
  733.         case ELEMENT_TYPE_MODIFIER:
  734.              swprintf( buffer, L"ELEMENT_TYPE_MODIFIER" );
  735.              break;
  736.  
  737.  
  738.         case ELEMENT_TYPE_SENTINEL:
  739.              swprintf( buffer, L"ELEMENT_TYPE_SENTINEL" );
  740.              break;
  741.  
  742.  
  743.         case ELEMENT_TYPE_PINNED:
  744.              swprintf( buffer, L"ELEMENT_TYPE_PINNED" );
  745.              break;
  746.  
  747.  
  748.         default:
  749.              ret = -1;
  750.              swprintf( buffer, L"<UNKNOWN>" );
  751.     }
  752.  
  753.     
  754.     return ret;
  755.  
  756. } // BASEHELPER::ElementType2String
  757.  
  758.  
  759. /***************************************************************************************
  760.  *    Method:
  761.  *
  762.  *
  763.  *    Purpose:
  764.  *
  765.  *
  766.  *    Parameters: 
  767.  *
  768.  *
  769.  *    Return value:
  770.  *
  771.  *
  772.  *    Notes:
  773.  *
  774.  ***************************************************************************************/
  775. DECLSPEC
  776. /* static public */
  777. DWORD BASEHELPER::GetEnvVarValue( char *value )
  778. {    
  779.     DWORD retValue = -1;
  780.     int base = BASEHELPER::String2Number( value );
  781.  
  782.  
  783.     if ( base != -1 )
  784.         retValue = (DWORD)strtoul( value, NULL, base );
  785.  
  786.  
  787.     return retValue;
  788.  
  789. } // BASEHELPER::GetEnvVarValue
  790.  
  791.  
  792. /***************************************************************************************
  793.  *    Method:
  794.  *
  795.  *
  796.  *    Purpose:
  797.  *
  798.  *
  799.  *    Parameters: 
  800.  *
  801.  *
  802.  *    Return value:
  803.  *
  804.  *
  805.  *    Notes:
  806.  *
  807.  ***************************************************************************************/
  808. DECLSPEC
  809. /* static public */
  810. PCCOR_SIGNATURE BASEHELPER::ParseElementType( IMetaDataImport *pMDImport,
  811.                                               PCCOR_SIGNATURE signature, 
  812.                                               char *buffer )
  813. {    
  814.     switch ( *signature++ ) 
  815.     {    
  816.         case ELEMENT_TYPE_VOID:
  817.             strcat( buffer, "void" );    
  818.             break;                    
  819.         
  820.         
  821.         case ELEMENT_TYPE_BOOLEAN:    
  822.             strcat( buffer, "bool" );    
  823.             break;    
  824.         
  825.         
  826.         case ELEMENT_TYPE_CHAR:
  827.             strcat( buffer, "wchar" );    
  828.             break;        
  829.                     
  830.         
  831.         case ELEMENT_TYPE_I1:
  832.             strcat( buffer, "int8" );    
  833.             break;        
  834.          
  835.         
  836.         case ELEMENT_TYPE_U1:
  837.             strcat( buffer, "unsigned int8" );    
  838.             break;        
  839.         
  840.         
  841.         case ELEMENT_TYPE_I2:
  842.             strcat( buffer, "int16" );    
  843.             break;        
  844.         
  845.         
  846.         case ELEMENT_TYPE_U2:
  847.             strcat( buffer, "unsigned int16" );    
  848.             break;            
  849.         
  850.         
  851.         case ELEMENT_TYPE_I4:
  852.             strcat( buffer, "int32" );    
  853.             break;
  854.             
  855.         
  856.         case ELEMENT_TYPE_U4:
  857.             strcat( buffer, "unsigned int32" );    
  858.             break;        
  859.         
  860.         
  861.         case ELEMENT_TYPE_I8:
  862.             strcat( buffer, "int64" );    
  863.             break;        
  864.         
  865.         
  866.         case ELEMENT_TYPE_U8:
  867.             strcat( buffer, "unsigned int64" );    
  868.             break;        
  869.         
  870.         
  871.         case ELEMENT_TYPE_R4:
  872.             strcat( buffer, "float32" );    
  873.             break;            
  874.         
  875.         
  876.         case ELEMENT_TYPE_R8:
  877.             strcat( buffer, "float64" );    
  878.             break;        
  879.         
  880.         
  881.         case ELEMENT_TYPE_U:
  882.             strcat( buffer, "unsigned int" );    
  883.             break;         
  884.         
  885.         
  886.         case ELEMENT_TYPE_I:
  887.             strcat( buffer, "int" );    
  888.             break;              
  889.         
  890.         
  891.         case ELEMENT_TYPE_OBJECT:
  892.             strcat( buffer, "Object" );    
  893.             break;         
  894.         
  895.         
  896.         case ELEMENT_TYPE_STRING:
  897.             strcat( buffer, "String" );    
  898.             break;         
  899.         
  900.         
  901.         case ELEMENT_TYPE_TYPEDBYREF:
  902.             strcat( buffer, "refany" );    
  903.             break;                       
  904.  
  905.         case ELEMENT_TYPE_CLASS:    
  906.         case ELEMENT_TYPE_VALUETYPE:
  907.         case ELEMENT_TYPE_CMOD_REQD:
  908.         case ELEMENT_TYPE_CMOD_OPT:
  909.             {    
  910.                 mdToken    token;    
  911.                 char classname[MAX_LENGTH];
  912.  
  913.  
  914.                 classname[0] = '\0';
  915.                    signature += CorSigUncompressToken( signature, &token ); 
  916.                 if ( TypeFromToken( token ) != mdtTypeRef )
  917.                 {
  918.                     HRESULT    hr;
  919.                     WCHAR zName[MAX_LENGTH];
  920.                     
  921.                     
  922.                     hr = pMDImport->GetTypeDefProps( token, 
  923.                                                      zName,
  924.                                                      MAX_LENGTH,
  925.                                                      NULL,
  926.                                                      NULL,
  927.                                                      NULL );
  928.                     if ( SUCCEEDED( hr ) )
  929.                         wcstombs( classname, zName, MAX_LENGTH );
  930.                 }
  931.                     
  932.                 strcat( buffer, classname );        
  933.             }
  934.             break;    
  935.         
  936.         
  937.         case ELEMENT_TYPE_SZARRAY:     
  938.             signature = BASEHELPER::ParseElementType( pMDImport, signature, buffer ); 
  939.             strcat( buffer, "[]" );
  940.             break;        
  941.         
  942.         
  943.         case ELEMENT_TYPE_ARRAY:    
  944.             {    
  945.                 ULONG rank;
  946.                 
  947.  
  948.                 signature = BASEHELPER::ParseElementType( pMDImport, signature, buffer );                 
  949.                 rank = CorSigUncompressData( signature );                                                    
  950.                 if ( rank == 0 ) 
  951.                     strcat( buffer, "[?]" );
  952.  
  953.                 else 
  954.                 {
  955.                     ULONG *lower;    
  956.                     ULONG *sizes;     
  957.                     ULONG numsizes; 
  958.                     ULONG arraysize = (sizeof ( ULONG ) * 2 * rank);
  959.                     
  960.                                          
  961.                     lower = (ULONG *)_alloca( arraysize );                                                        
  962.                     memset( lower, 0, arraysize ); 
  963.                     sizes = &lower[rank];
  964.  
  965.                     numsizes = CorSigUncompressData( signature );    
  966.                     if ( numsizes <= rank )
  967.                     {
  968.                         ULONG numlower;
  969.                         
  970.                         
  971.                         for ( ULONG i = 0; i < numsizes; i++ )    
  972.                             sizes[i] = CorSigUncompressData( signature );    
  973.                         
  974.                         
  975.                         numlower = CorSigUncompressData( signature );    
  976.                         if ( numlower <= rank )
  977.                         {
  978.                             for ( i = 0; i < numlower; i++)    
  979.                                 lower[i] = CorSigUncompressData( signature ); 
  980.                             
  981.                             
  982.                             strcat( buffer, "[" );    
  983.                             for ( i = 0; i < rank; i++ )    
  984.                             {    
  985.                                 if ( (sizes[i] != 0) && (lower[i] != 0) )    
  986.                                 {    
  987.                                     if ( lower[i] == 0 )    
  988.                                         sprintf ( buffer, "%d", sizes[i] );    
  989.  
  990.                                     else    
  991.                                     {    
  992.                                         sprintf( buffer, "%d", lower[i] );    
  993.                                         strcat( buffer, "..." );    
  994.                                         
  995.                                         if ( sizes[i] != 0 )    
  996.                                             sprintf( buffer, "%d", (lower[i] + sizes[i] + 1) );    
  997.                                     }    
  998.                                 }
  999.                                     
  1000.                                 if ( i < (rank - 1) ) 
  1001.                                     strcat( buffer, "," );    
  1002.                             }    
  1003.                             
  1004.                             strcat( buffer, "]" );  
  1005.                         }                        
  1006.                     }
  1007.                 }
  1008.             } 
  1009.             break;    
  1010.  
  1011.         
  1012.         case ELEMENT_TYPE_PINNED:
  1013.             signature = BASEHELPER::ParseElementType( pMDImport, signature, buffer ); 
  1014.             strcat( buffer, "pinned" );    
  1015.             break;    
  1016.          
  1017.         
  1018.         case ELEMENT_TYPE_PTR:   
  1019.             signature = BASEHELPER::ParseElementType( pMDImport, signature, buffer ); 
  1020.             strcat( buffer, "*" );    
  1021.             break;   
  1022.         
  1023.         
  1024.         case ELEMENT_TYPE_BYREF:   
  1025.             signature = BASEHELPER::ParseElementType( pMDImport, signature, buffer ); 
  1026.             strcat( buffer, "&" );    
  1027.             break;              
  1028.  
  1029.  
  1030.         default:    
  1031.         case ELEMENT_TYPE_END:    
  1032.         case ELEMENT_TYPE_SENTINEL:    
  1033.             strcat( buffer, "<UNKNOWN>" );    
  1034.             break;                                                                  
  1035.                             
  1036.     } // switch    
  1037.     
  1038.     
  1039.     return signature;
  1040.  
  1041. } // BASEHELPER::ParseElementType
  1042.  
  1043.  
  1044. /***************************************************************************************
  1045.  *    Method:
  1046.  *
  1047.  *
  1048.  *    Purpose:
  1049.  *
  1050.  *
  1051.  *    Parameters: 
  1052.  *
  1053.  *
  1054.  *    Return value:
  1055.  *
  1056.  *
  1057.  *    Notes:
  1058.  *
  1059.  ***************************************************************************************/
  1060. DECLSPEC
  1061. /* static public */
  1062. HRESULT BASEHELPER::GetFunctionProperties( ICorProfilerInfo *pPrfInfo,
  1063.                                            FunctionID functionID,
  1064.                                            BOOL *isStatic,
  1065.                                            ULONG *argCount,
  1066.                                            WCHAR *returnTypeStr, 
  1067.                                            WCHAR *functionParameters,
  1068.                                            WCHAR *functionName )
  1069. {
  1070.     HRESULT hr = E_FAIL; // assume success
  1071.     
  1072.         
  1073.  
  1074.     // init return values
  1075.     *argCount = 0;
  1076.     *isStatic = FALSE;
  1077.     returnTypeStr[0] = NULL; 
  1078.     functionParameters[0] = NULL;
  1079.     functionName[0] = NULL;
  1080.  
  1081.  
  1082.     if ( functionID != NULL )
  1083.     {
  1084.         mdToken    token;
  1085.         ClassID classID;
  1086.         IMetaDataImport *pMDImport = NULL;        
  1087.         WCHAR funName[MAX_LENGTH] = L"UNKNOWN";
  1088.                 
  1089.                 
  1090.         
  1091.         //
  1092.         // Get the classID 
  1093.         //
  1094.         hr = pPrfInfo->GetFunctionInfo( functionID,
  1095.                                         &classID,
  1096.                                         NULL,
  1097.                                         NULL );
  1098.         if ( SUCCEEDED( hr ) )
  1099.         {
  1100.             //
  1101.             // Get the MetadataImport interface and the metadata token 
  1102.             //
  1103.             hr = pPrfInfo->GetTokenAndMetaDataFromFunction( functionID, 
  1104.                                                                 IID_IMetaDataImport, 
  1105.                                                             (IUnknown **)&pMDImport,
  1106.                                                             &token );
  1107.             if ( SUCCEEDED( hr ) )
  1108.             {
  1109.                 hr = pMDImport->GetMethodProps( token,
  1110.                                                 NULL,
  1111.                                                 funName,
  1112.                                                 MAX_LENGTH,
  1113.                                                 0,
  1114.                                                 0,
  1115.                                                 NULL,
  1116.                                                 NULL,
  1117.                                                 NULL, 
  1118.                                                 NULL );
  1119.                 if ( SUCCEEDED( hr ) )
  1120.                 {
  1121.                     mdTypeDef classToken = NULL;
  1122.                     WCHAR className[MAX_LENGTH] = L"UNKNOWN";
  1123.  
  1124.  
  1125.                     hr = pPrfInfo->GetClassIDInfo( classID, 
  1126.                                                    NULL,  
  1127.                                                    &classToken );
  1128.                     
  1129.                     if SUCCEEDED( hr )
  1130.                     {
  1131.                           if ( classToken != mdTypeDefNil )
  1132.                         {
  1133.                               hr = pMDImport->GetTypeDefProps( classToken, 
  1134.                                                              className, 
  1135.                                                              MAX_LENGTH,
  1136.                                                              NULL, 
  1137.                                                              NULL, 
  1138.                                                              NULL ); 
  1139.                         }
  1140.                         swprintf( functionName, L"%s::%s", className, funName );                    
  1141.  
  1142.  
  1143.                         DWORD methodAttr = 0;
  1144.                         PCCOR_SIGNATURE sigBlob = NULL;
  1145.  
  1146.  
  1147.                         hr = pMDImport->GetMethodProps( (mdMethodDef) token,
  1148.                                                         NULL,
  1149.                                                         NULL,
  1150.                                                         0,
  1151.                                                         NULL,
  1152.                                                         &methodAttr,
  1153.                                                         &sigBlob,
  1154.                                                         NULL,
  1155.                                                         NULL,
  1156.                                                         NULL );
  1157.                         if ( SUCCEEDED( hr ) )
  1158.                         {
  1159.                             ULONG callConv;
  1160.  
  1161.  
  1162.                             //
  1163.                             // Is the method static ?
  1164.                             //
  1165.                             (*isStatic) = (BOOL)((methodAttr & mdStatic) != 0);
  1166.  
  1167.                              //
  1168.                             // Make sure we have a method signature.
  1169.                             //
  1170.                             char buffer[2 * MAX_LENGTH];
  1171.                             
  1172.                             
  1173.                             sigBlob += CorSigUncompressData( sigBlob, &callConv );
  1174.                             if ( callConv != IMAGE_CEE_CS_CALLCONV_FIELD )
  1175.                             {
  1176.                                 static WCHAR* callConvNames[8] = 
  1177.                                 {    
  1178.                                     L"", 
  1179.                                     L"unmanaged cdecl ", 
  1180.                                     L"unmanaged stdcall ",    
  1181.                                     L"unmanaged thiscall ",    
  1182.                                     L"unmanaged fastcall ",    
  1183.                                     L"vararg ",     
  1184.                                     L"<error> "     
  1185.                                     L"<error> "     
  1186.                                 };    
  1187.                                 buffer[0] = '\0';
  1188.                                 if ( (callConv & 7) != 0 )
  1189.                                     sprintf( buffer, "%s ", callConvNames[callConv & 7]);    
  1190.                                 
  1191.                                 //
  1192.                                 // Grab the argument count
  1193.                                 //
  1194.                                 sigBlob += CorSigUncompressData( sigBlob, argCount );
  1195.  
  1196.                                 //
  1197.                                 // Get the return type
  1198.                                 //
  1199.                                 sigBlob = ParseElementType( pMDImport, sigBlob, buffer );
  1200.  
  1201.                                 //
  1202.                                 // if the return typ returned back empty, write void
  1203.                                 //
  1204.                                 if ( buffer[0] == '\0' )
  1205.                                     sprintf( buffer, "void" );
  1206.  
  1207.                                 swprintf( returnTypeStr, L"%S",buffer );
  1208.                                 
  1209.                                 //
  1210.                                 // Get the parameters
  1211.                                 //                                
  1212.                                 for ( ULONG i = 0; 
  1213.                                       (SUCCEEDED( hr ) && (sigBlob != NULL) && (i < (*argCount))); 
  1214.                                       i++ )
  1215.                                 {
  1216.                                     buffer[0] = '\0';
  1217.  
  1218.                                     sigBlob = ParseElementType( pMDImport, sigBlob, buffer );                                    
  1219.                                     if ( i == 0 )
  1220.                                         swprintf( functionParameters, L"%S", buffer );
  1221.  
  1222.                                     else if ( sigBlob != NULL )
  1223.                                         swprintf( functionParameters, L"%s+%S", functionParameters, buffer );
  1224.                                     
  1225.                                     else
  1226.                                         hr = E_FAIL;
  1227.                                 }                                                                    
  1228.                             }
  1229.                             else
  1230.                             {
  1231.                                 //
  1232.                                 // Get the return type
  1233.                                 //
  1234.                                 buffer[0] = '\0';
  1235.                                 sigBlob = ParseElementType( pMDImport, sigBlob, buffer );
  1236.                                 swprintf( returnTypeStr, L"%s %S",returnTypeStr, buffer );
  1237.                             }
  1238.                         } 
  1239.                     } 
  1240.                 } 
  1241.  
  1242.                 pMDImport->Release();
  1243.             }         
  1244.         } 
  1245.     }
  1246.     //
  1247.     // This corresponds to an unmanaged frame
  1248.     //
  1249.     else
  1250.     {
  1251.         //
  1252.         // Set up return parameters
  1253.         //
  1254.         hr = S_OK;
  1255.         swprintf( functionName, L"UNMANAGED FRAME" );    
  1256.     }
  1257.  
  1258.     
  1259.     return hr;
  1260.  
  1261. } // BASEHELPER::GetFunctionProperties
  1262.  
  1263.  
  1264. /***************************************************************************************
  1265.  *    Method:
  1266.  *
  1267.  *
  1268.  *    Purpose:
  1269.  *
  1270.  *
  1271.  *    Parameters: 
  1272.  *
  1273.  *
  1274.  *    Return value:
  1275.  *
  1276.  *
  1277.  *    Notes:
  1278.  *
  1279.  ***************************************************************************************/
  1280. DECLSPEC
  1281. /* static public */
  1282. void BASEHELPER::Indent( DWORD indent )
  1283. {
  1284.     for ( DWORD i = 0; i < indent; i++ )
  1285.         LOG_TO_FILE( ("   ") )
  1286.  
  1287. } // BASEHELPER::Indent
  1288.  
  1289.  
  1290. /***************************************************************************************
  1291.  *    Method:
  1292.  *
  1293.  *
  1294.  *    Purpose:
  1295.  *
  1296.  *
  1297.  *    Parameters: 
  1298.  *
  1299.  *
  1300.  *    Return value:
  1301.  *
  1302.  *
  1303.  *    Notes:
  1304.  *
  1305.  ***************************************************************************************/
  1306. /* public */
  1307. char *BASEHELPER::GetEERegistryKeySTRING( char *regKeyName )
  1308. {
  1309.     DWORD type;
  1310.     DWORD size;
  1311.     HKEY userKey = NULL;
  1312.     HKEY machineKey = NULL;
  1313.     char *retValue = NULL;
  1314.     char buffer[MAX_LENGTH];
  1315.  
  1316.  
  1317.     //
  1318.     // local machine
  1319.     //
  1320.     size = MAX_LENGTH;
  1321.     if ( (RegOpenKeyExA( HKEY_LOCAL_MACHINE, 
  1322.                            EE_REGISTRY_ROOT,
  1323.                          0, 
  1324.                            KEY_READ, 
  1325.                          &machineKey ) == ERROR_SUCCESS) &&
  1326.  
  1327.             (RegQueryValueExA( machineKey, 
  1328.                              regKeyName, 
  1329.                              0, 
  1330.                              &type, 
  1331.                              (LPBYTE)&buffer, 
  1332.                              &size ) == ERROR_SUCCESS) &&
  1333.           
  1334.           (type == REG_SZ) )
  1335.        {                            
  1336.            retValue = new char[size + 1];
  1337.            sprintf( retValue, "%s", buffer );  
  1338.                  
  1339.         printf( "Registry LM Variable: %s=%s\n", regKeyName, retValue );
  1340.     }
  1341.     //
  1342.     // current user
  1343.     //
  1344.     else if ( (RegOpenKeyExA( HKEY_CURRENT_USER, 
  1345.                               EE_REGISTRY_ROOT, 
  1346.                               0, 
  1347.                               KEY_READ, 
  1348.                               &userKey ) == ERROR_SUCCESS) &&
  1349.              
  1350.               (RegQueryValueExA( userKey, 
  1351.                                  regKeyName, 
  1352.                                  0, 
  1353.                                  &type, 
  1354.                                  (LPBYTE)&buffer, 
  1355.                                  &size ) == ERROR_SUCCESS) &&
  1356.  
  1357.               (type == REG_SZ) )
  1358.        {                                        
  1359.         retValue = new char[size + 1];
  1360.            sprintf( retValue, "%s", buffer );  
  1361.                  
  1362.         printf( "Registry CU Variable: %s=%s\n", regKeyName, retValue );    
  1363.     }
  1364.  
  1365.     RegCloseKey( userKey );                
  1366.     RegCloseKey( machineKey );
  1367.        
  1368.        
  1369.        return retValue; 
  1370.  
  1371. } // BASEHELPER::GetEERegistryKeySTRING
  1372.  
  1373.  
  1374. /***************************************************************************************
  1375.  *    Method:
  1376.  *
  1377.  *
  1378.  *    Purpose:
  1379.  *
  1380.  *
  1381.  *    Parameters: 
  1382.  *
  1383.  *
  1384.  *    Return value:
  1385.  *
  1386.  *
  1387.  *    Notes:
  1388.  *
  1389.  ***************************************************************************************/
  1390. /* public */
  1391. DWORD BASEHELPER::GetEERegistryKeyDWORD( char *regKeyName )
  1392. {
  1393.     DWORD type;
  1394.     DWORD size;
  1395.     DWORD retValue = -1;
  1396.     HKEY userKey = NULL;
  1397.     HKEY machineKey = NULL;
  1398.  
  1399.  
  1400.     //
  1401.     // local machine
  1402.     //
  1403.     size = 4;
  1404.     if ( (RegOpenKeyExA( HKEY_LOCAL_MACHINE, 
  1405.                            EE_REGISTRY_ROOT,
  1406.                          0, 
  1407.                            KEY_READ, 
  1408.                          &machineKey ) == ERROR_SUCCESS) &&
  1409.  
  1410.             (RegQueryValueExA( machineKey, 
  1411.                              regKeyName, 
  1412.                              0, 
  1413.                              &type, 
  1414.                              (LPBYTE)&retValue, 
  1415.                              &size ) == ERROR_SUCCESS) &&
  1416.           
  1417.           (type == REG_DWORD) )
  1418.        {                                        
  1419.         printf( "Registry LM Variable: %s=%d\n", regKeyName, retValue );
  1420.     }
  1421.     //
  1422.     // current user
  1423.     //
  1424.     else if ( (RegOpenKeyExA( HKEY_CURRENT_USER, 
  1425.                               EE_REGISTRY_ROOT, 
  1426.                               0, 
  1427.                               KEY_READ, 
  1428.                               &userKey ) == ERROR_SUCCESS) &&
  1429.              
  1430.               (RegQueryValueExA( userKey, 
  1431.                                  regKeyName, 
  1432.                                  0, 
  1433.                                  &type, 
  1434.                                  (LPBYTE)&retValue, 
  1435.                                  &size ) == ERROR_SUCCESS) &&
  1436.  
  1437.               (type == REG_DWORD) )
  1438.        {                                        
  1439.         printf( "Registry CU Variable: %s=%d\n", regKeyName, retValue );
  1440.     }
  1441.  
  1442.     RegCloseKey( userKey );                
  1443.     RegCloseKey( machineKey );
  1444.        
  1445.        
  1446.        return retValue; 
  1447.  
  1448. } // BASEHELPER::GetEERegistryKeyDWORD
  1449.  
  1450.  
  1451. /***************************************************************************************
  1452.  *    Method:
  1453.  *
  1454.  *
  1455.  *    Purpose:
  1456.  *
  1457.  *
  1458.  *    Parameters: 
  1459.  *
  1460.  *
  1461.  *    Return value:
  1462.  *
  1463.  *
  1464.  *    Notes:
  1465.  *
  1466.  ***************************************************************************************/
  1467. DECLSPEC
  1468. /* static public */
  1469. ULONG BASEHELPER::GetElementType( PCCOR_SIGNATURE pSignature, CorElementType *pType, BOOL bDeepParse )
  1470. {
  1471.     ULONG index = 0;
  1472.     mdToken typeRef;
  1473.     ULONG elementType;
  1474.     ULONG tempType;
  1475.     
  1476.     
  1477.     // picking apart primitive types is easy;  
  1478.     // the ones below require a bit more processing
  1479.     index += CorSigUncompressData( &pSignature[index], &elementType );                   
  1480.     switch ( elementType )
  1481.     {
  1482.         // SENTINEL, PINNED and BYREF are not types, just modifiers
  1483.         case ELEMENT_TYPE_SENTINEL:
  1484.         case ELEMENT_TYPE_BYREF:    
  1485.         case ELEMENT_TYPE_PINNED:
  1486.                 DEBUG_OUT( ("**** PROCESSING SENTINEL/PINNED/BYREF ****") )
  1487.                 index += GetElementType( &pSignature[index], (CorElementType *)&elementType, bDeepParse );
  1488.                 break;
  1489.  
  1490.  
  1491.         case ELEMENT_TYPE_PTR:
  1492.         case ELEMENT_TYPE_SZARRAY:  
  1493.                 DEBUG_OUT( ("**** PROCESSING PTR/SZARRAY ****") )
  1494.                 if ( bDeepParse )
  1495.                     index += GetElementType( &pSignature[index], (CorElementType *)&elementType );
  1496.                 else
  1497.                     index += GetElementType( &pSignature[index], (CorElementType *)&tempType );
  1498.  
  1499.                 break;
  1500.                         
  1501.                         
  1502.         case ELEMENT_TYPE_CLASS:
  1503.         case ELEMENT_TYPE_VALUETYPE:                                             
  1504.                 DEBUG_OUT( ("**** PROCESSING CLASS/OBJECT/VALUECLASS ****") )
  1505.                 index += CorSigUncompressToken( &pSignature[index], &typeRef );
  1506.                 break;                   
  1507.                     
  1508.  
  1509.         case ELEMENT_TYPE_CMOD_OPT:
  1510.         case ELEMENT_TYPE_CMOD_REQD:                                                            
  1511.                 DEBUG_OUT( ("**** PROCESSING CMOD_OPT/CMOD_REQD ****") )
  1512.                 index += CorSigUncompressToken( &pSignature[index], &typeRef ); 
  1513.                 if ( bDeepParse )
  1514.                     index += GetElementType( &pSignature[index], (CorElementType *)&elementType );                                                                                                                                   
  1515.                 else
  1516.                     index += GetElementType( &pSignature[index], (CorElementType *)&tempType );
  1517.  
  1518.                 break;                                            
  1519.  
  1520.  
  1521.         case ELEMENT_TYPE_ARRAY:     
  1522.                 DEBUG_OUT( ("**** PROCESSING ARRAY ****") )
  1523.                 if ( bDeepParse )
  1524.                     index += ProcessArray( &pSignature[index], (CorElementType *)&elementType );                                                                                                                                   
  1525.                 else
  1526.                     index += ProcessArray( &pSignature[index], (CorElementType *)&tempType );
  1527.  
  1528.                 break;
  1529.  
  1530.  
  1531.         case ELEMENT_TYPE_FNPTR:     
  1532.                 DEBUG_OUT( ("**** PROCESSING FNPTR ****") )
  1533.  
  1534.                 // !!! this will throw exception !!!
  1535.                 index += ProcessMethodDefRef( &pSignature[index], (CorElementType *)&tempType );                                                                                                                                   
  1536.  
  1537.                 break;                                            
  1538.                 
  1539.     } // switch
  1540.  
  1541.     *pType = (CorElementType)elementType;
  1542.     
  1543.  
  1544.     return index;
  1545.  
  1546. } // BASEHELPER::GetElementType
  1547.  
  1548.  
  1549. /***************************************************************************************
  1550.  *    Method:
  1551.  *
  1552.  *
  1553.  *    Purpose:
  1554.  *
  1555.  *
  1556.  *    Parameters: 
  1557.  *
  1558.  *
  1559.  *    Return value:
  1560.  *
  1561.  *
  1562.  *    Notes:
  1563.  *
  1564.  ***************************************************************************************/
  1565. DECLSPEC
  1566. /* static public */
  1567. ULONG BASEHELPER::ProcessArray( PCCOR_SIGNATURE pSignature, CorElementType *pType )
  1568. {
  1569.     ULONG index = 0;
  1570.     ULONG rank;
  1571.  
  1572.  
  1573.     index += GetElementType( &pSignature[index], pType );                                                                                                                                   
  1574.     index += CorSigUncompressData( &pSignature[index], &rank );
  1575.     if ( rank > 0 )
  1576.     {
  1577.         UINT i;
  1578.         ULONG sizes;
  1579.         ULONG lowers;
  1580.  
  1581.  
  1582.         index += CorSigUncompressData( &pSignature[index], &sizes );
  1583.         for ( i = 0; i < sizes; i++ ) 
  1584.         {
  1585.             ULONG dimension;
  1586.  
  1587.  
  1588.             index += CorSigUncompressData( &pSignature[index], &dimension );
  1589.         } // for
  1590.  
  1591.         
  1592.         index += CorSigUncompressData( &pSignature[index], &lowers );
  1593.         for ( i = 0; i < lowers; i++ )
  1594.         {
  1595.             int lowerBound;
  1596.  
  1597.  
  1598.             index += CorSigUncompressSignedInt( &pSignature[index], &lowerBound );
  1599.         } // for
  1600.     }
  1601.  
  1602.  
  1603.     return index;
  1604.     
  1605. } // BASEHELPER::ProcessArray
  1606.  
  1607.  
  1608. /***************************************************************************************
  1609.  *    Method:
  1610.  *
  1611.  *
  1612.  *    Purpose:
  1613.  *
  1614.  *
  1615.  *    Parameters: 
  1616.  *
  1617.  *
  1618.  *    Return value:
  1619.  *
  1620.  *
  1621.  *    Notes:
  1622.  *
  1623.  ***************************************************************************************/
  1624. DECLSPEC
  1625. /* static public */
  1626. ULONG BASEHELPER::ProcessMethodDefRef( PCCOR_SIGNATURE pSignature, CorElementType *pType )
  1627. {
  1628.     _THROW_EXCEPTION( "**** ELEMENT_TYPE_FNPTR not supported by the framework ****" )
  1629.  
  1630.     return 0;
  1631.     
  1632. } // BASEHELPER::ProcessArray
  1633.  
  1634. // End of File
  1635.  
  1636.