Re: Why does this cause "data abort" ?

Ulrich,

Thank you for some interesting pointers. My background is indeed mostly
MFC, but am doing embedded CE development now.
The code I wrote is indeed not original code, but after long searching, I
found "data abort" (it's an exception raised by ARM cpu's, when out of
bounds memory is accessed) is caused by the call to CreateWindow. The
window gets created and windows handle returned, but there's nothing there
that can go wrong, other than the initial call to WM_CREATE I think. I am
not handling WM_CREATE, or just returning 0, so there's no code there that
can cause the problem.

The only other thing that could possibly be related, is fact that it is
inside a DLL like so:

// sample class
class CMyWnd
{
public:
   CMyWnd() :
           m_hWnd(NULL), m_lpszClassName(NULL),
           m_hInstance(NULL), m_hIcon(NULL) {};
   virtual ~CMyWnd(){
           if (m_hIcon) DestroyIcon(m_hIcon);
   };

   HWND m_hWnd;
   HINSTANCE m_hInstance;
   LPTSTR m_lpszClassName;
   HICON m_hIcon;

   BOOL RegisterWndClass(LPCTSTR lpszClassName, HINSTANCE hInstance,
WNDPROC wndProc) {
           m_lpszClassName = lpszClassName;
           m_hInstance = hInstance;
           UnregisterWndClass();
           WNDCLASS wc;
           wc.style = CS_HREDRAW | CS_VREDRAW;
           wc.lpfnWndProc = (WNDPROC) wndProc;
           wc.cbClsExtra = 0;
           wc.cbWndExtra = 0;
           wc.hInstance = hInstance;
           wc.hIcon = 0;
           wc.hCursor = 0;
           wc.hbrBackground = (HBRUSH) GetStockObject(HOLLOW_BRUSH);
           wc.lpszMenuName = 0;
           wc.lpszClassName = lpszClassName;
           return (0 != RegisterClass(&wc));
   }
   void UnregisterWndClass() {
           UnregisterClass(m_lpszClassName, m_hInstance);
   }

   BOOL SetIcon(UINT nRescID) {
           m_hIcon = (HICON) LoadImage(m_hInstance,
                               MAKEINTRESOURCE(nRescID), IMAGE_ICON, 16,
16, LR_DEFAULTCOLOR);
           return (NULL != m_hIcon);
   }

   BOOL Create(HWND hParentWnd, LPCTSTR lpszWindowName, DWORD
dwStyle=WS_VISIBLE|WS_CHILD) {
           m_hWnd = CreateWindow(m_lpszClassName, m_lpszWindowName,
dwStyle,
                                       0, 0, 0, 0, hParentWnd, NULL,
m_hInstance, NULL);
           return (NULL != m_hWnd);
   }

   virtual OnPaint(HDC hDC) {};
   virtual OnCreate(LPCREATESTRUCT lpcs) { return 0; };
   virtual OnMessage(MSG uMsg, WPARAM wParam, LPARAM lParam) {
           switch (uMsg)
           {
           case WM_CREATE:
                   {
                           LPCREATESTRUCT lpcs = (LPCREATESTRUCT) lParam;
                           return OnCreate(lpcs);
                   }
           case WM_PAINT:
                   {
                           PAINTSTRUCT ps;
                           HDC hDC = BeginPaint(m_hWnd, &ps);
                           OnPaint(hDC);
                           EndPaint(m_hWnd, &ps);
                           return 0;
                   }
           case WM_DESTROY:
                   PostQuitMessage(0);
                   return 0;
           }
           return DefWindowProc(m_hWnd, uMsg, wParam, lParam);
   }
}

// global vars. Do they need to be declared static???
static const g_szClassName[] = _T("MyClass");
static HINSTANCE g_hInstance = NULL;
static CMyWnd* pWnd = NULL;

LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM
lParam)
{
   return pWnd->OnMessage(uMsg, wParam, lParam);
}

BOOL APIENTRY DllMain(HANDLE hModule, DWORD dwReason, LPVOID lpReserved)
{
   switch (dwReason)
   {
   case DLL_PROCESS_ATTACH :
           g_hInstance = (HINSTANCE) hModule;
           pWnd = new CMyWnd();
           pWnd->RegisterWndClass(g_szClassName, g_hInstance, (WNDPROC)
WndProc);
           break;
   case DLL_PROCESS_DETACH :
           if (pWnd) {
                   pWnd->UnregisterWndClass();
                   delete pWnd;
           }
           break;
   }
   return TRUE;
}

// .def file has EXPORTS Initialize @ 240 NONAME
HWND Initialize(HWND hWndParent)
{
   HICON hIcon = (HICON) LoadImage(
   pWnd->Create(hWndParent, _T("My Window Title"));
   return pWnd->m_hWnd;
}

This is a plugin, where Initialize gets called by an application, via
ordinal, passing it its own hwnd.
The above is causing a "data abort" exception in coredll.

It doesn't cause exception when I use SetWindowLong(m_hWnd, GWL_USERDATA,
(LONG) this); in CMyWnd::Create() after CreateWindow, and then CMyWnd*
pWnd = reinterpret_cast<CMyWnd*>(GetWindowLong(m_hWnd, GWL_USERDATA)); in
WndProc and then pWnd->OnMessage(...).

But I don't understand why.. plus, the latter causes all kinds of other
exceptions elsewhere in my code, but that's of later concern.
I haven't compiled above code, just typed it here, but it's really all
that's going on in my code.

I'm not sure how the host application is using and calling my dll
exactely.. maybe DLL loaded in a different thread than Initialize being
called or some other way that might cause issues, and why first way causes
problems but is resolved with SetWindowLong method.

Any clues?

"Ulrich Eckhardt" <eckhardt@satorlaser.com> wrote in message
news:35b3v4-3q6.ln1@satorlaser.homedns.org...