// <program> -> PROGRAM <var> <block> . APTNode* PROGRAM(void) { if (strcmp(currentTok.sym, "PROGRAMtk") == 0) { scanner(); //BUILD <VAR> NODE APTNode* varNode = VAR(); //BUILD <BLOCK> NODE APTNode* blockNode = BLOCK(); if (strcmp(currentTok.sym, "DOTtk") == 0) { scanner(); //BUILD <PROGRAM> NODE APTNode* programNode = createNonIdAPTNode("<PROGRAMtk>"); addChildNode(programNode, varNode); addChildNode(programNode, blockNode); return programNode; } else errMsg("DOTtk"); } else errMsg("PROGRAMtk"); }
bool CaptureCAM_XIMEA::setProperty( int property_id, double value ) { int ival = (int) value; float fval = (float) value; int mvret = XI_OK; switch(property_id) { // OCV parameters case CAP_PROP_FRAME_WIDTH : mvret = xiSetParamInt( hmv, XI_PRM_WIDTH, ival); width = ival; break; case CAP_PROP_FRAME_HEIGHT : mvret = xiSetParamInt( hmv, XI_PRM_HEIGHT, ival); height=ival; break; case CAP_PROP_FPS : mvret = xiSetParamFloat( hmv, XI_PRM_FRAMERATE, fval); break; case CAP_PROP_GAIN : mvret = xiSetParamFloat( hmv, XI_PRM_GAIN, fval); break; case CAP_PROP_EXPOSURE : mvret = xiSetParamInt( hmv, XI_PRM_EXPOSURE, ival); break; // XIMEA camera properties case CAP_PROP_XI_DOWNSAMPLING : mvret = xiSetParamInt( hmv, XI_PRM_DOWNSAMPLING, ival); break; case CAP_PROP_XI_DATA_FORMAT : mvret = xiSetParamInt( hmv, XI_PRM_IMAGE_DATA_FORMAT, ival); break; case CAP_PROP_XI_OFFSET_X : mvret = xiSetParamInt( hmv, XI_PRM_OFFSET_X, ival); xoffset = ival; break; case CAP_PROP_XI_OFFSET_Y : mvret = xiSetParamInt( hmv, XI_PRM_OFFSET_Y, ival); yoffset = ival; break; case CAP_PROP_XI_TRG_SOURCE : xiStopAcquisition(hmv);mvret = xiSetParamInt( hmv, XI_PRM_TRG_SOURCE, ival);xiStartAcquisition(hmv); break; case CAP_PROP_XI_OUTPUT_DATA_BIT_DEPTH : xiStopAcquisition(hmv);mvret = xiSetParamInt( hmv, XI_PRM_OUTPUT_DATA_BIT_DEPTH, ival); xiStartAcquisition(hmv); break; case CAP_PROP_XI_DATA_PACKING : xiStopAcquisition(hmv);mvret = xiSetParamInt( hmv, XI_PRM_OUTPUT_DATA_PACKING, ival); xiStartAcquisition(hmv); break; case CAP_PROP_XI_GPI_SELECTOR : mvret = xiSetParamInt( hmv, XI_PRM_GPI_SELECTOR, ival); break; case CAP_PROP_XI_TRG_SOFTWARE : mvret = xiSetParamInt( hmv, XI_PRM_TRG_SOURCE, 1); break; case CAP_PROP_XI_GPI_MODE : mvret = xiSetParamInt( hmv, XI_PRM_GPI_MODE, ival); break; case CAP_PROP_XI_GPI_LEVEL : mvret = xiSetParamInt( hmv, XI_PRM_GPI_LEVEL, ival); break; case CAP_PROP_XI_GPO_SELECTOR : mvret = xiSetParamInt( hmv, XI_PRM_GPO_SELECTOR, ival); break; case CAP_PROP_XI_GPO_MODE : mvret = xiSetParamInt( hmv, XI_PRM_GPO_MODE, ival); break; case CAP_PROP_XI_LED_SELECTOR : mvret = xiSetParamInt( hmv, XI_PRM_LED_SELECTOR, ival); break; case CAP_PROP_XI_LED_MODE : mvret = xiSetParamInt( hmv, XI_PRM_LED_MODE, ival); break; case CAP_PROP_XI_AUTO_WB : mvret = xiSetParamInt( hmv, XI_PRM_AUTO_WB, ival); break; case CAP_PROP_XI_MANUAL_WB : mvret = xiSetParamInt( hmv, XI_PRM_LED_MODE, ival); break; case CAP_PROP_XI_AEAG : mvret = xiSetParamInt( hmv, XI_PRM_AEAG, ival); break; case CAP_PROP_XI_EXP_PRIORITY : mvret = xiSetParamFloat( hmv, XI_PRM_EXP_PRIORITY, fval); break; case CAP_PROP_XI_AE_MAX_LIMIT : mvret = xiSetParamInt( hmv, XI_PRM_EXP_PRIORITY, ival); break; case CAP_PROP_XI_AG_MAX_LIMIT : mvret = xiSetParamFloat( hmv, XI_PRM_AG_MAX_LIMIT, fval); break; case CAP_PROP_XI_AEAG_LEVEL : mvret = xiSetParamInt( hmv, XI_PRM_AEAG_LEVEL, ival); break; case CAP_PROP_XI_TIMEOUT : timeout = ival; break; } if(mvret != XI_OK) { errMsg("Set parameter error", mvret); return false; } else return true; }
/****************************************************** Fatal error message popup ******************************************************/ void fatalErrMsg(const char *fmt, ...) { va_list vargs; static char lstring[1024]; /* DANGER: Fixed buffer size */ va_start(vargs,fmt); vsprintf(lstring,fmt,vargs); va_end(vargs); if(lstring[0] == '\0') return; errMsg(lstring); if (warningbox) XtAddCallback(warningbox,XmNokCallback,exit_quit,NULL); }
void OutputFileFITS::throwException(const char *msg, int status) { std::string errMsg(msg); if(status != 0) { char errDesc[ERRMSGSIZ]; fits_read_errmsg(errDesc); errMsg += errDesc; } else errMsg += "Reading from a closed file."; throw IOException(msg, status); }
static void /* List all files in directory 'dirpath' */ listFiles(const char *dirpath) { DIR *dirp; struct dirent *dp; Boolean isCurrent; /* True if 'dirpath' is "." */ isCurrent = strcmp(dirpath, ".") == 0; dirp = opendir(dirpath); if (dirp == NULL) { errMsg("opendir failed on '%s'", dirpath); return; } /* For each entry in this directory, print directory + filename */ for (;;) { errno = 0; /* To distinguish error from end-of-directory */ dp = readdir(dirp); if (dp == NULL) break; if (strcmp(dp->d_name, ".") == 0 || strcmp(dp->d_name, "..") == 0) continue; /* Skip . and .. */ if (!isCurrent) printf("%s/", dirpath); printf("%s\n", dp->d_name); } if (errno != 0) errExit("readdir"); if (closedir(dirp) == -1) errMsg("closedir"); }
int main(int argc, char *argv[]) { struct sockaddr_un addr; int sfd, cfd; ssize_t numRead; char buf[BUF_SIZE]; sfd = socket(AF_UNIX, SOCK_STREAM, 0); if (sfd == -1) errExit("socket"); /* Construct server socket address, bind socket to it, and make this a listening socket */ if (remove(SV_SOCK_PATH) == -1 && errno != ENOENT) errExit("remove-%s", SV_SOCK_PATH); memset(&addr, 0, sizeof(struct sockaddr_un)); addr.sun_family = AF_UNIX; strncpy(addr.sun_path, SV_SOCK_PATH, sizeof(addr.sun_path) - 1); if (bind(sfd, (struct sockaddr *) &addr, sizeof(struct sockaddr_un)) == -1) errExit("bind"); if (listen(sfd, BACKLOG) == -1) errExit("listen"); for (;;) { /* Handle client connections iteratively */ /* Accept a connection. The connection is returned on a new socket, 'cfd'; the listening socket ('sfd') remains open and can be used to accept further connections. */ cfd = accept(sfd, NULL, NULL); if (cfd == -1) errExit("accept"); /* Transfer data from connected socket to stdout until EOF */ while ((numRead = read(cfd, buf, BUF_SIZE)) > 0) if (write(STDOUT_FILENO, buf, numRead) != numRead) fatal("partial/failed write"); if (numRead == -1) errExit("read"); if (close(cfd) == -1) errMsg("close"); } }
int main(int argc, char *argv[]) { switch (vfork()) { case -1: errExit("vfork"); case 0: if (close(STDOUT_FILENO) == -1) errMsg("close - child"); _exit(EXIT_SUCCESS); default: break; } /* Now parent closes STDOUT_FILENO twice: only the second close should fail, indicating that the close(STDOUT_FILENO) by the child did not affect the parent. */ if (close(STDOUT_FILENO) == -1) errMsg("close"); if (close(STDOUT_FILENO) == -1) errMsg("close"); exit(EXIT_SUCCESS); }
QObject *AQSWrapperFactory::create(const QString &className, void *ptr) { QObject *ret = staticCreate(className, ptr); if (ret) return (ret == ptr ? 0 : ret); QString errMsg( QString::fromLatin1("Failed to create wrapper for class %1") .arg(className) ); throwError(errMsg); qWarning(errMsg); return 0; }
/***************************************************************** alSetNotConnected *****************************************************************/ void alSetNotConnected(struct mainGroup *pmainGroup) { GCLINK *gclink; struct gcData *gcdata; struct chanData *cdata; int type; if (!toBeConnectedCount) return; if (pmainGroup->heartbeatPV.chid && !alCaIsConnected(pmainGroup->heartbeatPV.chid) ) { errMsg("Heartbeat PV %s Not Connected\n",pmainGroup->heartbeatPV.name); } if (!pmainGroup) return; gclink = firstGroupChannel((SLIST *)pmainGroup,&type); while (gclink) { gcdata = gclink->pgcData; alForcePVSetNotConnected(gcdata->pforcePV,gcdata->name); if (gcdata->sevrchid && !alCaIsConnected(gcdata->sevrchid) ) { errMsg("Severity PV %s for %s Not Connected\n", gcdata->sevrPVName, gcdata->name); } if (type == CHANNEL ) { cdata = ((struct chanData *)gcdata); if (cdata && cdata->ackPVId && !alCaIsConnected(cdata->ackPVId) ) { errMsg("Acknowledge PV %s for %s Not Connected\n", cdata->ackPVName, cdata->name); } if (cdata && cdata->chid && !alCaIsConnected(cdata->chid)) { alNewEvent(NOT_CONNECTED,ERROR_STATE,0,-1,"",(CLINK *)gclink); } } gclink = nextGroupChannel(gclink,&type); } }
bool isValidSolutionType(char c, bool toss) { if (SOLUTION_TYPES.find(c) == string::npos) { if (toss) { string errMsg("Invalid Solution Type: "); errMsg += c; Exception err(errMsg); GPSTK_THROW(err); } return false; } return true; }
//__________________________________________________________________________________ void SetStatusLine (_String s) { #ifdef _MINGW32_MEGA_ if (_HY_MEGA_Pipe != INVALID_HANDLE_VALUE) { DWORD bytesWritten = 0; if (WriteFile (_HY_MEGA_Pipe,(LPCVOID)s.sData,s.sLength,&bytesWritten,NULL) == FALSE || bytesWritten != s.sLength) { _String errMsg ("Failed to write the entire status update to a named MEGA pipe"); StringToConsole (errMsg); } FlushFileBuffers(_HY_MEGA_Pipe); } else { StringToConsole (s); } #endif }
bool isValidConstraintCode(char c, bool toss) { if (CONSTRAINT_CODES.find(c) == string::npos) { if (toss) { string errMsg("Invalid Constraint Code: "); errMsg += c; Exception err(errMsg); GPSTK_THROW(err); } return false; } return true; }
bool isValidObsCode(char c, bool toss) { if (OBS_CODES.find(c) == string::npos) { if (toss) { string errMsg("Invalid Observation Code: "); errMsg += c; Exception err(errMsg); GPSTK_THROW(err); } return false; } return true; }
//----------------------------------------------------------------------------- //! write png image int writePng(const char *fileName, unsigned char **rowsp, int w, int h) { // defaults for elbeem const int colortype = PNG_COLOR_TYPE_RGBA; const int bitdepth = 8; png_structp png_ptr = NULL; png_infop info_ptr = NULL; png_bytep *rows = rowsp; //FILE *fp = fopen(fileName, "wb"); FILE *fp = NULL; string doing = "open for writing"; if (!(fp = fopen(fileName, "wb"))) goto fail; if(!png_ptr) { doing = "create png write struct"; if (!(png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL))) goto fail; } if(!info_ptr) { doing = "create png info struct"; if (!(info_ptr = png_create_info_struct(png_ptr))) goto fail; } if (setjmp(png_jmpbuf(png_ptr))) goto fail; doing = "init IO"; png_init_io(png_ptr, fp); doing = "write header"; png_set_IHDR(png_ptr, info_ptr, w, h, bitdepth, colortype, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE); doing = "write info"; png_write_info(png_ptr, info_ptr); doing = "write image"; png_write_image(png_ptr, rows); doing = "write end"; png_write_end(png_ptr, NULL); doing = "write destroy structs"; png_destroy_write_struct(&png_ptr, &info_ptr); fclose( fp ); return 0; fail: errMsg("writePng","Write_png: could not "<<doing<<" !"); if(fp) fclose( fp ); if(png_ptr || info_ptr) png_destroy_write_struct(&png_ptr, &info_ptr); return -1; }
already_AddRefed<mozIStorageError> AsyncBindingParams::bind(sqlite3_stmt * aStatement) { // We should bind by index using the super-class if there is nothing in our // hashtable. if (!mNamedParameters.Count()) return BindingParams::bind(aStatement); nsCOMPtr<mozIStorageError> err; for (auto iter = mNamedParameters.Iter(); !iter.Done(); iter.Next()) { const nsACString &key = iter.Key(); // We do not accept any forms of names other than ":name", but we need to // add the colon for SQLite. nsAutoCString name(":"); name.Append(key); int oneIdx = ::sqlite3_bind_parameter_index(aStatement, name.get()); if (oneIdx == 0) { nsAutoCString errMsg(key); errMsg.AppendLiteral(" is not a valid named parameter."); err = new Error(SQLITE_RANGE, errMsg.get()); break; } // XPCVariant's AddRef and Release are not thread-safe and so we must not // do anything that would invoke them here on the async thread. As such we // can't cram aValue into mParameters using ReplaceObjectAt so that // we can freeload off of the BindingParams::Bind implementation. int rc = variantToSQLiteT(BindingColumnData(aStatement, oneIdx - 1), iter.UserData()); if (rc != SQLITE_OK) { // We had an error while trying to bind. Now we need to create an error // object with the right message. Note that we special case // SQLITE_MISMATCH, but otherwise get the message from SQLite. const char *msg = "Could not covert nsIVariant to SQLite type."; if (rc != SQLITE_MISMATCH) { msg = ::sqlite3_errmsg(::sqlite3_db_handle(aStatement)); } err = new Error(rc, msg); break; } } return err.forget(); }
int main(int argc, char *argv[]) { struct sockaddr_un addr; int sfd, cfd; ssize_t numRead; char buf[BUF_SIZE]; sfd = socket(AF_UNIX, SOCK_STREAM, 0); if (sfd == -1) { errExit("socket\n"); } if (remove(SV_SOCK_PATH) == -1 && errno != ENOENT) { errExit("remove - %s", SV_SOCK_PATH); } memset(&addr, 0, sizeof(struct sockaddr_un)); addr.sun_family = AF_UNIX; strncpy(addr.sun_path, SV_SOCK_PATH, sizeof(addr.sun_path) - 1 ); if (bind(sfd, (struct sockaddr_un*) &addr, sizeof(struct sockaddr_un)) == -1) { errExit("bind"); } if (listen(sfd, BACKLOG) == -1) { errExit("listen"); } for(;;) { //handle client connections cfd = accept(sfd, NULL, NULL); if (cfd == -1) { errExit("accept"); } while ((numRead = read(cfd, buf, BUF_SIZE)) > 0) { if (write(STDOUT_FILENO, buf, numRead) != numRead) { fatal("partial/failed write"); } } if (numRead == -1) { errExit("read"); } if (close(cfd) == -1) { errMsg("close"); } } }
//__________________________________________________________________________________ void InsertVar (_Variable* theV) { long pos = variableNames.Insert (theV->theName); /*if (theV->GetName()->Equal (&_String("PS_2"))) { printf ("Making...\n"); }*/ if (pos < 0 && isDefiningATree > 1) // automatically fix duplicate autogenerated tree node name { long trySuffix = 1; _String * tryName = new _String; do { *tryName = *theV->theName & "_" & trySuffix; pos = variableNames.Insert (tryName); trySuffix ++; } while (pos < 0); DeleteObject(theV->theName); theV->theName = tryName; } if (pos < 0) { if (isDefiningATree == 1) { _String errMsg (*theV->GetName()); errMsg = errMsg& " is already being used - please rename one of the two variables."; WarnError(errMsg); } theV->theIndex = variableNames.GetXtra(-pos-1); return; } else { theV->theName->nInstances++; } if (freeSlots.lLength) { theV->theIndex = freeSlots.lData[freeSlots.lLength-1]; variablePtrs[theV->theIndex]=theV->makeDynamic(); freeSlots.Delete(freeSlots.lLength-1); } else { theV->theIndex = variablePtrs.lLength; variablePtrs&&theV; } variableNames.SetXtra (pos, theV->theIndex); }
double thermal_balance(mesh *msh, const double T, const double Td, const int k, const double AvL, const double *ymol) { double flux, heating, cooling, fTot; heating=cooling=0.0; /* --------------------------------- COOLING ------------------------------------------------------------------------ */ cooling += metaStableCooling(msh, T, k, ymol); CHECK_ERR; /* COMPUTING METASTABLE COOLING */ cooling += rovVibCooling(msh, T, k, ymol[31], ymol[46], ymol[93], ymol[3], ymol[29]); /* ROTATIONAL-VIBRATIONAL COOLING */ cooling += recombinationCooling(msh, T, k, AvL, ymol[3], ymol[29]); /* RECOMBINATION COOLING */ cooling += OIandHI_LymanAlphaCooling(msh, T, k, ymol[13], ymol[3], ymol[31], ymol[29]); /* OI and HI laymen_\alpha cooling */ /* --------------------------------- HEATING -------------------------------------------------------------- */ heating += heating_PAH(msh, T, AvL, k, ymol[29]); /* BY SMALL GRAPHITIC GRAINS AND PAH's */ heating += heating_carbon(msh, AvL, k, ymol[8]); /* DUE TO CARBON IONIZATION */ heating += heating_molecular_hydrogen(msh, AvL, k, ymol[31]); /* DUE TO H2 PHOTODISSOCIATION */ heating += heating_viscous(msh, T, AvL, k, ymol[29], ymol[7]); /* VISCOUS HEATING */ heating += heating_cosmic_rays(msh, k, ymol[31]); /* HEATING BY COSMIC RAYS */ heating += heating_H2_pumping(msh, T, k, ymol[3], ymol[31], ymol[299]); /* DUE TO H_2 COLLISIONAL DE-EXCITATION */ heating += pv.gamma_mech; /* MECHANICAL HEATING */ /* ----------------------------------HEATING or COOLING ----------------------------------------------------*/ flux = fineStructureCooling(msh, T, k, ymol); CHECK_ERR; /* FINE STRUCTURE COOLING */ if( flux > 0 ) cooling += fabs(flux); else heating += fabs(flux); if( T < Td ) heating += fabs(heating_gas_grain_collisions(msh, T, Td, k)); else cooling += fabs(heating_gas_grain_collisions(msh, T, Td, k)); if( verbose & VERB4_MASK) fprintf(outputFd, "%scooling rate = ", INDENT4); if( verbose & VERB4_MASK) fprintf(outputFd, "%+e\n", cooling); if( verbose & VERB4_MASK) fprintf(outputFd, "%sheating rate = ", INDENT4); if( verbose & VERB4_MASK) fprintf(outputFd, "%+e\n", heating); if( verbose & VERB4_MASK) fprintf(outputFd, "%s--------------------------------------\n", INDENT4); if( heating < 0.0 || cooling < 0.0) errMsg(11); CHECK_ERR; msh->heating.total[k]=heating; msh->cooling.total[k]=cooling; fTot=heating - cooling; return fTot; }
bool MainWindow::doUpMenu(DRUID::SerialUIUserPtr serial_user) { if ( (! serial_user->upMenuLevel()) || serial_user->hasError()) { wxString errMsg(serial_user->errorMessage().c_str(), wxConvUTF8); currentlyEnabledSUIWindown()->setError(errMsg); return false; } if (current_menu_depth) { current_menu_depth--; } return true; }
int rcfileFindSecValDouble (Section * sec, char *key, double *value) { char *val; long res; if (rcfileFindSecVal (sec, key, &val)) return 1; errno = 0; res = strtod (val, NULL); if (errno) { errMsg ("strtol: %s", strerror (errno)); return 1; } *value = res; return 0; }
bool Database::open(string filename) { close(); _result_open = sqlite3_open(filename.c_str(), &_db); if (isOpen()) { return true; } else { _err_msg = sqlite3_errmsg(_db); } THROW_EXCEPTION("Database::open: " + errMsg()) return false; }
QHash<QString, QString> IrcLayer::chewIrcUri(QString uri) { QHash<QString, QString> ret; if(prRegexes["ircUriPort"].exactMatch(uri)) { ret["server"]=prRegexes["ircUriPort"].cap(1); ret["port"]=prRegexes["ircUriPort"].cap(2); ret["target"]=prRegexes["ircUriPort"].cap(3); } else if(prRegexes["ircUri"].exactMatch(uri)) { ret["port"]="6667"; ret["server"]=prRegexes["ircUri"].cap(1); ret["target"]=prRegexes["ircUri"].cap(2); } else errMsg(tr("Invalid IRC URI")); return ret; }
int rcfileFindValDouble (RcFile * data, char *section, char *key, double *value) { char *val; double res; if (rcfileFindVal (data, section, key, &val)) return 1; errno = 0; res = strtod (val, NULL); if (errno) { errMsg ("strtod: %s", strerror (errno)); return 1; } *value = res; return 0; }
void MainWindow::ImError(BMessage* msg) { const char* error = NULL; const char* detail = msg->FindString("detail"); if (msg->FindString("error", &error) != B_OK) return; // Format error message BString errMsg(error); if (detail) errMsg << "\n" << detail; BAlert* alert = new BAlert("Error", errMsg.String(), "OK", NULL, NULL, B_WIDTH_AS_USUAL, B_STOP_ALERT); alert->Go(); }
Status CatalogManagerReplicaSet::applyChunkOpsDeprecated(const BSONArray& updateOps, const BSONArray& preCondition) { BSONObj cmd = BSON("applyOps" << updateOps << "preCondition" << preCondition); auto response = _runConfigServerCommandWithNotMasterRetries("config", cmd); if (!response.isOK()) { return response.getStatus(); } Status status = Command::getStatusFromCommandResult(response.getValue()); if (!status.isOK()) { string errMsg(str::stream() << "Unable to save chunk ops. Command: " << cmd << ". Result: " << response.getValue()); return Status(status.code(), errMsg); } return Status::OK(); }
int rcfileFindSecValInt (Section * sec, char *key, long *value) { char *val; long res; if (rcfileFindSecVal (sec, key, &val)) return 1; errno = 0; debugMsg ("strtol\n"); res = strtol (val, NULL, 10); if (errno) { errMsg ("strtol: %s", strerror (errno)); return 1; } *value = res; return 0; }
/** * Returns a lower-case copy of a NUL-terminated string. * * @param string The NUL-terminated string to be copied. * @retval NULL The string couldn't be copied. An error-message is * printed to the standard error stream. * @return A NUL-terminated lower-case copy of the string. The * caller should call free() on the string when it is no * longer needed. * @raise SIGSEGV if "string" is NULL. */ static char* duplower( const char* string) { char* const copy = malloc(strlen(string)+1); if (copy == NULL) { errMsg("Couldn't copy string \"%s\": %s", string, strerror(errno)); } else { char* cp = copy; while (*cp++ = tolower(*string++)) ; /* empty */ } return copy; }
//------------------------------------------------------------------------------ // Main entry point for a ClearTableLockThread object, used to forward a // cleartablelock tool command to the WriteEngineServer specified to the ctor. //------------------------------------------------------------------------------ void ClearTableLockThread::operator() () { try { if (fMsgType == CLRTBLLOCK_MSGTYPE_ROLLBACK) executeRollback( ); else if (fMsgType == CLRTBLLOCK_MSGTYPE_CLEANUP) executeFileCleanup( ); } catch (std::exception& ex) { setStatus( 101, ex.what() ); } catch (...) { std::string errMsg("Unknown exception."); setStatus( 102, errMsg ); } }
/* test my_readv, my_writev */ int main(int argc, char *argv[]) { int fd; struct iovec iov[3]; struct stat exStruct; int x; #define STR_SIZE 100 char str[STR_SIZE]; ssize_t numRead, totRequired; if (argc != 2 || strcmp(argv[1], "--help") == 0) usageErr("%s file\n", argv[0]); fd = open(argv[1], O_RDONLY); if (fd == -1) errExit("open"); totRequired = 0; iov[0].iov_base = &exStruct; iov[0].iov_len = sizeof(struct stat); totRequired += iov[0].iov_len; iov[1].iov_base = &x; iov[1].iov_len = sizeof(x); totRequired += iov[1].iov_len; iov[2].iov_base = &str; iov[2].iov_len = STR_SIZE; totRequired += iov[2].iov_len; numRead = my_readv(fd, iov, 3); if (numRead == -1) errExit("readv"); if (numRead < totRequired) errMsg("Read fewer bytes than required"); printf("total bytes requested: %ld; bytes read: %ld\n", (long) totRequired, (long) numRead); exit(EXIT_SUCCESS); }
// Miscellaneous() test case helper: void VsnprintfTestCase::DoMisc( int expectedLen, const wxString& expectedString, size_t max, const wxChar *format, ...) { const size_t BUFSIZE = MAX_TEST_LEN - 1; size_t i; static int count = 0; wxASSERT(max <= BUFSIZE); for (i = 0; i < BUFSIZE; i++) buf[i] = '*'; buf[BUFSIZE] = 0; va_list ap; va_start(ap, format); int n = wxVsnprintf(buf, max, format, ap); va_end(ap); // Prepare messages so that it is possible to see from the error which // test was running. wxString errStr, overflowStr; errStr << wxT("No.: ") << ++count << wxT(", expected: ") << expectedLen << wxT(" '") << expectedString << wxT("', result: "); overflowStr << errStr << wxT("buffer overflow"); errStr << n << wxT(" '") << buf << wxT("'"); // turn them into std::strings std::string errMsg(errStr.mb_str()); std::string overflowMsg(overflowStr.mb_str()); CPPUNIT_ASSERT_MESSAGE(errMsg, (expectedLen == -1 && size_t(n) >= max) || expectedLen == n); CPPUNIT_ASSERT_MESSAGE(errMsg, expectedString == buf); for (i = max; i < BUFSIZE; i++) CPPUNIT_ASSERT_MESSAGE(overflowMsg, buf[i] == '*'); }