/* A Rook's move is valid iff:
- Destination is on the same file/rank (note: mutually exclusive)
- There are no other pieces in intermediate spaces
- Piece at destination, if exist, is not a friendly
(or there are no piece at destination)
Rook.isValidMove() post-cond: return 0 iff move is valid
respective error code otherwise
*/
int Rook::isValidMove
(string sourceFileRank, string destFileRank, map<string, Piece*>* board) {
if (isSameFile(sourceFileRank, destFileRank) &&
isSameRank(sourceFileRank, destFileRank)) {
return ChessErrHandler::DEST_EQ_SOURCE;
}
if (!(isSameFile (sourceFileRank, destFileRank) ||
isSameRank (sourceFileRank, destFileRank))) {
return ChessErrHandler::ILLEGAL_MOVE_PATTERN;
}
/* Obstruction for a Rook only occurs if it is on its intended way
Lazy boolean evalution of C++ ensure !no_Obstruction is evaluated only
after satisfying isSame_, prevents breaking pre-cond of no_Obstruction
*/
if ((isSameFile (sourceFileRank, destFileRank) &&
!noVerticalObstruction (sourceFileRank, destFileRank, board)) ||
(isSameRank (sourceFileRank, destFileRank) &&
!noHorizontalObstruction (sourceFileRank, destFileRank, board))) {
return ChessErrHandler::OBSTRUCTION_EN_ROUTE;
}
if (destExistFriendlyPiece (destFileRank, board)) {
return ChessErrHandler::FRIENDLY_AT_DEST;
}
return ChessErrHandler::NO_ERROR;
}
PDL_HANDLE ideMsgLog::getFD()
{
if ( mEnabled == ID_TRUE )
{
if ( checkExist() == ID_FALSE )
{
IDE_TEST( createFileAndHeader() != IDE_SUCCESS );
}
else
{
if ( isSameFile( mFD, mPath ) == ID_TRUE )
{
/* do nothing */
}
else
{
(void)close();
IDE_TEST( open( mDebug ) != IDE_SUCCESS );
IDE_TEST( writeWarningMessage() != IDE_SUCCESS );
}
}
}
else
{
/* do nothing */
}
return mFD;
IDE_EXCEPTION_END;
return PDL_INVALID_HANDLE;
}
extern boolean isRecursiveLink (const char* const dirName)
{
boolean result = FALSE;
fileStatus *status = eStat (dirName);
if (status->isSymbolicLink)
{
char* const path = absoluteFilename (dirName);
while (path [strlen (path) - 1] == PATH_SEPARATOR)
path [strlen (path) - 1] = '\0';
while (! result && strlen (path) > (size_t) 1)
{
char *const separator = strrchr (path, PATH_SEPARATOR);
if (separator == NULL)
break;
else if (separator == path) /* backed up to root directory */
*(separator + 1) = '\0';
else
*separator = '\0';
result = isSameFile (path, dirName);
}
eFree (path);
}
return result;
}
static void setupChplHome(const char* argv0) {
const char* chpl_home = getenv("CHPL_HOME");
char* guess = NULL;
// Get the executable path.
guess = findProgramPath(argv0);
if (guess) {
// Determine CHPL_HOME based on the exe path.
// Determined exe path, but don't have a env var set
// Look for ../../../util/chplenv
// Remove the /bin/some-platform/chpl part
// from the path.
if( guess[0] ) {
int j = strlen(guess) - 5; // /bin and '\0'
for( ; j >= 0; j-- ) {
if( guess[j] == '/' &&
guess[j+1] == 'b' &&
guess[j+2] == 'i' &&
guess[j+3] == 'n' ) {
guess[j] = '\0';
break;
}
}
}
if( isMaybeChplHome(guess) ) {
// OK!
} else {
// Maybe we are in e.g. /usr/bin.
free(guess);
guess = NULL;
}
}
if( chpl_home ) {
if( strlen(chpl_home) > FILENAME_MAX )
USR_FATAL("$CHPL_HOME=%s path too long", chpl_home);
if( guess == NULL ) {
// Could not find exe path, but have a env var set
strncpy(CHPL_HOME, chpl_home, FILENAME_MAX);
} else {
// We have env var and found exe path.
// Check that they match and emit a warning if not.
if( ! isSameFile(chpl_home, guess) ) {
// Not the same. Emit warning.
USR_WARN("$CHPL_HOME=%s mismatched with executable home=%s",
chpl_home, guess);
}
// Since we have an enviro var, always use that.
strncpy(CHPL_HOME, chpl_home, FILENAME_MAX);
}
} else {
if( guess == NULL ) {
// Could not find enviro var, and could not
// guess at exe's path name.
USR_FATAL("$CHPL_HOME must be set to run chpl");
} else {
int rc;
if( strlen(guess) > FILENAME_MAX )
USR_FATAL("chpl guessed home %s too long", guess);
// Determined exe path, but don't have a env var set
strncpy(CHPL_HOME, guess, FILENAME_MAX);
// Also need to setenv in this case.
rc = setenv("CHPL_HOME", guess, 0);
if( rc ) USR_FATAL("Could not setenv CHPL_HOME");
}
}
// Check that the resulting path is a Chapel distribution.
if( ! isMaybeChplHome(CHPL_HOME) ) {
// Bad enviro var.
USR_WARN("CHPL_HOME=%s is not a Chapel distribution", CHPL_HOME);
}
if( guess ) free(guess);
parseCmdLineConfig("CHPL_HOME", astr("\"", CHPL_HOME, "\""));
}
IDE_RC ideMsgLog::rotate(void)
{
idBool sNeedWriteMessage = ID_FALSE;
if(mEnabled == ID_TRUE)
{
size_t sOffset;
SInt sRotating;
/* For IDE_ERR, do not perform rotation */
IDE_TEST_RAISE(mSelf == IDE_ERR, IAMERR);
sRotating = acpAtomicCas32(&mRotating, 1, 0);
if(sRotating == 1)
{
/* spin */
do
{
idlOS::thr_yield();
sRotating = acpAtomicCas32(&mRotating, 1, 0);
} while(sRotating == 1);
}
else
{
/* fall through */
}
if(checkExist() == ID_FALSE)
{
IDE_TEST(createFileAndHeader() != IDE_SUCCESS);
}
else
{
if ( isSameFile( mFD, mPath ) == ID_TRUE )
{
/* do nothing */
}
else
{
/* file is modified so close and open */
(void)close();
IDE_TEST( open( mDebug ) != IDE_SUCCESS );
sNeedWriteMessage = ID_TRUE;
}
if(mMaxNumber > 0)
{
sOffset = (size_t)idlOS::lseek(mFD, 0, SEEK_END);
if(sOffset >= mSize)
{
IDE_TEST(closeAndRename() != IDE_SUCCESS);
mCurNumber = (mCurNumber + 1) % mMaxNumber;
IDE_TEST(createFileAndHeader() != IDE_SUCCESS);
}
else
{
/* do not create file */
}
}
else
{
/* fall through */
}
if ( sNeedWriteMessage == ID_TRUE )
{
IDE_TEST( writeWarningMessage() != IDE_SUCCESS );
}
else
{
/* do nothing */
}
}
}
else
{
/* pass */
}
/* For IDE_ERR, do not perform rotation */
IDE_EXCEPTION_CONT(IAMERR);
return IDE_SUCCESS;
IDE_EXCEPTION_END;
unrotate();
return IDE_FAILURE;
}
/*
* Copy the contents of one directory to another. Both "src" and "dst"
* must be directories. We will create "dst" if it does not exist.
*/
int copyDirectory(const char* src, const char* dst, const struct stat* pSrcStat, unsigned int options)
{
int retVal = 0;
struct stat dstStat;
DIR* dir;
int cc, statResult;
DBUG(("--- copy dir '%s' to '%s'\n", src, dst));
statResult = stat(dst, &dstStat);
if (statResult == 0 && !S_ISDIR(dstStat.st_mode)) {
fprintf(stderr,
"acp: destination '%s' exists and is not a directory\n", dst);
return -1;
} else if (statResult != 0 && errno != ENOENT) {
fprintf(stderr, "acp: unable to stat destination '%s'\n", dst);
return -1;
}
if (statResult == 0) {
if (isSameFile(pSrcStat, &dstStat)) {
fprintf(stderr,
"acp: cannot copy directory into itself ('%s' and '%s')\n",
src, dst);
return -1;
}
} else {
DBUG(("--- creating dir '%s'\n", dst));
cc = mkdir(dst, 0755);
if (cc != 0) {
fprintf(stderr, "acp: unable to create directory '%s': %s\n",
dst, strerror(errno));
return -1;
}
/* only print on mkdir */
printCopyMsg(src, dst, options);
}
/*
* Open the directory, and plow through its contents.
*/
dir = opendir(src);
if (dir == NULL) {
fprintf(stderr, "acp: unable to open directory '%s': %s\n",
src, strerror(errno));
return -1;
}
while (1) {
struct dirent* ent;
char* srcFile;
char* dstFile;
int srcLen, dstLen, nameLen;
ent = readdir(dir);
if (ent == NULL)
break;
if (strcmp(ent->d_name, ".") == 0 ||
strcmp(ent->d_name, "..") == 0)
{
continue;
}
nameLen = strlen(ent->d_name);
srcLen = strlen(src);
dstLen = strlen(dst);
srcFile = malloc(srcLen +1 + nameLen +1);
memcpy(srcFile, src, srcLen);
srcFile[srcLen] = FSSEP;
memcpy(srcFile + srcLen+1, ent->d_name, nameLen +1);
dstFile = malloc(dstLen +1 + nameLen +1);
memcpy(dstFile, dst, dstLen);
dstFile[dstLen] = FSSEP;
memcpy(dstFile + dstLen+1, ent->d_name, nameLen +1);
if (copyFileRecursive(srcFile, dstFile, false, options) != 0)
retVal = -1; /* note failure and keep going */
free(srcFile);
free(dstFile);
}
closedir(dir);
setPermissions(dst, pSrcStat, options);
return retVal;
}
/*
* Copy a symlink. This only happens if we're in "no derefence" mode,
* in which we copy the links rather than the files that are pointed at.
*
* We always discard the destination file. If it's a symlink already,
* we want to throw it out and replace it. If it's not a symlink, we
* need to trash it so we can create one.
*/
static int copySymlink(const char* src, const char* dst, const struct stat* pSrcStat, unsigned int options)
{
struct stat dstStat;
char linkBuf[PATH_MAX+1];
int statResult, nameLen;
assert(options & COPY_NO_DEREFERENCE);
DBUG(("--- copying symlink '%s' to '%s'\n", src, dst));
/* NOTE: we use lstat() here */
statResult = lstat(dst, &dstStat);
if (statResult == 0 && !S_ISREG(dstStat.st_mode)
&& !S_ISLNK(dstStat.st_mode)
)
{
fprintf(stderr,
"acp: destination '%s' exists and is not regular or symlink\n",
dst);
return -1;
}
if (statResult == 0) {
if (isSameFile(pSrcStat, &dstStat)) {
fprintf(stderr, "acp: '%s' and '%s' are the same file\n",
src, dst);
return -1;
}
if (options & COPY_UPDATE_ONLY) {
if (!isSourceNewer(pSrcStat, &dstStat)) {
DBUG(("--- source is not newer: '%s'\n", src));
printNotNewerMsg(src, dst, options);
return 0;
}
}
}
/* extract the symlink contents */
nameLen = readlink(src, linkBuf, sizeof(linkBuf)-1);
if (nameLen <= 0) {
fprintf(stderr, "acp: unable to read symlink '%s': %s\n",
src, strerror(errno));
return -1;
}
linkBuf[nameLen] = '\0';
DBUG(("--- creating symlink file '%s' (--> %s)\n", dst, linkBuf));
if (statResult == 0) {
DBUG(("--- removing '%s'\n", dst));
if (unlink(dst) != 0) {
fprintf(stderr, "acp: unable to remove '%s': %s\n",
dst, strerror(errno));
return -1;
}
}
if (symlink(linkBuf, dst) != 0) {
fprintf(stderr, "acp: unable to create symlink '%s' [%s]: %s\n",
dst, linkBuf, strerror(errno));
return -1;
}
/*
* There's no way to set the file date or access permissions, but
* it is possible to set the owner.
*/
if (options & COPY_PERMISSIONS) {
if (lchown(dst, pSrcStat->st_uid, pSrcStat->st_gid) != 0)
DBUG(("--- lchown failed: %s\n", strerror(errno)));
}
printCopyMsg(src, dst, options);
return 0;
}
/*
* Copy a regular file. If the destination file exists and is not a
* regular file, we fail. However, we use stat() rather than lstat(),
* because it's okay to write through a symlink (the noDereference stuff
* only applies to the source file).
*
* If the file doesn't exist, create it. If it does exist, truncate it.
*/
static int copyRegular(const char* src, const char* dst, const struct stat* pSrcStat, unsigned int options)
{
struct stat dstStat;
int srcFd, dstFd, statResult, copyResult;
DBUG(("--- copying regular '%s' to '%s'\n", src, dst));
statResult = stat(dst, &dstStat);
if (statResult == 0 && !S_ISREG(dstStat.st_mode)) {
fprintf(stderr,
"acp: destination '%s' exists and is not regular file\n",
dst);
return -1;
} else if (statResult != 0 && errno != ENOENT) {
fprintf(stderr, "acp: unable to stat destination '%s'\n", dst);
return -1;
}
if (statResult == 0) {
if (isSameFile(pSrcStat, &dstStat)) {
fprintf(stderr, "acp: '%s' and '%s' are the same file\n",
src, dst);
return -1;
}
if (options & COPY_UPDATE_ONLY) {
if (!isSourceNewer(pSrcStat, &dstStat)) {
DBUG(("--- source is not newer: '%s'\n", src));
printNotNewerMsg(src, dst, options);
return 0;
}
}
}
/* open src */
srcFd = open(src, O_RDONLY | O_BINARY, 0);
if (srcFd < 0) {
fprintf(stderr, "acp: unable to open '%s': %s\n", src, strerror(errno));
return -1;
}
/* open dest with O_CREAT | O_TRUNC */
DBUG(("--- opening '%s'\n", dst));
dstFd = open(dst, O_CREAT | O_TRUNC | O_WRONLY | O_BINARY, 0644);
if (dstFd < 0) {
if (errno == ENOENT) {
/* this happens if the target directory doesn't exist */
fprintf(stderr,
"acp: cannot create '%s': %s\n", dst, strerror(errno));
(void) close(srcFd);
return -1;
}
/* if "force" is set, try removing the destination file and retry */
if (options & COPY_FORCE) {
if (unlink(dst) != 0) {
#ifdef HAVE_MS_C_RUNTIME
/* MSVCRT.DLL unlink will fail with EACCESS if the file is set read-only */
/* so try to change its mode, and unlink again */
if (errno == EACCESS) {
if (chmod(dst, S_IWRITE|S_IREAD) == 0 && unlink(dst) == 0)
goto Open_File;
}
#endif
fprintf(stderr, "acp: unable to remove '%s': %s\n",
dst, strerror(errno));
(void) close(srcFd);
return -1;
}
#ifdef HAVE_MS_C_RUNTIME
Open_File:
#endif
dstFd = open(dst, O_CREAT | O_TRUNC | O_WRONLY | O_BINARY, 0644);
}
}
if (dstFd < 0) {
fprintf(stderr, "acp: unable to open '%s': %s\n",
dst, strerror(errno));
(void) close(srcFd);
return -1;
}
copyResult = copyFileContents(dst, dstFd, src, srcFd);
(void) close(srcFd);
(void) close(dstFd);
if (copyResult != 0)
return -1;
#ifdef MACOSX_RSRC
{
char* srcRsrcName = NULL;
char* dstRsrcName = NULL;
struct stat rsrcStat;
srcRsrcName = malloc(strlen(src) + 5 + 1);
strcpy(srcRsrcName, src);
strcat(srcRsrcName, "/rsrc");
dstRsrcName = malloc(strlen(dst) + 5 + 1);
strcpy(dstRsrcName, dst);
strcat(dstRsrcName, "/rsrc");
if (stat(srcRsrcName, &rsrcStat) == 0 && rsrcStat.st_size > 0) {
DBUG(("--- RSRC: %s --> %s\n", srcRsrcName, dstRsrcName));
srcFd = open(srcRsrcName, O_RDONLY);
dstFd = open(dstRsrcName, O_TRUNC | O_WRONLY, 0);
copyResult = -1;
if (srcFd >= 0 && dstFd >= 0) {
copyResult = copyFileContents(dstRsrcName, dstFd,
srcRsrcName, srcFd);
(void) close(srcFd);
(void) close(dstFd);
}
if (copyResult != 0)
return -1;
}
free(srcRsrcName);
free(dstRsrcName);
}
#endif
setPermissions(dst, pSrcStat, options);
printCopyMsg(src, dst, options);
return 0;
}
