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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
hxwinver.cpp
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：31k
源码类别：

Symbian

开发平台：

Visual C++

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