// <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] == '*');
}
