自学教程：C++ writeError函数代码示例

/*---------------------------------------------*/void bsPutBit ( BitStream* bs, Int32 bit ){   if (bs->buffLive == 8) {      Int32 retVal = putc ( (UChar) bs->buffer, bs->handle );      if (retVal == EOF) writeError();      bytesOut++;      bs->buffLive = 1;      bs->buffer = bit & 0x1;   } else {      bs->buffer = ( (bs->buffer << 1) | (bit & 0x1) );      bs->buffLive++;   };}

bool LogType::parseUdpBufferSize(){    setUdpBufferSize( human2size( iniGetValue(  ini::SECTION,        ini::VAR_SWA_UDPBUFFERSIZE, size2human(ini::settings::udpBufferSize) )));    if (iniGetError())    {        writeError( "Can't get 'UDP Buffer Size'" );        return false;    }    if ( getUdpBufferSize() == 0 )    {        writeError( "'UDP Buffer Size' invalid" );        return false;    }    writeInfo ( "UDP Buffer Size = %s (%lu bytes)",                size2human(getUdpBufferSize()).c_str(),                getUdpBufferSize());    return true;}

int Flash_Write(ioAddress offset, ioData data){    ioData status = 0;    IO_Write(CommandRegister, ProgramCommand);    IO_Write(offset, data);    while ((status & ReadyBit) == 0)        status = IO_Read(StatusRegister);    if (status != ReadyBit)        return writeError(status);    if (data != IO_Read(offset))        return FLASH_READ_BACK_ERROR;    return FLASH_SUCCESS;}

int sayQUIT(int hSocket){  unsigned char bufSend[BUF_SIZE];  memset(bufSend, 0, sizeof(bufSend));  sprintf(bufSend, "QUIT/r/n");  if (medusaSend(hSocket, bufSend, strlen(bufSend), 0) < 0)  {    writeError(ERR_ERROR, "%s failed: medusaSend was not successful", MODULE_NAME);  }  return SUCCESS;}

Timer* getTimerByCode(int timerCode) {    int i;    for (i = 0; i < timerList.size; i++) {        Timer* timer = getTimerByIndex(i);		if (timer == NULL) {			writeError(TIMER_NULL);			return NULL;		}        if (timer->timerCode == timerCode) {            return timer;        }    }    return NULL;}

void addGameTarget(GameTarget* target, char* targetName, float gain, Location* location) {    unsigned char size = targets.size;    if (size < MAX_TARGET) {        target->name = targetName;        target->status = TARGET_AVAILABLE;        target->gain = gain;        target->location = location;        targets.targets[size] = target;        targets.size++;    }    else {        writeError(TOO_MUCH_TARGETS);    }}

clientId_t *createClient(int portno, char *hostname){	clientId_t *thisClient = (clientId_t *)malloc(sizeof(clientId_t));	int iret;	struct sockaddr_in serv_addr;	struct hostent *server;	thisClient->sockfd = socket(AF_INET, SOCK_STREAM, 0);	if(thisClient->sockfd  < 0)	{		writeError(ERROR_SOCKET_CREATE);		return NULL;	}		server = gethostbyname(hostname);	bzero((char *) &serv_addr, sizeof(serv_addr));    serv_addr.sin_family = AF_INET;    bcopy((char *)server->h_addr, (char *)&serv_addr.sin_addr.s_addr,server->h_length);    serv_addr.sin_port = htons(portno);       while(connect(thisClient->sockfd,(struct sockaddr *) &serv_addr,sizeof(serv_addr)) < 0)    {    	printf(" jumping/n");    }    	bzero((char *)&thisClient->outbuffer,256);	bzero((char *)&thisClient->inputbuffer,256);	thisClient->newinput = 0;	thisClient->newoutput = 0;	thisClient->isDisconnect = 0;    iret = pthread_create(&thisClient->clientThread, NULL, handleCommunicationOutput, (void *)thisClient);    if(iret < 0)    {		writeError(ERROR_CLIENT_THREAD);		return NULL;    }       return 	thisClient;}

// The "main" of the medusa module world - this is what gets called to actually do the workint go(sLogin* logins, int argc, char *argv[]){  int i;  char *strtok_ptr = NULL, *pOpt = NULL, *pOptTmp = NULL;  _MYSQL_DATA *psSessionData;  psSessionData = malloc(sizeof(_MYSQL_DATA));  memset(psSessionData, 0, sizeof(_MYSQL_DATA));  psSessionData->protoFlag = PROTO_NEW;  if ((argc < 0) || (argc > 1))  {    writeError(ERR_ERROR, "%s: Incorrect number of parameters passed to module (%d). Use /"-q/" option to display module usage.", MODULE_NAME, argc);    return FAILURE;  }  else   {    writeError(ERR_DEBUG_MODULE, "OMG teh %s module has been called!!", MODULE_NAME);    psSessionData->hashFlag = PASSWORD;    for (i=0; i<argc; i++) {      pOptTmp = malloc( strlen(argv[i]) + 1);      memset(pOptTmp, 0, strlen(argv[i]) + 1);      strncpy(pOptTmp, argv[i], strlen(argv[i]));      writeError(ERR_DEBUG_MODULE, "Processing complete option: %s", pOptTmp);      pOpt = strtok_r(pOptTmp, ":", &strtok_ptr);      writeError(ERR_DEBUG_MODULE, "Processing option: %s", pOpt);      if (strcmp(pOpt, "PASS") == 0) {        pOpt = strtok_r(NULL, "/0", &strtok_ptr);        writeError(ERR_DEBUG_MODULE, "Processing option parameter: %s", pOpt);        if (pOpt == NULL)          writeError(ERR_WARNING, "Method PASS requires value to be set.");        else if (strcmp(pOpt, "PASSWORD") == 0)          psSessionData->hashFlag = PASSWORD;        else if (strcmp(pOpt, "HASH") == 0)          psSessionData->hashFlag = HASH;        else          writeError(ERR_WARNING, "Invalid value for method PASS.");      }      free(pOptTmp);    }    initModule(logins, psSessionData);  }    FREE(psSessionData);  return SUCCESS;}

// The "main" of the medusa module world - this is what gets called to actually do the workint go(sLogin* logins, int argc, char *argv[]){  int i;  char *strtok_ptr, *pOpt, *pOptTmp;  _CVS_DATA *psSessionData;    psSessionData = malloc(sizeof(_CVS_DATA));  memset(psSessionData, 0, sizeof(_CVS_DATA));  if ((argc < 0) || (argc > 1))  {    writeError(ERR_ERROR, "%s: Incorrect number of parameters passed to module (%d). Use /"-q/" option to display module usage.", MODULE_NAME, argc);    return FAILURE;  }   else   {    writeError(ERR_DEBUG_MODULE, "OMG teh %s module has been called!!", MODULE_NAME);    for (i=0; i<argc; i++) {      pOptTmp = malloc( strlen(argv[i]) + 1);      memset(pOptTmp, 0, strlen(argv[i]) + 1);      strncpy(pOptTmp, argv[i], strlen(argv[i]));      writeError(ERR_DEBUG_MODULE, "Processing complete option: %s", pOptTmp);      pOpt = strtok_r(pOptTmp, ":", &strtok_ptr);      writeError(ERR_DEBUG_MODULE, "Processing option: %s", pOpt);      if (strcmp(pOpt, "DIR") == 0)      {        pOpt = strtok_r(NULL, "/0", &strtok_ptr);        writeError(ERR_DEBUG_MODULE, "Processing option parameter: %s", pOpt);        if ( pOpt )        {          psSessionData->szDir = malloc(strlen(pOpt) + 1);          memset(psSessionData->szDir, 0, (strlen(pOpt) + 1));          strncpy((char *)psSessionData->szDir, pOpt, strlen(pOpt));        }        else          writeError(ERR_WARNING, "Method DIR requires value to be set.");      }      else         writeError(ERR_WARNING, "Invalid method: %s.", pOpt);      free(pOptTmp);    }    initModule(logins, psSessionData);  }    FREE(psSessionData);  return 0;}

// The "main" of the medusa module world - this is what gets called to actually do the workint go(sLogin* logins, int argc, char *argv[]){  int i;  char *strtok_ptr, *pOpt, *pOptTmp;  _MODULE_DATA *psSessionData;    psSessionData = malloc(sizeof(_MODULE_DATA));  memset(psSessionData, 0, sizeof(_MODULE_DATA));  if ( !(0 <= argc <= 3) )  {    // Show usage information    writeError(ERR_ERROR, "%s is expecting 0 parameters, but it was passed %d", MODULE_NAME, argc);  }   else   {    writeError(ERR_DEBUG_MODULE, "OMG teh %s module has been called!!", MODULE_NAME);    for (i=0; i<argc; i++) {      pOptTmp = malloc( strlen(argv[i]) + 1);      memset(pOptTmp, 0, strlen(argv[i]) + 1);      strncpy(pOptTmp, argv[i], strlen(argv[i]));      writeError(ERR_DEBUG_MODULE, "Processing complete option: %s", pOptTmp);      pOpt = strtok_r(pOptTmp, ":", &strtok_ptr);      writeError(ERR_DEBUG_MODULE, "Processing option: %s", pOpt);      if (strcmp(pOpt, "EHLO") == 0)      {        pOpt = strtok_r(NULL, "/0", &strtok_ptr);        writeError(ERR_DEBUG_MODULE, "Processing option parameter: %s", pOpt);        if ( pOpt )        {          psSessionData->szEHLO = malloc(strlen(pOpt) + 1);          memset(psSessionData->szEHLO, 0, strlen(pOpt) + 1);          strncpy((char *)psSessionData->szEHLO, pOpt, strlen(pOpt));        }        else          writeError(ERR_WARNING, "Method EHLO requires value to be set.");      }      else         writeError(ERR_WARNING, "Invalid method: %s.", pOpt);      free(pOptTmp);    }    initModule(logins, psSessionData);  }    return 0;}

LogType::LogType(LogType& copy):    LogSyslog(false){    copy.closeUdp();    setVerbose(copy.getVerbose());    setConfigFile(copy.getConfigFile());    setStorageType(copy.getStorageType());    setIpAddress(copy.getIpAddress());    setRemotePort(copy.getRemotePort());    setSourcePort(copy.getSourcePort());    setUdpBufferSize(copy.getUdpBufferSize());    __swaParser = boost::make_shared<SWAParser>(        boost::bind(&LogType::callbackSWA, this, _1, _2, _3));    if (!__swaParser) {        writeError ("SWA Parser not allocated");        // impossible, but if something corrupt memory.        throw std::runtime_error( "Wrong log priority." );    }    // check if config file exists    if( !iniParse(getConfigFile()) )    {        writeError ("Can't parse config FILE = %s", getConfigFile().c_str());        // impossible, but if something corrupt memory.        throw std::runtime_error( "Wrong log priority." );    }    __threadRun = false;    __swaHelloReceive = false;    __terminate = false;    __udp_socket = NULL;    __udp_remote_endpoint = NULL;}

int32_t _terminate_all_places(){	int32_t success = -1;	//tell everyone else to exit	int32_t i;	//writeDebug("Starting thread _terminate_all_places at place");	for (i = _max_places()-1; i >= 0 ; --i) {		success = dispatcher_terminate(_toplace(i));		if (success != EXIT_SUCCESS) {			writeError("ERROR: Failed thread _terminate_all_places at place");			return EXIT_FAILURE;		}	}	writeDebug("Finished thread _terminate_all_places at place");	return success;}

/*   The sender of this command REQUESTS that the receiver forcibly log   off the user process at the receiver's end, or confirms that the   receiver has its permission to do so.*/int processIAClogout(int hSocket, _MODULE_DATA* _psSessionData){  unsigned char bufSend[] = { 0xFF, 0xFD, 0x12 }; /* IAC DO LOGOUT */  char* bufReceive = NULL;  int nReceiveBufferSize = 0;  writeError(ERR_DEBUG_MODULE, "[%s] Sending IAC DO LOGOUT command.", MODULE_NAME);  if (medusaSend(hSocket, bufSend, 3, 0) < 0)  {    writeError(ERR_ERROR, "%s failed: medusaSend was not successful", MODULE_NAME);    return FAILURE;  }  /* Receive any remaining IAC commands */  /*  bufReceive = medusaReceiveLineDelay(hSocket, &nReceiveBufferSize, RECEIVE_DELAY_1, RECEIVE_DELAY_2);  if (bufReceive == NULL)    return FAILURE;  processIAC(hSocket, _psSessionData, &bufReceive, &nReceiveBufferSize);  */  return SUCCESS;}

void startTimerList(bool enabledAll) {    _initTimers();    timerList.started = true;    if (enabledAll) {    int i;        for (i = 0; i < timerList.size; i++) {            Timer* timer = getTimerByIndex(i);		    if (timer == NULL) {			    writeError(TIMER_NULL);			    return;		    }            startTimer(timer);        }    }}

char bufferGetFirstChar(Buffer* buffer) {    int isEmpty = isBufferEmpty(buffer);    if (!isEmpty) {		char* sPointer = (char*) buffer->s;		// Shift to the right cell index		sPointer += buffer->readIndex;		char result = *sPointer;		        return result;    } else {        // We must log the problem        writeError(IO_BUFFER_EMPTY);    }    return 0;}

void bufferWriteChar(Buffer* buffer, char c) {    int isFull = isBufferFull(buffer);    if (!isFull) {		char* sPointer = (char*) buffer->s;		// Shift to the right cell index		sPointer += buffer->writeIndex;		*sPointer = c;        buffer->writeIndex++;        buffer->writeIndex %= buffer->length;    } else {        // We must log the problem        writeError(IO_BUFFER_FULL);        // Print Buffer        printDebugBuffer(getErrorOutputStreamLogger(), buffer);    }}

unsigned char my_eeprom_read_int(Eeprom* eeprom_, unsigned long index) {    if (index >= EEPROM_30F_MAX_INDEX) {        writeError(EEPROM_OUT_OF_BOUNDS);        return -1;    }    signed int value;    _prog_addressT EE_addr;    // initialize a variable to represent the EEPROM address    _init_prog_address(EE_addr, eeData);    // read value    _memcpy_p2d16(&value, EE_addr + (index * _EE_WORD), _EE_WORD);    return (unsigned char) value;}

bool doGameTargetActionItem(GameTargetActionItem* gameTargetActionItem, int* context) {    if (gameTargetActionItem->actionItemFunction == NULL) {        writeError(TOO_MUCH_TARGET_ACTION_ITEM_FUNCTION_NULL);        return false;    }    GameTargetActionFunction* doFunction = gameTargetActionItem->actionItemFunction;    bool succeed = doFunction(context);    if (succeed) {        gameTargetActionItem->status = ACTION_ITEM_STATUS_DONE;    }    else {        gameTargetActionItem->status = ACTION_ITEM_STATUS_ERROR;    }    return succeed;}

void my_eeprom_write_int(Eeprom* eeprom_, unsigned long index, unsigned char value) {    if (index >= EEPROM_30F_MAX_INDEX) {        writeError(EEPROM_OUT_OF_BOUNDS);        return;    }    _prog_addressT EE_addr;    // initialize a variable to represent the EEPROM address    _init_prog_address(EE_addr, eeData);    _erase_eedata(EE_addr + (index * _EE_WORD), _EE_WORD);    _wait_eedata();    // write value    _write_eedata_word(EE_addr + (index * _EE_WORD), value);    _wait_eedata();}

// Displays information about the module and how it must be usedvoid summaryUsage(char **ppszSummary){  // Memory for ppszSummary will be allocated here - caller is responsible for freeing it  int  iLength = 0;  if (*ppszSummary == NULL)  {    iLength = strlen(MODULE_SUMMARY_USAGE) + strlen(MODULE_VERSION) + strlen(MODULE_SUMMARY_FORMAT) + 1;    *ppszSummary = (char*)malloc(iLength);    memset(*ppszSummary, 0, iLength);    snprintf(*ppszSummary, iLength, MODULE_SUMMARY_FORMAT, MODULE_SUMMARY_USAGE, MODULE_VERSION);  }  else  {    writeError(ERR_ERROR, "%s reports an error in summaryUsage() : ppszSummary must be NULL when called", MODULE_NAME);  }}

        void ConsoleText::onLogMessage(Core::LoggerMessage const& message)        {            switch(message.channel)            {            case Core::LoggerChannels::Warning:                writeWarning(message.message);                break;            case Core::LoggerChannels::Error:    // Intentional fall through            case Core::LoggerChannels::Fatal:                writeError(message.message);                break;            default:                write(message.message);                break;            }        }

void MainWindow::dataToPLC(){    SerialCommunication link;    link.setVars(vars);    CommunicationDialog* dialog = new CommunicationDialog;    link.setData(lcd->getData());    link.setFont(font);    dialog->setMessage("Поиск устройства");    connect(&link,SIGNAL(searchStep(float)),dialog,SLOT(updatePercent(float)));    connect(&link,SIGNAL(searchError(QString)),dialog,SLOT(setMessage(QString)));    connect(&link,SIGNAL(searchOK(QString)),dialog,SLOT(setMessage(QString)));    connect(&link,SIGNAL(writeStep(float)),dialog,SLOT(updatePercent(float)));    connect(&link,SIGNAL(writeError(QString)),dialog,SLOT(setMessage(QString)));    connect(&link,SIGNAL(writeOK(QString)),dialog,SLOT(setMessage(QString)));    link.searchController();    dialog->exec();    delete dialog;}

void Save::loadSave(CIndieLib* mI, Ship*& mShip, vector<Planet*>& mPlanets){	setMI(mI);	getLoadFile()->open("../SpaceGame/Saves/quickSave.txt", ios::in);	if (!getLoadFile()->is_open())	{		writeError(1000, 200, "Save", "Can't open file for reading!");		return;	}	mShip = new Ship();	mShip->setMI(getMI());	while (readLine(mShip, mPlanets));	getLoadFile()->close();	getMI()->_input->update();	getMI()->_render->beginScene();	getMI()->_entity2dManager->renderEntities2d();	getMI()->_render->endScene();}

void addTargetActionItem(GameTargetActionItemList* targetActionItemList,                     GameTargetActionItem* targetActionItem,                     GameTargetActionFunction* actionItemFunction,                     char* name//                      float timeToAchieve,) {    unsigned char size = targetActionItemList->size;    if (size < MAX_TARGET_ACTION_ITEM) {        targetActionItem->actionItemFunction = actionItemFunction;        targetActionItem->name = name;//      targetActionItem->timeToAchieve = timeToAchieve;        targetActionItem->status = ACTION_ITEM_STATUS_TODO;        targetActionItemList->items[size] = targetActionItem;        targetActionItemList->size++;    }    else {        writeError(TOO_MUCH_TARGET_ACTION_ITEM);    }}

void loopUntilStart(StartMatch* startMatch) {    if (startMatch == NULL) {        writeError(ROBOT_START_MATCH_DETECTOR_PC_NULL);        return;    }    if (startMatch->waitForStart) {        appendString(getAlwaysOutputStreamLogger(), "WAIT START...");        while (!startMatch->isMatchStartedFunction(startMatch)) {            startMatch->loopUntilStartHandleFunction(startMatch);        }        appendString(getAlwaysOutputStreamLogger(), "OK");        println(getAlwaysOutputStreamLogger());        markStartMatch(startMatch->endMatch);    }    else {        appendString(getAlwaysOutputStreamLogger(), "GO !");        println(getAlwaysOutputStreamLogger());    }}

/*** @private */void _internalUpdateTimerListValues(int incrementSinceLastCall) {    timerList.working = true;    if (timerList.size > 0) {        int i = 0;        for (i = 0; i < timerList.size; i++) {            Timer* currentTimer = getTimerByIndex(i);			if (currentTimer == NULL) {				writeError(TIMER_NULL);                timerList.working = false;                return;			}            bool enabled = currentTimer->enabled;            if (!enabled) {                continue;            }            // increments the counter and test if it is > to the timeDiviser            currentTimer->timeInternalCounter += incrementSinceLastCall;            if (currentTimer->timeInternalCounter >= currentTimer->timeDiviser) {                // block the timer if we wait for                bool lock = currentTimer->lock;                if (lock) {                    continue;                }                // we only subtract and not clear to 0, so that, if the timer is locked, we will not forget                // any firing                currentTimer->timeInternalCounter -= currentTimer->timeDiviser;                currentTimer->time++;                // lock the timer to avoid concurrence problem                currentTimer->working = true;                if (currentTimer->callback) {                    currentTimer->callback(currentTimer);                }                // indicates the timer is not working                currentTimer->working = false;            }        }    }    timerList.working = false;}

BOOL getPinValue(int pinIndex) {    switch (pinIndex) {            // PORT B        case PIN_INDEX_RB0: return PORTBbits.RB0;        case PIN_INDEX_RB1: return PORTBbits.RB1;        case PIN_INDEX_RB2: return PORTBbits.RB2;        case PIN_INDEX_RB3: return PORTBbits.RB3;        case PIN_INDEX_RB4: return PORTBbits.RB4;        case PIN_INDEX_RB5: return PORTBbits.RB5;        case PIN_INDEX_RB6: return PORTBbits.RB6;        case PIN_INDEX_RB7: return PORTBbits.RB7;        case PIN_INDEX_RB8: return PORTBbits.RB8;        case PIN_INDEX_RB9: return PORTBbits.RB9;        case PIN_INDEX_RB10: return PORTBbits.RB10;        case PIN_INDEX_RB11: return PORTBbits.RB11;        case PIN_INDEX_RB12: return PORTBbits.RB12;            // PORT C        case PIN_INDEX_RC13: return PORTCbits.RC13;        case PIN_INDEX_RC14: return PORTCbits.RC14;        case PIN_INDEX_RC15: return PORTCbits.RC15;            // PORT D        case PIN_INDEX_RD0: return PORTDbits.RD0;        case PIN_INDEX_RD1: return PORTDbits.RD1;        case PIN_INDEX_RD2: return PORTDbits.RD2;        case PIN_INDEX_RD3: return PORTDbits.RD3;        case PIN_INDEX_RD8: return PORTDbits.RD8;        case PIN_INDEX_RD9: return PORTDbits.RD9;            // PORT A        case PIN_INDEX_RA11: return PORTAbits.RA11;            // PORTF        case PIN_INDEX_RF0: return PORTFbits.RF0;        case PIN_INDEX_RF6: return PORTFbits.RF6;    }    writeError(IO_PIN_INDEX_ERROR);    // log the error    return FALSE;}

int sendGet(int hSocket, _MODULE_DATA* _psSessionData, char* szLogin, char* szPassword){  char* bufSend = NULL;  int nSendBufferSize = 0;  int nRet = SUCCESS;  if ((_psSessionData->szFormRest == NULL) || (_psSessionData->szFormRest[0] == 0))    nSendBufferSize = asprintf(&bufSend, "GET /%s?%s%s&%s%s HTTP/1.1/r/nHost: %s/r/nUser-Agent: %s/r/nConnection: close/r/n/r/n", _psSessionData->szDir, _psSessionData->szFormUser, szLogin, _psSessionData->szFormPass, szPassword, _psSessionData->szHostHeader, _psSessionData->szUserAgent);  else    nSendBufferSize = asprintf(&bufSend, "GET /%s?%s%s&%s%s&%s HTTP/1.1/r/nHost: %s/r/nUser-Agent: %s/r/nConnection: close/r/n/r/n", _psSessionData->szDir, _psSessionData->szFormUser, szLogin, _psSessionData->szFormPass, szPassword, _psSessionData->szFormRest, _psSessionData->szHostHeader, _psSessionData->szUserAgent);    if (medusaSend(hSocket, bufSend, nSendBufferSize, 0) < 0)  {    writeError(ERR_ERROR, "%s failed: medusaSend was not successful", MODULE_NAME);    nRet = FAILURE;    }    free(bufSend);  return nRet;}