Tools/Xabsl2/yabsl/vsyabsl/dllmain.cpp

Go to the documentation of this file.

/***************************************************************************
         Copyright (c) Microsoft Corporation, All rights reserved.             
    This code sample is provided "AS IS" without warranty of any kind, 
    it is not recommended for use in a production environment.
***************************************************************************/

#include <malloc.h>
#include "common.h"
#include "dllmain.h"
#include "languagedef.h"

/*---------------------------------------------------------
  globals
-----------------------------------------------------------*/
ITypeInfo* g_typeInfoBabelService     = NULL;

static HINSTANCE  g_instance          = NULL;
static ULONG      g_dllRefCount       = 0;

//babel package clsid's
static const CLSID babelPackageCLSID7 = 
  { 0x221f0eb7, 0x30f7, 0x45ff, { 0xae, 0x73, 0x59, 0x68, 0xb1, 0x67, 0xcf, 0x9 } };

//registry paths
static CStr regPathVS7                  = STR("Software\\Microsoft\\VisualStudio\\7.1");
static CStr regPathVS7_NoVersion        = STR("Software\\Microsoft\\VisualStudio\\");

static CStr regPathFileExts  = STR("Languages\\File Extensions");
static CStr regPathLServices = STR("Languages\\Language Services");
static CStr regPathServices  = STR("Services");


/*---------------------------------------------------------
  Prototypes
-----------------------------------------------------------*/
static HRESULT RegisterServer( in bool registerIt);
static HRESULT GetRegistrationRoot(Str pszRegistrationRoot, ULONG cchBuffer = _MAX_PATH);
static HRESULT LoadTypeInfo();

//registry helpers
static HRESULT RegCreateValue( in HKEY key, in CStr name, in CStr value );
static HRESULT RegCreateDwordValue( in HKEY key, in CStr name, in DWORD value );
static HRESULT RegDeleteRecursive( in HKEY keyRoot, in CStr path );


/*---------------------------------------------------------
  Class Factory
-----------------------------------------------------------*/
class BabelServiceFactory : IClassFactory
{
private:
  ULONG   m_refCount;

public:
  BabelServiceFactory();
  ~BabelServiceFactory();

  //IUnknown
  STDMETHODIMP QueryInterface( REFIID iid, LPVOID* obj );
  STDMETHODIMP_(ULONG) AddRef();
  STDMETHODIMP_(ULONG) Release();

  //IClassFactory
  STDMETHODIMP CreateInstance( IUnknown* outer, REFIID iid, LPVOID* obj );
  STDMETHODIMP LockServer( BOOL lockIt );
};



/*---------------------------------------------------------
  Dll entry points
-----------------------------------------------------------*/
BOOL APIENTRY DllMain( HINSTANCE instance, DWORD reason, LPVOID reserved )
{
  switch (reason)
  {
  case DLL_PROCESS_ATTACH:
    TRACE_INIT( g_languageName );
    TRACE( "load dll" );
    g_instance    = instance;
    g_dllRefCount = 0;
    LoadTypeInfo();
    break;
  case DLL_PROCESS_DETACH:
    TRACE("unload dll");
    RELEASE(g_typeInfoBabelService);
    TRACE_DONE;
    break;
  case DLL_THREAD_ATTACH:
    TRACE("dll attach thread");
    break;
  case DLL_THREAD_DETACH:
    TRACE("dll detach thread");
    break;
  }

  return TRUE;
}

STDAPI DllCanUnloadNow()
{
  return (g_dllRefCount == 0);
}


STDAPI DllGetClassObject( REFCLSID clsid, REFIID iid, LPVOID* obj )
{
  OUTARG(obj);

  if (clsid == g_languageCLSID)
  {
    BabelServiceFactory* factory  = new BabelServiceFactory();
    if (!factory) return E_OUTOFMEMORY;

    HRESULT hr = factory->QueryInterface(iid,obj);
    RELEASE(factory);
    return hr;
  }
  else 
    return CLASS_E_CLASSNOTAVAILABLE;
}


STDAPI DllRegisterServer()
{
  return RegisterServer(true);
}


STDAPI DllUnregisterServer()
{
  return RegisterServer(false);
}


/*---------------------------------------------------------
  Class Factory
-----------------------------------------------------------*/
BabelServiceFactory::BabelServiceFactory()
{
  TRACE_CREATE("BabelServiceFactory", this );
  m_refCount = 1;
}

BabelServiceFactory::~BabelServiceFactory()
{
  TRACE_DESTROY(this);
}

//IUnknown
STDMETHODIMP BabelServiceFactory::QueryInterface( REFIID iid, LPVOID* obj )
{
  OUTARG(obj);

  if (iid == IID_IUnknown || iid == IID_IClassFactory)
  {
    *obj = static_cast<IClassFactory*>(this);
  }
  else
    return E_NOINTERFACE;

  AddRef();
  return S_OK;
}

STDMETHODIMP_(ULONG) BabelServiceFactory::AddRef()
{
  return IncRefCount(&m_refCount);
}

STDMETHODIMP_(ULONG) BabelServiceFactory::Release()
{
  if (DecRefCount(&m_refCount) == 0)
  {
    delete this;
    return 0;
  }
  else
    return m_refCount;
}

//IClassFactory
STDMETHODIMP BabelServiceFactory::CreateInstance( IUnknown* outer, REFIID iid, LPVOID* obj )
{
  TRACE("BabelServiceFactory::CreateInstance");
  OUTARG(obj);
  HRESULT hr;

  if (outer) return CLASS_E_NOAGGREGATION;

  IBabelService* babelService;
  hr = CreateBabelService( &babelService );
  if (FAILED(hr)) return hr;

  hr = babelService->QueryInterface( iid, obj );
  RELEASE(babelService);

  return hr;
}

STDMETHODIMP BabelServiceFactory::LockServer( BOOL lockIt )
{
  if (lockIt)
  {
    IncRefCount( &g_dllRefCount );
  }
  else
  {
    DecRefCount( &g_dllRefCount );
  }

  return S_OK;
}

/*---------------------------------------------------------
  Load the BabelService type library
-----------------------------------------------------------*/
static HRESULT LoadTypeInfo()
{
  HRESULT hr;

  //load it only once
  if (g_typeInfoBabelService) return S_OK;

  //load the library
  ITypeLib* lib;
  hr = LoadRegTypeLib( LIBID_BabelServiceLib, 1, 0, LANG_NEUTRAL, &lib );
  if (FAILED(hr)) return hr;

  //get the typeinfo 
  hr = lib->GetTypeInfoOfGuid( IID_IBabelService, &g_typeInfoBabelService );
  RELEASE(lib);
  if (FAILED(hr)) return hr; 
  
  return S_OK;
}

/*---------------------------------------------------------
  Registration
-----------------------------------------------------------*/
static HRESULT RegisterService( in CStr         regPathVS, 
                                in const CLSID& packageCLSID, 
                                in bool         registerIt )
{
  USECONV;
  HRESULT hr;

  //get clsid's as string
  OleChar oleLanguageCLSID[128];
  if (StringFromGUID2(g_languageCLSID, oleLanguageCLSID, 127) == 0)
  { return E_FAIL; }

  OleChar olePackageCLSID[128];
  if (StringFromGUID2(packageCLSID, olePackageCLSID, 127) == 0)
  { return E_FAIL; }

  //open root key
  HKEY    keyVS   = 0;
  HKEY    keySub  = 0;
  HKEY    key     = 0;

  hr = RegOpenKey( HKEY_LOCAL_MACHINE, regPathVS, &keyVS );
  if (FAILED(hr)) return hr;

  //file extensions
  hr = RegOpenKey( keyVS, regPathFileExts, &keySub );
  if (FAILED(hr)) goto fail;

  int idx;
  for (idx = 0; g_languageFileExtensions[idx] != NULL; idx++)
  {
    const char* fileExt;

    fileExt = g_languageFileExtensions[idx];

    if (!registerIt)
    {
      RegDeleteRecursive( keySub, Ansi2CStr(fileExt) );
    }
    else
    {
      hr = RegCreateKey( keySub, Ansi2CStr(fileExt), &key );
      if (FAILED(hr)) goto fail;

      hr = RegCreateValue( key, NULL, Ole2CStr(oleLanguageCLSID) );
      if (FAILED(hr)) goto fail;

      hr = RegCreateValue( key, STR("Name"), Ansi2CStr(g_languageName) );
      if (FAILED(hr)) goto fail;

      RegCloseKey(key); key = 0;
    }
  }
  RegCloseKey(keySub); keySub = 0;


  //Create an extensions string
  Char fileExtensions[MAXPATH+1];
  fileExtensions[0] = 0;
  for (idx = 0; g_languageFileExtensions[idx] != NULL; idx++)
  {
    ansiToStrCat( fileExtensions, g_languageFileExtensions[idx], MAXPATH );
    strCat( fileExtensions, STR(";"), MAXPATH );
  }

  //language service
  hr = RegOpenKey( keyVS, regPathLServices, &keySub );
  if (FAILED(hr)) goto fail;

  if (!registerIt)
  {
    RegDeleteRecursive( keySub, Ansi2CStr(g_languageName) );
  }
  else
  {
    hr = RegCreateKey( keySub, Ansi2CStr(g_languageName), &key );
    if (FAILED(hr)) goto fail;

    hr = RegCreateValue( key, NULL, Ole2CStr(oleLanguageCLSID) );
    if (FAILED(hr)) goto fail;

    hr = RegCreateValue( key, STR("Package"), Ole2CStr(olePackageCLSID) );
    if (FAILED(hr)) goto fail;

    hr = RegCreateValue( key, STR("Extensions"), fileExtensions );
    if (FAILED(hr)) goto fail;

    hr = RegCreateDwordValue( key, STR("LangResId"), 0 );
    if (FAILED(hr)) goto fail;

    hr = RegCreateDwordValue( key, STR("RequestStockColors"), 1 );
    if (FAILED(hr)) goto fail;

    hr = RegCreateDwordValue( key, STR("ShowCompletion"), 0 );
    if (FAILED(hr)) goto fail;


    //babel specific entries
    hr = RegCreateDwordValue( key, OLE("ThreadModel"), 1 ); //colorizer/parser can be called from two different threads
    if (FAILED(hr)) goto fail;

    hr = RegCreateDwordValue( key, OLE("MatchBraces"), 1 );
    if (FAILED(hr)) goto fail;

    hr = RegCreateDwordValue( key, OLE("QuickInfo"), 1 );
    if (FAILED(hr)) goto fail;

    const LanguageProperty* property;
    for (property = g_languageProperties; property->name; property++)
    {
      hr = RegCreateDwordValue( key, Ansi2CStr(property->name), property->value );
      if (FAILED(hr)) goto fail;
    }
    
    RegCloseKey( key ); key = 0;
  }
  RegCloseKey( keySub ); keySub = 0;

  //services
  hr = RegOpenKey( keyVS, regPathServices, &keySub );
  if (FAILED(hr)) goto fail;

  if (!registerIt)
  {
    RegDeleteRecursive( keySub, Ole2CStr(oleLanguageCLSID) );
  }
  else
  {
    hr = RegCreateKey( keySub, Ole2CStr(oleLanguageCLSID), &key );
    if (FAILED(hr)) goto fail;

    hr = RegCreateValue( key, NULL, Ole2CStr(olePackageCLSID) );
    if (FAILED(hr)) goto fail;

    hr = RegCreateValue( key, STR("Name"), Ansi2CStr(g_languageName) );
    if (FAILED(hr)) goto fail;

    RegCloseKey( key ); key = 0;
  }
  RegCloseKey( keySub ); keySub = 0;

  //release resources
fail:
  if (key)    RegCloseKey(key);
  if (keySub) RegCloseKey(keySub);
  if (keyVS)  RegCloseKey(keyVS);
  if (FAILED(hr)) return hr;

  return S_OK;
}

static HRESULT RegisterServer( in bool registerIt)
{
  USECONV;
  HRESULT hr = S_OK;

  HKEY    keyCLSID  = 0;
  HKEY    keyClass  = 0;
  HKEY    keyInProc = 0;

  //get clsid as string
  OleChar oleCLSID[128];
  if (StringFromGUID2(g_languageCLSID, oleCLSID, 127) == 0)
  { hr = E_FAIL; goto fail; }

  //get dll path
  Char dllPath[MAX_PATH+1];
  DWORD dwLen = ::GetModuleFileName(g_instance, dllPath, MAX_PATH);
  if (dwLen == 0)
  {
    hr = HRESULT_FROM_WIN32(::GetLastError());
    goto fail;
  }
  if (dwLen == MAX_PATH)
  {
    hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
    goto fail;
  }
 
  //open CLSID key
  Char szRegistrationRoot[_MAX_PATH + 1];
  hr = GetRegistrationRoot(szRegistrationRoot, _MAX_PATH);
  if (FAILED(hr)) goto fail;

  Char szClsidRoot[_MAX_PATH + 11];
  strCopy(szClsidRoot, szRegistrationRoot, _MAX_PATH);
  strCat(szClsidRoot, STR("\\CLSID"), _MAX_PATH + 10);

  hr = RegOpenKey( HKEY_LOCAL_MACHINE, szClsidRoot, &keyCLSID );
  if (FAILED(hr)) goto fail;

  if (!registerIt)
  {
    //delete it
    hr = RegDeleteRecursive( keyCLSID, Ole2CStr(oleCLSID) );
    if (FAILED(hr)) goto fail;
  }
  else
  {
    //create it
    hr = RegCreateKey( keyCLSID, Ole2CStr(oleCLSID), &keyClass );
    if (FAILED(hr)) goto fail;

    RegCreateValue( keyClass, NULL, Ansi2CStr(g_languageName));
    
    RegCreateValue( keyClass, STR("InprocServer32"), dllPath );
  }

  
fail:
  if (keyInProc) RegCloseKey(keyInProc);
  if (keyClass)  RegCloseKey(keyClass);
  if (keyCLSID)  RegCloseKey(keyCLSID);

  //register language service with VS.NET
  if (SUCCEEDED(hr) || (registerIt == false))  
  {
     hr = RegisterService(szRegistrationRoot, babelPackageCLSID7, registerIt );
  }

  if (FAILED(hr)) return hr;

  return S_OK;
}


/*---------------------------------------------------------
  Registry helpers
-----------------------------------------------------------*/
static HRESULT RegCreateValue( in HKEY key, in CStr name, in CStr value )
{
  return RegSetValueEx( key, name, 0, REG_SZ, 
                        reinterpret_cast<const BYTE*>(value), 
                        sizeof(Char) * (strLen(value)+1) );
}

static HRESULT RegCreateDwordValue( in HKEY key, in CStr name, in DWORD value )
{
  return RegSetValueEx( key, name, 0, REG_DWORD, 
                        reinterpret_cast<const BYTE*>(&value), sizeof(value) );
}

static HRESULT RegDeleteRecursive( in HKEY keyRoot, in CStr path )
{
  HRESULT hr;
  HKEY    key       = 0;
  ULONG   subKeys   = 0;
  ULONG   maxKeyLen = 0;

  ULONG   currentKey= 0;
  Str     keyName   = NULL;
  
  hr = WINERROR(RegOpenKeyEx( keyRoot, path, 0, KEY_ALL_ACCESS, &key ));
  if (FAILED(hr)) goto fail;

  hr = WINERROR(RegQueryInfoKey( key, NULL, NULL, NULL,
                                &subKeys, &maxKeyLen, 
                                NULL, NULL, NULL, NULL, NULL, NULL ));
  if (FAILED(hr))   goto fail;
  if (subKeys == 0) goto fail;

  keyName = (Str) malloc(sizeof(Char) * (maxKeyLen+1) );
  if (keyName == NULL) 
  {
    hr = E_OUTOFMEMORY;
    goto fail;
  }

  for (currentKey = 0; currentKey < subKeys; currentKey++)
  {
    ULONG keyLen;

    keyLen = maxKeyLen+1;
    hr = WINERROR( RegEnumKeyEx( key, currentKey, keyName, &keyLen, NULL, NULL, NULL, NULL ));
    if (SUCCEEDED(hr))
    {
      RegDeleteRecursive(key,keyName);
    }
    else ASSERT(0);
  }

fail:
  hr = WINERROR(RegDeleteKey( keyRoot, path ));
  if (key) RegCloseKey(key);
  if (keyName) free(keyName);
  return hr;
}


static HRESULT GetRegistrationRoot(Str pszRegistrationRoot, ULONG cchBuffer /* = _MAX_PATH*/)
{
  DWORD cchFreeBuffer = cchBuffer - 1;
  strCopy(pszRegistrationRoot, regPathVS7_NoVersion, -1);

  // this is Environment SDK specific
  // we check for  EnvSdk_RegKey environment variable to
  // determine where to register
  DWORD cchDefRegRoot = lstrlen(regPathVS7_NoVersion);
  cchFreeBuffer = cchFreeBuffer - cchDefRegRoot;
  DWORD cchEnvVarRead = GetEnvironmentVariable(
    /* LPCTSTR */ TEXT("EnvSdk_RegKey"),               // environment variable name
    /* LPTSTR  */ &pszRegistrationRoot[cchDefRegRoot],// buffer for variable value
    /* DWORD   */ cchFreeBuffer);// size of buffer
  cchEnvVarRead = 0; //use always 7.1
  if (cchEnvVarRead >= cchFreeBuffer)
    return E_UNEXPECTED;
  // If the environment variable does not exist then we must use 
  // regPathVS7 which has the version number.
  if (0 == cchEnvVarRead)
    strCopy(pszRegistrationRoot, regPathVS7, -1);

  return S_OK;
}

---