BOOL ServiceControl(int ctrl)
{
    SC_HANDLE service;
    SC_HANDLE scm;
    BOOL res;
    SERVICE_STATUS status;

    scm = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
    if (!scm) {
        ErrorHandler("OpenSCManager", GetLastError());
    }

    service = OpenService(scm, ServiceName, SERVICE_ALL_ACCESS);
    if (!service) {
        ErrorHandler("OpenService", GetLastError());
    }

    if (ctrl == SERVICE_CONTROL_STOP) {
        printf("Service is stopping...\n");
        res = ControlService(service, SERVICE_CONTROL_STOP, &status);
    } else if (ctrl == SERVICE_CONTROL_PAUSE) {
        printf("Service is pausing...\n");
        res = ControlService(service, SERVICE_CONTROL_PAUSE, &status);
    } else if (ctrl == SERVICE_CONTROL_CONTINUE) {
        printf("Service is resuming...\n");
        res = ControlService(service, SERVICE_CONTROL_CONTINUE, &status);
    }

    if (!res) {
        ErrorHandler("ControlService", GetLastError());
    } else {
        srvc.GetStatus(service);
    }

    CloseServiceHandle(service);
    CloseServiceHandle(scm);

    return TRUE;
}

void CService::PreInit()
{
    // set up the system context
    

   // Initialize Events
   for(int i = 0 ; i < NUMEVENTS ; i++)
   {
      m_hEvents[i] = CreateEvent(NULL, FALSE, FALSE, NULL);
      if(!m_hEvents[i])
         ErrorHandler(NTEXT("CreateEvent"));
   }
}

void CFat32FileSystem::Execute(Long64 aPartitionSize,EntryList aNodeList,
							   ofstream& aOutPutStream,ConfigurableFatAttributes* aConfigurableFatAttributes)
{
	CDirRegion* dirRegionPtr = NULL;
	try
	{
		CreateBootSector(aPartitionSize,aConfigurableFatAttributes);
		ComputeTotalClusters(aPartitionSize);
		WriteBootSector(aOutPutStream);
		dirRegionPtr = new CDirRegion(aNodeList,this);
		dirRegionPtr->Execute();
		iClustersPerEntry = dirRegionPtr->GetClustersPerEntryMap();
		CreateFSinfoSector(aOutPutStream);
		RestReservedSectors(aOutPutStream);
		CreateFatTable(aOutPutStream);
		dirRegionPtr->WriteClustersIntoFile(aOutPutStream);
		delete dirRegionPtr;
		dirRegionPtr = NULL;
	}
	catch(ErrorHandler &aError)
	{
		delete dirRegionPtr;
		dirRegionPtr = NULL;
		throw ErrorHandler(aError.iMessageIndex,(char*)aError.iSubMessage.c_str(),(char*)aError.iFileName.c_str(),aError.iLineNumber);
	}
	/**
	Irrespective of successful or unsuccessful data drive image generation ROFSBUILD
	may try to generate images for successive ".oby" file input.
	During this course unhandled exceptions may cause leaving some memory on heap 
	unused. so the unhandled exceptions handling is used to free the memory allocated 
	on heap. 
	*/
	catch(...)
	{
		delete dirRegionPtr;
		dirRegionPtr = NULL;
		throw ErrorHandler(UNKNOWNERROR,__FILE__,__LINE__);
	}
}

/**
  * @brief  System Clock Configuration
  *         The system Clock is configured as follow : 
  *            System Clock source            = MSI
  *            SYSCLK(Hz)                     = 2000000
  *            HCLK(Hz)                       = 2000000
  *            AHB Prescaler                  = 1
  *            APB1 Prescaler                 = 1
  *            APB2 Prescaler                 = 1
  *            Flash Latency(WS)              = 0
  *            Main regulator output voltage  = Scale3 mode
  * @param  None
  * @retval None
  */
static void SystemClock_Config(void)
{
  RCC_ClkInitTypeDef RCC_ClkInitStruct;
  RCC_OscInitTypeDef RCC_OscInitStruct;
  
  /* Enable Power Control clock */
  __PWR_CLK_ENABLE();
  
  /* The voltage scaling allows optimizing the power consumption when the device is 
     clocked below the maximum system frequency, to update the voltage scaling value 
     regarding system frequency refer to product datasheet.  */
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE3);
  
  /* Enable MSI Oscillator */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_MSI;
  RCC_OscInitStruct.MSIState = RCC_MSI_ON;
  RCC_OscInitStruct.MSIClockRange = RCC_MSIRANGE_5;
  RCC_OscInitStruct.MSICalibrationValue = 0x00;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
  if(HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    /* Error */
    ErrorHandler();
  }
  
  /* Select MSI as system clock source and configure the HCLK, PCLK1 and PCLK2 
     clocks dividers */
  RCC_ClkInitStruct.ClockType = (RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2);
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_MSI;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;  
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;  
  if(HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
  {
    /* Error */
    ErrorHandler();
  }
}

Calculadora criarThread(Calculadora calc, int opt, int integer)
{
    PMYDATA pDataArray[MAX_THREADS];
    DWORD   dwThreadIdArray[MAX_THREADS];
    HANDLE  hThreadArray[MAX_THREADS]; 

	for( int i=0; i<MAX_THREADS; i++ )
	{
        pDataArray[i] = (PMYDATA) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
                sizeof(MYDATA));

        if( pDataArray[i] == NULL )
        {
            ExitProcess(2);
        }

		pDataArray[i]->opt = opt;
		pDataArray[i]->n = i;
		pDataArray[i]->c1 = &calc;
		pDataArray[i]->val = integer;


        hThreadArray[i] = CreateThread( 
            NULL,                   // default security attributes
            0,                      // use default stack size  
            conversaoThread,       // thread function name
            pDataArray[i],          // argument to thread function 
            0,                      // use default creation flags 
            &dwThreadIdArray[i]);   // returns the thread identifier 

        if (hThreadArray[i] == NULL) 
        {
           ErrorHandler(TEXT("CreateThread"));
           ExitProcess(3);
        }
    }

    WaitForMultipleObjects(MAX_THREADS, hThreadArray, TRUE, INFINITE);

    for(int i=0; i<MAX_THREADS; i++)
    {
        CloseHandle(hThreadArray[i]);
        if(pDataArray[i] != NULL)
        {
            HeapFree(GetProcessHeap(), 0, pDataArray[i]);
            pDataArray[i] = NULL;    // Ensure address is not reused.
        }
    }
	return calc;
}

/******************************************************************************

MODULE:  GetSpectralSubset

PURPOSE:  read a list of spectral subset values and store them for actual
    use in the read parameter file routine

RETURN VALUE:
Type = int
Value           Description
-----           -----------
n               number of things found
	
HISTORY:
Version  Date   Programmer       Code  Reason
-------  -----  ---------------  ----  -------------------------------------
         05/00  John Weiss             Original Development
         01/01  John Rishea            Standardized formatting

NOTES:

******************************************************************************/
int GetSpectralSubset
(
    ModisDescriptor *P,		/* O:  session info */
    char *str			/* I:  string to be parsed */
)

{
    int i, count = 0;
    char errmsg[SMALL_STRING];

    /* check for valid values */
    for ( i = 0; i < (int) strlen( str ); i++ )
    {
        if ( str[i] != '0' && str[i] != '1' && str[i] != ' ' )
        {
            sprintf( errmsg, "Error processing spectral subset (%s) for "
                "resampler. Only '0's and '1's are allowed.", optarg );
            ErrorHandler( FALSE, "GetSpectralSubset", ERROR_GENERAL,
                errmsg );
            return 0;
        }
        else if ( str[i] == '0' || str[i] == '1' )
            count++;
    }

    /* Copy the spectral subset string to the tmpspectralsubset string in
       the ModisDescriptor */
    P->tmpspectralsubset = strdup (str);
    if (P->tmpspectralsubset == NULL)
    {
        ErrorHandler( FALSE, "GetSpectralSubset", ERROR_GENERAL,
           "Error copying the spectral subset string to the MODIS descriptor");
        return 0;
    }

    return count;
}

errno_t
scanf_m(const string_m format, int *count, ...){
  va_list ap;
  errno_t rv;

  if(!format){
    ErrorHandler("scanf_m: 1st Argument NULL Pointer", format, EINVAL);
    ERROR(EINVAL);
  }

  va_start(ap, count);
  rv = vfscanf_m(stdin, format, count, ap);
  va_end(ap);
  return rv;
}

errno_t
printf_m(const string_m fmt, int *count, ...){
  errno_t rv;

  if (!fmt){
    ErrorHandler("printf_m: 1st Argument NULL pointer", fmt, EINVAL);
    ERROR(EINVAL);
  }
  VA_OPEN(ap, count);
  VA_FIXEDARG(ap, const string_m, fmt);
  VA_FIXEDARG(ap, int *, count);
  rv = vprintf_m(fmt, count, ap);
  VA_CLOSE(ap);
  return rv;
}

BOOL GetConfiguration()
{
    SC_HANDLE service;
    SC_HANDLE scm;
    BOOL res;
    LPQUERY_SERVICE_CONFIG buffer;
    DWORD sizeNeeded;

    scm = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
    if (!scm) {
        ErrorHandler("OpenSCManager", GetLastError());
    }

    service = OpenService(scm, ServiceName, SERVICE_QUERY_CONFIG);
    if (!service) {
        ErrorHandler("OpenService", GetLastError());
    }

    buffer = (LPQUERY_SERVICE_CONFIG)LocalAlloc(LPTR, 4096);
    res = QueryServiceConfig(service, buffer, 4096, &sizeNeeded);
    if (!res) {
        ErrorHandler("QueryServiceConfig", GetLastError());
    }

    printf("Service name:\t%s\n", buffer->lpDisplayName);
    printf("Service type:\t%d\n", buffer->dwServiceType);
    printf("Start type:\t%d\n",buffer->dwStartType);
    printf("Start name:\t%s\n",buffer->lpServiceStartName);
    printf("Path:\t\t%s\n",buffer->lpBinaryPathName);

    LocalFree(buffer);

    CloseServiceHandle(service);
    CloseServiceHandle(scm);
    return TRUE;
}

errno_t
fscanf_m(FILE *file, const string_m format, int *count, ...){
  va_list ap;
  errno_t rv;

  if(!format){
    ErrorHandler("fscanf_m: 2nd Argument NULL Pointer", format, EINVAL);
    ERROR(EINVAL);
  }

  va_start(ap, count);
  rv = vfscanf_m(file, format, count, ap);
  va_end(ap);
  return rv;
}

//
// DoRegisterDeviceInterfaceToHwnd
//
BOOL DoRegisterDeviceInterfaceToHwnd(
	IN GUID InterfaceClassGuid,
	IN HWND hWnd,
	OUT HDEVNOTIFY *hDeviceNotify
	)
	// Routine Description:
	//     Registers an HWND for notification of changes in the device interfaces
	//     for the specified interface class GUID. 

	// Parameters:
	//     InterfaceClassGuid - The interface class GUID for the device 
	//         interfaces. 

	//     hWnd - Window handle to receive notifications.

	//     hDeviceNotify - Receives the device notification handle. On failure, 
	//         this value is NULL.

	// Return Value:
	//     If the function succeeds, the return value is TRUE.
	//     If the function fails, the return value is FALSE.

	// Note:
	//     RegisterDeviceNotification also allows a service handle be used,
	//     so a similar wrapper function to this one supporting that scenario
	//     could be made from this template.
{
	DEV_BROADCAST_DEVICEINTERFACE NotificationFilter;

	ZeroMemory(&NotificationFilter, sizeof(NotificationFilter));
	NotificationFilter.dbcc_size = sizeof(DEV_BROADCAST_DEVICEINTERFACE);
	NotificationFilter.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
	NotificationFilter.dbcc_classguid = InterfaceClassGuid;

	*hDeviceNotify = RegisterDeviceNotification(
		hWnd,                       // events recipient
		&NotificationFilter,        // type of device
		DEVICE_NOTIFY_WINDOW_HANDLE // type of recipient handle
		);

	if (NULL == *hDeviceNotify)
	{
		ErrorHandler(TEXT("RegisterDeviceNotification"));
		return FALSE;
	}

	return TRUE;
}

int SkpModel::LoadVertices(){
	SUResult res;
	int out = 0;

	for (int f=0; f<faces_.size(); f++){
		//Form the mesh
		SUMeshHelperRef mesh = SU_INVALID;
		res = SUMeshHelperCreate(&mesh, faces_[f]);
		ErrorHandler(res);
		
		// Get number of vertices. 
		size_t num_vertices;
		res = SUMeshHelperGetNumVertices(mesh, &num_vertices);
		ErrorHandler(res);

		//Get vertices.
		std::vector<SUPoint3D>   vertices(num_vertices);
		res = SUMeshHelperGetVertices(mesh, num_vertices, &vertices[0], &num_vertices);
		ErrorHandler(res);
		vertices_.add(vertices);
		
		//Get Normals
		std::vector<SUVector3D>  normals(num_vertices);
		res = SUMeshHelperGetNormals (mesh, num_vertices, &normals[0], &num_vertices);
		ErrorHandler(res);
		normals_.add(normals);

		//Front Texture Coordinates
		std::vector<SUPoint3D> texture_coords(num_vertices);
		size_t num_coords;
		res = SUMeshHelperGetFrontSTQCoords(mesh, num_vertices, &texture_coords[0], &num_coords);
		ErrorHandler(res);
		assert(num_coords == num_vertices);
		stqcoords_front_.add(texture_coords);

		//Back Texture Coordinates
		std::vector<SUPoint3D> texture_coords_back(num_vertices);
		res = SUMeshHelperGetFrontSTQCoords(mesh, num_vertices, &texture_coords_back[0], &num_coords);
		ErrorHandler(res);
		assert(num_coords == num_vertices);
		stqcoords_back_.add(texture_coords_back);

		SUMeshHelperRelease(&mesh);
		//*/
		/*
		size_t num_vertices;
		SUFaceGetNumVertices(faces_[f], &num_vertices);
		std::vector<SUVertexRef> vertices(num_vertices);
		SUFaceGetVertices(faces_[f], num_vertices, &vertices[0], &num_vertices);
		vertices_.add(vertices);
		*/

	}
	return out;
}

void Senddde(char* tempstr)
{
  try
  {
    //Connect to the service and request the topic
    if ((hcnv = DdeConnect(idInst, hszService, hszTopic, NULL)) == 0)
    {
      ColorStop();
      return;
    }

    //Start a DDE transaction
    if (DdeClientTransaction((LPBYTE)tempstr, strlen(tempstr)+1,
          hcnv, hszItem, CF_TEXT, XTYP_POKE, 5000, &dwResult) == 0)
    {
      UINT result = DdeGetLastError(idInst);
      switch (result)
      {
        case DMLERR_ADVACKTIMEOUT:
        case DMLERR_BUSY:
        case DMLERR_DATAACKTIMEOUT:
        case DMLERR_DLL_NOT_INITIALIZED:
        case DMLERR_EXECACKTIMEOUT:
        case DMLERR_INVALIDPARAMETER:
        case DMLERR_MEMORY_ERROR:
        case DMLERR_NO_CONV_ESTABLISHED:
        case DMLERR_NO_ERROR:
        case DMLERR_NOTPROCESSED:
        case DMLERR_POKEACKTIMEOUT:
        case DMLERR_POSTMSG_FAILED:
        case DMLERR_REENTRANCY:
        case DMLERR_SERVER_DIED:
        case DMLERR_UNADVACKTIMEOUT:
        default:
          ColorStop();
      }
    }

    //Free DDE
    DdeDisconnect(hcnv);
  }
  catch(...)
  {
    ErrorHandler("Exception thrown in Senddde()!");
  }
}

void ButtonLaunch::Launch()
{
    // If Description mode is on, Save the application launch, launch a description if one is 
    // available, otherwise run the application as normal
    if(m_pMControl->getDescMode() == "On" && m_pAppDescription != "" && m_showTestMenu )
    {
        SaveLaunch();
        MenuPage * pMenuPage = new MenuPage(m_pMdiArea, m_pAppDescription, false , m_pParentWindow, m_pMControl);
        pMenuPage->Launch();
    }
    else
    {
        m_showTestMenu = true;

       // Create a process to run the app.
       m_pProcess = new QProcess(this);
       m_pProcess->setProcessChannelMode(QProcess::MergedChannels);
       // Disable parent menu while this process is running to prevent false button triggering.
       m_pParentWindow->Disable();

       connect(m_pProcess, SIGNAL(error(QProcess::ProcessError)), this, SLOT(ErrorHandler()));
       if (m_appTextFlag)
       {
           // Hook signals for apps that generate stdout text.
           connect(m_pProcess, SIGNAL(readyRead()), this, SLOT(TextOutput()));
       }
       else    // For apps that do not need a window to display stdout text.
       {
           connect(m_pProcess, SIGNAL(finished(int, QProcess::ExitStatus)), m_pParentWindow, SLOT(Enable()));
       }
       // Launch the app by its stored name.
       QStringList appParameters;
       appParameters << m_appParameter;

       if (!m_terminateMatrix) {
           m_pProcess->start(m_appName, appParameters, QIODevice::ReadOnly | 
               QIODevice::Text);
       }
       else {
           // If we need to terminate the matrix we must start the application as 
           // a detached process.
           m_pProcess->startDetached(m_appName, appParameters);
       } 
    }
    //qDebug() << "Launched App: " << m_appName << " " << m_appParameter;
}

Mailbox::Mailbox(char* name, unsigned numSubjects):
	mail()
{
	// Copy args
	strcpy(sName, name);
	iSubjects = numSubjects;
	
	// Copy the rest of the args derived from the mailbox name
	strcpy(sSetting, name);
	strcat(sSetting, "server");
	if(GetRCString(sSetting, sServer, NULL, MAX_LINE_LENGTH))
	{
		strcpy(sSetting, name);
		strcat(sSetting, "type");
		GetRCString(sSetting, sType, "pop3", MAX_LINE_LENGTH);
		strcpy(sSetting, name);
		strcat(sSetting, "user");
		GetRCString(sSetting, sUser, "anonymous", MAX_LINE_LENGTH);
		strcpy(sSetting, name);
		strcat(sSetting, "port");
		if (!strcmp("imap", sType)) GetRCString(sSetting, sPort, "143", MAX_LINE_LENGTH);
		else GetRCString(sSetting, sPort, "110", MAX_LINE_LENGTH);
		strcpy(sSetting, name);
		strcat(sSetting, "password");
		GetRCString(sSetting, sPass, "", MAX_LINE_LENGTH);
		strcpy(sSetting, name);
		strcat(sSetting, "folder");
		GetRCString(sSetting, sFolder, "inbox", MAX_LINE_LENGTH);

		// If no password was found in config, get it from database/dialog
		if (!(*sPass)) GetPass();

		// Set evars
		strcpy(sEvar, "AcidMail");
		strcat(sEvar, name);
		LSSetVariable(sEvar, "0");
		strcpy(sErrorVar, sEvar);
		strcat(sErrorVar, "Error");
		LSSetVariable(sErrorVar, "none");		
	}
	else
	{
		ErrorHandler(Error(false, LOG_ERROR, "No host found in config files", NULL));
		mail.bError = true;		
	}
}

errno_t vfscanf_m(FILE *file, const string_m format, int *count, va_list args){
  int orientation;
  errno_t rv;

  if(!format){
    ErrorHandler("vfscanf_m: 2nd Argument NULL Pointer", format, EINVAL);
    ERROR(EINVAL);
  }

  orientation = fwide(file, 0);

  if(orientation > 0)
    rv = wvfscanf_m(file, format, count, args);
  else 
    rv = cvfscanf_m(file, format, count, args);
  if (rv) ERROR(rv);
  return rv;
}

	void IoServicesImpl::AsyncConnect(ConnectCallback&& connectCb, ErrorCallback&& errCb, std::string ipAddress, int port)
	{
		auto errCbCopy = std::move(errCb);
		auto errHandler = [this, errCbCopy](std::shared_ptr<TcpPeerConnection> conn, const boost::system::error_code& ec) {
			// Call the application error handler first.
			errCbCopy(conn, ec);

			// Then call our cleanup handler.
			ErrorHandler(conn, ec);
		};

		auto conn = std::make_shared<TcpConnection>(&_ioService, std::move(errHandler));

		// All access is from the context of the IO service so should not need mutexing.
		_clientConnections[conn] = conn;

		conn->AsyncConnect(std::move(connectCb), ipAddress, port);
	}

			void Renderer::End() {
				HRESULT tmpResult;

				memcpy(MappedSubresource.pData, &Vertices[0], sizeof(SVertex)*Vertices.size());                 // copy the data
				DeviceContext->Unmap(VertexBuffer, NULL);

				// draw vertices
				DeviceContext->Draw(Vertices.size(), 0);

				// present screen
				tmpResult = SwapChain->Present(VSync, 0);
				if (ErrorHandler(tmpResult)) {
					return;
				}

#ifdef FRAMEWORK_DEBUG
				std::cout << "X11 End" << std::endl;
#endif
			}

void
nsSetupTypeDlg::CreateDestYes(GtkWidget *aWidget, gpointer aData)
{
    DUMP("CreateDestYes");
    int err = 0; 
    char path[PATH_MAX + 1];
    int  pathLen = strlen(gCtx->opt->mDestination);

    if (pathLen > PATH_MAX)
        pathLen = PATH_MAX;
    memcpy(path, gCtx->opt->mDestination, pathLen);
    path[pathLen] = '/';  // for uniform handling

    struct stat buf;

    for (int i = 1; !err && i <= pathLen; i++) 
    {
        if (path[i] == '/') 
        {
            path[i] = '\0';
            if (stat(path, &buf) != 0) 
            {
                err = mkdir(path, 0755);
            }
            path[i] = '/';
        }
    }

    if (gCtx->opt->mMode == nsXIOptions::MODE_DEFAULT)
    {
        gtk_widget_destroy(sCreateDestDlg);
    }

    if (err != 0)
    {
        ErrorHandler(E_MKDIR_FAIL);
    }
    else
    {
        // try to move forward to installer dialog again
        nsSetupTypeDlg::Next((GtkWidget *)NULL, NULL);
    }
}

BOOL DataBase::Execute(char* CmdStr, long * lRecordAffected, long Option)
{
	VARIANT var;
	var.vt = VT_I4;
	try
	{
		m_Conn->Execute(CmdStr, &var, Option);
		*lRecordAffected = var.iVal;
	}
	catch(_com_error &e)
	{
		ErrorHandler(e, m_ErrStr);
		MessageBox(NULL, m_ErrStr, "´íÎó", MB_OK);
		return FALSE;
	}

	sprintf(m_ErrStr, "Success");
	return TRUE;
}