开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
hxwinver.cpp
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：30k
源码类别：

Symbian

开发平台：

C/C++

hxwinver.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. #include "hxtypes.h"
  38. #ifdef _WINDOWS
  39. #include <windows.h>
  40. #include <stdlib.h>             // needed for _MAX_PATH
  41. #include <string.h>             // needed for strXXX() functions
  42. #endif
  44. #ifdef _MACINTOSH
  45. #include <stdio.h>
  46. #include <stdlib.h>
  47. #include <string.h>
  48. #ifndef _MAC_MACHO
  49. #include "OpenTransport.h"
  50. #endif
  51. //#include "productversion.r"
  52. #endif
  54. #if defined(HELIX_CONFIG_NOSTATICS)
  55. # include "globals/hxglobals.h"
  56. #endif
  57. #include "hxassert.h"
  58. #include "hxwinver.h"
  59. #include "dbcs.h"
  60. //#include "hlxclib/stdio.h"
  62. #ifdef _WIN32
  63. #include "hxdllldr.h"
  64. #endif
  66. #ifdef _UNIX
  67. #include <stdlib.h>
  68. #ifndef _VXWORKS
  69. #include <sys/utsname.h>
  70. #endif  // VXWORKS
  71. #endif
  72. #include "hxstrutl.h"
  74. #include "hxheap.h"
  75. #ifdef _DEBUG
  76. #undef HX_THIS_FILE
  77. static const char HX_THIS_FILE[] = __FILE__;
  78. #endif
  80. #ifdef _WINDOWS
  81. // Helper function for Win32.
  82. #if defined(_WIN32)
  83. BOOL IsCoProcessorPresentInWinNT(void);
  84. #else
  85. extern "C" int FAR PASCAL Is586( void );
  86. #endif
  87. #if defined(_WIN32) || defined(_WINDOWS)
  88. BOOL ExtractDistributionCode(char* pDistBuffer, HMODULE hModule);
  89. #endif
  90. #endif //_WINDOWS
  92. // Helper functions for macintosh
  93. #if defined(_MACINTOSH) || defined(_MAC_UNIX)
  94. void    GetMacSystemVersion(UINT16      *major, UINT16  *minor, UINT16  *release);
  96. #if !defined(_CARBON) && !defined(_MAC_UNIX)
  97. BOOL    IsPPC(void);
  98. BOOL    HasFPU(void);
  99. BOOL    HasOpenTransport (void);
  100. #endif
  101. #endif
  103. /*
  104. ** DWORD HXGetWinVer( HXVERSIONINFO *pVersionInfo )
  105. *
  106. *  PARAMETERS:
  107. *              pVersionInfo : A pointer to the version info struct to receive the
  108. *                             results.  (Can be NULL, in which case our only side
  109. *                             effect is our return value).
  110. *
  111. *  DESCRIPTION:
  112. *              Gets information on the Windows platform and version we are running on.
  113. *
  114. *  RETURNS:
  115. *              A flag indicating the platform we are running on.
  116. *
  117. *              If this is a 16bit build of a Helix module, then
  118. *              one of the following values is possible:
  119. *
  120. *                      HX_PLATFORM_WINNT
  121. *                      HX_PLATFORM_WIN95
  122. *                      HX_PLATFORM_WIN16
  123. *
  124. *              If this is a 32bit build of a Helix module, then
  125. *              one of the following values is possible:
  126. *
  127. *                      HX_PLATFORM_WINNT
  128. *                      HX_PLATFORM_WIN95
  129. *                      HX_PLATFORM_WIN32S
  130. *
  131. *  NOTES:
  132. *    The behavior of the GetVersion() API is totally different under
  133. *    16bit and 32bit builds. As such we have been forced to implement
  134. *    this function differently for each compiler version.
  135. *
  136. */
  138. ULONG32 HXGetWinVer( HXVERSIONINFO* lpVersionInfo )
  139. {
  140.     HXVERSIONINFO       rVersionInfo;
  142.     // Initialize Defaults!
  143.     rVersionInfo.dwPlatformId  = HX_PLATFORM_UNKNOWN;
  144.     rVersionInfo.dwMachineType = HX_MACHINE_UNKNOWN;
  145.     rVersionInfo.wMajorVersion = 0;
  146.     rVersionInfo.wMinorVersion = 0;
  147.     rVersionInfo.wReleaseVersion = 0;
  148.     rVersionInfo.bFPUAvailable = FALSE;
  150. #ifdef _WINDOWS ////////// WINDOWS SPECIFIC //////////
  152. #ifdef _WIN32
  153.     OSVERSIONINFO osVersionInfo;
  154.     memset(&osVersionInfo, 0, sizeof(OSVERSIONINFO));
  155.     osVersionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
  156.     GetVersionEx(&osVersionInfo);
  157.     rVersionInfo.wMajorVersion = (UINT16)(osVersionInfo.dwMajorVersion);
  158.     rVersionInfo.wMinorVersion = (UINT16)(osVersionInfo.dwMinorVersion);
  159.     rVersionInfo.wReleaseVersion = (UINT16)(osVersionInfo.dwBuildNumber);
  160.     BOOL bIsNT = (osVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_NT);
  161. #else
  162.     ULONG32 dwVersion = GetVersion();
  163.     rVersionInfo.wMajorVersion = (WORD)(LOBYTE( LOWORD( dwVersion ) ));
  164.     rVersionInfo.wMinorVersion = (WORD)(HIBYTE( LOWORD( dwVersion ) ));
  165.     BOOL bIsNT = ((GetWinFlags() & 0x4000) == 0x4000);
  166. #endif
  169.     if (bIsNT)
  170.     {
  171.         // Windows NT
  172.         rVersionInfo.dwPlatformId = HX_PLATFORM_WINNT;
  173.     }
  175. #ifdef _WIN32
  176.     // In a 32bit build, we call GetVersionEx:
  177.     // Win95 returns MajorVersion 4, MinorVersion 0
  178.     // Win98 returns MajorVersion 4, MinorVersion 10
  179.     //
  180.     else if (rVersionInfo.wMajorVersion < 4)
  181.     {
  182.         // Win32s
  183.         rVersionInfo.dwPlatformId = HX_PLATFORM_WIN32S;
  184.     }
  185.     else if (rVersionInfo.wMajorVersion == 4)
  186.     {
  187.         if (rVersionInfo.wMinorVersion < 10)
  188.         {
  189.             // Win95
  190.             rVersionInfo.dwPlatformId = HX_PLATFORM_WIN95;
  191.         }
  192.         else        {
  193.             // Windows 98
  194.             rVersionInfo.dwPlatformId = HX_PLATFORM_WIN98;
  195.         }
  196.     }
  197. #else
  198.     // In a 16bit build, we call GetVersion:
  199.     // Win95 returns MajorVersion 3, MinorVersion 95
  200.     // Win98 returns MajorVersion ??, MinorVersion ??
  201.     //
  202.     else if (rVersionInfo.wMajorVersion == 3)
  203.     {
  204.         if (rVersionInfo.wMinorVersion < 95)
  205.         {
  206.             // Win16
  207.             rVersionInfo.dwPlatformId = HX_PLATFORM_WIN16;
  208.         }
  209.         else if (rVersionInfo.wMinorVersion < 98)
  210.         {
  211.             // Windows 98
  212.             rVersionInfo.dwPlatformId = HX_PLATFORM_WIN95;
  213.         }
  214.         // XXXBJP need to confirm minorVersion > 95 in 16-bit Win98
  215.         else 
  216.         {
  217.             // Windows 98
  218.             rVersionInfo.dwPlatformId = HX_PLATFORM_WIN98;
  219.         }
  220.     }
  221. #endif
  223.     // Don't bother with any of the rest of this code, if no
  224.     // struct was passed in!!!!!
  226.     if (lpVersionInfo)
  227.     {
  228.         // Determine processor and FPU capabilities...
  229. #if defined(_WIN32)
  230.         SYSTEM_INFO     sysInfo;
  231.         GetSystemInfo(&sysInfo);
  233.         switch (sysInfo.wProcessorArchitecture)
  234.         {
  235.            case PROCESSOR_ARCHITECTURE_INTEL:
  236.            {
  237.                rVersionInfo.dwMachineType = HX_MACHINE_UNKNOWN;
  239.                // Only Newer versions of NT correctly supports wProcessorLevel.
  240.                if       (
  241.                    bIsNT
  242.                    &&
  243.                    (
  244.                        (rVersionInfo.wMajorVersion > 3)
  245.                        ||
  246.                        (rVersionInfo.wMajorVersion == 3 && rVersionInfo.wMinorVersion >= 50)
  247.                        )
  248.                    )
  249.                {
  250.                    int nVerGreaterThan486 = (sysInfo.wProcessorLevel - 4);
  251.                    if (nVerGreaterThan486 < 0)
  252.                    {
  253.                        rVersionInfo.dwMachineType = HX_MACHINE_TOOSLOW;
  254.                    }
  255.                    else if (nVerGreaterThan486 == 0)
  256.                    {
  257.                        rVersionInfo.dwMachineType = HX_MACHINE_486;
  258.                    }
  259.                    else if (nVerGreaterThan486 == 1)
  260.                    {
  261.                        rVersionInfo.dwMachineType = HX_MACHINE_586;
  262.                    }
  263.                    else if (nVerGreaterThan486 == 2)
  264.                    {
  265.                        rVersionInfo.dwMachineType = HX_MACHINE_686;
  266.                    }
  267.                    else
  268.                    {
  269.                        rVersionInfo.dwMachineType = HX_MACHINE_UNKNOWN;
  270.                    }
  271.                }
  272.                else
  273.                {
  274.                    // Win95, Win32s, and old versions of NT don't correctly support
  275.                    // Processor level, so instead we look at dwProcessorType
  276.                    switch (sysInfo.dwProcessorType)
  277.                    {
  278.                       case PROCESSOR_INTEL_386:      rVersionInfo.dwMachineType = HX_MACHINE_TOOSLOW;  break;
  279.                       case PROCESSOR_INTEL_486:      rVersionInfo.dwMachineType = HX_MACHINE_486;      break;
  280.                       case PROCESSOR_INTEL_PENTIUM:  rVersionInfo.dwMachineType = HX_MACHINE_586;      break;
  281.                       default:                       rVersionInfo.dwMachineType = HX_MACHINE_UNKNOWN;  break;
  282.                    }
  283.                }
  284.            }
  285.            break;
  287.            case PROCESSOR_ARCHITECTURE_MIPS:
  288.            {
  289.                rVersionInfo.dwMachineType = HX_MACHINE_MIPS;
  290.            }
  291.            break;
  293.            case PROCESSOR_ARCHITECTURE_ALPHA:
  294.            {
  295.                rVersionInfo.dwMachineType = HX_MACHINE_ALPHA;
  296.            }
  297.            break;
  299.            case PROCESSOR_ARCHITECTURE_PPC:
  300.            {
  301.                rVersionInfo.dwMachineType = HX_MACHINE_PPC;
  302.            }
  303.            break;
  305.            default:
  306.            {
  307.                rVersionInfo.dwMachineType = HX_MACHINE_UNKNOWN;
  308.            }
  309.            break;
  310.         }
  312.         rVersionInfo.bFPUAvailable = IsCoProcessorPresentInWinNT();
  314. #else
  315.         DWORD dwWinFlags = GetWinFlags();
  316.         if      (
  317.             (dwWinFlags & WF_CPU386)
  318.             ||
  319.             (dwWinFlags & WF_CPU286)
  320.             ||
  321.             (dwWinFlags & WF_CPU186)
  322.             ||
  323.             (dwWinFlags & WF_CPU086)
  324.             )
  325.         {
  326.             rVersionInfo.dwMachineType = HX_MACHINE_TOOSLOW;
  327.         }
  328.         if (dwWinFlags & WF_CPU486)
  329.         {
  330. #ifdef _WIN16
  331.             //=-=w16.3 Is586() asserts pentium.obj; must be fixed; #ifdefed to TRUE
  332.             int nVerGreaterThan486 = TRUE;
  333. #else
  334.             int nVerGreaterThan486 = Is586();
  335. #endif
  336.             switch(nVerGreaterThan486)
  337.             {
  338.                case 0:  rVersionInfo.dwMachineType = HX_MACHINE_486;     break;
  339.                case 1:  rVersionInfo.dwMachineType = HX_MACHINE_586;     break;
  340.                case 2:  rVersionInfo.dwMachineType = HX_MACHINE_686;     break;
  341.                default: rVersionInfo.dwMachineType = HX_MACHINE_UNKNOWN; break;
  342.             }
  343.         }
  344.         if (dwWinFlags & WF_80x87)
  345.         {
  346.             rVersionInfo.bFPUAvailable = TRUE;
  347.         }
  348. #endif
  349.     }
  352. ////////// END WINDOWS SPECIFIC //////////
  354. ////////// START MACINTOSH SPECIFIC CODE//////////
  355. #elif defined(_MACINTOSH) || defined(_MAC_UNIX)
  358. #if defined(_CARBON) || defined(_MAC_UNIX)
  359.     rVersionInfo.dwPlatformId  = HX_PLATFORM_MACOT;
  360.     rVersionInfo.dwMachineType = HX_MACHINE_PPC;
  361.     rVersionInfo.bFPUAvailable = FALSE;
  362. #else
  363.     if (HasOpenTransport())
  364.         rVersionInfo.dwPlatformId  = HX_PLATFORM_MACOT;
  365.     else
  366.         rVersionInfo.dwPlatformId  = HX_PLATFORM_MACTCP;
  368.     if (IsPPC())
  369.         rVersionInfo.dwMachineType = HX_MACHINE_PPC;
  370.     else
  371.         rVersionInfo.dwMachineType = HX_MACHINE_68K;
  372.     rVersionInfo.bFPUAvailable = HasFPU();
  373. #endif
  374.     GetMacSystemVersion(&rVersionInfo.wMajorVersion,
  375.                         &rVersionInfo.wMinorVersion,
  376.                         &rVersionInfo.wReleaseVersion);
  379. ////////// END MACINTOSH SPECIFIC CODE////////////
  380. #elif defined(_UNIX)
  382.     struct utsname osInfo;   // structure to hold uname info
  383.     if (uname(&osInfo) != -1)
  384.     {
  385.         double nVersionNum = atof(osInfo.release);  // version number
  386.         char *pPeriod = NULL;
  387.         rVersionInfo.wMajorVersion = (UINT16)nVersionNum;
  388.         if (pPeriod = strchr(osInfo.release,'.'))
  389.             rVersionInfo.wMinorVersion = atoi(pPeriod+1);
  391.         // CODE FOR LINUX
  392. #ifdef _LINUX
  393.         // These are defaults, they are not 100% correct but they shouldn't be needed
  394.         rVersionInfo.dwPlatformId = HX_PLATFORM_LINUX;
  395.         rVersionInfo.dwMachineType = HX_MACHINE_586;
  397.         // CODE FOR SOLARIS
  398. #elif _SOLARIS
  399.         // These are defaults, they are not 100% correct but they shouldn't be needed
  400.         rVersionInfo.dwPlatformId = HX_PLATFORM_SOLARIS;
  401.         rVersionInfo.dwMachineType = HX_MACHINE_SPARC;
  403.         // do platform mapping
  404.         if (!strcasecmp("SunOS",osInfo.sysname))
  405.         {
  406.             if (nVersionNum > 5.0)
  407.                 rVersionInfo.dwPlatformId = HX_PLATFORM_SOLARIS;
  408.             else
  409.                 rVersionInfo.dwPlatformId = HX_PLATFORM_SUNOS;
  410.         }
  412.         // do machine mapping
  413.         if (!strcasecmp("sun4m",osInfo.machine))
  414.             rVersionInfo.dwMachineType = HX_MACHINE_SPARC;
  416.         // CODE FOR IRIX
  417. #elif _IRIX
  418.         rVersionInfo.dwPlatformId = HX_PLATFORM_IRIX;
  419.         rVersionInfo.dwMachineType = HX_MACHINE_MIPS;
  421.         // CODE FOR SUNOS
  422. #elif _SUNOS
  423.         // These are defaults, they are not 100% correct but they shouldn't be needed
  424.         rVersionInfo.dwPlatformId = HX_PLATFORM_SUNOS;
  425.         rVersionInfo.dwMachineType = HX_MACHINE_SPARC;
  427.         // do platform mapping
  428.         if (!strcasecmp("SunOS",osInfo.sysname))
  429.         {
  430.             if (nVersionNum > 5.0)
  431.                 rVersionInfo.dwPlatformId = HX_PLATFORM_SOLARIS;
  432.             else
  433.                 rVersionInfo.dwPlatformId = HX_PLATFORM_SUNOS;
  434.         }
  436.         // do machine mapping
  437.         if (!strcasecmp("sun4m",osInfo.machine))
  438.             rVersionInfo.dwMachineType = HX_MACHINE_SPARC;
  440. #else
  441.         rVersionInfo.dwPlatformId = HX_PLATFORM_UNKNOWN;
  442.         rVersionInfo.dwMachineType = HX_MACHINE_UNKNOWN;
  443. #endif
  445.     }
  446.     rVersionInfo.bFPUAvailable = TRUE;
  448. ////////// END UNIX SPECIFIC CODE////////////
  449. #elif defined(_SYMBIAN)
  450.     
  451.     rVersionInfo.dwPlatformId  = HX_PLATFORM_SYMBIAN;
  452. #ifdef __WINS__    
  453.     rVersionInfo.dwMachineType = HX_MACHINE_SYMEMULATOR;
  454. #else
  455.     rVersionInfo.dwMachineType = HX_MACHINE_ARM;
  456. #endif
  457.     //XXGFW need to not hard code this.
  458.     rVersionInfo.wMajorVersion   = 6;
  459.     rVersionInfo.wMinorVersion   = 1;
  460.     rVersionInfo.wReleaseVersion = 0;
  461.     rVersionInfo.bFPUAvailable   = FALSE;
  462.     
  463. #elif defined(_OPENWAVE)
  464.     
  465.     rVersionInfo.dwPlatformId  = HX_PLATFORM_OPENWAVE;
  466. #ifdef _OPENWAVE_SIMULATOR
  467.     rVersionInfo.dwMachineType = HX_MACHINE_OWEMULATOR;
  468. #else
  469.     rVersionInfo.dwMachineType = HX_MACHINE_ARM;
  470. #endif
  472.     // XXXSAB need to not hard code this.
  473.     rVersionInfo.wMajorVersion   = 6;
  474.     rVersionInfo.wMinorVersion   = 1;
  475.     rVersionInfo.wReleaseVersion = 0;
  476.     rVersionInfo.bFPUAvailable   = FALSE;
  477.     
  478. #else
  481. #error Add your platform code here!
  483. #endif
  485.     if (lpVersionInfo)
  486.     {
  487.         *lpVersionInfo = rVersionInfo;
  488.     }
  489.     return( rVersionInfo.dwPlatformId );
  490. }
  493. /*
  494.  *      const char* HXGetOSName( ULONG32 nPlatformID)
  495.  *
  496.  *  PARAMETERS:
  497.  *              nPlatformID:    A platformID (defined in hxwinver.h)
  498.  *
  499.  *  DESCRIPTION:
  500.  *              Returns an OS string. Indicates the OS, not the build of
  501.  *      the player.
  502.  *
  503.  *  RETURNS:
  504.  *              pointer to static const buffer containing OS string.
  505.  */
  506. const char* HXGetOSName(ULONG32 nPlatformID)
  507. {
  508.     const char* strResult = NULL;
  510.     switch (nPlatformID)
  511.     {
  512.        case (HX_PLATFORM_WIN16) :
  513.            strResult="Win16";
  514.            break;
  516.        case (HX_PLATFORM_WIN32S) :
  517.            strResult="Win32S";
  518.            break;
  520.        case (HX_PLATFORM_WIN95) :
  521.            strResult="Win95";
  522.            break;
  524.        case (HX_PLATFORM_WIN98) :
  525.            strResult="Win98";
  526.            break;
  528.        case (HX_PLATFORM_WINNT) :
  529.            strResult="WinNT";
  530.            break;
  532.        case (HX_PLATFORM_MACOT) :
  533.            strResult="MacOT";
  534.            break;
  536.        case (HX_PLATFORM_MACTCP) :
  537.            strResult="MacTCP";
  538.            break;
  540.        case (HX_PLATFORM_LINUX) :
  541.            strResult="Linux";
  542.            break;
  544.        case (HX_PLATFORM_SOLARIS) :
  545.            strResult="Solaris";
  546.            break;
  548.        case (HX_PLATFORM_IRIX) :
  549.            strResult="Irix";
  550.            break;
  552.        case (HX_PLATFORM_SUNOS) :
  553.            strResult="SunOS";
  554.            break;
  556.        case (HX_PLATFORM_SYMBIAN):
  557.            strResult="Symbian";
  558.            break;
  560.        case (HX_PLATFORM_UNKNOWN) :
  561.        default:
  562.            strResult="UNK";
  563.            break;
  564.     }
  566.     return(strResult);
  567. }
  570. /*
  571.  *      const char* HXGetMachName(ULONG32 nMachineType)
  572.  *
  573.  *  PARAMETERS:
  574.  *              nMachineType:   A machine ID (defined in hxwinver.h)
  575.  *
  576.  *  DESCRIPTION:
  577.  *              Returns a Machine string. Indicates the installed CPU,
  578.  *      not the build of the player.
  579.  *
  580.  *  RETURNS:
  581.  *              pointer to static const buffer containing Machine string.
  582.  */
  583. const char* HXGetMachName(ULONG32 nMachineType)
  584. {
  585.     const char* pProcName = NULL;
  587.     switch (nMachineType)
  588.     {
  589.        case HX_MACHINE_486:
  590.            pProcName = "486";
  591.            break;
  593.        case HX_MACHINE_586:
  594.            pProcName = "586";
  595.            break;
  597.        case HX_MACHINE_686:
  598.            pProcName = "686";
  599.            break;
  601.        case HX_MACHINE_PPC:
  602.            pProcName = "PPC";
  603.            break;
  605.        case HX_MACHINE_68K:
  606.            pProcName = "68K";
  607.            break;
  609.        case HX_MACHINE_ALPHA:
  610.            pProcName = "Alpha";
  611.            break;
  613.        case HX_MACHINE_MIPS:
  614.            pProcName = "Mips";
  615.            break;
  617.        case HX_MACHINE_SPARC:
  618.            pProcName = "Sparc";
  619.            break;
  621.        case HX_MACHINE_TOOSLOW:
  622.            pProcName = "SLOW";
  623.            break;
  625.        case HX_MACHINE_ARM:
  626.            pProcName = "ARM";
  627.            break;
  629.        case HX_MACHINE_SYMEMULATOR:
  630.            pProcName = "SymbianEmulator";
  631.            break;
  632.  
  633.        case HX_MACHINE_UNKNOWN:
  634.        default:
  635.            pProcName = "UNK";
  636.            break;
  637.     }
  639.     return(pProcName);
  640. }
  642. /*
  643.  *      const char* HXGetVerEncodedName( HXVERSIONINFO* pVersionInfo,
  644.  *                                      const char* pProductName, const char* pProductVer,
  645.  *                                      const char* pDistCode)
  646.  *
  647.  *  PARAMETERS:
  648.  *              pVersionInfo :  A pointer to the version info struct to receive the
  649.  *                                              results.
  650.  *
  651.  *              pProductName :  A pointer to the name of the product like play16 for
  652.  *                                              the 16bit compiled player or plug32 for the 32bit
  653.  *                                              compiled plugin.
  654.  *
  655.  *              pProductVer :   A pointer to the string form of the version of the
  656.  *                                              product like 2.0b3.
  657.  *
  658.  *              pDistCode       :       A pointer to the string form of the version of the
  659.  *                                              distribution code like PN01 for the player.
  660.  *
  661.  *  DESCRIPTION:    
  663.  *              Returns a standard formatted encoded platform string.
  664.  *
  665.  *  RETURNS:
  666.  *              pointer to temporary buffer containing the encoded string.
  667.  */
  668. const char* HXGetVerEncodedName
  669. (
  670.     HXVERSIONINFO* pVersionInfo,
  671.     const char* pProductName,
  672.     const char* pProductVer,
  673.     const char* pLanguage,
  674.     const char* pDistCode
  675.     )
  676. {
  677. #if defined(HELIX_CONFIG_NOSTATICS)
  678.     static const char _szEncodedName = '';
  679.     char*& szEncodedName = HXGlobalCharArray::Get(&_szEncodedName, MAX_ENCODED_NAME, "" );
  680. #else
  681.     static char szEncodedName[MAX_ENCODED_NAME]; /* Flawfinder: ignore */
  682. #endif        
  684.     HX_ASSERT_VALID_READ_PTR(pVersionInfo);
  685.     HX_ASSERT_VALID_READ_PTR(pProductName);
  686.     HX_ASSERT_VALID_READ_PTR(pProductVer);
  687.     HX_ASSERT_VALID_READ_PTR(pLanguage);
  688.     HX_ASSERT_VALID_READ_PTR(pDistCode);
  690.     const char* pOSName = "UNK";
  691.     const char* pProcName = "UNK";
  693.     // Calculate OS Name from
  694.     pOSName = HXGetOSName(pVersionInfo->dwPlatformId);
  696.     // CPU/Process/machine. same thing...
  697.     pProcName = HXGetMachName(pVersionInfo->dwMachineType);
  699. #ifdef _MACINTOSH
  700.     // Macintosh OS version currently includes a wReleaseVersion number.
  701.     SafeSprintf(szEncodedName,MAX_ENCODED_NAME,"%s_%d.%d.%d_%s_%s_%s_%s_%s%s",
  702.                 pOSName,
  703.                 pVersionInfo->wMajorVersion,
  704.                 pVersionInfo->wMinorVersion,
  705.                 pVersionInfo->wReleaseVersion,
  706.                 pProductVer,
  707.                 pProductName,
  708.                 pDistCode,
  709.                 pLanguage,
  710.                 pProcName,
  711.                 (pVersionInfo->bFPUAvailable ? "" : "_No-FPU")
  712.                 );
  713. #else
  714.     // WINDOWS and UNIX
  715.     SafeSprintf(szEncodedName,MAX_ENCODED_NAME, "%s_%d.%d_%s_%s_%s_%s_%s%s",
  716.                 pOSName,
  717.                 pVersionInfo->wMajorVersion,
  718.                 pVersionInfo->wMinorVersion,
  719.                 pProductVer,
  720.                 pProductName,
  721.                 pDistCode,
  722.                 pLanguage,
  723.                 pProcName,
  724.                 (pVersionInfo->bFPUAvailable ? "" : "_No-FPU")
  725.                 );
  727. #endif
  729.     return szEncodedName;
  730. };
  732. //      Code From:
  733. //
  734. //      PSS ID Number: Q124207
  735. //
  736. //      Authored 21-Dec-1994                    Last modified 05-Jan-1995
  737. //
  738. //      The information in this article applies to:
  739. //
  740. //      - Microsoft Win32 Software Development Kit (SDK) for Windows NT
  741. //      versions 3.1 and 3.5
  742. #if defined(_WIN32) 
  743. BOOL IsCoProcessorPresentInWinNT(void)
  744. {
  745. #if !defined(WIN32_PLATFORM_PSPC)
  746.     HKEY hKey;
  747.     SYSTEM_INFO SystemInfo;
  748.     
  749.     // return FALSE if we are not running under Windows NT
  750.     // this should be expanded to cover alternative Win32 platforms
  751.     
  752.     if(!(GetVersion() & 0x7FFFFFFF))
  753.     {
  754.         return(FALSE); // We can't tell, assume it doesn't
  755.     }
  756.     
  757.     // we return TRUE if we're not running on x86
  758.     // other CPUs have built in floating-point, with no registry entry
  759.     GetSystemInfo(&SystemInfo);
  760.     if(SystemInfo.wProcessorArchitecture != PROCESSOR_ARCHITECTURE_INTEL)
  761.     {
  762.         return(TRUE);
  763.     }
  765.     if(RegOpenKeyEx(HKEY_LOCAL_MACHINE,
  766.                     "HARDWARE\DESCRIPTION\System\FloatingPointProcessor",
  767.                     0,
  768.                     KEY_EXECUTE,
  769.                     &hKey) != ERROR_SUCCESS)
  770.     {
  772.         // GetLastError() will indicate ERROR_RESOURCE_DATA_NOT_FOUND
  773.         // if we can't find the key.  This indicates no coprocessor present
  774.         return(FALSE);
  775.     }
  777.     RegCloseKey(hKey);
  778.     return(TRUE);
  779. #else /*!defined(WIN32_PLATFORM_PSPC) */
  780.     return FALSE;
  781. #endif /* !defined(WIN32_PLATFORM_PSPC) */
  782. }
  783. #endif
  785. ///////////////////////////////////////////////////////////////////////
  786. //
  787. //      FUNCTION:
  788. //
  789. //              HXExtractDistributionCode()
  790. //
  791. //      Description:
  792. //
  793. //              Extracts the distribution code resource from the version
  794. //              information of the module.
  795. //
  796. //
  797. BOOL HXExtractDistributionCode(char* pDistBuffer, UINT32 ulDistBufferLen, void* hMod)
  798. {
  799.     BOOL        bOk = FALSE;
  801. #if (defined(_WIN32) || defined(_WINDOWS)) && !defined(WIN32_PLATFORM_PSPC)
  802.     // load version.dll
  803.     HINSTANCE               hLib = NULL;
  804.     VERQUERYVALUE           _pVerQueryValue = NULL;
  805.     GETFILEVERSIONINFO      _pGetFileVersionInfo = NULL;
  806.     GETFILEVERSIONINFOSIZE  _pGetFileVersionInfoSize = NULL;
  808.     if (hLib = HXLoadLibrary("version.dll"))
  809.     {
  810.         _pVerQueryValue = (VERQUERYVALUE)GetProcAddress(hLib, "VerQueryValueA");
  811.         _pGetFileVersionInfo = (GETFILEVERSIONINFO)GetProcAddress(hLib, "GetFileVersionInfoA");
  812.         _pGetFileVersionInfoSize = (GETFILEVERSIONINFOSIZE)GetProcAddress(hLib, "GetFileVersionInfoSizeA");
  813.     }
  815.     if (_pVerQueryValue         &&
  816.         _pGetFileVersionInfo    &&
  817.         _pGetFileVersionInfoSize)
  818.     {
  819.         HINSTANCE hModule = (HINSTANCE)(long)hMod;
  821.         DWORD   dwVerInfoSize;
  822.         DWORD   dwVerHnd;
  823.         char    szFullPath[_MAX_PATH+1]; /* Flawfinder: ignore */
  825.         if (GetModuleFileName(hModule,szFullPath, _MAX_PATH))
  826.         {
  828.             dwVerInfoSize = _pGetFileVersionInfoSize(szFullPath, &dwVerHnd);
  830.             if (dwVerInfoSize)
  831.             {
  832.                 LPSTR   lpstrVffInfo;             // Pointer to block to hold info
  833.                 HANDLE  hMem;                     // handle to mem alloc'ed
  835.                 // Get a block big enough to hold version info
  836.                 hMem          = GlobalAlloc(GMEM_MOVEABLE, dwVerInfoSize);
  837.                 lpstrVffInfo  = (char *)GlobalLock(hMem);
  839.                 if(_pGetFileVersionInfo(szFullPath, dwVerHnd, dwVerInfoSize, lpstrVffInfo ))
  840.                 {
  841.                     char    szGetName[_MAX_PATH]; /* Flawfinder: ignore */
  842.                     UINT    VersionLen;
  843.                     LPSTR   lpVersion;
  844.                     BOOL    bRetCode;
  846.                     SafeStrCpy(szGetName, "\VarFileInfo\Translation", _MAX_PATH);
  847.                     bRetCode = _pVerQueryValue(lpstrVffInfo, szGetName,
  848.                                                (void FAR* FAR*)&lpVersion, &VersionLen);
  850.                     char TransNumber[10]; /* Flawfinder: ignore */
  851.                     wsprintf(TransNumber, "%8lx", *(long *)lpVersion);
  852.                     char *pSpace = HXFindChar(TransNumber, ' ');
  853.                     while(pSpace)
  854.                     {
  855.                         *pSpace = '0';
  856.                         pSpace = (char*)HXFindChar(TransNumber, ' ');
  857.                     }
  859.                     SafeStrCpy(szGetName, "\StringFileInfo\", _MAX_PATH);
  860.                     SafeStrCat(szGetName, TransNumber + 4, _MAX_PATH);
  861.                     TransNumber[4] = 0;
  862.                     SafeStrCat(szGetName, TransNumber, _MAX_PATH);
  863.                     SafeStrCat(szGetName, "\DistCode", _MAX_PATH);
  865.                     bRetCode = _pVerQueryValue(lpstrVffInfo, szGetName,
  866.                                                (void FAR* FAR*)&lpVersion, &VersionLen);
  868.                     if ( bRetCode && VersionLen && lpVersion)
  869.                     {
  870.                         SafeStrCpy(pDistBuffer,lpVersion, ulDistBufferLen);
  871.                         bOk = TRUE;
  872.                     }
  873.                 }
  875.                 // Let go of the memory
  876.                 GlobalUnlock(hMem);
  877.                 GlobalFree(hMem);
  878.             }
  879.         }
  881.         if (!bOk)
  882.         {
  883.             SafeStrCpy(pDistBuffer,"UNK", ulDistBufferLen);
  884.         }
  885.     }
  887.     HXFreeLibrary("version.dll");
  889. #elif defined (_MACINTOSH)
  890.     // dist code stored in STR 1000 resource of application
  891.     INT16 strResId = 1000;
  892.     StringHandle hStr = ::GetString(strResId);
  893.     if (hStr)
  894.     {
  895.         if ((*hStr)[0] < ulDistBufferLen)
  896.         {
  897.             strncpy(pDistBuffer,(char*)*hStr+1,(*hStr)[0]); /* Flawfinder: ignore */
  898.             pDistBuffer[(*hStr)[0]] = 0;
  899.         }
  900.         ::ReleaseResource((Handle)hStr);
  901.         bOk = TRUE;
  902.     }
  903.     else
  904.     {
  905.         SafeStrCpy(pDistBuffer,"UNK", ulDistBufferLen);
  906.     }
  907.     
  908. #endif // defined(_WIN32) || defined(_WINDOWS)
  910.     return bOk;
  911. }
  915. #if defined(_MACINTOSH) || defined(_MAC_UNIX)
  917. // Support functions for HXGetWinVer for Macintosh
  919. #if !defined(_CARBON) && !defined(_MAC_UNIX) // Carbon code runs only on PPC processors with OT so runtime checks are pointless
  920. BOOL
  921. HasOpenTransport (void)
  922. {
  923.     OSErr   theErr = noErr;
  924.     LONG32  result;
  925.     Boolean hasOT = FALSE;
  927.     theErr = Gestalt(gestaltOpenTpt, &result);
  928.     hasOT = theErr == noErr &&
  929.         (result & gestaltOpenTptPresentMask) != 0 &&
  930.         (result & gestaltOpenTptTCPPresentMask) != 0;
  932.     return hasOT;
  933. }
  935. BOOL
  936. HasFPU(void)
  937. {
  938.     long    theFPU;
  940.     /* Determine the coprocessor type */
  941.     Gestalt(gestaltFPUType, &theFPU);
  943.     if(theFPU == gestaltNoFPU)
  944.         return FALSE;
  946.     return TRUE;
  948. }
  950. BOOL
  951. IsPPC(void) {
  952.     long    theCPU;
  953.     Gestalt(gestaltNativeCPUtype, &theCPU);
  954.     if (theCPU >= gestaltCPU601) return(TRUE);
  955.     return(FALSE);
  956. }
  957. #endif // !_CARBON
  959. static UINT16 
  960. BCDtoDecimal(UINT16 bcd)
  961. {
  962.     UINT16 decimal;
  963.     decimal =            1 * ((bcd & 0x000F) >> 0)
  964.         +   10 * ((bcd & 0x00F0) >> 4) 
  965.         +  100 * ((bcd & 0x0F00) >> 8) 
  966.         + 1000 * ((bcd & 0xF000) >> 12); 
  967.     return decimal;
  968. }
  970. void
  971. GetMacSystemVersion(UINT16 *major, UINT16 *minor, UINT16 *release)
  972. {
  973.     long    gestVer;
  974.     UINT16  ver, bigRev, littleRev;
  976.     OSErr err = Gestalt(gestaltSystemVersion, &gestVer); // returns a BCD number, like 0x00001015 for 10.1.5
  977.     if (err == noErr)
  978.     {
  979.         ver =       BCDtoDecimal((gestVer & 0x0000FF00) >> 8);
  980.         bigRev =    BCDtoDecimal((gestVer & 0x000000F0) >> 4);
  981.         littleRev = BCDtoDecimal((gestVer & 0x0000000F));
  982.     }
  983.     else
  984.     {
  985.         ver = bigRev = littleRev = 0;
  986.     }
  987.         
  988. //don't want to include mathlib in plugin
  989. //      ::sprintf(s,"%ld.%ld.%ld",ver,majorRev,minorRev);
  990. //      ver += 0x30; majorRev += 0x30; minorRev += 0x30;  // GR 7/4/02 why was this converting to ascii? (the conversion would fail for numbers over 9 anyway)
  992.     if (major)      *major = ver;
  993.     if (minor)      *minor = bigRev;
  994.     if (release)    *release = littleRev;
  995. }
  998. #endif // _MACINTOSH