Always release the GIL when calling N++

bruderstein · bruderstein · commit cba6b6ace0c3 · 2014-09-27T16:41:09.000+02:00
Notifications can come at any time due to WM_NOTIFY messages from child windows being forwarded by N++ to plugins. This means we can always get a notification, even when we're not expecting it. Added check to see if we're interested in the notification before we claim the GIL. This is a belt-and-braces fix, as actually, simply performing a check if we're interested in the notification would be enough. However, there are so many hidden cases, always giving up the GIL whilst calling into N++ will eliminate all chance of deadlocks, and we can optimize later if it becomes an issue. Reported by "Kadner" https://sourceforge.net/p/npppythonscript/discussion/1188886/thread/915d6d40/?limit=25
diff --git a/PythonScript/src/NotepadPlusWrapper.cpp b/PythonScript/src/NotepadPlusWrapper.cpp
@@ -47,6 +47,25 @@ void NotepadPlusWrapper::notify(SCNotification *notifyCode)
 	if (!m_notificationsEnabled)
 		return;
 
+
+    // Optimisation. Count the number of callbacks registered for this code,
+    // if there are none, then we can simply return without claiming the GIL.
+    // This is especially helpful as N++ forwards WM_NOTIFY messages from child windows, so we 
+    // get all manor of garbage from RebarWindows etc, that we just don't care about.
+    // Overall, it's slightly slower in the case of a real callback (we count them, then
+    // find them all with the equal_range() call below, but much quicker in the case of a 
+    // notification that we don't care about, as we don't need to grab the GIL then give it back.
+    // We use count, because *ANY* operation that involves the boost::python::object (e.g. creating 
+    // an iterator) requires the GIL to manage the refcounts. A count() only involves the integer keys,
+    // so we're safe to do that without the GIL.
+    callbackT::size_type count = m_callbacks.count(notifyCode->nmhdr.code);
+	if (0 == count)
+        return;
+
+    DEBUG_TRACE_S(("Notepad notify with code %d\n", notifyCode->nmhdr.code));
+
+    
+
     GILLock gilLock;
 
 
@@ -165,7 +184,6 @@ bool NotepadPlusWrapper::addCallback(boost::python::object callback, boost::pyth
 
 void NotepadPlusWrapper::save()
 {
-	GILRelease release;
 	callNotepad(NPPM_SAVECURRENTFILE);
 	
 }
@@ -176,7 +194,6 @@ void NotepadPlusWrapper::newDocument()
     DEBUG_TRACE(L"NotepadPlusWrapper::newDocument\n");
     notAllowedInScintillaCallback("new() cannot be called in a synchronous editor callback. "
 		"Use an asynchronous callback, or avoid using new() in the callback handler");
-	GILRelease release;
 	callNotepad(NPPM_MENUCOMMAND, 0, IDM_FILE_NEW);
 	
 }
@@ -186,7 +203,6 @@ void NotepadPlusWrapper::newDocumentWithFilename(const char *filename)
     notAllowedInScintillaCallback("new() cannot be called in a synchronous editor callback. "
 		"Use an asynchronous callback, or avoid using new() in the callback handler");
 
-	GILRelease release;
 	callNotepad(NPPM_MENUCOMMAND, 0, IDM_FILE_NEW);
 	std::shared_ptr<TCHAR> tFilename = WcharMbcsConverter::char2tchar(filename);
 	callNotepad(NPPM_SAVECURRENTFILEAS, 0, reinterpret_cast<LPARAM>(tFilename.get()));
@@ -195,14 +211,12 @@ void NotepadPlusWrapper::newDocumentWithFilename(const char *filename)
 
 void NotepadPlusWrapper::saveAs(const char *filename)
 {
-	GILRelease release;
 	callNotepad(NPPM_SAVECURRENTFILEAS, FALSE, reinterpret_cast<LPARAM>(WcharMbcsConverter::char2tchar(filename).get()));
 	
 }
 	
 void NotepadPlusWrapper::saveAsCopy(const char *filename)
 {
-	GILRelease release;
 	callNotepad(NPPM_SAVECURRENTFILEAS, TRUE, reinterpret_cast<LPARAM>(WcharMbcsConverter::char2tchar(filename).get()));
 	
 }
@@ -211,7 +225,6 @@ void NotepadPlusWrapper::open(const char *filename)
 {
     notAllowedInScintillaCallback("open() cannot be called in a synchronous editor callback. "
 		"Use an asynchronous callback, or avoid using open() in the callback handler");
-	GILRelease release;
 	callNotepad(NPPM_DOOPEN, 0, reinterpret_cast<LPARAM>(WcharMbcsConverter::char2tchar(filename).get()));
 	
 }
@@ -221,7 +234,6 @@ bool NotepadPlusWrapper::activateFile(const char *filename)
     notAllowedInScintillaCallback("activateFile() cannot be called in a synchronous editor callback. "
 		"Use an asynchronous callback, or avoid using activateFile() in the callback handler");
 	bool retVal;
-	GILRelease release;
 	retVal = 0 != callNotepad(NPPM_SWITCHTOFILE, 0, reinterpret_cast<LPARAM>(WcharMbcsConverter::char2tchar(filename).get()));
 	
 	return retVal;
@@ -244,7 +256,6 @@ LangType NotepadPlusWrapper::getCurrentLangType()
 
 void NotepadPlusWrapper::setCurrentLangType(LangType lang)
 {
-	GILRelease release;
 	callNotepad(NPPM_SETCURRENTLANGTYPE, 0, static_cast<LPARAM>(lang));
 	
 }
@@ -369,7 +380,6 @@ void NotepadPlusWrapper::saveSession(const char *sessionFilename, boost::python:
 	
 	si.nbFile = (int)filesCount;
 
-	GILRelease release;
 	callNotepad(NPPM_SAVESESSION, 0, reinterpret_cast<LPARAM>(&si));
 	
 
@@ -383,7 +393,6 @@ void NotepadPlusWrapper::saveSession(const char *sessionFilename, boost::python:
 
 void NotepadPlusWrapper::saveCurrentSession(const char *filename)
 {
-	GILRelease release;
 	callNotepad(NPPM_SAVECURRENTSESSION, 0, reinterpret_cast<LPARAM>(WcharMbcsConverter::char2tchar(filename).get()));
 	
 }
@@ -412,7 +421,6 @@ idx_t NotepadPlusWrapper::getCurrentDocIndex(int view)
 
 void NotepadPlusWrapper::setStatusBar(StatusBarSection section, const char *text)
 {
-	GILRelease release;
 #ifdef UNICODE
 		std::shared_ptr<TCHAR> s = WcharMbcsConverter::char2tchar(text);
 	callNotepad(NPPM_SETSTATUSBAR, static_cast<WPARAM>(section), reinterpret_cast<LPARAM>(s.get()));
@@ -430,7 +438,6 @@ long NotepadPlusWrapper::getPluginMenuHandle()
 
 void NotepadPlusWrapper::activateIndex(int view, int index)
 {
-	GILRelease release; 
 	callNotepad(NPPM_ACTIVATEDOC, static_cast<WPARAM>(view), static_cast<LPARAM>(index));
 	
 }
@@ -441,10 +448,8 @@ void NotepadPlusWrapper::loadSession(boost::python::str filename)
 		"Use an asynchronous callback, or avoid using loadSession() in the callback handler");
 #ifdef UNICODE
 	std::shared_ptr<TCHAR> s = WcharMbcsConverter::char2tchar((const char*)boost::python::extract<const char*>(filename));
-	GILRelease release;
 	callNotepad(NPPM_LOADSESSION, 0, reinterpret_cast<LPARAM>(s.get()));
 #else
-	GILRelease release;
 	callNotepad(NPPM_LOADSESSION, 0, reinterpret_cast<LPARAM>((const char*)boost::python::extract<const char*>(filename)));
 #endif
 	
@@ -456,10 +461,8 @@ void NotepadPlusWrapper::activateFileString(boost::python::str filename)
 		"Use an asynchronous callback, or avoid using activateFile() in the callback handler");
 	#ifdef UNICODE
 	std::shared_ptr<TCHAR> s = WcharMbcsConverter::char2tchar((const char*)boost::python::extract<const char*>(filename));
-	GILRelease release;
 	callNotepad(NPPM_SWITCHTOFILE, 0, reinterpret_cast<LPARAM>(s.get()));
 #else
-	GILRelease release;
 	callNotepad(NPPM_SWITCHTOFILE, 0, reinterpret_cast<LPARAM>((const char*)boost::python::extract<const char*>(filename)));
 #endif
 	
@@ -468,7 +471,6 @@ void NotepadPlusWrapper::activateFileString(boost::python::str filename)
 
 void NotepadPlusWrapper::reloadFile(boost::python::str filename, bool alert)
 {
-	GILRelease release;
 #ifdef UNICODE
 	callNotepad(NPPM_RELOADFILE, alert ? 1 : 0, reinterpret_cast<LPARAM>(static_cast<const TCHAR *>(WcharMbcsConverter::char2tchar(boost::python::extract<const char *>(filename)).get())));
 #else
@@ -480,7 +482,6 @@ void NotepadPlusWrapper::reloadFile(boost::python::str filename, bool alert)
 
 void NotepadPlusWrapper::saveAllFiles()
 {
-	GILRelease release;
 	callNotepad(NPPM_SAVEALLFILES);
 	
 }
@@ -494,7 +495,6 @@ boost::python::str NotepadPlusWrapper::getPluginConfigDir()
 
 void NotepadPlusWrapper::menuCommand(int commandID)
 {
-	GILRelease release;
 	callNotepad(NPPM_MENUCOMMAND, 0, commandID);
 	
 }
@@ -542,101 +542,86 @@ boost::python::tuple NotepadPlusWrapper::getVersion()
 
 void NotepadPlusWrapper::hideTabBar()
 {
-	GILRelease release;
 	callNotepad(NPPM_HIDETABBAR, 0, TRUE);
 	
 }
 
 void NotepadPlusWrapper::showTabBar()
 {
-	GILRelease release;
 	callNotepad(NPPM_HIDETABBAR, 0, FALSE);
 	
 }
 
 int NotepadPlusWrapper::getCurrentBufferID()
 {
-	GILRelease release;
 	return callNotepad(NPPM_GETCURRENTBUFFERID);
 }
 
 void NotepadPlusWrapper::reloadBuffer(int bufferID, bool withAlert)
 {
-	GILRelease release;
 	callNotepad(NPPM_RELOADBUFFERID, static_cast<WPARAM>(bufferID), static_cast<LPARAM>(withAlert));
 	
 }
 
 LangType NotepadPlusWrapper::getLangType()
 {
-	GILRelease release;
 	return getBufferLangType(callNotepad(NPPM_GETCURRENTBUFFERID));
 }
 
 LangType NotepadPlusWrapper::getBufferLangType(int bufferID)
 {
-	GILRelease release;
 	return static_cast<LangType>(callNotepad(NPPM_GETBUFFERLANGTYPE, bufferID));
 }
 
 
 
 void NotepadPlusWrapper::setBufferLangType(LangType language, int bufferID)
 {
-	GILRelease release;
 	callNotepad(NPPM_SETBUFFERLANGTYPE, static_cast<WPARAM>(bufferID), static_cast<LPARAM>(language));
 	
 }
 
 BufferEncoding NotepadPlusWrapper::getEncoding()
 {
-	GILRelease release;
 	return getBufferEncoding(callNotepad(NPPM_GETCURRENTBUFFERID));
 }
 
 BufferEncoding NotepadPlusWrapper::getBufferEncoding(int bufferID)
 {
-	GILRelease release;
 	return static_cast<BufferEncoding>(callNotepad(NPPM_GETBUFFERENCODING, static_cast<WPARAM>(bufferID)));
 }
 
 void NotepadPlusWrapper::setEncoding(BufferEncoding encoding)
 {
-	GILRelease release;
 	callNotepad(NPPM_SETBUFFERENCODING, static_cast<WPARAM>(callNotepad(NPPM_GETCURRENTBUFFERID)), static_cast<LPARAM>(encoding));
 	
 }
 
 void NotepadPlusWrapper::setBufferEncoding(BufferEncoding encoding, int bufferID)
 {
-	GILRelease release; 
 	callNotepad(NPPM_SETBUFFERENCODING, static_cast<WPARAM>(bufferID), static_cast<LPARAM>(encoding));
 	
 }
 
 FormatType NotepadPlusWrapper::getFormatType()
 {
-	GILRelease release;
 	return getBufferFormatType(callNotepad(NPPM_GETCURRENTBUFFERID));
 }
 
 
 FormatType NotepadPlusWrapper::getBufferFormatType(int bufferID)
 {
-	GILRelease release;
 	return static_cast<FormatType>(callNotepad(NPPM_GETBUFFERFORMAT, static_cast<WPARAM>(bufferID)));
 }
 
 void NotepadPlusWrapper::setFormatType(FormatType format)
 {
-	GILRelease release;
 	setBufferFormatType(format, callNotepad(NPPM_GETCURRENTBUFFERID));
 	
 }
 
 void NotepadPlusWrapper::setBufferFormatType(FormatType format, int bufferID)
 {
-	GILRelease release;
 	callNotepad(NPPM_SETBUFFERFORMAT, static_cast<WPARAM>(bufferID), static_cast<LPARAM>(format));
 	
 }
@@ -645,7 +630,6 @@ void NotepadPlusWrapper::closeDocument()
 {
     notAllowedInScintillaCallback("close() cannot be called in a synchronous editor callback. "
 		"Use an asynchronous callback, or avoid using close() in the callback handler");
-	GILRelease release; 
 	callNotepad(NPPM_MENUCOMMAND, 0, IDM_FILE_CLOSE);
 	
 }
@@ -654,7 +638,6 @@ void NotepadPlusWrapper::closeAllDocuments()
 {
     notAllowedInScintillaCallback("closeAll() cannot be called in a synchronous editor callback. "
 		"Use an asynchronous callback, or avoid using closeAll() in the callback handler");
-	GILRelease release; 
 	callNotepad(NPPM_MENUCOMMAND, 0, IDM_FILE_CLOSEALL);
 	
 }
@@ -663,14 +646,12 @@ void NotepadPlusWrapper::closeAllButCurrentDocument()
 {
     notAllowedInScintillaCallback("closeAllButCurrent() cannot be called in a synchronous editor callback. "
 		"Use an asynchronous callback, or avoid using closeAllButCurrent() in the callback handler");
-	GILRelease release; 
 	callNotepad(NPPM_MENUCOMMAND, 0, IDM_FILE_CLOSEALL_BUT_CURRENT);
 	
 }
 
 void NotepadPlusWrapper::reloadCurrentDocument()
 {
-	GILRelease release; 
 	callNotepad(NPPM_MENUCOMMAND, 0, IDM_FILE_RELOAD);
 	
 }
@@ -799,7 +780,6 @@ void NotepadPlusWrapper::activateBufferID(int bufferID)
 {
     notAllowedInScintillaCallback("activateBufferID() cannot be called in a synchronous editor callback. "
 		"Use an asynchronous callback, or avoid using activateBufferID() in the callback handler");
-	GILRelease release; 
 	idx_t index = (idx_t)callNotepad(NPPM_GETPOSFROMBUFFERID, static_cast<WPARAM>(bufferID));
 	UINT view = (index & 0xC0000000) >> 30;
 	index = index & 0x3FFFFFFF;
@@ -809,22 +789,18 @@ void NotepadPlusWrapper::activateBufferID(int bufferID)
 }
 boost::python::str NotepadPlusWrapper::getBufferFilename(int bufferID)
 { 
-    GILRelease release;
 	TCHAR buffer[MAX_PATH];
 	callNotepad(NPPM_GETFULLPATHFROMBUFFERID, static_cast<WPARAM>(bufferID), reinterpret_cast<LPARAM>(buffer));
 	std::shared_ptr<char> filename = WcharMbcsConverter::tchar2char(buffer);
-    release.reacquire();
 	return boost::python::str(const_cast<const char *>(filename.get()));
 }
 
 boost::python::str NotepadPlusWrapper::getCurrentFilename()
 {
-	GILRelease release;
 	idx_t bufferID = callNotepad(NPPM_GETCURRENTBUFFERID);
 	TCHAR buffer[MAX_PATH];
 	callNotepad(NPPM_GETFULLPATHFROMBUFFERID, bufferID, reinterpret_cast<LPARAM>(buffer));
 	std::shared_ptr<char> filename = WcharMbcsConverter::tchar2char(buffer);
-    release.reacquire();
 	return boost::python::str(const_cast<const char *>(filename.get()));
 }
 
@@ -876,9 +852,7 @@ bool NotepadPlusWrapper::runMenuCommand(boost::python::str menuName, boost::pyth
 boost::python::str NotepadPlusWrapper::getNppDir()
 {
 	TCHAR buffer[MAX_PATH];
-    GILRelease release;
-	::SendMessage(m_nppHandle, NPPM_GETNPPDIRECTORY, MAX_PATH, reinterpret_cast<LPARAM>(buffer));
-    release.reacquire();
+    callNotepad(NPPM_GETNPPDIRECTORY, MAX_PATH, reinterpret_cast<LPARAM>(buffer)); 
 	return boost::python::str(const_cast<const char *>(WcharMbcsConverter::tchar2char(buffer).get()));
 }
 
@@ -889,16 +863,13 @@ boost::python::str NotepadPlusWrapper::getCommandLine()
 
 bool NotepadPlusWrapper::allocateSupported()
 {
-    GILRelease release;
-	return 1 == ::SendMessage(m_nppHandle, NPPM_ALLOCATESUPPORTED, 0, 0);
+	return 1 == callNotepad(NPPM_ALLOCATESUPPORTED);
 }
 
 boost::python::object NotepadPlusWrapper::allocateCmdID(int quantity)
 {
 	int startID;
-    GILRelease release;
-	bool result = 1 == ::SendMessage(m_nppHandle, NPPM_ALLOCATECMDID, static_cast<WPARAM>(quantity), reinterpret_cast<LPARAM>(&startID));
-    release.reacquire();
+	bool result = 1 == callNotepad(NPPM_ALLOCATECMDID, static_cast<WPARAM>(quantity), reinterpret_cast<LPARAM>(&startID));
 	if (result)
 	{
 		return boost::python::object(startID);
@@ -912,9 +883,7 @@ boost::python::object NotepadPlusWrapper::allocateCmdID(int quantity)
 boost::python::object NotepadPlusWrapper::allocateMarker(int quantity)
 {
 	int startID;
-    GILRelease release;
-	bool result = 1 == ::SendMessage(m_nppHandle, NPPM_ALLOCATEMARKER, static_cast<WPARAM>(quantity), reinterpret_cast<LPARAM>(&startID));
-    release.reacquire();
+	bool result = 1 == callNotepad(NPPM_ALLOCATEMARKER, static_cast<WPARAM>(quantity), reinterpret_cast<LPARAM>(&startID));
 	if (result)
 	{
 		return boost::python::object(startID);
diff --git a/PythonScript/src/NotepadPlusWrapper.h b/PythonScript/src/NotepadPlusWrapper.h
@@ -9,6 +9,8 @@
 #include "menuCmdID.h"
 #endif
 
+#include "GILManager.h"
+
 struct SCNotification;
 namespace NppPythonScript
 {
@@ -575,6 +577,7 @@ class NotepadPlusWrapper
 protected:
 	LRESULT callNotepad(UINT message, WPARAM wParam = 0, LPARAM lParam = 0)
 	{
+        GILRelease release;
 		return SendMessage(m_nppHandle, message, wParam, lParam);
 	}
 

Original file line number	Diff line number	Diff line change
`@@ -47,6 +47,25 @@ void NotepadPlusWrapper::notify(SCNotification *notifyCode)`
`47`	`47`	`if (!m_notificationsEnabled)`
`48`	`48`	`return;`
`49`	`49`
	`50`	`+`
	`51`	`+ // Optimisation. Count the number of callbacks registered for this code,`
	`52`	`+ // if there are none, then we can simply return without claiming the GIL.`
	`53`	`+ // This is especially helpful as N++ forwards WM_NOTIFY messages from child windows, so we`
	`54`	`+ // get all manor of garbage from RebarWindows etc, that we just don't care about.`
	`55`	`+ // Overall, it's slightly slower in the case of a real callback (we count them, then`
	`56`	`+ // find them all with the equal_range() call below, but much quicker in the case of a`
	`57`	`+ // notification that we don't care about, as we don't need to grab the GIL then give it back.`
	`58`	`+ // We use count, because ANY operation that involves the boost::python::object (e.g. creating`
	`59`	`+ // an iterator) requires the GIL to manage the refcounts. A count() only involves the integer keys,`
	`60`	`+ // so we're safe to do that without the GIL.`
	`61`	`+ callbackT::size_type count = m_callbacks.count(notifyCode->nmhdr.code);`
	`62`	`+ if (0 == count)`
	`63`	`+ return;`
	`64`	`+`
	`65`	`+ DEBUG_TRACE_S(("Notepad notify with code %d\n", notifyCode->nmhdr.code));`
	`66`	`+`
	`67`	`+`
	`68`	`+`
`50`	`69`	`GILLock gilLock;`
`51`	`70`
`52`	`71`
`@@ -165,7 +184,6 @@ bool NotepadPlusWrapper::addCallback(boost::python::object callback, boost::pyth`
`165`	`184`
`166`	`185`	`void NotepadPlusWrapper::save()`
`167`	`186`	`{`
`168`		`- GILRelease release;`
`169`	`187`	`callNotepad(NPPM_SAVECURRENTFILE);`
`170`	`188`
`171`	`189`	`}`
`@@ -176,7 +194,6 @@ void NotepadPlusWrapper::newDocument()`
`176`	`194`	`DEBUG_TRACE(L"NotepadPlusWrapper::newDocument\n");`
`177`	`195`	`notAllowedInScintillaCallback("new() cannot be called in a synchronous editor callback. "`
`178`	`196`	`"Use an asynchronous callback, or avoid using new() in the callback handler");`
`179`		`- GILRelease release;`
`180`	`197`	`callNotepad(NPPM_MENUCOMMAND, 0, IDM_FILE_NEW);`
`181`	`198`
`182`	`199`	`}`
`@@ -186,7 +203,6 @@ void NotepadPlusWrapper::newDocumentWithFilename(const char *filename)`
`186`	`203`	`notAllowedInScintillaCallback("new() cannot be called in a synchronous editor callback. "`
`187`	`204`	`"Use an asynchronous callback, or avoid using new() in the callback handler");`
`188`	`205`
`189`		`- GILRelease release;`
`190`	`206`	`callNotepad(NPPM_MENUCOMMAND, 0, IDM_FILE_NEW);`
`191`	`207`	`std::shared_ptr<TCHAR> tFilename = WcharMbcsConverter::char2tchar(filename);`
`192`	`208`	`callNotepad(NPPM_SAVECURRENTFILEAS, 0, reinterpret_cast<LPARAM>(tFilename.get()));`
`@@ -195,14 +211,12 @@ void NotepadPlusWrapper::newDocumentWithFilename(const char *filename)`
`195`	`211`
`196`	`212`	`void NotepadPlusWrapper::saveAs(const char *filename)`
`197`	`213`	`{`
`198`		`- GILRelease release;`
`199`	`214`	`callNotepad(NPPM_SAVECURRENTFILEAS, FALSE, reinterpret_cast<LPARAM>(WcharMbcsConverter::char2tchar(filename).get()));`
`200`	`215`
`201`	`216`	`}`
`202`	`217`
`203`	`218`	`void NotepadPlusWrapper::saveAsCopy(const char *filename)`
`204`	`219`	`{`
`205`		`- GILRelease release;`
`206`	`220`	`callNotepad(NPPM_SAVECURRENTFILEAS, TRUE, reinterpret_cast<LPARAM>(WcharMbcsConverter::char2tchar(filename).get()));`
`207`	`221`
`208`	`222`	`}`
`@@ -211,7 +225,6 @@ void NotepadPlusWrapper::open(const char *filename)`
`211`	`225`	`{`
`212`	`226`	`notAllowedInScintillaCallback("open() cannot be called in a synchronous editor callback. "`
`213`	`227`	`"Use an asynchronous callback, or avoid using open() in the callback handler");`
`214`		`- GILRelease release;`
`215`	`228`	`callNotepad(NPPM_DOOPEN, 0, reinterpret_cast<LPARAM>(WcharMbcsConverter::char2tchar(filename).get()));`
`216`	`229`
`217`	`230`	`}`
`@@ -221,7 +234,6 @@ bool NotepadPlusWrapper::activateFile(const char *filename)`
`221`	`234`	`notAllowedInScintillaCallback("activateFile() cannot be called in a synchronous editor callback. "`
`222`	`235`	`"Use an asynchronous callback, or avoid using activateFile() in the callback handler");`
`223`	`236`	`bool retVal;`
`224`		`- GILRelease release;`
`225`	`237`	`retVal = 0 != callNotepad(NPPM_SWITCHTOFILE, 0, reinterpret_cast<LPARAM>(WcharMbcsConverter::char2tchar(filename).get()));`
`226`	`238`
`227`	`239`	`return retVal;`
`@@ -244,7 +256,6 @@ LangType NotepadPlusWrapper::getCurrentLangType()`
`244`	`256`
`245`	`257`	`void NotepadPlusWrapper::setCurrentLangType(LangType lang)`
`246`	`258`	`{`
`247`		`- GILRelease release;`
`248`	`259`	`callNotepad(NPPM_SETCURRENTLANGTYPE, 0, static_cast<LPARAM>(lang));`
`249`	`260`
`250`	`261`	`}`
`@@ -369,7 +380,6 @@ void NotepadPlusWrapper::saveSession(const char *sessionFilename, boost::python:`
`369`	`380`
`370`	`381`	`si.nbFile = (int)filesCount;`
`371`	`382`
`372`		`- GILRelease release;`
`373`	`383`	`callNotepad(NPPM_SAVESESSION, 0, reinterpret_cast<LPARAM>(&si));`
`374`	`384`
`375`	`385`
`@@ -383,7 +393,6 @@ void NotepadPlusWrapper::saveSession(const char *sessionFilename, boost::python:`
`383`	`393`
`384`	`394`	`void NotepadPlusWrapper::saveCurrentSession(const char *filename)`
`385`	`395`	`{`
`386`		`- GILRelease release;`
`387`	`396`	`callNotepad(NPPM_SAVECURRENTSESSION, 0, reinterpret_cast<LPARAM>(WcharMbcsConverter::char2tchar(filename).get()));`
`388`	`397`
`389`	`398`	`}`
`@@ -412,7 +421,6 @@ idx_t NotepadPlusWrapper::getCurrentDocIndex(int view)`
`412`	`421`
`413`	`422`	`void NotepadPlusWrapper::setStatusBar(StatusBarSection section, const char *text)`
`414`	`423`	`{`
`415`		`- GILRelease release;`
`416`	`424`	`#ifdef UNICODE`
`417`	`425`	`std::shared_ptr<TCHAR> s = WcharMbcsConverter::char2tchar(text);`
`418`	`426`	`callNotepad(NPPM_SETSTATUSBAR, static_cast<WPARAM>(section), reinterpret_cast<LPARAM>(s.get()));`
`@@ -430,7 +438,6 @@ long NotepadPlusWrapper::getPluginMenuHandle()`
`430`	`438`
`431`	`439`	`void NotepadPlusWrapper::activateIndex(int view, int index)`
`432`	`440`	`{`
`433`		`- GILRelease release;`
`434`	`441`	`callNotepad(NPPM_ACTIVATEDOC, static_cast<WPARAM>(view), static_cast<LPARAM>(index));`
`435`	`442`
`436`	`443`	`}`
`@@ -441,10 +448,8 @@ void NotepadPlusWrapper::loadSession(boost::python::str filename)`
`441`	`448`	`"Use an asynchronous callback, or avoid using loadSession() in the callback handler");`
`442`	`449`	`#ifdef UNICODE`
`443`	`450`	`std::shared_ptr<TCHAR> s = WcharMbcsConverter::char2tchar((const char)boost::python::extract<const char>(filename));`
`444`		`- GILRelease release;`
`445`	`451`	`callNotepad(NPPM_LOADSESSION, 0, reinterpret_cast<LPARAM>(s.get()));`
`446`	`452`	`#else`
`447`		`- GILRelease release;`
`448`	`453`	`callNotepad(NPPM_LOADSESSION, 0, reinterpret_cast<LPARAM>((const char)boost::python::extract<const char>(filename)));`
`449`	`454`	`#endif`
`450`	`455`
`@@ -456,10 +461,8 @@ void NotepadPlusWrapper::activateFileString(boost::python::str filename)`
`456`	`461`	`"Use an asynchronous callback, or avoid using activateFile() in the callback handler");`
`457`	`462`	`#ifdef UNICODE`
`458`	`463`	`std::shared_ptr<TCHAR> s = WcharMbcsConverter::char2tchar((const char)boost::python::extract<const char>(filename));`
`459`		`- GILRelease release;`
`460`	`464`	`callNotepad(NPPM_SWITCHTOFILE, 0, reinterpret_cast<LPARAM>(s.get()));`
`461`	`465`	`#else`
`462`		`- GILRelease release;`
`463`	`466`	`callNotepad(NPPM_SWITCHTOFILE, 0, reinterpret_cast<LPARAM>((const char)boost::python::extract<const char>(filename)));`
`464`	`467`	`#endif`
`465`	`468`
`@@ -468,7 +471,6 @@ void NotepadPlusWrapper::activateFileString(boost::python::str filename)`
`468`	`471`
`469`	`472`	`void NotepadPlusWrapper::reloadFile(boost::python::str filename, bool alert)`
`470`	`473`	`{`
`471`		`- GILRelease release;`
`472`	`474`	`#ifdef UNICODE`
`473`	`475`	`callNotepad(NPPM_RELOADFILE, alert ? 1 : 0, reinterpret_cast<LPARAM>(static_cast<const TCHAR >(WcharMbcsConverter::char2tchar(boost::python::extract<const char >(filename)).get())));`
`474`	`476`	`#else`
`@@ -480,7 +482,6 @@ void NotepadPlusWrapper::reloadFile(boost::python::str filename, bool alert)`
`480`	`482`
`481`	`483`	`void NotepadPlusWrapper::saveAllFiles()`
`482`	`484`	`{`
`483`		`- GILRelease release;`
`484`	`485`	`callNotepad(NPPM_SAVEALLFILES);`
`485`	`486`
`486`	`487`	`}`
`@@ -494,7 +495,6 @@ boost::python::str NotepadPlusWrapper::getPluginConfigDir()`
`494`	`495`
`495`	`496`	`void NotepadPlusWrapper::menuCommand(int commandID)`
`496`	`497`	`{`
`497`		`- GILRelease release;`
`498`	`498`	`callNotepad(NPPM_MENUCOMMAND, 0, commandID);`
`499`	`499`
`500`	`500`	`}`
`@@ -542,101 +542,86 @@ boost::python::tuple NotepadPlusWrapper::getVersion()`
`542`	`542`
`543`	`543`	`void NotepadPlusWrapper::hideTabBar()`
`544`	`544`	`{`
`545`		`- GILRelease release;`
`546`	`545`	`callNotepad(NPPM_HIDETABBAR, 0, TRUE);`
`547`	`546`
`548`	`547`	`}`
`549`	`548`
`550`	`549`	`void NotepadPlusWrapper::showTabBar()`
`551`	`550`	`{`
`552`		`- GILRelease release;`
`553`	`551`	`callNotepad(NPPM_HIDETABBAR, 0, FALSE);`
`554`	`552`
`555`	`553`	`}`
`556`	`554`
`557`	`555`	`int NotepadPlusWrapper::getCurrentBufferID()`
`558`	`556`	`{`
`559`		`- GILRelease release;`
`560`	`557`	`return callNotepad(NPPM_GETCURRENTBUFFERID);`
`561`	`558`	`}`
`562`	`559`
`563`	`560`	`void NotepadPlusWrapper::reloadBuffer(int bufferID, bool withAlert)`
`564`	`561`	`{`
`565`		`- GILRelease release;`
`566`	`562`	`callNotepad(NPPM_RELOADBUFFERID, static_cast<WPARAM>(bufferID), static_cast<LPARAM>(withAlert));`
`567`	`563`
`568`	`564`	`}`
`569`	`565`
`570`	`566`	`LangType NotepadPlusWrapper::getLangType()`
`571`	`567`	`{`
`572`		`- GILRelease release;`
`573`	`568`	`return getBufferLangType(callNotepad(NPPM_GETCURRENTBUFFERID));`
`574`	`569`	`}`
`575`	`570`
`576`	`571`	`LangType NotepadPlusWrapper::getBufferLangType(int bufferID)`
`577`	`572`	`{`
`578`		`- GILRelease release;`
`579`	`573`	`return static_cast<LangType>(callNotepad(NPPM_GETBUFFERLANGTYPE, bufferID));`
`580`	`574`	`}`
`581`	`575`
`582`	`576`
`583`	`577`
`584`	`578`	`void NotepadPlusWrapper::setBufferLangType(LangType language, int bufferID)`
`585`	`579`	`{`
`586`		`- GILRelease release;`
`587`	`580`	`callNotepad(NPPM_SETBUFFERLANGTYPE, static_cast<WPARAM>(bufferID), static_cast<LPARAM>(language));`
`588`	`581`
`589`	`582`	`}`
`590`	`583`
`591`	`584`	`BufferEncoding NotepadPlusWrapper::getEncoding()`
`592`	`585`	`{`
`593`		`- GILRelease release;`
`594`	`586`	`return getBufferEncoding(callNotepad(NPPM_GETCURRENTBUFFERID));`
`595`	`587`	`}`
`596`	`588`
`597`	`589`	`BufferEncoding NotepadPlusWrapper::getBufferEncoding(int bufferID)`
`598`	`590`	`{`
`599`		`- GILRelease release;`
`600`	`591`	`return static_cast<BufferEncoding>(callNotepad(NPPM_GETBUFFERENCODING, static_cast<WPARAM>(bufferID)));`
`601`	`592`	`}`
`602`	`593`
`603`	`594`	`void NotepadPlusWrapper::setEncoding(BufferEncoding encoding)`
`604`	`595`	`{`
`605`		`- GILRelease release;`
`606`	`596`	`callNotepad(NPPM_SETBUFFERENCODING, static_cast<WPARAM>(callNotepad(NPPM_GETCURRENTBUFFERID)), static_cast<LPARAM>(encoding));`
`607`	`597`
`608`	`598`	`}`
`609`	`599`
`610`	`600`	`void NotepadPlusWrapper::setBufferEncoding(BufferEncoding encoding, int bufferID)`
`611`	`601`	`{`
`612`		`- GILRelease release;`
`613`	`602`	`callNotepad(NPPM_SETBUFFERENCODING, static_cast<WPARAM>(bufferID), static_cast<LPARAM>(encoding));`
`614`	`603`
`615`	`604`	`}`
`616`	`605`
`617`	`606`	`FormatType NotepadPlusWrapper::getFormatType()`
`618`	`607`	`{`
`619`		`- GILRelease release;`
`620`	`608`	`return getBufferFormatType(callNotepad(NPPM_GETCURRENTBUFFERID));`
`621`	`609`	`}`
`622`	`610`
`623`	`611`
`624`	`612`	`FormatType NotepadPlusWrapper::getBufferFormatType(int bufferID)`
`625`	`613`	`{`
`626`		`- GILRelease release;`
`627`	`614`	`return static_cast<FormatType>(callNotepad(NPPM_GETBUFFERFORMAT, static_cast<WPARAM>(bufferID)));`
`628`	`615`	`}`
`629`	`616`
`630`	`617`	`void NotepadPlusWrapper::setFormatType(FormatType format)`
`631`	`618`	`{`
`632`		`- GILRelease release;`
`633`	`619`	`setBufferFormatType(format, callNotepad(NPPM_GETCURRENTBUFFERID));`
`634`	`620`
`635`	`621`	`}`
`636`	`622`
`637`	`623`	`void NotepadPlusWrapper::setBufferFormatType(FormatType format, int bufferID)`
`638`	`624`	`{`
`639`		`- GILRelease release;`
`640`	`625`	`callNotepad(NPPM_SETBUFFERFORMAT, static_cast<WPARAM>(bufferID), static_cast<LPARAM>(format));`
`641`	`626`
`642`	`627`	`}`
`@@ -645,7 +630,6 @@ void NotepadPlusWrapper::closeDocument()`
`645`	`630`	`{`
`646`	`631`	`notAllowedInScintillaCallback("close() cannot be called in a synchronous editor callback. "`
`647`	`632`	`"Use an asynchronous callback, or avoid using close() in the callback handler");`
`648`		`- GILRelease release;`
`649`	`633`	`callNotepad(NPPM_MENUCOMMAND, 0, IDM_FILE_CLOSE);`
`650`	`634`
`651`	`635`	`}`
`@@ -654,7 +638,6 @@ void NotepadPlusWrapper::closeAllDocuments()`
`654`	`638`	`{`
`655`	`639`	`notAllowedInScintillaCallback("closeAll() cannot be called in a synchronous editor callback. "`
`656`	`640`	`"Use an asynchronous callback, or avoid using closeAll() in the callback handler");`
`657`		`- GILRelease release;`
`658`	`641`	`callNotepad(NPPM_MENUCOMMAND, 0, IDM_FILE_CLOSEALL);`
`659`	`642`
`660`	`643`	`}`
`@@ -663,14 +646,12 @@ void NotepadPlusWrapper::closeAllButCurrentDocument()`
`663`	`646`	`{`
`664`	`647`	`notAllowedInScintillaCallback("closeAllButCurrent() cannot be called in a synchronous editor callback. "`
`665`	`648`	`"Use an asynchronous callback, or avoid using closeAllButCurrent() in the callback handler");`
`666`		`- GILRelease release;`
`667`	`649`	`callNotepad(NPPM_MENUCOMMAND, 0, IDM_FILE_CLOSEALL_BUT_CURRENT);`
`668`	`650`
`669`	`651`	`}`
`670`	`652`
`671`	`653`	`void NotepadPlusWrapper::reloadCurrentDocument()`
`672`	`654`	`{`
`673`		`- GILRelease release;`
`674`	`655`	`callNotepad(NPPM_MENUCOMMAND, 0, IDM_FILE_RELOAD);`
`675`	`656`
`676`	`657`	`}`
`@@ -799,7 +780,6 @@ void NotepadPlusWrapper::activateBufferID(int bufferID)`
`799`	`780`	`{`
`800`	`781`	`notAllowedInScintillaCallback("activateBufferID() cannot be called in a synchronous editor callback. "`
`801`	`782`	`"Use an asynchronous callback, or avoid using activateBufferID() in the callback handler");`
`802`		`- GILRelease release;`
`803`	`783`	`idx_t index = (idx_t)callNotepad(NPPM_GETPOSFROMBUFFERID, static_cast<WPARAM>(bufferID));`
`804`	`784`	`UINT view = (index & 0xC0000000) >> 30;`
`805`	`785`	`index = index & 0x3FFFFFFF;`
`@@ -809,22 +789,18 @@ void NotepadPlusWrapper::activateBufferID(int bufferID)`
`809`	`789`	`}`
`810`	`790`	`boost::python::str NotepadPlusWrapper::getBufferFilename(int bufferID)`
`811`	`791`	`{`
`812`		`- GILRelease release;`
`813`	`792`	`TCHAR buffer[MAX_PATH];`
`814`	`793`	`callNotepad(NPPM_GETFULLPATHFROMBUFFERID, static_cast<WPARAM>(bufferID), reinterpret_cast<LPARAM>(buffer));`
`815`	`794`	`std::shared_ptr<char> filename = WcharMbcsConverter::tchar2char(buffer);`
`816`		`- release.reacquire();`
`817`	`795`	`return boost::python::str(const_cast<const char *>(filename.get()));`
`818`	`796`	`}`
`819`	`797`
`820`	`798`	`boost::python::str NotepadPlusWrapper::getCurrentFilename()`
`821`	`799`	`{`
`822`		`- GILRelease release;`
`823`	`800`	`idx_t bufferID = callNotepad(NPPM_GETCURRENTBUFFERID);`
`824`	`801`	`TCHAR buffer[MAX_PATH];`
`825`	`802`	`callNotepad(NPPM_GETFULLPATHFROMBUFFERID, bufferID, reinterpret_cast<LPARAM>(buffer));`
`826`	`803`	`std::shared_ptr<char> filename = WcharMbcsConverter::tchar2char(buffer);`
`827`		`- release.reacquire();`
`828`	`804`	`return boost::python::str(const_cast<const char *>(filename.get()));`
`829`	`805`	`}`
`830`	`806`
`@@ -876,9 +852,7 @@ bool NotepadPlusWrapper::runMenuCommand(boost::python::str menuName, boost::pyth`
`876`	`852`	`boost::python::str NotepadPlusWrapper::getNppDir()`
`877`	`853`	`{`
`878`	`854`	`TCHAR buffer[MAX_PATH];`
`879`		`- GILRelease release;`
`880`		`- ::SendMessage(m_nppHandle, NPPM_GETNPPDIRECTORY, MAX_PATH, reinterpret_cast<LPARAM>(buffer));`
`881`		`- release.reacquire();`
	`855`	`+ callNotepad(NPPM_GETNPPDIRECTORY, MAX_PATH, reinterpret_cast<LPARAM>(buffer));`
`882`	`856`	`return boost::python::str(const_cast<const char *>(WcharMbcsConverter::tchar2char(buffer).get()));`
`883`	`857`	`}`
`884`	`858`
`@@ -889,16 +863,13 @@ boost::python::str NotepadPlusWrapper::getCommandLine()`
`889`	`863`
`890`	`864`	`bool NotepadPlusWrapper::allocateSupported()`
`891`	`865`	`{`
`892`		`- GILRelease release;`
`893`		`- return 1 == ::SendMessage(m_nppHandle, NPPM_ALLOCATESUPPORTED, 0, 0);`
	`866`	`+ return 1 == callNotepad(NPPM_ALLOCATESUPPORTED);`
`894`	`867`	`}`
`895`	`868`
`896`	`869`	`boost::python::object NotepadPlusWrapper::allocateCmdID(int quantity)`
`897`	`870`	`{`
`898`	`871`	`int startID;`
`899`		`- GILRelease release;`
`900`		`- bool result = 1 == ::SendMessage(m_nppHandle, NPPM_ALLOCATECMDID, static_cast<WPARAM>(quantity), reinterpret_cast<LPARAM>(&startID));`
`901`		`- release.reacquire();`
	`872`	`+ bool result = 1 == callNotepad(NPPM_ALLOCATECMDID, static_cast<WPARAM>(quantity), reinterpret_cast<LPARAM>(&startID));`
`902`	`873`	`if (result)`
`903`	`874`	`{`
`904`	`875`	`return boost::python::object(startID);`
`@@ -912,9 +883,7 @@ boost::python::object NotepadPlusWrapper::allocateCmdID(int quantity)`
`912`	`883`	`boost::python::object NotepadPlusWrapper::allocateMarker(int quantity)`
`913`	`884`	`{`
`914`	`885`	`int startID;`
`915`		`- GILRelease release;`
`916`		`- bool result = 1 == ::SendMessage(m_nppHandle, NPPM_ALLOCATEMARKER, static_cast<WPARAM>(quantity), reinterpret_cast<LPARAM>(&startID));`
`917`		`- release.reacquire();`
	`886`	`+ bool result = 1 == callNotepad(NPPM_ALLOCATEMARKER, static_cast<WPARAM>(quantity), reinterpret_cast<LPARAM>(&startID));`
`918`	`887`	`if (result)`
`919`	`888`	`{`
`920`	`889`	`return boost::python::object(startID);`
Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,8 @@`
`9`	`9`	`#include "menuCmdID.h"`
`10`	`10`	`#endif`
`11`	`11`
	`12`	`+#include "GILManager.h"`
	`13`	`+`
`12`	`14`	`struct SCNotification;`
`13`	`15`	`namespace NppPythonScript`
`14`	`16`	`{`
`@@ -575,6 +577,7 @@ class NotepadPlusWrapper`
`575`	`577`	`protected:`
`576`	`578`	`LRESULT callNotepad(UINT message, WPARAM wParam = 0, LPARAM lParam = 0)`
`577`	`579`	`{`
	`580`	`+ GILRelease release;`
`578`	`581`	`return SendMessage(m_nppHandle, message, wParam, lParam);`
`579`	`582`	`}`
`580`	`583`