Squiggly/ane/WinDLLHunspellANE/HunspellNativeExtension/HunspellNativeExtension.cpp - flex-utilities - Git at Google

 ////////////////////////////////////////////////////////////////////////////////
 //
 //  Licensed to the Apache Software Foundation (ASF) under one or more
 //  contributor license agreements.  See the NOTICE file distributed with
 //  this work for additional information regarding copyright ownership.
 //  The ASF licenses this file to You under the Apache License, Version 2.0
 //  (the "License"); you may not use this file except in compliance with
 //  the License.  You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 //  Unless required by applicable law or agreed to in writing, software
 //  distributed under the License is distributed on an "AS IS" BASIS,
 //  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 //  See the License for the specific language governing permissions and
 //  limitations under the License.
 //
 ////////////////////////////////////////////////////////////////////////////////

 // This is the main DLL file.

 //#include "stdafx.h"
 #include <windows.h>
 #include "EncConv.h"
 #include "win\Utilities.h"
 #include <stdio.h>
 #include "HunspellNativeExtension.h"

 typedef Hunspell * (__cdecl *HUNSPELL_INIT)(char *, char*);
 typedef int (__cdecl *HUNSPELL_SPELL)(void *, char*);
 typedef int (__cdecl *HUNSPELL_SUGGEST)(void *, char*, char ***);
 typedef void (__cdecl *HUNSPELL_FREE_LIST)(void *, char***, int);
 typedef char * (__cdecl *HUNSPELL_GET_ENCODING)(void *);
 typedef void (__cdecl * HUNSPELL_UNINIT)(void *);
 HINSTANCE hinstLib;

 FREObject talkBack(FREContext ctx, void* funcData, uint32_t argc, FREObject argv[]) {
 	const uint8_t *locale = 0;
 	const uint8_t *inpWord = 0;
 	uint32_t len = 0;
 	FREObject retObj=0;

 	//get first argument
 	if(FREGetObjectAsUTF8(argv[0], &len, &inpWord) != FRE_OK)
 	return retObj;

 	FRENewObjectFromUTF8((uint32_t)(strlen((char *)inpWord)),(const uint8_t*)(inpWord), &retObj);

 	return retObj;

 }


 FREObject initHunspellObject(FREContext ctx, void* funcData, uint32_t argc, FREObject argv[]){
 	const uint8_t *locale = 0;
 	const uint8_t *dictionaryPath = 0;
 	uint32_t len = -1;
 	FREObject retObj=0;
 	Hunspell * hunspellObject;
 	BOOL  fRunTimeLinkSuccess = FALSE;
 	//get first argument
 	if(FREGetObjectAsUTF8(argv[1], &len, &dictionaryPath) != FRE_OK)
 	return retObj;
 	len = 0;

 	//get second argument
 	if(FREGetObjectAsUTF8(argv[0], &len, &locale) != FRE_OK)
 	return retObj;

 	//check in cache and return if already present
 	if(!(Hunspell_cache.find(std::string((char *)locale))==Hunspell_cache.end()))
 		{
 			FRENewObjectFromInt32(HUNSPELL_INIT_SUCCESS, &retObj);
 			return retObj;
 		}

 	U16Char_t * dic_path_U16= EncConv::convCharStrToU16Str((char *)dictionaryPath, "UTF-8");
 	U16Char_t *locale_U16= EncConv::convCharStrToU16Str((char *)locale, "UTF-8");
 	std::wstring aff_file= std::wstring((wchar_t *)dic_path_U16)+std::wstring(L"\\Dictionaries\\")+std::wstring((wchar_t *)locale_U16)+std::wstring(L"\\")+std::wstring((wchar_t *)locale_U16)+std::wstring(L".aff");
 	std::wstring dic_file= std::wstring((wchar_t *)dic_path_U16)+std::wstring(L"\\Dictionaries\\")+std::wstring((wchar_t *)locale_U16)+std::wstring(L"\\")+std::wstring((wchar_t *)locale_U16)+std::wstring(L".dic");
 	std::wstring lib_file= std::wstring((wchar_t *)dic_path_U16)+std::wstring(L"\\libhunspell.dll");

 	EncConv::releaseU16Str(dic_path_U16);
 	EncConv::releaseU16Str(locale_U16);
 	//creating OS specific aff,dic file paths refer: DanishOS Issue of CS6 AHP
 	std::string aff_file_U8= makeString(aff_file.c_str());
 	std::string dic_file_U8= makeString(dic_file.c_str());

 	//make the file url's
 	std::string lib_file_U8= std::string((char *)dictionaryPath)+std::string("\\libhunspell.dll");

 	//check for file is present

 	if( (FileExists(aff_file) && FileExists(dic_file) && FileExists(lib_file)) == false )
 	{
 		FRENewObjectFromInt32(RESOURCE_FILES_MISSING, &retObj);
 		return retObj;
 	}


 	LPCTSTR lib_file_lpstring= (wchar_t *)lib_file.c_str();

 	//make a new hunspell object
 	hinstLib = LoadLibrary(lib_file_lpstring);
 	if (hinstLib != NULL)
     {
        HUNSPELL_INIT initAdd = (HUNSPELL_INIT) GetProcAddress(hinstLib, "hunspell_initialize");

         // If the function address is valid, call the function.

         if (NULL != initAdd)
         {
             fRunTimeLinkSuccess = TRUE;
           hunspellObject = (initAdd) ((char *)aff_file_U8.c_str(), (char *)dic_file_U8.c_str());
         }

     }

 //add to hunspell cache
 	if(Hunspell_cache.find(std::string((char *)locale))==Hunspell_cache.end())
 		Hunspell_cache[std::string((char *)locale)]= hunspellObject;

 	if(hunspellObject)
 	{
 		FRENewObjectFromInt32(HUNSPELL_INIT_SUCCESS, &retObj);
 	}
 	else
 	{
 		FRENewObjectFromInt32(HUNSPELL_INIT_FAIL, &retObj);
 	}
 	return retObj;
 }

 FREObject checkWord(FREContext ctx, void* funcData, uint32_t argc, FREObject argv[]) {
 	const uint8_t *locale = 0;
 	const uint8_t *inpWord = 0;
 	uint32_t len = -1;
 	FREObject retObj=0;
 	int rv=0;

 	U16Char_t* inpWordU16 = NULL;
 	std::string  inpWordDictEncoded;
 	bool isConversionUnSuccesful=false;
 	//get first argument
 	if(FREGetObjectAsUTF8(argv[1], &len, &locale) != FRE_OK)
 	return retObj;
 	len = 0;

 	//get second argument
 	if(FREGetObjectAsUTF8(argv[0], &len, &inpWord) != FRE_OK)
 	return retObj;

 	//get the hunspell object from cache
 	Hunspell * hunspellObject=getHunspellObject(std::string((char *)locale));

 	if(!hunspellObject)
 		return retObj;

 	//convert input utf8 to u16 string
 	inpWordU16 = EncConv::convCharStrToU16Str((char *)inpWord, "UTF-8");

 	//get dictionary encoding
 	HUNSPELL_GET_ENCODING getEncAdd=(HUNSPELL_GET_ENCODING) GetProcAddress(hinstLib, "hunspell_get_dic_encoding");
 	char * m_MainEncoding= (getEncAdd)(hunspellObject);

 	//convert u16 to dictionary encoding
 	inpWordDictEncoded=EncConv::convU16StrToCharStr(inpWordU16,m_MainEncoding);

 	if(inpWordDictEncoded.length()==0)
 	{
 		isConversionUnSuccesful = true;
 	}

 	//Get spellAddress
 	HUNSPELL_SPELL spellAdd= (HUNSPELL_SPELL) GetProcAddress(hinstLib, "hunspell_spell");

 	//Do spell check with converted word else try with UTF-8
 	if((!isConversionUnSuccesful) )
 	{
 		rv= (spellAdd)(hunspellObject, (char * )inpWordDictEncoded.c_str());
 	}
 	else
 	{
 		rv= (spellAdd)(hunspellObject, (char * )inpWord);
 	}

 	//return results
 	FRENewObjectFromInt32(rv, &retObj);
 	EncConv::releaseU16Str(inpWordU16);
 	 return retObj;
 }

 FREObject getSuggestions(FREContext ctx, void* funcData, uint32_t argc, FREObject argv[]) {
 	const uint8_t *locale = 0;
 	const uint8_t *inpWord = 0;
 	uint32_t len = -1;
 	FREObject retObj=0;
 	FREObject oneSuggestion=0;

 	U16Char_t* inpWordU16 = NULL;
 	std::string  inpWordDictEncoded;
 	bool isConversionUnSuccesful=false;
 	char * oneSuggestionEncoded=NULL;
 	U16Char_t * oneSuggestionU16=NULL;
 	std::string oneSuggestionU8;

 	//assign memory to retobj
 	FRENewObject((const uint8_t*)"Array", 0, NULL, &retObj, 0);

 	//get first argument
 	if(FREGetObjectAsUTF8(argv[1], &len, &locale) != FRE_OK)
 	return retObj;
 	len = 0;

 	//get second argument
 	if(FREGetObjectAsUTF8(argv[0], &len, &inpWord) != FRE_OK)
 	return retObj;

 	//get the hunspell object from cache
 	Hunspell * hunspellObject=getHunspellObject(std::string((char *)locale));

 	if(!hunspellObject) return retObj;

 	//convert input utf8 to u16 string
 	inpWordU16 = EncConv::convCharStrToU16Str((char *)inpWord, "UTF-8");

 	//get dictionary encoding
 	HUNSPELL_GET_ENCODING getEncAdd=(HUNSPELL_GET_ENCODING) GetProcAddress(hinstLib, "hunspell_get_dic_encoding");
 	char * m_MainEncoding= (getEncAdd)(hunspellObject);

 	//convert u16 to dictionary encoding
 	inpWordDictEncoded=EncConv::convU16StrToCharStr(inpWordU16,m_MainEncoding);

 	if(inpWordDictEncoded.length()==0)
 	{
 		isConversionUnSuccesful = true;
 	}

 	//get suggestAddress &freelistAddress
 	HUNSPELL_SUGGEST suggestAdd= (HUNSPELL_SUGGEST) GetProcAddress(hinstLib, "hunspell_suggest");
 	HUNSPELL_FREE_LIST freeListAdd= (HUNSPELL_FREE_LIST) GetProcAddress(hinstLib, "hunspell_free_list");

 	char** suggList = NULL;
 	int numSugg = 0;

 	//Try getting suggestions with encoded word else try with UTF8
 	if(suggestAdd && !isConversionUnSuccesful)
 	{
 		numSugg = (suggestAdd)(hunspellObject,(char *) (inpWordDictEncoded.c_str()),&suggList);
 	}
 	else
 	{
 		numSugg = (suggestAdd)(hunspellObject,(char *) (inpWord),&suggList);
 	}


 	if(numSugg)
 				{
 					FRESetArrayLength( retObj, numSugg );

 					for(int iCount=0; iCount <numSugg; iCount++)
 					{
 						oneSuggestionEncoded=suggList[iCount];
 						oneSuggestionU16=EncConv::convCharStrToU16Str(oneSuggestionEncoded, m_MainEncoding);
 						oneSuggestionU8= EncConv::convU16StrToCharStr(oneSuggestionU16, "UTF-8");
 						FRENewObjectFromUTF8((uint32_t)(oneSuggestionU8.length()),(const uint8_t*)(oneSuggestionU8.c_str()), &oneSuggestion);
 						FRESetArrayElementAt(retObj, iCount, oneSuggestion);
 						EncConv::releaseU16Str(oneSuggestionU16);
 					}
 					(freeListAdd)(hunspellObject, &suggList,numSugg);

 				}
 	EncConv::releaseU16Str(inpWordU16);
 	return retObj;
 }

 Hunspell * getHunspellObject(std::string locale)
 {
 	Hunspell_cache_iterator iter;
 	if((iter=Hunspell_cache.find(locale)) == Hunspell_cache.end() )
 		return NULL;
 	else
 		return iter->second;
 }

 void ContextInitializer(void* extData, const uint8_t* ctxType, FREContext ctx,
 						uint32_t* numFunctionsToTest, const FRENamedFunction** functionsToSet)
 {
 	*numFunctionsToTest = 4;
 	FRENamedFunction* func = (FRENamedFunction*)malloc(sizeof(FRENamedFunction)*5);

 	func[0].name = (const uint8_t*)"talkBack";
 	func[0].functionData = NULL;
 	func[0].function = &talkBack;

 	func[1].name = (const uint8_t*)"initHunspellObject";
 	func[1].functionData = NULL;
 	func[1].function = &initHunspellObject;

 	func[2].name = (const uint8_t*)"checkWord";
 	func[2].functionData = NULL;
 	func[2].function = &checkWord;

 	func[3].name = (const uint8_t*)"getSuggestions";
 	func[3].functionData = NULL;
 	func[3].function = &getSuggestions;

 	*functionsToSet = func;
 }

 void ContextFinalizer(FREContext ctx) {
 	return;
 }

 __declspec(dllexport) void ExtInitializer(void** extDataToSet, FREContextInitializer* ctxInitializerToSet,
 					FREContextFinalizer* ctxFinalizerToSet) {
 	*extDataToSet = NULL;
 	*ctxInitializerToSet = ContextInitializer;
 	*ctxFinalizerToSet = ContextFinalizer;
 }

 __declspec(dllexport) void ExtFinalizer(void* extData) {
 	HUNSPELL_UNINIT uninitAdd= (HUNSPELL_UNINIT) GetProcAddress(hinstLib, "hunspell_uninitialize");
 	//clear all hunspell cache
 	for(Hunspell_cache_iterator hunspell_cache_iter= Hunspell_cache.begin(); hunspell_cache_iter!=Hunspell_cache.end(); hunspell_cache_iter++)
 	{
 		(uninitAdd)(hunspell_cache_iter->second);//uninitialize hunspell objects properly
 		hunspell_cache_iter->second=NULL;
 	}
 	Hunspell_cache.clear();
 	FreeLibrary(hinstLib);//unload hunspell dll
 	return;
 }
	////////////////////////////////////////////////////////////////////////////////
	//
	// Licensed to the Apache Software Foundation (ASF) under one or more
	// contributor license agreements. See the NOTICE file distributed with
	// this work for additional information regarding copyright ownership.
	// The ASF licenses this file to You under the Apache License, Version 2.0
	// (the "License"); you may not use this file except in compliance with
	// the License. You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.
	//
	////////////////////////////////////////////////////////////////////////////////

	// This is the main DLL file.

	//#include "stdafx.h"
	#include <windows.h>
	#include "EncConv.h"
	#include "win\Utilities.h"
	#include <stdio.h>
	#include "HunspellNativeExtension.h"

	typedef Hunspell * (__cdecl HUNSPELL_INIT)(char , char*);
	typedef int (__cdecl HUNSPELL_SPELL)(void , char*);
	typedef int (__cdecl HUNSPELL_SUGGEST)(void , char, char **);
	typedef void (__cdecl HUNSPELL_FREE_LIST)(void , char***, int);
	typedef char * (__cdecl HUNSPELL_GET_ENCODING)(void );
	typedef void (__cdecl * HUNSPELL_UNINIT)(void *);
	HINSTANCE hinstLib;

	FREObject talkBack(FREContext ctx, void* funcData, uint32_t argc, FREObject argv[]) {
	const uint8_t *locale = 0;
	const uint8_t *inpWord = 0;
	uint32_t len = 0;
	FREObject retObj=0;

	//get first argument
	if(FREGetObjectAsUTF8(argv[0], &len, &inpWord) != FRE_OK)
	return retObj;

	FRENewObjectFromUTF8((uint32_t)(strlen((char )inpWord)),(const uint8_t)(inpWord), &retObj);

	return retObj;

	}


	FREObject initHunspellObject(FREContext ctx, void* funcData, uint32_t argc, FREObject argv[]){
	const uint8_t *locale = 0;
	const uint8_t *dictionaryPath = 0;
	uint32_t len = -1;
	FREObject retObj=0;
	Hunspell * hunspellObject;
	BOOL fRunTimeLinkSuccess = FALSE;
	//get first argument
	if(FREGetObjectAsUTF8(argv[1], &len, &dictionaryPath) != FRE_OK)
	return retObj;
	len = 0;

	//get second argument
	if(FREGetObjectAsUTF8(argv[0], &len, &locale) != FRE_OK)
	return retObj;

	//check in cache and return if already present
	if(!(Hunspell_cache.find(std::string((char *)locale))==Hunspell_cache.end()))
	{
	FRENewObjectFromInt32(HUNSPELL_INIT_SUCCESS, &retObj);
	return retObj;
	}

	U16Char_t * dic_path_U16= EncConv::convCharStrToU16Str((char *)dictionaryPath, "UTF-8");
	U16Char_t locale_U16= EncConv::convCharStrToU16Str((char )locale, "UTF-8");
	std::wstring aff_file= std::wstring((wchar_t )dic_path_U16)+std::wstring(L"\\Dictionaries\\")+std::wstring((wchar_t )locale_U16)+std::wstring(L"\\")+std::wstring((wchar_t *)locale_U16)+std::wstring(L".aff");
	std::wstring dic_file= std::wstring((wchar_t )dic_path_U16)+std::wstring(L"\\Dictionaries\\")+std::wstring((wchar_t )locale_U16)+std::wstring(L"\\")+std::wstring((wchar_t *)locale_U16)+std::wstring(L".dic");
	std::wstring lib_file= std::wstring((wchar_t *)dic_path_U16)+std::wstring(L"\\libhunspell.dll");

	EncConv::releaseU16Str(dic_path_U16);
	EncConv::releaseU16Str(locale_U16);
	//creating OS specific aff,dic file paths refer: DanishOS Issue of CS6 AHP
	std::string aff_file_U8= makeString(aff_file.c_str());
	std::string dic_file_U8= makeString(dic_file.c_str());

	//make the file url's
	std::string lib_file_U8= std::string((char *)dictionaryPath)+std::string("\\libhunspell.dll");

	//check for file is present

	if( (FileExists(aff_file) && FileExists(dic_file) && FileExists(lib_file)) == false )
	{
	FRENewObjectFromInt32(RESOURCE_FILES_MISSING, &retObj);
	return retObj;
	}


	LPCTSTR lib_file_lpstring= (wchar_t *)lib_file.c_str();

	//make a new hunspell object
	hinstLib = LoadLibrary(lib_file_lpstring);
	if (hinstLib != NULL)
	{
	HUNSPELL_INIT initAdd = (HUNSPELL_INIT) GetProcAddress(hinstLib, "hunspell_initialize");

	// If the function address is valid, call the function.

	if (NULL != initAdd)
	{
	fRunTimeLinkSuccess = TRUE;
	hunspellObject = (initAdd) ((char )aff_file_U8.c_str(), (char )dic_file_U8.c_str());
	}

	}

	//add to hunspell cache
	if(Hunspell_cache.find(std::string((char *)locale))==Hunspell_cache.end())
	Hunspell_cache[std::string((char *)locale)]= hunspellObject;

	if(hunspellObject)
	{
	FRENewObjectFromInt32(HUNSPELL_INIT_SUCCESS, &retObj);
	}
	else
	{
	FRENewObjectFromInt32(HUNSPELL_INIT_FAIL, &retObj);
	}
	return retObj;
	}

	FREObject checkWord(FREContext ctx, void* funcData, uint32_t argc, FREObject argv[]) {
	const uint8_t *locale = 0;
	const uint8_t *inpWord = 0;
	uint32_t len = -1;
	FREObject retObj=0;
	int rv=0;

	U16Char_t* inpWordU16 = NULL;
	std::string inpWordDictEncoded;
	bool isConversionUnSuccesful=false;
	//get first argument
	if(FREGetObjectAsUTF8(argv[1], &len, &locale) != FRE_OK)
	return retObj;
	len = 0;

	//get second argument
	if(FREGetObjectAsUTF8(argv[0], &len, &inpWord) != FRE_OK)
	return retObj;

	//get the hunspell object from cache
	Hunspell * hunspellObject=getHunspellObject(std::string((char *)locale));

	if(!hunspellObject)
	return retObj;

	//convert input utf8 to u16 string
	inpWordU16 = EncConv::convCharStrToU16Str((char *)inpWord, "UTF-8");

	//get dictionary encoding
	HUNSPELL_GET_ENCODING getEncAdd=(HUNSPELL_GET_ENCODING) GetProcAddress(hinstLib, "hunspell_get_dic_encoding");
	char * m_MainEncoding= (getEncAdd)(hunspellObject);

	//convert u16 to dictionary encoding
	inpWordDictEncoded=EncConv::convU16StrToCharStr(inpWordU16,m_MainEncoding);

	if(inpWordDictEncoded.length()==0)
	{
	isConversionUnSuccesful = true;
	}

	//Get spellAddress
	HUNSPELL_SPELL spellAdd= (HUNSPELL_SPELL) GetProcAddress(hinstLib, "hunspell_spell");

	//Do spell check with converted word else try with UTF-8
	if((!isConversionUnSuccesful) )
	{
	rv= (spellAdd)(hunspellObject, (char * )inpWordDictEncoded.c_str());
	}
	else
	{
	rv= (spellAdd)(hunspellObject, (char * )inpWord);
	}

	//return results
	FRENewObjectFromInt32(rv, &retObj);
	EncConv::releaseU16Str(inpWordU16);
	return retObj;
	}

	FREObject getSuggestions(FREContext ctx, void* funcData, uint32_t argc, FREObject argv[]) {
	const uint8_t *locale = 0;
	const uint8_t *inpWord = 0;
	uint32_t len = -1;
	FREObject retObj=0;
	FREObject oneSuggestion=0;

	U16Char_t* inpWordU16 = NULL;
	std::string inpWordDictEncoded;
	bool isConversionUnSuccesful=false;
	char * oneSuggestionEncoded=NULL;
	U16Char_t * oneSuggestionU16=NULL;
	std::string oneSuggestionU8;

	//assign memory to retobj
	FRENewObject((const uint8_t*)"Array", 0, NULL, &retObj, 0);

	//get first argument
	if(FREGetObjectAsUTF8(argv[1], &len, &locale) != FRE_OK)
	return retObj;
	len = 0;

	//get second argument
	if(FREGetObjectAsUTF8(argv[0], &len, &inpWord) != FRE_OK)
	return retObj;

	//get the hunspell object from cache
	Hunspell * hunspellObject=getHunspellObject(std::string((char *)locale));

	if(!hunspellObject) return retObj;

	//convert input utf8 to u16 string
	inpWordU16 = EncConv::convCharStrToU16Str((char *)inpWord, "UTF-8");

	//get dictionary encoding
	HUNSPELL_GET_ENCODING getEncAdd=(HUNSPELL_GET_ENCODING) GetProcAddress(hinstLib, "hunspell_get_dic_encoding");
	char * m_MainEncoding= (getEncAdd)(hunspellObject);

	//convert u16 to dictionary encoding
	inpWordDictEncoded=EncConv::convU16StrToCharStr(inpWordU16,m_MainEncoding);

	if(inpWordDictEncoded.length()==0)
	{
	isConversionUnSuccesful = true;
	}

	//get suggestAddress &freelistAddress
	HUNSPELL_SUGGEST suggestAdd= (HUNSPELL_SUGGEST) GetProcAddress(hinstLib, "hunspell_suggest");
	HUNSPELL_FREE_LIST freeListAdd= (HUNSPELL_FREE_LIST) GetProcAddress(hinstLib, "hunspell_free_list");

	char** suggList = NULL;
	int numSugg = 0;

	//Try getting suggestions with encoded word else try with UTF8
	if(suggestAdd && !isConversionUnSuccesful)
	{
	numSugg = (suggestAdd)(hunspellObject,(char *) (inpWordDictEncoded.c_str()),&suggList);
	}
	else
	{
	numSugg = (suggestAdd)(hunspellObject,(char *) (inpWord),&suggList);
	}


	if(numSugg)
	{
	FRESetArrayLength( retObj, numSugg );

	for(int iCount=0; iCount <numSugg; iCount++)
	{
	oneSuggestionEncoded=suggList[iCount];
	oneSuggestionU16=EncConv::convCharStrToU16Str(oneSuggestionEncoded, m_MainEncoding);
	oneSuggestionU8= EncConv::convU16StrToCharStr(oneSuggestionU16, "UTF-8");
	FRENewObjectFromUTF8((uint32_t)(oneSuggestionU8.length()),(const uint8_t*)(oneSuggestionU8.c_str()), &oneSuggestion);
	FRESetArrayElementAt(retObj, iCount, oneSuggestion);
	EncConv::releaseU16Str(oneSuggestionU16);
	}
	(freeListAdd)(hunspellObject, &suggList,numSugg);

	}
	EncConv::releaseU16Str(inpWordU16);
	return retObj;
	}

	Hunspell * getHunspellObject(std::string locale)
	{
	Hunspell_cache_iterator iter;
	if((iter=Hunspell_cache.find(locale)) == Hunspell_cache.end() )
	return NULL;
	else
	return iter->second;
	}

	void ContextInitializer(void* extData, const uint8_t* ctxType, FREContext ctx,
	uint32_t* numFunctionsToTest, const FRENamedFunction** functionsToSet)
	{
	*numFunctionsToTest = 4;
	FRENamedFunction* func = (FRENamedFunction)malloc(sizeof(FRENamedFunction)5);

	func[0].name = (const uint8_t*)"talkBack";
	func[0].functionData = NULL;
	func[0].function = &talkBack;

	func[1].name = (const uint8_t*)"initHunspellObject";
	func[1].functionData = NULL;
	func[1].function = &initHunspellObject;

	func[2].name = (const uint8_t*)"checkWord";
	func[2].functionData = NULL;
	func[2].function = &checkWord;

	func[3].name = (const uint8_t*)"getSuggestions";
	func[3].functionData = NULL;
	func[3].function = &getSuggestions;

	*functionsToSet = func;
	}

	void ContextFinalizer(FREContext ctx) {
	return;
	}

	__declspec(dllexport) void ExtInitializer(void** extDataToSet, FREContextInitializer* ctxInitializerToSet,
	FREContextFinalizer* ctxFinalizerToSet) {
	*extDataToSet = NULL;
	*ctxInitializerToSet = ContextInitializer;
	*ctxFinalizerToSet = ContextFinalizer;
	}

	__declspec(dllexport) void ExtFinalizer(void* extData) {
	HUNSPELL_UNINIT uninitAdd= (HUNSPELL_UNINIT) GetProcAddress(hinstLib, "hunspell_uninitialize");
	//clear all hunspell cache
	for(Hunspell_cache_iterator hunspell_cache_iter= Hunspell_cache.begin(); hunspell_cache_iter!=Hunspell_cache.end(); hunspell_cache_iter++)
	{
	(uninitAdd)(hunspell_cache_iter->second);//uninitialize hunspell objects properly
	hunspell_cache_iter->second=NULL;
	}
	Hunspell_cache.clear();
	FreeLibrary(hinstLib);//unload hunspell dll
	return;
	}