C / C++ / MFC

M77ATTAT wrote:

I want to...

int* printArray(int *input,int max)
{
	int *res;res=(int*)malloc(max*sizeof(int));for(int i = 0; i<max; i++) {res[i]=0;}
 	int current_kind = -1;
 	int count = 0;int cp=0;
	for(int i = 0; i<max; ++i) {
		 
 		if (current_kind!=input[i]) 
		{  
			if (count!=0)  res[ cp]=count; 
			current_kind = input[i] ;
			count = 1;cp++; 
		} else { count++; }
		 
		}
	res[cp]=count; 
return res;	
}

CSerialDevice::TransmitData( int bytesToSend )
{
	OVERLAPPED ovlWrite = {0};
	WriteFile( m_hCommPort, mTxBuf, bytesToSend, NULL, &ovlWrite );
}

pasztorpisti wrote:

the vtable is set the the vtable of the class whose ctor/dtor is being executed even if this object is the instance of a derived class

Base::Base()
{
    auto generated: vtable = Base::vtable
    <your ctor code here>
}

Derived1::Derived1()
{
    auto generated: call Base::Base
    auto generated: vtable = Derived1::vtable
    <your ctor code here>
}

Derived2::Derived2()
{
    auto generated: call Derived1::Derived1
    auto generated: vtable = Derived2::vtable
    <your ctor code here>
}

Base::~Base()
{
    auto generated: vtable = Base::vtable
    <your dtor code here>
}

Derived1::~Derived1()
{
    auto generated: vtable = Derived1::vtable
    <your ctor code here>
    auto generated: call Base::~Base
}

Derived2::~Derived2()
{
    auto generated: vtable = Derived2::vtable
    <your ctor code here>
    auto generated: call Derived1::~Derived1
}

class Base
{
public:
    Base()
    {
        VirtualCall();
    }
    ~Base()
    {
        VirtualCall();
    }

    virtual void VirtualCall()
    {
        printf("Base::VirtualCall()\n");
    }
};

class Derived : public Base
{
public:
    virtual void VirtualCall()
    {
        printf("Derived::VirtualCall()\n");
    }
};

void TestFunc()
{
    Derived* d = new Derived;
    delete d;
}

class Base
{
public:
    Base()
    {
        IndirectVirtualCallFromCtorDtor();
    }
    ~Base()
    {
        IndirectVirtualCallFromCtorDtor();
    }


    void IndirectVirtualCallFromCtorDtor()
    {
        VirtualCall();
    }

    virtual void VirtualCall()
    {
        printf("Base::VirtualCall()\n");
    }
};

class Derived : public Base
{
public:
    virtual void VirtualCall()
    {
        printf("Derived::VirtualCall()\n");
    }
};

void TestFunc()
{
    Derived* d = new Derived;
    delete d;
}

class Base;
static void HelperFunc(Base* b);

class Base
{
public:
    Base()
    {
        // comment out this call if you want to try the destructor
        HelperFunc(this);
    }
    ~Base()
    {
        HelperFunc(this);
    }

    virtual void VirtualCall() = 0;
};

static void HelperFunc(Base* b)
{
    // This function doesn't know that b is half constructed or half destructed
    b->VirtualCall();

}


class Derived : public Base
{
public:
    virtual void VirtualCall()
    {
        printf("Derived::VirtualCall()\n");
    }
};

void TestFunc()
{
    Derived* d = new Derived;
    delete d;
}

ForNow wrote:

I am having trouble getting a MFC C++ app off the ground As a Child Process

return_code = CreateProcess((LPCSTR) &herc_command[0],      // command
                                    (LPCSTR) &herc_parm[0],  // paramter
                                    (LPCSTR) &sa,
                                    NULL,
                                    TRUE,
                                    (DWORD) DEBUG_ONLY_THIS_PROCESS,
                                    NULL,
                                    NULL,
                                    &si,
                                    &pi);

     if (return_code == 0 )
         errcd = GetLastError();





    bContinueDebugging = 1;

    dwContinueStatus = DBG_CONTINUE;



    while(bContinueDebugging)
    {
        if (!WaitForDebugEvent(&debug_event, INFINITE))
            return;

        switch(debug_event.dwDebugEventCode)
        {
        case CREATE_PROCESS_DEBUG_EVENT:
            {
                file_name = GetFileNameFromHandle(debug_event.u.CreateProcessInfo.hFile);
            }
            break;

        case CREATE_THREAD_DEBUG_EVENT:
        //  strEventMessage.Format(L"Thread 0x%x (Id: %d) created at: 0x%x",
            //  debug_event.u.CreateThread.hThread,
            //  debug_event.dwThreadId,
            //  debug_event.u.CreateThread.lpStartAddress); // Thread 0xc (Id: 7920) created at: 0x77b15e58

            break;
        case EXIT_THREAD_DEBUG_EVENT:

        //  strEventMessage.Format(L"The thread %d exited with code: %d",
        //      debug_event.dwThreadId,
    //          debug_event.u.ExitThread.dwExitCode);   // The thread 2760 exited with code: 0

            break;

        case EXIT_PROCESS_DEBUG_EVENT:
        //  strEventMessage.Format(L"0x%x", debug_event.u.ExitProcess.dwExitCode);
            bContinueDebugging=0;
            break;

        case LOAD_DLL_DEBUG_EVENT:
            {
            //  strEventMessage = GetFileNameFromHandle(debug_event.u.LoadDll.hFile);
                file_name = GetFileNameFromHandle(debug_event.u.LoadDll.hFile);
        //      DllNameMap.insert(
            //      std::make_pair( debug_event.u.LoadDll.lpBaseOfDll, strEventMessage) );

            //  strEventMessage.AppendFormat(L"%x", debug_event.u.LoadDll.lpBaseOfDll);
            }
            break;

        case UNLOAD_DLL_DEBUG_EVENT:
        //  strEventMessage.Format(L"%s",  DllNameMap[debug_event.u.UnloadDll.lpBaseOfDll] );
            break;

        case OUTPUT_DEBUG_STRING_EVENT:
            {
            //  OUTPUT_DEBUG_STRING_INFO & DebugString = debug_event.u.DebugString;
                // LPSTR p = ;

                (void *) msg = malloc (debug_event.u.DebugString.nDebugStringLength);
            //  ZeroMemory(msg, DebugString.nDebugStringLength);

            ReadProcessMemory(pi.hProcess, debug_event.u.DebugString.lpDebugStringData, msg, debug_event.u.DebugString.nDebugStringLength, NULL);

            //  if ( DebugString.fUnicode )
        //          strEventMessage = msg;
        //      else
            //      strEventMessage = (LPSTR)msg;

            //  delete []msg;
            }

            break;

        case EXCEPTION_DEBUG_EVENT:
            {
            //  EXCEPTION_DEBUG_INFO & exception = debug_event.u.Exception;
                EXCEPTION_DEBUG_INFO exception = debug_event.u.Exception;
                switch( exception.ExceptionRecord.ExceptionCode)
                {
                case STATUS_DLL_NOT_FOUND:
            //      strEventMessage= "Break point";
                    i = 1;
                    break;
                 case STATUS_ACCESS_VIOLATION:
                     i = 2;
                 case  STATUS_BREAKPOINT:
                     i = 3;
                 case STATUS_STACK_BUFFER_OVERRUN:
                     i = 4;
                 case STATUS_PRIVILEGED_INSTRUCTION:
                     i = 5;
                 case STATUS_INVALID_HANDLE:
                     i = 6;
                 case EXCEPTION_FLT_INEXACT_RESULT:
                     i = 7;
                 case EXCEPTION_FLT_INVALID_OPERATION:
                     i = 8;
                 case EXCEPTION_FLT_OVERFLOW:
                     i = 9;
                 case EXCEPTION_FLT_STACK_CHECK:
                     i = 10;
                 case EXCEPTION_FLT_UNDERFLOW:
                     i = 11;
                 case EXCEPTION_ILLEGAL_INSTRUCTION:
                     i = 12;
                 case EXCEPTION_IN_PAGE_ERROR:
                     i = 13;
                 case EXCEPTION_INT_DIVIDE_BY_ZERO:
                     i = 15;
                 case EXCEPTION_INT_OVERFLOW:
                     i = 16;
                 case EXCEPTION_INVALID_DISPOSITION:
                     i = 17;
                 case EXCEPTION_NONCONTINUABLE_EXCEPTION:
                     i = 18;
                 case EXCEPTION_SINGLE_STEP:
                     i = 20;
                 case EXCEPTION_STACK_OVERFLOW:
                     i = 21;
                default:
                    if(exception.dwFirstChance == 1)
                    {
            //          strEventMessage.Format(L"First chance exception at %x, exception-code: 0x%08x",
                        //  exception.ExceptionRecord.ExceptionAddress,
                    //      exception.ExceptionRecord.ExceptionCode);
                    }
                    // else
                    // { Let the OS handle }


                    // There are cases where OS ignores the dwContinueStatus,
                    // and executes the process in its own way.
                    // For first chance exceptions, this parameter is not-important
                    // but still we are saying that we have NOT handled this event.

                    // Changing this to DBG_CONTINUE (for 1st chance exception also),
                    // may cause same debugging event to occur continously.
                    // In short, this debugger does not handle debug exception events
                    // efficiently, and let's keep it simple for a while!
                    dwContinueStatus = DBG_EXCEPTION_NOT_HANDLED;
                }

                break;
            }
        }

    //  SendMessage(DEBUG_EVENT_MESSAGE, (WPARAM) strEventMessage, debug_event.dwDebugEventCode);

        ContinueDebugEvent(debug_event.dwProcessId,
            debug_event.dwThreadId,
            dwContinueStatus);

        // Reset
        dwContinueStatus = DBG_CONTINUE;
    }
}

#include "stdafx.h"
// #include <Winsock2.h>
#include "afxsock.h"
// #include "MainFrm.h"
#include "Tlhelp32.h"
#include "afxmt.h"
#include "HERC_CMD.h"
 #include "mainfrm.h"
#include "resource.h"
#include "Windows.h"
#include "MyBaseEvent.h"
#include "Show_storage.h"
#include "afx.h"
// #include "SockCLient.h"
// #include "SockCLeintThread.h"
class SockCLeintThread;  
// extern CSingleLock HercLock;
// UINT WM_SEND_SOCK_MESS = WM_USER + 1;
// UINT WM_RECEIVE_SOCK_MESS = WM_USER + 2;
#define  WM_HERCGUI_MESS (WM_USER + 3)

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

INT i;
HANDLE snap_shot;
PROCESSENTRY32 process32;
BOOL return_cde;
DWORD pid;
DWORD herc_process;
#pragma optimize("",off)
LPCWSTR pipe_name = (LPCWSTR) TEXT("\\\\.\\pipe\\HercPipe");
 DWORD errcd;
 HANDLE myevent_read, myevent_write;
// OVERLAPPED herc_overread, herc_overwrite, herc_over;
  HANDLE herc_object;
  UINT  hercgui_commands(LPVOID lparam);
 LPVOID lparam;
HANDLE mymutex;
HANDLE thread_handle, herc_thread;
#ifdef _DEBUG
CMemoryState  msOld,  msnew,  diffMemState;
#endif
// CCriticalSection socklock;
// CEvent Sockevent(FALSE,FALSE,NULL,NULL);
char buffer[105];
      // message map for main thread

BEGIN_MESSAGE_MAP(CHERC_CMDApp, CWinApp)
 //       ON_COMMAND(ID_APP_ABOUT, &CHERC_CMDApp::OnAppAbout)
        // Standard file based document commands
  //      ON_COMMAND(ID_FILE_NEW, &CWinApp::OnFileNew)
  //      ON_COMMAND(ID_FILE_OPEN, &CWinApp::OnFileOpen)

   // Standard print setup command
  //      ON_COMMAND(ID_FILE_PRINT_SETUP, &CWinApp::OnFilePrintSetup)

END_MESSAGE_MAP()


// CHERC_CMDApp construction

CHERC_CMDApp theApp;

CHERC_CMDApp::CHERC_CMDApp()
{
__debugbreak();
}        


        // TODO: add construction code here,
        // Place all significant initialization in InitInstance



// The one and only CHERC_CMDApp object

                    // Start the ball rolling


// CHERC_CMDApp initialization

BOOL CHERC_CMDApp::InitInstance()
{
void SetThreadName( DWORD dwThreadID, LPCSTR szThreadName);

static char *thread[] = {"one", "two", "three", "four"}; 	
   static AFX_DATA const CRect rectDefaut;
// UINT nID;
        // RECT&  rectDefault;
        static AFX_DATA const CRect rectDefault;
        // CWnd* pParentWnd;
        // InitCommonControlsEx() is required on Windows XP if an application
        // manifest specifies use of ComCtl32.dll version 6 or later to enable
        // visual styles.  Otherwise, any window creation will fail.
        INITCOMMONCONTROLSEX InitCtrls;
        InitCtrls.dwSize = sizeof(InitCtrls);
        // Set this to include all the common control classes you want to use
        // in your application.
        InitCtrls.dwICC = ICC_WIN95_CLASSES;
        InitCommonControlsEx(&InitCtrls);
 
   // call thedefault iNITINSTANCE

        CWinApp::InitInstance();

        // Initialize OLE libraries
        if (!AfxOleInit())
        {
                AfxMessageBox(IDP_OLE_INIT_FAILED);
                return FALSE;
        }
     //   AfxEnableControlContainer();
        // Standard initialization
        // If you are not using these features and wish to reduce the size
        // of your final executable, you should remove from the following
        // the specific initialization routines you do not need
        // Change the registry key under which our settings are stored
        // TODO: You should modify this string to be something appropriate
        // such as the name of your company or organization
        SetRegistryKey(_T("HERCCMD Hercules GUI interface"));
        LoadStdProfileSettings(4);  // Load standard INI file options (including MRU)
        // Register the application's document templates.  Document templates
                  //  serve as the connection between documents, frame windows and views
    //    CMultiDocTemplate* pDocTemplate;
    //    pDocTemplate = new CMultiDocTemplate(IDR_HERC_CMDTYPE,
    //            RUNTIME_CLASS(CHERC_CMDDoc),
    //            RUNTIME_CLASS(CChildFrame), // custom MDI child frame
     //           RUNTIME_CLASS(CHERC_CMDView));
    //    if (!pDocTemplate)
    //            return FALSE;
     //   AddDocTemplate(pDocTemplate);
      WNDCLASS wcex;
	//  __debugbreak();

    FARPROC hercgui;
	
	LPTSTR  command_line  = GetCommandLine();
	  
	 strncpy ((char *) &hercgui,(const char *) command_line,8); 

  	         // 32 bit addr
        wcex.style             = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
        wcex.cbClsExtra         = 0;
        wcex.cbWndExtra         = 0;
        wcex.hIcon               = LoadIcon(IDR_MAINFRAME);
        wcex.hCursor            = LoadCursor(IDC_ARROW);
       wcex.hbrBackground      = (HBRUSH) GetStockObject(LTGRAY_BRUSH);
        wcex.lpszMenuName       = MAKEINTRESOURCE(IDR_MAINFRAME);
        wcex.lpszClassName      = _T("HERCCMD");

        wcex.hIcon            = LoadIcon(MAKEINTRESOURCE(IDR_MAINFRAME));
       AfxRegisterClass(&wcex);
//  strdlg = FindResource(NULL,MAKEINTRESOURCE(IDD_DIALOG6),MAKEINTRESOURCE(RT_DIALOG));
//  strglb = LoadResource(NULL,strdlg);
   myshow_storageptr = NULL;
// intilize TCP/IP connection to the MainFrame
//if( WSAStartup( WINSOCKVERSION, &wsaData) != 0 ) return ERROR;
// INIT Windows Sockets
           AfxSocketInit();   // socket DLL
// INIT RICH EDIT
  AfxInitRichEdit();             // RichEdit

// get hercules PID
                     
// if (my_wparam == 0) // Call From Tcpip thread
   //     myshow_storageptr->mytcpipmess = (LPSTR) my_lparam;
// else
                   
          //      }
          //      else
           //     {
             //           myshow_storageptr->mystringptr = (unsigned char *) my_lparam;
   // Connect to a Object
				



 snap_shot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);

  process32.dwSize = sizeof(PROCESSENTRY32);

  return_cde =     Process32First(snap_shot,&process32);

 pid = GetCurrentProcessId();       // Get Current process id

      while(pid != process32.th32ProcessID)
 {
       return_cde = Process32Next(snap_shot,&process32);
 }

   herc_process = process32.th32ParentProcessID;


      my_herc  =  OpenProcess(PROCESS_ALL_ACCESS,FALSE,herc_process);      // Get a Handle to Hercules kernels Object

             if (my_herc == NULL)
                   errcd= GetLastError();

SECURITY_ATTRIBUTES sa;
LPVOID lparam; 
DWORD threadid;

        
               sa.nLength =  sizeof(sa);
               sa.lpSecurityDescriptor = NULL;
               sa.bInheritHandle = TRUE;

    lparam = NULL;

            CreateRemoteThread(my_herc,
                               &sa,
                               NULL,
                               (LPTHREAD_START_ROUTINE) hercgui,
                               lparam,
                               NULL,
                               &threadid);


			



   filehdl =  CreateFile((LPCTSTR) pipe_name,
                    GENERIC_READ | GENERIC_WRITE,
                    FILE_SHARE_READ | FILE_SHARE_WRITE,
                    NULL,
                    OPEN_EXISTING,
                    FILE_FLAG_OVERLAPPED,
                    NULL);

    if (filehdl == INVALID_HANDLE_VALUE)
      errcd= GetLastError();

      herc_over.hEvent = OpenEvent(EVENT_ALL_ACCESS,FALSE,TEXT("herceventread"));

         if (myevent_read == NULL)
                  errcd= GetLastError();

   ResetEvent(herc_over.hEvent);

   herc_over1.hEvent = OpenEvent(EVENT_ALL_ACCESS,FALSE,TEXT("herceventwrite"));

         if (myevent_write == NULL)
                  errcd= GetLastError();

                 ResetEvent(herc_over1.hEvent);

        herc_over.hEvent= CreateEvent(NULL,
                                     FALSE,           // let Windows Re-set
                                       FALSE,           // Intially set off
                                       NULL);

      herc_over1.hEvent= CreateEvent(NULL,
                                       TRUE,           // let Windows Re-set
                                      FALSE,           // Intially set off
                                        NULL);



	  

         //      DuplicateHandle(GetCurrentProcess(),myevent_read,herc_object,&herc_overread.hEvent,0,FALSE,DUPLICATE_SAME_ACCESS);


           ///     DuplicateHandle(GetCurrentProcess(),myevent_write,herc_object,&herc_overwrite.hEvent,0,FALSE,DUPLICATE_SAME_ACCESS);

    /* Create Mutex to searlize access HWND structure  */

    //    mymutex = CreateMutex(NULL,
      //                       FALSE,
        //                                         NULL);



            /* Create a thread to wait for Hercules to send back completed commands */
#ifdef _DEBUG
afxMemDF |= checkAlwaysMemDF;
// msOld.DumpAllObjectsSince();

msOld.Checkpoint();
#endif
  mybaseeventptr =   new MyBaseEvent(FALSE,FALSE,NULL,NULL);

#ifdef _DEBUG
msnew.Checkpoint();

if( diffMemState.Difference(msOld, msnew))
{
   diffMemState.DumpStatistics();
   diffMemState.DumpAllObjectsSince();
}
msOld.Checkpoint();
#endif

        // create the main Window
         m_pMainWnd  = new CMainFrame;
#ifdef _DEBUG
msnew.Checkpoint();

if( diffMemState.Difference(msOld, msnew))
{
   diffMemState.DumpStatistics();
   diffMemState.DumpAllObjectsSince();
}
#endif
        /*if (!m_pMainWnd || ! static_cast<CFrameWnd *>(m_pMainWnd)->LoadFrame(IDR_MAINFRAME))

        {
                delete m_pMainWnd;
                return FALSE;
        }*/
      BOOL return_code =  static_cast<CFrameWnd *>(m_pMainWnd)->LoadFrame(IDR_MAINFRAME);
	  

	  if (return_code == NULL)
		  DWORD errcd = GetLastError();
       
  /* if (!m_pMainWnd)

        {
                delete m_pMainWnd;
                return FALSE;
        }*/
		

		pevent = new CEvent(FALSE,FALSE,NULL,NULL); 
int i;
UINT start_port;

     // Sockevent.SetEvent();

        for (i = 0, start_port = 11007; i < 4; start_port++, i++)
   {
 #ifdef _DEBUG
	   msOld.Checkpoint();
 #endif

         threadptr[i] = new SockCLeintThread(start_port);
 #ifdef _DEBUG

		   msnew.Checkpoint();

 if( diffMemState.Difference(msOld, msnew))
 {
   diffMemState.DumpStatistics();
   diffMemState.DumpAllObjectsSince();
 }
 #endif
 

         
		 
         if (threadptr[i] == NULL)
  	            m_pMainWnd->MessageBox((LPCTSTR)"SockClientThreadFail",NULL,MB_ICONERROR);

		      threadptr[i]->CreateThread(CREATE_SUSPENDED,0,NULL);  
   
             threadptr[i]->flags.is_connected = 0;
             
              threadptr[i]->ipaddr = (LPCTSTR)"192.168.1.4";					// ip address
  
 			 threadptr[i]->flags.busy = 0;
 
 			 SetThreadName(threadptr[i]->m_nThreadID,thread[i]);
 					
               
 	
       	
 		    threadptr[i]->ResumeThread();

			 WaitForSingleObject(*pevent,INFINITE);   // wait for connection
        
	   }     

	   // start hercgui command to process hercules commands

		  hercthread = AfxBeginThread(hercgui_commands,(LPVOID) mybaseeventptr,THREAD_PRIORITY_NORMAL,0,CREATE_SUSPENDED); // allocate in Gobal
               hercthread->m_pThreadParams = this; // pass the Locking object
               hercthread->ResumeThread();                                  // get it going

                         m_pMainWnd->SetWindowText((LPCTSTR) TEXT("HERCCMD"));

    

     

        // Parse command line for standard shell commands, DDE, file open
     //   CCommandLineInfo cmdInfo;
     //   ParseCommandLine(cmdInfo);

//          AfxInitRichEdit2();
        // LoadLibrary(TEXT("Riched20.dll"));

        // The main window has been initialized, so show and update it
        m_pMainWnd->ShowWindow(m_nCmdShow);
        m_pMainWnd->UpdateWindow();

        return TRUE;
}
BOOL CHERC_CMDApp::OnIdle()
{
        i = 1;
        return TRUE;
}
// CAboutDlg dialog used for App About


// BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
// END_MESSAGE_MAP()

// App command to run the dialog
// void CHERC_CMDApp::OnAppAbout()
// {
//        CAboutDlg aboutDlg;
//         aboutDlg.DoModal();
// }
#pragma optimize("",off)

UINT hercgui_commands(LPVOID lparam)
 {
 int i;
 CString storstrg;
 BOOL bresult;
 UNREFERENCED_PARAMETER(lparam);
 void SetThreadName( DWORD dwThreadID, LPCSTR szThreadName);
  CMutex mymutex(FALSE,(LPCTSTR)"HercLock",NULL);
 CSingleLock HercLock(&mymutex);
 DWORD dwbytestoread;
 CHERC_CMDApp* main_app;
 dwbytestoread = 1500;
 MyBaseEvent *my_event;


 main_app = (CHERC_CMDApp *)AfxGetApp();


  my_event = main_app->mybaseeventptr;

  SetThreadName(GetCurrentThreadId(),"HercGUI");

 // CSingleLock *HercLock = static_cast<Mythread *>(lparam)->HercLock;

    while(1)

         {


 WaitForSingleObject(my_event->m_hObject, INFINITE);
  if (!HercLock.IsLocked())
 {
         HercLock.Lock(INFINITE);


          WriteFile(main_app->filehdl,
                       (LPCVOID)my_event->buffer_ptr,
                        30,
                        NULL,
                        (LPOVERLAPPED) &main_app->herc_over);



  }


   bresult =    ReadFile(main_app->filehdl,
                   (LPVOID) my_event->buffer_ptr,
                    dwbytestoread,
                    NULL,
                     (LPOVERLAPPED) &main_app->herc_over1);

//  WaitForSingleObject(herc_over1.hEvent,INFINITE);
 WaitForSingleObject(main_app->herc_over1.hEvent,INFINITE);


     HercLock.Unlock();
// strncpy(&stor_buffer[0],&buffer[0],100);
BOOL ret;
DWORD error;

CWnd *pwnd = CWnd::FromHandle(my_event->send_win); 
ret = pwnd->PostMessage(WM_HERCGUI_MESS,(WPARAM) my_event->len,(LPARAM) my_event->buffer_ptr);
 if (ret == NULL)
	 error = GetLastError();
  
 // SendMessage(Mywindow,WM_HERCGUI_MESS,NULL, NULL);


     i = 1;
         }
   return 0;
 }
#pragma optimize("",on)
// #endif //_DEBUG


// CHERC_CMDApp message handlers

//
//
// Usage: SetThreadName (-1, "MainThread");
//

typedef struct tagTHREADNAME_INFO
{
  DWORD dwType; // must be 0x1000
  LPCSTR szName; // pointer to name (in user addr space)
  DWORD dwThreadID; // thread ID (-1=caller thread)
  DWORD dwFlags; // reserved for future use, must be zero
} THREADNAME_INFO;

void SetThreadName( DWORD dwThreadID, LPCSTR szThreadName)
{
  THREADNAME_INFO info;
  {
   CString a("Socket thread");
   a + (LPCTSTR)szThreadName;
    info.dwType = 0x1000;
    info.szName = (LPCSTR)a.GetBuffer();
    info.dwThreadID = dwThreadID;
    info.dwFlags = 0;
  }
//  __try
 // {
 //   RaiseException( 0x406D1388, 0, sizeof(info)/sizeof(DWORD), (DWORD*)&info );
 // }
  //__except (EXCEPTION_CONTINUE_EXECUTION)
 // {
  //}
}

HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\Image File Execution Options