environ.cpp

This software performs code conversion of Chinese characters, including GB2312/GBK and BIG5. It a

// environ.cpp

#include <windows.h>
#include <stdlib.h>
#include <string.h>
#include "msc.h"
#include "environ.h"



//////////////////////////////
//      GetEnvAlloc ()      //
//////////////////////////////



// 儊儌儕乕傪妋曐偟偰娐嫬曄悢傪庢摼偡傞乮ANSI斉乯
// free() 傪巊偭偰夝曻偡傞偙偲
// 幐攕偟偨傜 NULL 傪曉偡
char *GetEnvAllocA ( const char *szName ) {

   int nLength = GetEnvironmentVariableA ( szName, NULL, 0 ) ;
   if ( nLength <= 0 ) return NULL ;

   char *szBuffer ;
   if ( ! ( szBuffer = (char*) malloc ( nLength * sizeof(char) ) ) ) return NULL ;

   int nResult = GetEnvironmentVariableA ( szName, szBuffer, nLength ) ;
   if ( nResult <= 0 || nResult >= nLength ) { free ( szBuffer ) ; return NULL ; }

   return szBuffer ;
}



// 儊儌儕乕傪妋曐偟偰娐嫬曄悢傪庢摼偡傞乮UNICODE斉乯
// free() 傪巊偭偰夝曻偡傞偙偲
// 幐攕偟偨傜 NULL 傪曉偡
wchar_t *GetEnvAllocW ( const wchar_t *szName ) {

   int nLength = GetEnvironmentVariableW ( szName, NULL, 0 ) ;
   if ( nLength <= 0 ) return NULL ;

   wchar_t *szBuffer ;
   if ( ! ( szBuffer = (wchar_t*) malloc ( nLength * sizeof(wchar_t) ) ) ) return NULL ;

   int nResult = GetEnvironmentVariableW ( szName, szBuffer, nLength ) ;
   if ( nResult <= 0 || nResult >= nLength ) { free ( szBuffer ) ; return NULL ; }

   return szBuffer ;
}



//////////////////////////////
//         GetEnv ()        //
//////////////////////////////



static char *szEnvBufferA ;
static wchar_t *szEnvBufferW ;
static void __cdecl ExitProc ( void ) ;
static volatile long IsExitProcRegistered ;



// 娐嫬曄悢傪庢摼偡傞乮ANSI斉乯
// 幐攕偟偨傜 NULL 傪曉偡
// 彂偒崬傑傟偨暥帤楍偼師偵偙偺娭悢偑屇偽傟傞傑偱桳岠丄嵞擖晄壜
char *GetEnvA ( const char *szName ) {
   free ( szEnvBufferA ) ;
   szEnvBufferA = GetEnvAllocA ( szName ) ;
   if ( ! InterlockedExchange ( & IsExitProcRegistered, TRUE ) ) atexit ( ExitProc ) ;
   return szEnvBufferA ;
}



// 娐嫬曄悢傪庢摼偡傞乮UNICODE斉乯
// 幐攕偟偨傜 NULL 傪曉偡
// 彂偒崬傑傟偨暥帤楍偼師偵偙偺娭悢偑屇偽傟傞傑偱桳岠丄嵞擖晄壜
wchar_t *GetEnvW ( const wchar_t *szName ) {
   free ( szEnvBufferW ) ;
   szEnvBufferW = GetEnvAllocW ( szName ) ;
   if ( ! InterlockedExchange ( & IsExitProcRegistered, TRUE ) ) atexit ( ExitProc ) ;
   return szEnvBufferW ;
}



static void __cdecl ExitProc ( void ) {
   free ( szEnvBufferA ) ;
   free ( szEnvBufferW ) ;
}



//////////////////////////////
//         PutEnv ()        //
//////////////////////////////



// 娐嫬曄悢傪愝掕偡傞乮ANSI斉乯
// 堷偒悢偼 "柤慜=抣" 偺宍幃
// 堷偒悢偑 "柤慜=" 側傜丄娐嫬曄悢傪嶍彍偡傞
// 惉岟偟偨傜 0 傪丄幐攕偟偨傜 -1 傪曉偡
int PutEnvA ( const char *szString ) {

   int nResult = 0 ;

   char *szBuffer = strdup ( szString ) ;
   if ( szBuffer ) {
      char *szName = szBuffer ;
      char *szValue = strchr ( szBuffer, '=' ) ;
      if ( szValue ) {
         *szValue ++ = 0 ;
         if ( ! *szValue ) szValue = NULL ;
         nResult = SetEnvironmentVariableA ( szName, szValue ) ;
      }
      free ( szBuffer ) ;
   }

   return ( nResult ) ? 0 : -1 ;
}



// 娐嫬曄悢傪愝掕偡傞乮UNICODE斉乯
// 堷偒悢偼 "柤慜=抣" 偺宍幃
// 堷偒悢偑 "柤慜=" 側傜丄娐嫬曄悢傪嶍彍偡傞
// 惉岟偟偨傜 0 傪丄幐攕偟偨傜 -1 傪曉偡
int PutEnvW ( const wchar_t *szString ) {

   int nResult = 0 ;

   wchar_t *szBuffer = wcsdup ( szString ) ;
   if ( szBuffer ) {
      wchar_t *szName = szBuffer ;
      wchar_t *szValue = wcschr ( szBuffer, '=' ) ;
      if ( szValue ) {
         *szValue ++ = 0 ;
         if ( ! *szValue ) szValue = NULL ;
         nResult = SetEnvironmentVariableW ( szName, szValue ) ;
      }
      free ( szBuffer ) ;
   }

   return ( nResult ) ? 0 : -1 ;
}



//////////////////////////////
//         SetEnv ()        //
//////////////////////////////



// 娐嫬曄悢傪愝掕偡傞乮ANSI斉乯
// 堷偒悢 szValue 偑 NULL 側傜丄娐嫬曄悢傪嶍彍偡傞
// IsOverwrite 偑 0 側傜忋彂偒偟側偄
// 惉岟偟偨傜 0 傪丄幐攕偟偨傜 0 埲奜傪曉偡
int SetEnvA ( const char *szName, const char *szValue, int IsOverwrite ) {

   if ( ! IsOverwrite ) {
      int nLength = GetEnvironmentVariableA ( szName, NULL, 0 ) ;
      if ( nLength ) return 1 ;
   }

   int nResult = SetEnvironmentVariableA ( szName, szValue ) ;
   return ! nResult ;
}



// 娐嫬曄悢傪愝掕偡傞乮UNICODE斉乯
// 堷偒悢 szValue 偑 NULL 側傜丄娐嫬曄悢傪嶍彍偡傞
// IsOverwrite 偑 0 側傜忋彂偒偟側偄
// 惉岟偟偨傜 0 傪丄幐攕偟偨傜 0 埲奜傪曉偡
int SetEnvW ( const wchar_t *szName, const wchar_t *szValue, int IsOverwrite ) {

   if ( ! IsOverwrite ) {
      int nLength = GetEnvironmentVariableW ( szName, NULL, 0 ) ;
      if ( nLength ) return 1 ;
   }

   int nResult = SetEnvironmentVariableW ( szName, szValue ) ;
   return ! nResult ;
}



//////////////////////////////
//       AddEnvPath ()      //
//////////////////////////////



static inline char *strmove ( char *dst, const char *src ) ;



// 娐嫬曄悢 PATH 偵僷僗柤傪捛壛偡傞乮ANSI斉乯
// 惉岟偡傟偽 0 傪丄幐攕偡傟偽 0 埲奜傪曉偡
int AddEnvPathA ( const char *szPath, int IsAddToTop ) {

   int nRetValue = 1 ;

   size_t nAddLength = strlen ( szPath ) ;
   if ( ! nAddLength ) return nRetValue ;

   // 娐嫬曄悢偺僶僢僼傽傪妋曐
   int nLength = GetEnvironmentVariableA ( "PATH", NULL, 0 ) ;
   char *szBuffer = (char*) malloc ( ( nLength + nAddLength + 2 ) * sizeof(char) ) ;
   if ( szBuffer ) {

      // 尰嵼偺娐嫬曄悢傪庢摼
      int nResult = GetEnvironmentVariableA ( "PATH", szBuffer, nLength ) ;
      if ( nResult < 0 || nResult && nResult >= nLength ) goto CAUGHT_ERROR ;
      if ( ! nResult ) *szBuffer = 0 ;

      // 偡偱偵僷僗柤偑搊榐偝傟偰偄傞偐丠
      for ( char *szString = szBuffer ; ( szString = strstr ( szString, szPath ) ) ; szString += nAddLength ) {
         if ( ( szString == szBuffer || *( szString - 1 ) == ';' ) &&               // 愭摢偼丠
              ( ! *( szString + nAddLength ) || *( szString + nAddLength ) == ';' ) // 枛旜偼丠
         ) {
            if ( IsAddToTop ) {
               if ( ! *( szString + nAddLength ) ) {
                  if ( szString == szBuffer ) *szString = 0 ;
                  else                        *( szString - 1 ) = 0 ;
               }
               else {
                  strmove ( szString, szString + nAddLength + 1 ) ;
               }
               break ;
            }
            else {
               nRetValue = 0 ;
               goto CAUGHT_ERROR ;
            }
         }
      }

      // 怴偟偄娐嫬曄悢傪嶌惉
      if ( IsAddToTop ) {
         strmove ( szBuffer + nAddLength + 1, szBuffer ) ;
         strmove ( szBuffer, szPath ) ;
         if ( *( szBuffer + nAddLength + 1 ) ) szBuffer [ nAddLength ] = ';' ;
      }
      else {
         if ( *szBuffer ) strcat ( szBuffer, ";" ) ;
         strcat ( szBuffer, szPath ) ;
      }

      // 怴偟偄娐嫬曄悢傪曐懚
      if ( ! SetEnvironmentVariableA ( "PATH", szBuffer ) ) goto CAUGHT_ERROR ;

      nRetValue = 0 ;
   }

   CAUGHT_ERROR :
   free ( szBuffer ) ;

   return nRetValue ;
}



// 暥帤楍傪僐僺乕偡傞乮ANSI斉乯
static inline char *strmove ( char *dst, const char *src ) {
   return (char*) memmove ( dst, src, ( strlen ( src ) + 1 ) * sizeof(char) ) ;
}



static inline wchar_t *wcsmove ( wchar_t *dst, const wchar_t *src ) ;



// 娐嫬曄悢 PATH 偵僷僗柤傪捛壛偡傞乮UNICODE斉乯
// 惉岟偡傟偽 0 傪丄幐攕偡傟偽 0 埲奜傪曉偡
int AddEnvPathW ( const wchar_t *szPath, int IsAddToTop ) {

   int nRetValue = 1 ;

   size_t nAddLength = wcslen ( szPath ) ;
   if ( ! nAddLength ) return nRetValue ;

   // 娐嫬曄悢偺僶僢僼傽傪妋曐
   int nLength = GetEnvironmentVariableW ( L"PATH", NULL, 0 ) ;
   wchar_t *szBuffer = (wchar_t*) malloc ( ( nLength + nAddLength + 2 ) * sizeof(wchar_t) ) ;
   if ( szBuffer ) {

      // 尰嵼偺娐嫬曄悢傪庢摼
      int nResult = GetEnvironmentVariableW ( L"PATH", szBuffer, nLength ) ;
      if ( nResult < 0 || nResult && nResult >= nLength ) goto CAUGHT_ERROR ;
      if ( ! nResult ) *szBuffer = 0 ;

      // 偡偱偵僷僗柤偑搊榐偝傟偰偄傞偐丠
      for ( wchar_t *szString = szBuffer ; ( szString = wcsstr ( szString, szPath ) ) ; szString += nAddLength ) {
         if ( ( szString == szBuffer || *( szString - 1 ) == ';' ) &&               // 愭摢偼丠
              ( ! *( szString + nAddLength ) || *( szString + nAddLength ) == ';' ) // 枛旜偼丠
         ) {
            if ( IsAddToTop ) {
               if ( ! *( szString + nAddLength ) ) {
                  if ( szString == szBuffer ) *szString = 0 ;
                  else                        *( szString - 1 ) = 0 ;
               }
               else {
                  wcsmove ( szString, szString + nAddLength + 1 ) ;
               }
               break ;
            }
            else {
               nRetValue = 0 ;
               goto CAUGHT_ERROR ;
            }
         }
      }

      // 怴偟偄娐嫬曄悢傪嶌惉
      if ( IsAddToTop ) {
         wcsmove ( szBuffer + nAddLength + 1, szBuffer ) ;
         wcsmove ( szBuffer, szPath ) ;
         if ( *( szBuffer + nAddLength + 1 ) ) szBuffer [ nAddLength ] = ';' ;
      }
      else {
         if ( *szBuffer ) wcscat ( szBuffer, L";" ) ;
         wcscat ( szBuffer, szPath ) ;
      }

      // 怴偟偄娐嫬曄悢傪曐懚
      if ( ! SetEnvironmentVariableW ( L"PATH", szBuffer ) ) goto CAUGHT_ERROR ;

      nRetValue = 0 ;
   }

   CAUGHT_ERROR :
   free ( szBuffer ) ;

   return nRetValue ;
}



// 暥帤楍傪僐僺乕偡傞乮UNICODE斉乯
static inline wchar_t *wcsmove ( wchar_t *dst, const wchar_t *src ) {
   return (wchar_t*) memmove ( dst, src, ( wcslen ( src ) + 1 ) * sizeof(wchar_t) ) ;
}



//////////////////////////////
//        EnumEnv ()        //
//////////////////////////////



// 娐嫬曄悢傪楍嫇偡傞乮ANSI斉乯
// 僐乕儖僶僢僋娭悢偑 0 傪曉偟偨傜丄楍嫇傪掆巭
//                    0 埲奜傪曉偟偨傜丄楍嫇傪宲懕
// 惉岟偟偨傜 0 傪, 幐攕偟偨傜 0 埲奜傪曉偡
int EnumEnvironmentVariablesA ( int ( CALLBACK *CallbackProc ) ( const char *szName, const char *szValue, LPARAM lParam ), LPARAM lParam ) {

   int nRetValue = 0 ;

   char *szEnvirion = GetEnvironmentStringsA () ;

   for ( char *szCurrent = szEnvirion ; *szCurrent ; szCurrent = strend ( szCurrent ) + 1 ) {

      char *szString = strdup ( szCurrent ) ;
      if ( ! szString ) {
         nRetValue = 1 ;
         break ;
      }

      char *szSeparator = strchr ( szString + 1, '=' ) ;
      if ( szSeparator ) *szSeparator = 0 ;

      char *szValue = ( szSeparator ) ? szSeparator + 1 : strend ( szString ) ;
      int nResult = CallbackProc ( szString, szValue, lParam ) ;

      free ( szString ) ;

      if ( ! nResult ) break ;
   }

   FreeEnvironmentStringsA ( szEnvirion ) ;

   return nRetValue ;
}



// 娐嫬曄悢傪楍嫇偡傞乮UNICODE斉乯
// 僐乕儖僶僢僋娭悢偑 0 傪曉偟偨傜丄楍嫇傪掆巭
//                    0 埲奜傪曉偟偨傜丄楍嫇傪宲懕
// 惉岟偟偨傜 0 傪, 幐攕偟偨傜 0 埲奜傪曉偡
int EnumEnvironmentVariablesW ( int ( CALLBACK *CallbackProc ) ( const wchar_t *szName, const wchar_t *szValue, LPARAM lParam ), LPARAM lParam ) {

   int nRetValue = 0 ;

   wchar_t *szEnvirion = GetEnvironmentStringsW () ;

   for ( wchar_t *szCurrent = szEnvirion ; *szCurrent ; szCurrent = wcsend ( szCurrent ) + 1 ) {

      wchar_t *szString = wcsdup ( szCurrent ) ;
      if ( ! szString ) {
         nRetValue = 1 ;
         break ;
      }

      wchar_t *szSeparator = wcschr ( szString + 1, '=' ) ;
      if ( szSeparator ) *szSeparator = 0 ;

      wchar_t *szValue = ( szSeparator ) ? szSeparator + 1 : wcsend ( szString ) ;
      int nResult = CallbackProc ( szString, szValue, lParam ) ;

      free ( szString ) ;

      if ( ! nResult ) break ;
   }

   FreeEnvironmentStringsW ( szEnvirion ) ;

   return nRetValue ;
}