void
SVNListBase::RefreshContent()
{
if (itsProcess != NULL)
{
JProcess* p = itsProcess;
itsProcess = NULL;
p->Kill();
delete p;
DeleteLinks();
}
else
{
itsSavedSelection->CleanOut();
JTableSelection& s = GetTableSelection();
JTableSelectionIterator iter(&s);
JPoint cell;
while (iter.Next(&cell))
{
const JString* line = itsLineList->NthElement(cell.y);
itsSavedSelection->InsertSorted(new JString(ExtractRelativePath(*line)));
}
}
itsDisplayState = SaveDisplayState();
itsLineList->CleanOut();
int outFD, errFD;
JError err = JNoError();
if ((GetDirector())->HasPath())
{
err = JProcess::Create(&itsProcess, GetPath(), itsCmd,
kJIgnoreConnection, NULL,
kJCreatePipe, &outFD,
kJCreatePipe, &errFD);
}
else // working with URL
{
err = JProcess::Create(&itsProcess, itsCmd,
kJIgnoreConnection, NULL,
kJCreatePipe, &outFD,
kJCreatePipe, &errFD);
}
if (err.OK())
{
itsProcess->ShouldDeleteWhenFinished();
ListenTo(itsProcess);
(GetDirector())->RegisterActionProcess(this, itsProcess, itsRefreshRepoFlag,
itsRefreshStatusFlag, itsReloadOpenFilesFlag);
SetConnection(outFD, errFD);
}
else
{
err.ReportIfError();
}
}
JError
JXImage::WriteXPM
(
const JCharacter* fileName
)
const
{
#ifdef _J_HAS_XPM
XpmAttributes attr;
attr.valuemask = XpmColormap;
attr.colormap = itsXColormap->GetXColormap();
int xpmErr;
if (itsImage != NULL)
{
XImage* mask_image = NULL;
if (itsMask != NULL)
{
itsMask->ConvertToImage();
mask_image = ((JXImage*) itsMask)->itsImage;
}
xpmErr = XpmWriteFileFromImage(*itsDisplay, const_cast<JCharacter*>(fileName),
itsImage, mask_image, &attr);
}
else
{
assert( itsPixmap != None );
Pixmap mask_pixmap = None;
if (itsMask != NULL)
{
itsMask->ConvertToPixmap();
mask_pixmap = ((JXImage*) itsMask)->itsPixmap;
}
xpmErr = XpmWriteFileFromPixmap(*itsDisplay, const_cast<JCharacter*>(fileName),
itsPixmap, mask_pixmap, &attr);
}
if (xpmErr == XpmOpenFailed)
{
return JAccessDenied(fileName);
}
else if (xpmErr == XpmNoMemory)
{
return JNoProcessMemory();
}
else
{
return JNoError();
}
#else
return XPMNotAvailable();
#endif
}
JError
JSendSignalToProcess
(
const pid_t pid,
const int signal
)
{
jclear_errno();
if (ACE_OS::kill(pid, signal) == 0)
{
return JNoError();
}
const int err = jerrno();
if (err == EINVAL)
{
return JInvalidSignal();
}
else if (err == ESRCH)
{
return JInvalidProcess();
}
else if (err == EPERM)
{
return JCanNotSignalProcess();
}
else
{
return JUnexpectedError(err);
}
}
JError
JCreatePipe
(
int fd[2]
)
{
jclear_errno();
if (pipe(fd) == 0)
{
return JNoError();
}
const int err = jerrno();
if (err == EFAULT)
{
return JSegFault();
}
else if (err == EMFILE || err == ENFILE)
{
return JTooManyDescriptorsOpen();
}
else
{
return JUnexpectedError(err);
}
}
JError
JGetFileLength
(
const JCharacter* name,
JSize* size
)
{
ACE_stat info;
if (ACE_OS::stat(name, &info) == 0)
{
*size = info.st_size;
return JNoError();
}
*size = 0;
const int err = jerrno();
if (err == ENOENT)
{
return JDirEntryDoesNotExist(name);
}
else
{
return JUnexpectedError(err);
}
}
JError
JDirInfo::GoUp()
{
JString theCWD = *itsCWD;
// strip trailing slashes
JStripTrailingDirSeparator(&theCWD);
if (JIsRootDirectory(theCWD))
{
return JNoError();
}
// change directory
JString newCWD, name;
if (JSplitPathAndName(theCWD, &newCWD, &name))
{
return GoTo(newCWD);
}
else
{
return JBadPath(theCWD);
}
}
JError
JDirInfo::GoTo
(
const JCharacter* origDirName
)
{
JString dirName;
if (JStringEmpty(origDirName) ||
!JConvertToAbsolutePath(origDirName, NULL, &dirName))
{
return JBadPath(origDirName);
}
if (JSameDirEntry(dirName, *itsCWD))
{
Update();
return JNoError();
}
JAppendDirSeparator(&dirName);
const JString origCWD = *itsCWD;
*itsCWD = dirName;
const JError err = BuildInfo();
if (err.OK())
{
Broadcast(PathChanged());
}
else
{
*itsCWD = origCWD;
}
return err;
}
JError
JGetPermissions
(
const JCharacter* name,
mode_t* perms
)
{
ACE_stat info;
if (ACE_OS::stat(name, &info) == 0)
{
*perms = info.st_mode;
return JNoError();
}
*perms = 0;
const int err = jerrno();
if (err == ENOENT)
{
return JDirEntryDoesNotExist(name);
}
else
{
return JUnexpectedError(err);
}
}
JError
JGetOwnerGroup
(
const JCharacter* name,
gid_t* gid
)
{
ACE_stat info;
if (ACE_OS::stat(name, &info) == 0)
{
*gid = info.st_gid;
return JNoError();
}
*gid = 0;
const int err = jerrno();
if (err == ENOENT)
{
return JDirEntryDoesNotExist(name);
}
else
{
return JUnexpectedError(err);
}
}
JError
JGetModificationTime
(
const JCharacter* name,
time_t* modTime
)
{
ACE_stat info;
if (ACE_OS::stat(name, &info) == 0)
{
*modTime = info.st_mtime;
return JNoError();
}
*modTime = 0;
const int err = jerrno();
if (err == ENOENT)
{
return JDirEntryDoesNotExist(name);
}
else
{
return JUnexpectedError(err);
}
}
JError
JCreateDirectory
(
const JCharacter* dirName,
const mode_t mode
)
{
if (JDirectoryExists(dirName))
{
return JSetPermissions(dirName, mode);
}
JString path = dirName;
JCleanPath(&path);
JAppendDirSeparator(&path);
JString dir;
JIndex slashIndex = 2;
while (path.LocateNextSubstring("/", &slashIndex))
{
dir = path.GetSubstring(1, slashIndex);
if (!JDirectoryExists(dir))
{
const JError err = JMkDir(dir, mode);
if (!err.OK())
{
return err;
}
}
slashIndex++; // move past the slash we found
}
return JNoError();
}
JError
JMkDir
(
const JCharacter* dirName,
const mode_t mode
)
{
jclear_errno();
if (mkdir(dirName, mode) == 0)
{
return JNoError();
}
const int err = jerrno();
if (err == EEXIST)
{
return JDirEntryAlreadyExists(dirName);
}
else if (err == EFAULT)
{
return JSegFault();
}
else if (err == EACCES)
{
return JAccessDenied(dirName);
}
else if (err == ENAMETOOLONG)
{
return JNameTooLong();
}
else if (err == ENOENT)
{
return JBadPath(dirName);
}
else if (err == ENOTDIR)
{
return JComponentNotDirectory(dirName);
}
else if (err == ENOMEM)
{
return JNoKernelMemory();
}
else if (err == EROFS)
{
return JFileSystemReadOnly();
}
else if (err == ELOOP)
{
return JPathContainsLoop(dirName);
}
else if (err == ENOSPC)
{
return JFileSystemFull();
}
else
{
return JUnexpectedError(err);
}
}
JError
JGetSymbolicLinkTarget
(
const char* linkFullName,
JString* targetFullName
)
{
const JSize kBufferSize = 10000;
char buf[ kBufferSize ];
const long linkNameSize = readlink(linkFullName, buf, kBufferSize-1);
if (linkNameSize != -1)
{
targetFullName->Set(buf, linkNameSize);
return JNoError();
}
targetFullName->Clear();
const int err = jerrno();
if (err == ENOTDIR)
{
return JComponentNotDirectory(linkFullName);
}
else if (err == ENAMETOOLONG)
{
return JNameTooLong();
}
else if (err == ENOENT)
{
return JDirEntryDoesNotExist(linkFullName);
}
else if (err == EPERM || err == EACCES)
{
return JAccessDenied(linkFullName);
}
else if (err == ELOOP)
{
return JTooManyLinks(linkFullName);
}
else if (err == EINVAL)
{
return JNotSymbolicLink(linkFullName);
}
else if (err == EIO)
{
return JGeneralIO();
}
else if (err == EFAULT)
{
return JSegFault();
}
else if (err == ENOMEM)
{
return JNoKernelMemory();
}
else
{
return JUnexpectedError(err);
}
}
JError
JRemoveDirectory
(
const JCharacter* dirName
)
{
jclear_errno();
if (rmdir(dirName) == 0)
{
return JNoError();
}
const int err = jerrno();
if (err == EPERM || err == EACCES)
{
return JAccessDenied(dirName);
}
else if (err == EFAULT)
{
return JSegFault();
}
else if (err == ENAMETOOLONG)
{
return JNameTooLong();
}
else if (err == ENOENT)
{
return JBadPath(dirName);
}
else if (err == ENOTDIR)
{
return JComponentNotDirectory(dirName);
}
else if (err == ENOTEMPTY)
{
return JDirectoryNotEmpty(dirName);
}
else if (err == EBUSY)
{
return JDirectoryBusy(dirName);
}
else if (err == ENOMEM)
{
return JNoKernelMemory();
}
else if (err == EROFS)
{
return JFileSystemReadOnly();
}
else if (err == ELOOP)
{
return JPathContainsLoop(dirName);
}
else
{
return JUnexpectedError(err);
}
}
JError
JCreateTempFile
(
const JCharacter* path,
const JCharacter* prefix,
JString* fullName
)
{
JString p;
if (!JStringEmpty(path))
{
p = path;
}
else if (!JGetTempDirectory(&p))
{
return JDirEntryDoesNotExist("/tmp");
}
if (!JStringEmpty(prefix))
{
p = JCombinePathAndName(p, prefix);
}
else
{
p = JCombinePathAndName(p, "temp_file_");
}
p += "XXXXXX";
char* s = p.AllocateCString();
jclear_errno();
int fd = mkstemp(s);
if (fd != -1)
{
close(fd);
*fullName = s;
delete [] s;
return JNoError();
}
fullName->Clear();
delete [] s;
// EINVAL counts as unexpected
const int err = jerrno();
if (err == EEXIST)
{
return JAccessDenied(p);
}
else
{
return JUnexpectedError(err);
}
}
JError
JDirInfo::BuildInfo()
{
if (!JDirectoryReadable(*itsCWD))
{
return JAccessDenied(*itsCWD);
}
const JString origDir = JGetCurrentDirectory();
JError err = JChangeDirectory(*itsCWD);
if (!err.OK())
{
return err;
}
// clear old information
itsDirEntries->CleanOut();
// update instance variables
JStripTrailingDirSeparator(itsCWD); // keep Windows happy
ACE_stat stbuf;
ACE_OS::stat(*itsCWD, &stbuf);
itsIsValidFlag = kJTrue;
itsIsWritableFlag = JDirectoryWritable(*itsCWD);
itsModTime = stbuf.st_mtime;
itsStatusTime = stbuf.st_ctime;
JAppendDirSeparator(itsCWD);
// process files in the directory
JLatentPG pg(itsContentRegex == NULL ? 100 : 10);
if (itsPG != NULL)
{
pg.SetPG(itsPG, kJFalse);
}
pg.VariableLengthProcessBeginning("Scanning directory...", kJTrue, kJFalse);
BuildInfo1(pg);
pg.ProcessFinished();
err = JChangeDirectory(origDir);
assert_ok( err );
ApplyFilters(kJFalse);
return JNoError();
}
JBoolean
SyGGetTrashDirectory
(
JString* path,
const JBoolean reportErrors
)
{
if (!theTrashDir.IsEmpty())
{
*path = theTrashDir;
return kJTrue;
}
if (!JGetPrefsDirectory(path))
{
if (reportErrors)
{
(JGetUserNotification())->ReportError(JGetString(kNoPrefsDirID));
}
return kJFalse;
}
*path = JCombinePathAndName(*path, kTrashDirName);
JError err = JNoError();
if (!JDirectoryExists(*path))
{
err = JCreateDirectory(*path, kTrashCanPerms);
}
else
{
err = JSetPermissions(*path, kTrashCanPerms);
}
if (err.OK())
{
theTrashDir = *path;
const JBoolean ok = JDirInfo::Create(theTrashDir, &theTrashDirInfo);
assert( ok );
return kJTrue;
}
else
{
path->Clear();
if (reportErrors)
{
(JGetStringManager())->ReportError(kCreateTrashErrorID, err);
}
return kJFalse;
}
}
JError
JSetPermissions
(
const JCharacter* name,
const mode_t perms
)
{
jclear_errno();
if (chmod(name, perms) == 0)
{
return JNoError();
}
const int err = jerrno();
if (err == EPERM || err == EACCES)
{
return JAccessDenied(name);
}
else if (err == EROFS)
{
return JFileSystemReadOnly();
}
else if (err == EFAULT)
{
return JSegFault();
}
else if (err == ENAMETOOLONG)
{
return JNameTooLong();
}
else if (err == ENOENT)
{
return JDirEntryDoesNotExist(name);
}
else if (err == ENOMEM)
{
return JNoKernelMemory();
}
else if (err == ENOTDIR)
{
return JComponentNotDirectory(name);
}
else if (err == ELOOP)
{
return JPathContainsLoop(name);
}
else
{
return JUnexpectedError(err);
}
}
JError
JRemoveFile
(
const JCharacter* fileName
)
{
jclear_errno();
if (remove(fileName) == 0)
{
return JNoError();
}
const int err = jerrno();
if (err == EFAULT)
{
return JSegFault();
}
else if (err == EACCES || err == EPERM)
{
return JAccessDenied(fileName);
}
else if (err == ENAMETOOLONG)
{
return JNameTooLong();
}
else if (err == ENOENT)
{
return JBadPath(fileName);
}
else if (err == ENOTDIR)
{
return JComponentNotDirectory(fileName);
}
else if (err == EISDIR)
{
return JTriedToRemoveDirectory();
}
else if (err == ENOMEM)
{
return JNoKernelMemory();
}
else if (err == EROFS)
{
return JFileSystemReadOnly();
}
else
{
return JUnexpectedError(err);
}
}
JBoolean
SyGGetRecentFileDirectory
(
JString* path,
const JBoolean reportErrors
)
{
if (!theRecentFileDir.IsEmpty())
{
*path = theRecentFileDir;
return kJTrue;
}
if (!JGetPrefsDirectory(path))
{
if (reportErrors)
{
(JGetUserNotification())->ReportError(JGetString(kNoPrefsDirID));
}
return kJFalse;
}
*path = JCombinePathAndName(*path, kRecentFileDirName);
JError err = JNoError();
if (!JDirectoryExists(*path))
{
err = JCreateDirectory(*path, kRecentFileDirPerms);
}
else
{
err = JSetPermissions(*path, kRecentFileDirPerms);
}
if (err.OK())
{
theRecentFileDir = *path;
return kJTrue;
}
else
{
path->Clear();
if (reportErrors)
{
(JGetStringManager())->ReportError(kCreateRecentFileDirErrorID, err);
}
return kJFalse;
}
}
JError
JChangeDirectory
(
const JCharacter* dirName
)
{
jclear_errno();
if (chdir(dirName) == 0)
{
return JNoError();
}
const int err = jerrno();
if (err == EPERM || err == EACCES)
{
return JAccessDenied(dirName);
}
else if (err == EFAULT)
{
return JSegFault();
}
else if (err == ENAMETOOLONG)
{
return JNameTooLong();
}
else if (err == ENOENT)
{
return JBadPath(dirName);
}
else if (err == ENOMEM)
{
return JNoKernelMemory();
}
else if (err == ENOTDIR)
{
return JComponentNotDirectory(dirName);
}
else if (err == ELOOP)
{
return JPathContainsLoop(dirName);
}
else
{
return JUnexpectedError(err);
}
}
JError
JWaitForChild
(
const pid_t pid,
ACE_exitcode* status
)
{
int err;
do
{
jclear_errno();
ACE_OS::waitpid(pid, status, 0);
err = jerrno();
}
while (err == EINTR);
return JNoError();
}
JError
JDirInfo::SetContentFilter
(
const JCharacter* regexStr
)
{
if (itsContentRegex != NULL && regexStr == itsContentRegex->GetPattern())
{
return JNoError();
}
JBoolean hadFilter = kJTrue;
JString prevPattern;
if (itsContentRegex == NULL)
{
hadFilter = kJFalse;
itsContentRegex = new JRegex;
assert( itsContentRegex != NULL );
itsContentRegex->SetSingleLine();
}
else
{
prevPattern = itsContentRegex->GetPattern();
}
JError err = itsContentRegex->SetPattern(regexStr);
if (err.OK())
{
ForceUpdate();
Broadcast(SettingsChanged());
}
else if (hadFilter)
{
err = itsContentRegex->SetPattern(prevPattern);
assert_ok( err );
}
else
{
delete itsContentRegex;
itsContentRegex = NULL;
}
return err;
}
JError
JWaitForChild
(
const JBoolean block,
pid_t* pid,
ACE_exitcode* status
)
{
int err;
do
{
jclear_errno();
*pid = ACE_OS::waitpid(-1, status, (block ? 0 : WNOHANG));
err = jerrno();
}
while (err == EINTR);
return JNoError();
}
JError
JCreatePipe
(
int fd[2]
)
{
jclear_errno();
if (_pipe(fd, 4096, _O_BINARY) == 0)
{
return JNoError();
}
const int err = jerrno();
if (err == EMFILE || err == ENFILE)
{
return JTooManyDescriptorsOpen();
}
else
{
return JUnexpectedError(err);
}
}
JError
CBSymbolTable::SetNameFilter
(
const JCharacter* filterStr,
const JBoolean isRegex
)
{
delete itsNameFilter;
itsNameFilter = NULL;
delete itsNameLiteral;
itsNameLiteral = NULL;
JError result = JNoError();
if (isRegex)
{
itsNameFilter = new JRegex;
assert( itsNameFilter != NULL );
result = itsNameFilter->SetPattern(filterStr);
if (!result.OK())
{
delete itsNameFilter;
itsNameFilter = NULL;
}
}
else
{
itsNameLiteral = new JString(filterStr);
assert( itsNameLiteral != NULL );
}
itsVisibleListLockedFlag = kJFalse;
ScrollTo(0,0);
RebuildTable();
return result;
}
JError
JCreateTempDirectory
(
const JCharacter* path,
const JCharacter* prefix,
JString* fullName
)
{
JString p;
if (!JStringEmpty(path))
{
p = path;
}
else if (!JGetTempDirectory(&p))
{
return JDirEntryDoesNotExist("/tmp");
}
if (!JStringEmpty(prefix))
{
p = JCombinePathAndName(p, prefix);
}
else
{
p = JCombinePathAndName(p, "temp_dir_");
}
p += "XXXXXX";
char* s = p.AllocateCString();
jclear_errno();
char* d = mkdtemp(s);
if (d != NULL)
{
*fullName = s;
JAppendDirSeparator(fullName);
delete [] s;
return JNoError();
}
fullName->Clear();
delete [] s;
// EINVAL counts as unexpected
const int err = jerrno();
if (err == EEXIST)
{
return JDirEntryAlreadyExists(p);
}
else if (err == EFAULT)
{
return JSegFault();
}
else if (err == EACCES)
{
return JAccessDenied(p);
}
else if (err == ENAMETOOLONG)
{
return JNameTooLong();
}
else if (err == ENOENT)
{
return JBadPath(p);
}
else if (err == ENOTDIR)
{
return JComponentNotDirectory(p);
}
else if (err == ENOMEM)
{
return JNoKernelMemory();
}
else if (err == EROFS)
{
return JFileSystemReadOnly();
}
else if (err == ELOOP)
{
return JPathContainsLoop(p);
}
else if (err == ENOSPC)
{
return JFileSystemFull();
}
else
{
return JUnexpectedError(err);
}
}
JError
JCreateSymbolicLink
(
const JCharacter* src,
const JCharacter* dest
)
{
jclear_errno();
if (symlink(src, dest) == 0)
{
return JNoError();
}
const int err = jerrno();
if (err == EPERM || err == EACCES)
{
return JAccessDenied(dest);
}
else if (err == EFAULT)
{
return JSegFault();
}
else if (err == ENAMETOOLONG)
{
return JNameTooLong();
}
else if (err == ENOENT)
{
return JBadPath(dest);
}
else if (err == ENOTDIR)
{
return JComponentNotDirectory(dest);
}
else if (err == ENOMEM)
{
return JNoKernelMemory();
}
else if (err == EROFS)
{
return JFileSystemReadOnly();
}
else if (err == EEXIST)
{
return JDirEntryAlreadyExists(dest);
}
else if (err == ELOOP)
{
return JPathContainsLoop(dest);
}
else if (err == ENOSPC)
{
return JFileSystemFull();
}
else if (err == EIO)
{
return JGeneralIO();
}
else
{
return JUnexpectedError(err);
}
}
JError
JXImage::CreateFromXPM
(
JXDisplay* display,
const JCharacter* fileName,
JXImage** image
)
{
#ifdef _J_HAS_XPM
JXColormap* colormap = display->GetColormap();
Pixmap image_pixmap = None;
Pixmap mask_pixmap = None;
XpmAttributes attr;
attr.valuemask = XpmVisual | XpmColormap | XpmDepth |
XpmExactColors | XpmCloseness |
XpmColorKey | XpmAllocCloseColors |
XpmReturnAllocPixels;
attr.visual = colormap->GetVisual();
attr.colormap = colormap->GetXColormap();
attr.depth = display->GetDepth();
attr.color_key = XPM_COLOR;
attr.alloc_pixels = NULL;
attr.nalloc_pixels = 0;
attr.alloc_close_colors = kJTrue; // so we can free all resulting pixels
attr.exactColors = 1;
attr.closeness = 0;
const int xpmErr =
XpmReadFileToPixmap(*display, display->GetRootWindow(),
const_cast<JCharacter*>(fileName),
&image_pixmap, &mask_pixmap, &attr);
if (xpmErr == XpmOpenFailed && JFileExists(fileName))
{
return JAccessDenied(fileName);
}
else if (xpmErr == XpmOpenFailed)
{
return JDirEntryDoesNotExist(fileName);
}
else if (xpmErr == XpmFileInvalid)
{
return FileIsNotXPM(fileName);
}
else if (xpmErr == XpmNoMemory)
{
return JNoProcessMemory();
}
else if (xpmErr == XpmColorFailed || xpmErr == XpmColorError)
{
if (image_pixmap != None)
{
XFreePixmap(*display, image_pixmap);
}
if (mask_pixmap != None)
{
XFreePixmap(*display, mask_pixmap);
}
if (attr.alloc_pixels != NULL)
{
XFreeColors(*display, attr.colormap, attr.alloc_pixels, attr.nalloc_pixels, 0);
}
XpmFreeAttributes(&attr);
return TooManyColors();
}
// create image and mask
*image = new JXImage(display, image_pixmap);
assert( *image != NULL );
XFreePixmap(*display, image_pixmap);
if (mask_pixmap != None)
{
JXImageMask* mask = new JXImageMask(display, mask_pixmap);
assert( mask != NULL );
(**image).SetMask(mask);
XFreePixmap(*display, mask_pixmap);
}
// free pixels so X has usage count of 1
XFreeColors(*display, attr.colormap, attr.alloc_pixels, attr.nalloc_pixels, 0);
// clean up
XpmFreeAttributes(&attr);
return JNoError();
#else
return XPMNotAvailable();
#endif
}
JError
JRenameDirEntry
(
const JCharacter* oldName,
const JCharacter* newName
)
{
if (JNameUsed(newName))
{
return JDirEntryAlreadyExists(newName);
}
else if (JSameDirEntry(oldName, newName))
{
return JNoError();
}
jclear_errno();
if (rename(oldName, newName) == 0)
{
return JNoError();
}
const int err = jerrno();
if (err == EISDIR)
{
return JCantRenameFileToDirectory(oldName, newName);
}
else if (err == EXDEV)
{
return JCantRenameAcrossFilesystems();
}
else if (err == ENOTEMPTY)
{
return JCantRenameToNonemptyDirectory();
}
else if (err == EEXIST)
{
return JDirEntryAlreadyExists(newName);
}
else if (err == EBUSY)
{
return JFileBusy(newName);
}
else if (err == EINVAL)
{
return JDirectoryCantBeOwnChild();
}
else if (err == EMLINK)
{
return JTooManyLinks(oldName);
}
else if (err == ENOTDIR)
{
return JComponentNotDirectory(oldName, newName);
}
else if (err == EFAULT)
{
return JSegFault();
}
else if (err == EACCES || err == EPERM)
{
return JAccessDenied(oldName, newName);
}
else if (err == ENAMETOOLONG)
{
return JNameTooLong();
}
else if (err == ENOENT)
{
return JBadPath(oldName, newName);
}
else if (err == ENOMEM)
{
return JNoKernelMemory();
}
else if (err == EROFS)
{
return JFileSystemReadOnly();
}
else if (err == ELOOP)
{
return JPathContainsLoop(oldName, newName);
}
else if (err == ENOSPC)
{
return JFileSystemFull();
}
else
{
return JUnexpectedError(err);
}
}
