hg/stx-libbasic: comparison UnixOperatingSystem.st

equal deleted inserted replaced

-:757c038e8a90
+:ca342ae94cb7
 "create a new directory with name 'aPathName', which may be an absolute
 path, or relative to the current directory.
 Return true if successful (or the directory existed already), false if failed.
 This is a low-level entry - use Filename protocol for compatibility."
+|encodedPathName|
+encodedPathName := self encodePath:aPathName.
 %{
-if (__isStringLike(aPathName) && __isSmallInteger(umask)) {
+if (__isStringLike(encodedPathName) && __isSmallInteger(umask)) {
-	if (mkdir(__stringVal(aPathName), __smallIntegerVal(umask)) >= 0) {
+if (mkdir(__stringVal(encodedPathName), __smallIntegerVal(umask)) >= 0) {
-	    RETURN(true);
+RETURN(true);
-	}
+}
-	@global(LastErrorNumber) = __mkSmallInteger(errno);
+@global(LastErrorNumber) = __mkSmallInteger(errno);
 }
 %}.
 "/ could not create - if it already existed this is ok
 (self isDirectory:aPathName) ifTrue:[^ true].
 createHardLinkFrom:oldPath to:newPath
 "link the file 'oldPath' to 'newPath'. The link will be a hard link.
 Return true if successful, false if not."
+|encodedOldPathName encodedNewPathName|
+encodedOldPathName := self encodePath:oldPath.
+encodedNewPathName := self encodePath:newPath.
 %{
 int ret;
-if (__isStringLike(oldPath) && __isStringLike(newPath)) {
+if (__isStringLike(encodedOldPathName) && __isStringLike(encodedNewPathName)) {
-	__BEGIN_INTERRUPTABLE__
+__BEGIN_INTERRUPTABLE__
-	do {
+do {
-	    ret = link((char *) __stringVal(oldPath), (char *) __stringVal(newPath));
+ret = link((char *) __stringVal(encodedOldPathName), (char *) __stringVal(encodedNewPathName));
-	} while (ret < 0 && errno == EINTR);
+} while (ret < 0 && errno == EINTR);
-	__END_INTERRUPTABLE__
+__END_INTERRUPTABLE__
-	if (ret < 0) {
+if (ret < 0) {
-	    @global(LastErrorNumber) = __mkSmallInteger(errno);
+@global(LastErrorNumber) = __mkSmallInteger(errno);
-	    RETURN ( false );
+RETURN ( false );
-	}
+}
-	RETURN (true);
+RETURN (true);
 }
 %}.
 "/
 "/ bad argument(s) given
 "/
 createSymbolicLinkFrom:oldPath to:newPath
 "make a symbolic link for 'newPath' to the file 'oldPath'.
 The link will be a soft (symbolic) link.
 Return true if successful, false if not."
+|encodedOldPathName encodedNewPathName|
+encodedOldPathName := self encodePath:oldPath.
+encodedNewPathName := self encodePath:newPath.
 %{
 #ifdef S_IFLNK
 int ret;
-if (__isStringLike(oldPath) && __isStringLike(newPath)) {
+if (__isStringLike(encodedOldPathName) && __isStringLike(encodedNewPathName)) {
-	__BEGIN_INTERRUPTABLE__
+__BEGIN_INTERRUPTABLE__
-	do {
+do {
-	    ret = symlink((char *) __stringVal(oldPath), (char *) __stringVal(newPath));
+ret = symlink((char *) __stringVal(encodedOldPathName), (char *) __stringVal(encodedNewPathName));
-	} while (ret < 0 && errno == EINTR);
+} while (ret < 0 && errno == EINTR);
-	__END_INTERRUPTABLE__
+__END_INTERRUPTABLE__
-	if (ret < 0) {
+if (ret < 0) {
-	    @global(LastErrorNumber) = __mkSmallInteger(errno);
+@global(LastErrorNumber) = __mkSmallInteger(errno);
-	    RETURN ( false );
+RETURN ( false );
-	}
+}
-	RETURN (true);
+RETURN (true);
 }
 #endif
 %}.
-(oldPath isString not or:[newPath isString not]) ifTrue:[
+(encodedOldPathName isString not or:[encodedNewPathName isString not]) ifTrue:[
-	"/
+"/
-	"/ bad argument(s) given
+"/ bad argument(s) given
-	"/
+"/
-	^ self primitiveFailed
+^ self primitiveFailed
 ].
 "/
 "/ this Unix does not seem to support symbolic links
 "/
 open:path attributes:attributes mode:modeInteger
 "open a file, return an os specific fileHandle.
 openmode is a symbol defining the way to open
 valid modes are:
-	#O_RDONLY
+#O_RDONLY
-	#O_RDWR
+#O_RDWR
-	#O_WRONLY
+#O_WRONLY
-	#O_CREAT
+#O_CREAT
-	#O_APPEND
+#O_APPEND
-	#O_SYNC
+#O_SYNC
-	#O_LARGEFILE
+#O_LARGEFILE
 This is a private entry, but maybe useful to open/create a file in a special mode,
 which is proprietrary to the operatingSystem."
-|error fileDescriptor|
+|error fileDescriptor encodedPathName|
+encodedPathName := self encodePath:path.
 %{
 OBJ *ap;
 int nAttributes;
 int fd;
 int mode, openFlags = 0;
 int n;
-if (!__isStringLike(path)) {
+if (!__isStringLike(encodedPathName)) {
-	error = @symbol(badArgument1);
+error = @symbol(badArgument1);
-	goto err;
+goto err;
 }
 if (!__isArrayLike(attributes)) {
-	error = @symbol(badArgument2);
+error = @symbol(badArgument2);
-	goto err;
+goto err;
 }
 if (modeInteger == nil) {
-	mode = 0644;
+mode = 0644;
 } else if (__isSmallInteger(modeInteger)) {
-	mode = __intVal(modeInteger);
+mode = __intVal(modeInteger);
 } else {
-	error = @symbol(badArgument3);
+error = @symbol(badArgument3);
-	goto err;
+goto err;
 }
 nAttributes = __arraySize(attributes);
 for (n = 0, ap = __arrayVal(attributes); n < nAttributes; n++) {
-	OBJ attribute = ap[n];
+OBJ attribute = ap[n];
-	if (attribute == @symbol(O_RDONLY)) {
+if (attribute == @symbol(O_RDONLY)) {
-	    openFlags |= O_RDONLY;
+openFlags |= O_RDONLY;
-	} else if (attribute == @symbol(O_RDWR)) {
+} else if (attribute == @symbol(O_RDWR)) {
-	    openFlags |= O_RDWR;
+openFlags |= O_RDWR;
-	} else if (attribute == @symbol(O_WRONLY)) {
+} else if (attribute == @symbol(O_WRONLY)) {
-	    openFlags |= O_WRONLY;
+openFlags |= O_WRONLY;
-	} else if (attribute == @symbol(O_CREAT)) {
+} else if (attribute == @symbol(O_CREAT)) {
-	    openFlags |= O_CREAT;
+openFlags |= O_CREAT;
-	} else if (attribute == @symbol(O_APPEND)) {
+} else if (attribute == @symbol(O_APPEND)) {
-	    openFlags |= O_APPEND;
+openFlags |= O_APPEND;
-	} else if (attribute == @symbol(O_EXCL)) {
+} else if (attribute == @symbol(O_EXCL)) {
-	    openFlags |= O_EXCL;
+openFlags |= O_EXCL;
-	} else if (attribute == @symbol(O_TRUNC)) {
+} else if (attribute == @symbol(O_TRUNC)) {
-	    openFlags |= O_TRUNC;
+openFlags |= O_TRUNC;
-	} else if (attribute == @symbol(O_LARGEFILE)) {
+} else if (attribute == @symbol(O_LARGEFILE)) {
 #ifdef O_LARGEFILE
-	    openFlags |= O_LARGEFILE;
+openFlags |= O_LARGEFILE;
 #else
-	    error = @symbol(badArgument2);
+error = @symbol(badArgument2);
-	    goto err;
+goto err;
 #endif
-	} else if (attribute == @symbol(O_SYNC)) {
+} else if (attribute == @symbol(O_SYNC)) {
 #ifdef O_SYNC
-	    openFlags |= O_SYNC;
+openFlags |= O_SYNC;
 #else
-	    error = @symbol(badArgument2);
+error = @symbol(badArgument2);
-	    goto err;
+goto err;
 #endif
-	}
+}
 }
 #if defined(O_NONBLOCK)
 openFlags |= O_NONBLOCK;
 #elif defined(O_NDELAY)
 openFlags |= O_NDELAY;
 #endif
 again:
-fd = open((char *) __stringVal(path), openFlags, mode);
+fd = open((char *) __stringVal(encodedPathName), openFlags, mode);
 if (fd < 0) {
-	if (errno == EINTR) {
+if (errno == EINTR) {
-	    __HANDLE_INTERRUPTS__;
+__HANDLE_INTERRUPTS__;
-	    goto again;
+goto again;
-	} else {
+} else {
-	    error = __mkSmallInteger(errno);
+error = __mkSmallInteger(errno);
-	    goto err;
+goto err;
-	}
+}
 }
 fileDescriptor = __mkSmallInteger(fd);
 err:;
 %}.
 ^ fileDescriptor notNil ifTrue:[
-	FileDescriptorHandle for:fileDescriptor.
+FileDescriptorHandle for:fileDescriptor.
 ] ifFalse:[
-	(self errorHolderForNumber:error) reportError
+(self errorHolderForNumber:error) reportError
 ].
 "
-	self open:'/etc/hosts' attributes:#(O_RDONLY) mode:nil
+self open:'/etc/hosts' attributes:#(O_RDONLY) mode:nil
-	self open:'/tmp/xxzz' attributes:#(O_RDWR O_CREAT) mode:8r611
+self open:'/tmp/xxzz' attributes:#(O_RDWR O_CREAT) mode:8r611
-	self open:'/etc/passwd' attributes:#(O_RDWR) mode:nil
+self open:'/etc/passwd' attributes:#(O_RDWR) mode:nil
-	self open:'/no one knows this file' attributes:#(O_RDONLY) mode:nil
+self open:'/no one knows this file' attributes:#(O_RDONLY) mode:nil
-	self open:'foo/bar/baz' attributes:#(O_RDWR O_CREAT) mode:nil
+self open:'foo/bar/baz' attributes:#(O_RDWR O_CREAT) mode:nil
 "
 !
 openFileForAppend:pathName
 "remove the directory named 'fullPathName'.
 The directory must be empty and you must have appropriate access rights.
 Return true if successful, false if directory is not empty or no permission.
 This is a lowLevel entry - use Filename protocol for compatibility."
+|encodedPathName|
+encodedPathName := self encodePath:fullPathName.
 %{
 int ret;
-if (__isStringLike(fullPathName)) {
+if (__isStringLike(encodedPathName)) {
-	__BEGIN_INTERRUPTABLE__
+__BEGIN_INTERRUPTABLE__
-	do {
+do {
-	    ret = rmdir((char *) __stringVal(fullPathName));
+ret = rmdir((char *) __stringVal(encodedPathName));
-	} while (ret < 0 && errno == EINTR);
+} while (ret < 0 && errno == EINTR);
-	__END_INTERRUPTABLE__
+__END_INTERRUPTABLE__
-	if (ret < 0) {
+if (ret < 0) {
-	    @global(LastErrorNumber) = __mkSmallInteger(errno);
+@global(LastErrorNumber) = __mkSmallInteger(errno);
-	    RETURN ( false );
+RETURN ( false );
-	}
+}
-	RETURN (true);
+RETURN (true);
 }
 %}.
 "/
 "/ either not a string argument,
 "/ or not supported by OS
 removeFile:fullPathName
 "remove the file named 'fullPathName'; return true if successful.
 This is a lowLevel entry - use Filename protocol for compatibility."
+|encodedPathName|
+encodedPathName := self encodePath:fullPathName.
 %{
 int ret;
-if (__isStringLike(fullPathName)) {
+if (__isStringLike(encodedPathName)) {
-	__BEGIN_INTERRUPTABLE__
+__BEGIN_INTERRUPTABLE__
-	do {
+do {
-	    ret = unlink((char *) __stringVal(fullPathName));
+ret = unlink((char *) __stringVal(encodedPathName));
-	} while (ret < 0 && errno == EINTR);
+} while (ret < 0 && errno == EINTR);
-	__END_INTERRUPTABLE__
+__END_INTERRUPTABLE__
-	if (ret < 0) {
+if (ret < 0) {
-	    @global(LastErrorNumber) = __mkSmallInteger(errno);
+@global(LastErrorNumber) = __mkSmallInteger(errno);
-	    RETURN ( false );
+RETURN ( false );
-	}
+}
-	RETURN (true);
+RETURN (true);
 }
 %}.
 ^ self primitiveFailed
 !
 correct for the OS used - therefore, this should not be called
 directly. Instead, use Filename protocol to rename; this cares for
 any invalid names.
 Returns true if successful, false if not"
+|encodedOldPathName encodedNewPathName|
+encodedOldPathName := self encodePath:oldPath.
+encodedNewPathName := self encodePath:newPath.
 %{
 int ret, eno;
-if (__isStringLike(oldPath) && __isStringLike(newPath)) {
+if (__isStringLike(encodedOldPathName) && __isStringLike(encodedNewPathName)) {
 #if defined(HAS_RENAME)
-	__BEGIN_INTERRUPTABLE__
+__BEGIN_INTERRUPTABLE__
-	do {
+do {
-	    ret = rename((char *) __stringVal(oldPath), (char *) __stringVal(newPath));
+ret = rename((char *) __stringVal(encodedOldPathName), (char *) __stringVal(encodedNewPathName));
-	} while (ret < 0 && errno == EINTR);
+} while (ret < 0 && errno == EINTR);
-	__END_INTERRUPTABLE__
+__END_INTERRUPTABLE__
 #else
-	ret = link((char *) __stringVal(oldPath), (char *) __stringVal(newPath));
+ret = link((char *) __stringVal(encodedOldPathName), (char *) __stringVal(encodedNewPathName));
-	if (ret >= 0) {
+if (ret >= 0) {
-	    ret = unlink((char *) __stringVal(oldPath));
+ret = unlink((char *) __stringVal(encodedOldPathName));
-	    if (ret < 0) {
+if (ret < 0) {
-		eno = errno;
+eno = errno;
-		unlink((char *) __stringVal(newPath));
+unlink((char *) __stringVal(encodedNewPathName));
-		errno = eno;
+errno = eno;
-	    }
+}
-	}
+}
 #endif
-	if (ret < 0) {
+if (ret < 0) {
-	    @global(LastErrorNumber) = __mkSmallInteger(errno);
+@global(LastErrorNumber) = __mkSmallInteger(errno);
-	    RETURN ( false );
+RETURN ( false );
-	}
+}
-	RETURN (true);
+RETURN (true);
 }
 %}.
 ^ self primitiveFailed
 "
 truncateFile:aPathName to:newSize
 "change a files size return true on success, false on failure.
 This may not be supported on all architectures.
 This is a low-level entry - use Filename protocol."
+|encodedPathName|
+encodedPathName := self encodePath:aPathName.
 %{
 #if defined(HAS_TRUNCATE) || defined(HAS_FTRUNCATE)
 int ret;
 off_t truncateSize;
-if (!__isStringLike(aPathName))
+if (!__isStringLike(encodedPathName))
-	goto getOutOfHere;
+goto getOutOfHere;
 if (__isSmallInteger(newSize)) {
-	truncateSize = __intVal(newSize);
+truncateSize = __intVal(newSize);
-	if (truncateSize < 0) {
+if (truncateSize < 0) {
-	    goto getOutOfHere;
+goto getOutOfHere;
-	}
+}
 } else {
-	truncateSize = __signedLongIntVal(newSize);
+truncateSize = __signedLongIntVal(newSize);
-	if (truncateSize < 0) {
+if (truncateSize < 0) {
-	    goto getOutOfHere;
+goto getOutOfHere;
-	}
+}
-	if (truncateSize == 0) {
+if (truncateSize == 0) {
-	    if (sizeof(truncateSize) == 8) {
+if (sizeof(truncateSize) == 8) {
-		if (__signedLong64IntVal(newSize, &truncateSize) == 0 || truncateSize < 0) {
+if (__signedLong64IntVal(newSize, &truncateSize) == 0 || truncateSize < 0) {
-		    goto getOutOfHere;
+goto getOutOfHere;
-		}
+}
-	    } else {
+} else {
-		goto getOutOfHere;
+goto getOutOfHere;
-	    }
+}
-	}
+}
 }
 #if defined(HAS_TRUNCATE)
-	__BEGIN_INTERRUPTABLE__
+__BEGIN_INTERRUPTABLE__
-	do {
+do {
-	    ret = truncate((char *) __stringVal(aPathName), truncateSize);
+ret = truncate((char *) __stringVal(encodedPathName), truncateSize);
-	} while (ret < 0 && errno == EINTR);
+} while (ret < 0 && errno == EINTR);
-	__END_INTERRUPTABLE__
+__END_INTERRUPTABLE__
 #else
 # ifdef HAS_FTRUNCATE
 {
-	int fd;
+int fd;
-	do {
+do {
-	    fd = open((char *) __stringVal(aPathName), 2);
+fd = open((char *) __stringVal(encodedPathName), 2);
-	} while (fd < 0 && errno == EINTR);
+} while (fd < 0 && errno == EINTR);
-	if (fd < 0) {
+if (fd < 0) {
-	    @global(LastErrorNumber) = __mkSmallInteger(errno);
+@global(LastErrorNumber) = __mkSmallInteger(errno);
-	    RETURN ( false );
+RETURN ( false );
-	}
+}
-	ret = ftruncate(fd, truncateSize);
+ret = ftruncate(fd, truncateSize);
-	close(fd);
+close(fd);
 }
 # endif /* HAS_FTRUNCATE */
 #endif
 if (ret < 0) {
-	@global(LastErrorNumber) = __mkSmallInteger(errno);
+@global(LastErrorNumber) = __mkSmallInteger(errno);
-	RETURN ( false );
+RETURN ( false );
 }
 RETURN (true);
 getOutOfHere:;
 #endif
 %}.
 Notice that the returned number is OS dependent - use the
 modeMasks as returned by OperatingSystem>>accessMaskFor:"
 "
 this could have been implemented as:
-	(self infoOf:aPathName) at:#mode
+(self infoOf:aPathName) at:#mode
 but for huge directory searches the code below is faster
 "
+|encodedPathName|
+encodedPathName := self encodePath:aPathName.
 %{
 struct stat buf;
 int ret;
-if (__isStringLike(aPathName)) {
+if (__isStringLike(encodedPathName)) {
 # ifdef TRACE_STAT_CALLS
-	printf("stat on '%s' for accessMode\n", __stringVal(aPathName));
+printf("stat on '%s' for accessMode\n", __stringVal(encodedPathName));
 # endif
-	__BEGIN_INTERRUPTABLE__
+__BEGIN_INTERRUPTABLE__
-	do {
+do {
-	    ret = stat((char *) __stringVal(aPathName), &buf);
+ret = stat((char *) __stringVal(encodedPathName), &buf);
-	} while ((ret < 0) && (errno == EINTR));
+} while ((ret < 0) && (errno == EINTR));
-	__END_INTERRUPTABLE__
+__END_INTERRUPTABLE__
-	if (ret < 0) {
+if (ret < 0) {
-	    @global(LastErrorNumber) = __mkSmallInteger(errno);
+@global(LastErrorNumber) = __mkSmallInteger(errno);
-	    RETURN ( nil );
+RETURN ( nil );
-	}
+}
-	RETURN ( __mkSmallInteger(buf.st_mode & 0777) );
+RETURN ( __mkSmallInteger(buf.st_mode & 0777) );
 }
 %}.
 ^ self primitiveFailed
 "
 "change the access rights of aPathName to the OS dependent modeBits.
 You should construct this mask using accessMaskFor, to be OS
 independent. Return true if changed,
 false if such a file does not exist or change was not allowd."
+|encodedPathName|
+encodedPathName := self encodePath:aPathName.
 %{
 int ret;
-if (__isStringLike(aPathName) && __isSmallInteger(modeBits)) {
+if (__isStringLike(encodedPathName) && __isSmallInteger(modeBits)) {
-	__BEGIN_INTERRUPTABLE__
+__BEGIN_INTERRUPTABLE__
-	do {
+do {
-	    ret = chmod((char *)__stringVal(aPathName), __intVal(modeBits));
+ret = chmod((char *)__stringVal(encodedPathName), __intVal(modeBits));
-	} while (ret < 0 && errno == EINTR);
+} while (ret < 0 && errno == EINTR);
-	__END_INTERRUPTABLE__
+__END_INTERRUPTABLE__
-	if (ret < 0) {
+if (ret < 0) {
-	    @global(LastErrorNumber) = __mkSmallInteger(errno);
+@global(LastErrorNumber) = __mkSmallInteger(errno);
-	    RETURN ( false );
+RETURN ( false );
-	}
+}
-	RETURN ( true );
+RETURN ( true );
 }
 %}.
 ^ self primitiveFailed
 ! !
 "return the name of the current directory"
 |path|
 %{  /* UNLIMITEDSTACK */
-	char nameBuffer[MAXPATHLEN + 1];
+char nameBuffer[MAXPATHLEN + 1];
-	if (getcwd(nameBuffer, MAXPATHLEN)) {
+if (getcwd(nameBuffer, MAXPATHLEN)) {
-	    OBJ d;
+path = __MKSTRING(nameBuffer);
+}
-	    @global(CurrentDirectory) = d = __MKSTRING(nameBuffer);
-	    __GSTORE(d);
-	    RETURN (d);
-	}
 %}.
-^ self primitiveFailed
+path isNil ifTrue:[
+^ self primitiveFailed.
-"
+].
-	self getCurrentDirectory
+path := self decodePath:path.
+CurrentDirectory := path.
+^ path.
+"
+self getCurrentDirectory
 "
 !
 getDiskInfoOf:aDirectoryPath
 "return some disk info.
 infoOf:aPathName
 "return some object filled with info for the file 'aPathName';
 the info (for which corresponding access methods are understood by
 the returned object) is:
-	 type            - a symbol giving the files type
+type            - a symbol giving the files type
-	 mode            - numeric access mode
+mode            - numeric access mode
-	 uid             - owners user id
+uid             - owners user id
-	 gid             - owners group id
+gid             - owners group id
-	 size            - files size
+size            - files size
-	 id              - files number (i.e. inode number)
+id              - files number (i.e. inode number)
-	 accessed        - last access time (as Timestamp)
+accessed        - last access time (as Timestamp)
-	 modified        - last modification time (as Timestamp)
+modified        - last modification time (as Timestamp)
-	 statusChanged   - last status change time (as Timestamp)
+statusChanged   - last status change time (as Timestamp)
-	 alternativeName     - (windows only:) the MSDOS name of the file
+alternativeName     - (windows only:) the MSDOS name of the file
-	 recordFormatNumeric - (VMS only:) numeric value of the recordFormat
+recordFormatNumeric - (VMS only:) numeric value of the recordFormat
-	 recordFormat        - (VMS only:) symbolic value of the recordFormat
+recordFormat        - (VMS only:) symbolic value of the recordFormat
-	 recordAttributes    - (VMS only:) recordAttributes
+recordAttributes    - (VMS only:) recordAttributes
-	 fixedHeaderSize     - (VMS only:) fixed header size in a variable record format
+fixedHeaderSize     - (VMS only:) fixed header size in a variable record format
-	 recordSize          - (VMS only:) record size.
+recordSize          - (VMS only:) record size.
 Some of the fields may be returned as nil on systems which do not provide
 all of the information.
 Return nil if such a file does not exist.
 For symbolic links (if supported by the OS),
 the info of the pointed-to-file (i.e. the target) is returned;
 use #linkInfoOf: to get info about the link itself.
 "
-|type mode uid gid size id nLink aOStime mOStime cOStime error|
+|type mode uid gid size id nLink aOStime mOStime cOStime error encodedPathName|
+encodedPathName := self encodePath:aPathName.
 %{
 struct stat buf;
 int ret;
-if (!__isStringLike(aPathName)) {
+if (!__isStringLike(encodedPathName)) {
-	error = @symbol(badArgument);
+error = @symbol(badArgument);
-	goto out;
+goto out;
 }
 # ifdef TRACE_STAT_CALLS
 printf("stat on '%s' for info\n", __stringVal(aPathName));
 # endif
 __BEGIN_INTERRUPTABLE__
 do {
-	ret = stat((char *) __stringVal(aPathName), &buf);
+ret = stat((char *) __stringVal(encodedPathName), &buf);
 } while ((ret < 0) && (errno == EINTR));
 __END_INTERRUPTABLE__
 if (ret < 0) {
-	error = __mkSmallInteger(errno);
+error = __mkSmallInteger(errno);
-	@global(LastErrorNumber) = error;
+@global(LastErrorNumber) = error;
-	goto out;
+goto out;
 }
 switch (buf.st_mode & S_IFMT) {
-	case S_IFDIR:
+case S_IFDIR:
-	    type = @symbol(directory);
+type = @symbol(directory);
-	    break;
+break;
-	case S_IFREG:
+case S_IFREG:
-	    type = @symbol(regular);
+type = @symbol(regular);
-	    break;
+break;
 # ifdef S_IFCHR
-	case S_IFCHR:
+case S_IFCHR:
-	    type = @symbol(characterSpecial);
+type = @symbol(characterSpecial);
-	    break;
+break;
 # endif
 # ifdef S_IFBLK
-	case S_IFBLK:
+case S_IFBLK:
-	    type = @symbol(blockSpecial);
+type = @symbol(blockSpecial);
-	    break;
+break;
 # endif
 # ifdef S_IFMPC
-	case S_IFMPC:
+case S_IFMPC:
-	    type = @symbol(multiplexedCharacterSpecial);
+type = @symbol(multiplexedCharacterSpecial);
-	    break;
+break;
 # endif
 # ifdef S_IFMPB
-	case S_IFMPB:
+case S_IFMPB:
-	    type = @symbol(multiplexedBlockSpecial);
+type = @symbol(multiplexedBlockSpecial);
-	    break;
+break;
 # endif
 # ifdef S_IFLNK
-	case S_IFLNK:
+case S_IFLNK:
-	    type = @symbol(symbolicLink);
+type = @symbol(symbolicLink);
-	    break;
+break;
 # endif
 # ifdef S_IFSOCK
-	case S_IFSOCK:
+case S_IFSOCK:
-	    type = @symbol(socket);
+type = @symbol(socket);
-	    break;
+break;
 # endif
 # ifdef S_IFIFO
-	case S_IFIFO:
+case S_IFIFO:
-	    type = @symbol(fifo);
+type = @symbol(fifo);
-	    break;
+break;
 # endif
-	default:
+default:
-	    type = @symbol(unknown);
+type = @symbol(unknown);
-	    break;
+break;
 }
 if (sizeof(buf.st_ino) == 8) {
-	id = __MKUINT64(&buf.st_ino);
+id = __MKUINT64(&buf.st_ino);
 } else {
-	id = __MKUINT(buf.st_ino);
+id = __MKUINT(buf.st_ino);
 }
 mode = __mkSmallInteger(buf.st_mode & 0777);
 uid = __mkSmallInteger(buf.st_uid);
 gid = __mkSmallInteger(buf.st_gid);
 nLink = __mkSmallInteger(buf.st_nlink);
 if (sizeof(buf.st_size) == 8) {
-	size = __MKINT64(&buf.st_size);
+size = __MKINT64(&buf.st_size);
 } else {
-	size = __MKINT(buf.st_size);
+size = __MKINT(buf.st_size);
 }
 aOStime = __MKUINT(buf.st_atime);
 mOStime = __MKUINT(buf.st_mtime);
 cOStime = __MKUINT(buf.st_ctime);
 out:;
 %}.
 mode notNil ifTrue:[
-	"/ now done lazy in FileStatusInfo
+"/ now done lazy in FileStatusInfo
-	"/ atime := Timestamp fromOSTime:(aOStime * 1000).
+"/ atime := Timestamp fromOSTime:(aOStime * 1000).
-	"/ mtime := Timestamp fromOSTime:(mOStime * 1000).
+"/ mtime := Timestamp fromOSTime:(mOStime * 1000).
-	"/ ctime := Timestamp fromOSTime:(cOStime * 1000).
+"/ ctime := Timestamp fromOSTime:(cOStime * 1000).
-	^ FileStatusInfo
+^ FileStatusInfo
-		    type:type
+type:type
-		    mode:mode
+mode:mode
-		    uid:uid
+uid:uid
-		    gid:gid
+gid:gid
-		    size:size
+size:size
-		    id:id
+id:id
-		    accessed:aOStime
+accessed:aOStime
-		    modified:mOStime
+modified:mOStime
-		    statusChanged:cOStime
+statusChanged:cOStime
-		    path:nil
+path:nil
-		    numLinks:nLink.
+numLinks:nLink.
 ].
 error notNil ifTrue:[
-	^ nil.
+^ nil.
 ].
 ^ self primitiveFailed
 "
 "return true, if 'aPathName' is a valid directory path name.
 (i.e. exists and is a directory).
 This also returns true for symbolic links pointing to a directory;
 if you need to check for this, use #linkInfo:."
+|encodedPathName|
+encodedPathName := self encodePath:aPathName.
 %{
 int ret;
-if (__isStringLike(aPathName)) {
+if (__isStringLike(encodedPathName)) {
-	struct stat buf;
+struct stat buf;
 # ifdef TRACE_STAT_CALLS
-	printf("stat on '%s' for isDirectory\n", __stringVal(aPathName));
+printf("stat on '%s' for isDirectory\n", __stringVal(encodedPathName));
 # endif
-	__BEGIN_INTERRUPTABLE__
+__BEGIN_INTERRUPTABLE__
-	do {
+do {
-	    ret = stat((char *) __stringVal(aPathName), &buf);
+ret = stat((char *) __stringVal(encodedPathName), &buf);
-	} while ((ret < 0) && (errno == EINTR));
+} while ((ret < 0) && (errno == EINTR));
-	__END_INTERRUPTABLE__
+__END_INTERRUPTABLE__
-	if (ret < 0) {
+if (ret < 0) {
-	    @global(LastErrorNumber) = __mkSmallInteger(errno);
+@global(LastErrorNumber) = __mkSmallInteger(errno);
-	    RETURN ( false );
+RETURN ( false );
-	}
+}
-	RETURN ( ((buf.st_mode & S_IFMT) == S_IFDIR) ? true : false);
+RETURN ( ((buf.st_mode & S_IFMT) == S_IFDIR) ? true : false);
 }
 %}.
 ^ self primitiveFailed
 "an alternative implementation would be:
-	^ (self infoOf:aPathName) type == #directory
+^ (self infoOf:aPathName) type == #directory
 "
 !
 isExecutable:aPathName
 "return true, if the given file is executable.
 For symbolic links, the pointed-to-file is checked."
+|encodedPathName|
+encodedPathName := self encodePath:aPathName.
 %{
 int ret;
-if (__isStringLike(aPathName)) {
+if (__isStringLike(encodedPathName)) {
 # ifdef TRACE_ACCESS_CALLS
-	printf("access on '%s' for executable\n", __stringVal(aPathName));
+printf("access on '%s' for executable\n", __stringVal(encodedPathName));
 # endif
-	__BEGIN_INTERRUPTABLE__
+__BEGIN_INTERRUPTABLE__
-	do {
+do {
-	    ret = access(__stringVal(aPathName), X_OK);
+ret = access(__stringVal(encodedPathName), X_OK);
-	} while ((ret < 0) && (errno == EINTR));
+} while ((ret < 0) && (errno == EINTR));
-	__END_INTERRUPTABLE__
+__END_INTERRUPTABLE__
-	if (ret < 0) {
+if (ret < 0) {
-	    @global(LastErrorNumber) = __mkSmallInteger(errno);
+@global(LastErrorNumber) = __mkSmallInteger(errno);
-	}
+}
-	RETURN ( ((ret == 0) ? true : false) );
+RETURN ( ((ret == 0) ? true : false) );
 }
 %}.
 ^ self primitiveFailed
 !
 isReadable:aPathName
 "return true, if the file/dir 'aPathName' is readable.
 For symbolic links, the pointed-to-file is checked."
+|encodedPathName|
+encodedPathName := self encodePath:aPathName.
 %{
 int ret;
-if (__isStringLike(aPathName)) {
+if (__isStringLike(encodedPathName)) {
 # ifdef TRACE_ACCESS_CALLS
-	printf("access on '%s' for readable\n", __stringVal(aPathName));
+printf("access on '%s' for readable\n", __stringVal(encodedPathName));
 # endif
-	__BEGIN_INTERRUPTABLE__
+__BEGIN_INTERRUPTABLE__
-	do {
+do {
-	    ret = access(__stringVal(aPathName), R_OK);
+ret = access(__stringVal(encodedPathName), R_OK);
-	} while ((ret < 0) && (errno == EINTR));
+} while ((ret < 0) && (errno == EINTR));
-	__END_INTERRUPTABLE__
+__END_INTERRUPTABLE__
-	if (ret < 0) {
+if (ret < 0) {
-	    @global(LastErrorNumber) = __mkSmallInteger(errno);
+@global(LastErrorNumber) = __mkSmallInteger(errno);
-	}
+}
-	RETURN ( ((ret == 0) ? true : false) );
+RETURN ( ((ret == 0) ? true : false) );
 }
 %}.
 ^ self primitiveFailed
 !
 isValidPath:aPathName
 "return true, if 'aPathName' is a valid path name
 (i.e. the file or directory exists)"
+|encodedPathName|
+encodedPathName := self encodePath:aPathName.
 %{
 struct stat buf;
 int ret;
-if (__isStringLike(aPathName)) {
+if (__isStringLike(encodedPathName)) {
 # ifdef TRACE_STAT_CALLS
-	printf("stat on '%s' for isValidPath\n", __stringVal(aPathName));
+printf("stat on '%s' for isValidPath\n", __stringVal(encodedPathName));
 # endif
-	__BEGIN_INTERRUPTABLE__
+__BEGIN_INTERRUPTABLE__
-	do {
+do {
-	    ret = stat((char *) __stringVal(aPathName), &buf);
+ret = stat((char *) __stringVal(encodedPathName), &buf);
-	} while ((ret < 0) && (errno == EINTR));
+} while ((ret < 0) && (errno == EINTR));
-	__END_INTERRUPTABLE__
+__END_INTERRUPTABLE__
-	if (ret < 0) {
+if (ret < 0) {
-	    @global(LastErrorNumber) = __mkSmallInteger(errno);
+@global(LastErrorNumber) = __mkSmallInteger(errno);
-	    RETURN (false);
+RETURN (false);
-	}
+}
-	RETURN ( ret ? false : true );
+RETURN ( ret ? false : true );
 }
 %}.
 ^ self primitiveFailed
 "/ alternative:
 isWritable:aPathName
 "return true, if the given file is writable.
 For symbolic links, the pointed-to-file is checked."
+|encodedPathName|
+encodedPathName := self encodePath:aPathName.
 %{
 int ret;
-if (__isStringLike(aPathName)) {
+if (__isStringLike(encodedPathName)) {
 # ifdef TRACE_ACCESS_CALLS
-	printf("access on '%s' for writable\n", __stringVal(aPathName));
+printf("access on '%s' for writable\n", __stringVal(encodedPathName));
 # endif
-	__BEGIN_INTERRUPTABLE__
+__BEGIN_INTERRUPTABLE__
-	do {
+do {
-	    ret = access(__stringVal(aPathName), W_OK);
+ret = access(__stringVal(encodedPathName), W_OK);
-	} while ((ret < 0) && (errno == EINTR));
+} while ((ret < 0) && (errno == EINTR));
-	__END_INTERRUPTABLE__
+__END_INTERRUPTABLE__
-	if (ret < 0) {
+if (ret < 0) {
-	    @global(LastErrorNumber) = __mkSmallInteger(errno);
+@global(LastErrorNumber) = __mkSmallInteger(errno);
-	}
+}
-	RETURN ( ((ret == 0) ? true : false) );
+RETURN ( ((ret == 0) ? true : false) );
 }
 %}.
 ^ self primitiveFailed
 !
 Return the info about the link itself,
 on contrast to #infoOf:, which returns the info of the pointed to file
 in case of a symbolic link."
-|type mode uid gid size id nLink aOStime mOStime cOStime path|
+|type mode uid gid size id nLink aOStime mOStime cOStime path encodedPathName|
+encodedPathName := self encodePath:aPathName.
 %{  /* STACK: 1200 */
 #if defined(S_IFLNK)
 struct stat buf;
 int ret;
 char pathBuffer[1024];
-if (__isStringLike(aPathName)) {
+if (__isStringLike(encodedPathName)) {
 __BEGIN_INTERRUPTABLE__
 do {
-ret = lstat((char *) __stringVal(aPathName), &buf);
+ret = lstat((char *) __stringVal(encodedPathName), &buf);
 } while ((ret < 0) && (errno == EINTR));
 __END_INTERRUPTABLE__
 if (ret < 0) {
 @global(LastErrorNumber) = __mkSmallInteger(errno);
 }
 switch (buf.st_mode & S_IFMT) {
 # ifdef S_IFLNK
 case S_IFLNK:
 type = @symbol(symbolicLink);
-if ((ret = readlink((char *) __stringVal(aPathName), pathBuffer, sizeof(pathBuffer))) < 0) {
+if ((ret = readlink((char *) __stringVal(encodedPathName), pathBuffer, sizeof(pathBuffer))) < 0) {
 @global(LastErrorNumber) = __mkSmallInteger(errno);
 RETURN ( nil );
 }
 pathBuffer[ret] = '\0';  /* readlink does not 0-terminate */
 path = __MKSTRING(pathBuffer);
 #else
 RETURN ( nil );
 #endif
 %}.
-path notNil ifTrue:[
-[
-path := path utf8Decoded.
-] on:InvalidEncodingError do:[:ex|
-"maybe there are old filenames in ISO8859-x,
-just keep them untranslated"
-].
-].
 mode notNil ifTrue:[
 ^ FileStatusInfo
 type:type
 mode:mode
 uid:uid
 size:size
 id:id
 accessed:aOStime
 modified:mOStime
 statusChanged:cOStime
-path:path
+path:(self decodePath:path)
 numLinks:nLink.
 ].
 ^ self primitiveFailed
 "
 Notice: if symbolic links are involved, the result may look different
 from what you expect."
 |p path command|
+path = '.' ifTrue:[
+^ self getCurrentDirectory.
+].
 "some systems have a convenient function for this ..."
-path := self primPathNameOf:pathName.
+path := self primPathNameOf:(self encodePath:pathName).
 path isNil ifTrue:[
-	(self isValidPath:pathName) ifFalse:[
+(self isValidPath:pathName) ifFalse:[
-	    p := pathName.
+p := pathName.
-	    [(p size > 1)
+[(p size > 1)
-	     and:[p endsWith:(self fileSeparator)]
+and:[p endsWith:(self fileSeparator)]
-	    ] whileTrue:[
+] whileTrue:[
-		p := p copyWithoutLast:1.
+p := p copyWithoutLast:1.
-	    ].
+].
-	    ^ p
+^ p
-	].
+].
-	(SlowFork==true or:[PipeFailed==true]) ifFalse:[
+(SlowFork==true or:[PipeFailed==true]) ifFalse:[
-	    PipeStream openErrorSignal handle:[:ex |
+PipeStream openErrorSignal handle:[:ex |
-		PipeFailed := true.
+PipeFailed := true.
-		'UnixOperatingSystem [warning]: cannot fork/popen' errorPrintCR.
+'UnixOperatingSystem [warning]: cannot fork/popen' errorPrintCR.
-		ex return.
+ex return.
-	    ] do:[
+] do:[
-		"have to fall back ..."
+"have to fall back ..."
-		command := 'cd "' , pathName , '"; pwd'.
+command := 'cd "' , pathName , '"; pwd'.
-		p := PipeStream readingFrom:command.
+p := PipeStream readingFrom:command.
-	    ].
+].
-	    (p isNil or:[p atEnd]) ifTrue:[
+(p isNil or:[p atEnd]) ifTrue:[
-		('UnixOperatingSystem [warning]: PipeStream for <' , command , '> failed') errorPrintCR.
+('UnixOperatingSystem [warning]: PipeStream for <' , command , '> failed') errorPrintCR.
-	    ] ifFalse:[
+] ifFalse:[
-		path := p nextLine.
+path := p nextLine.
-		p close.
+p close.
-	    ]
+]
-	].
+].
-	path isNil ifTrue:[
+path isNil ifTrue:[
-	    "/
+"/
-	    "/ return the original - there is nothing else can we do
+"/ return the original - there is nothing else can we do
-	    "/
+"/
-	    path := pathName
+path := pathName
-	].
+].
-	(SlowFork==true or:[ForkFailed==true]) ifTrue:[
+(SlowFork==true or:[ForkFailed==true]) ifTrue:[
-	    path := self compressPath:path
+path := self compressPath:path
-	]
+]
 ].
 ^ path.
 "
 OperatingSystem pathNameOf:'.'
 !
 primIdOf:aPathName
 "the actual code to return the fileNumber (i.e. inode number) of a file."
+|encodedPathName|
+encodedPathName := self encodePath:aPathName.
 %{
 struct stat buf;
 int ret;
 unsigned INT ino;
 OBJ retVal;
-if (__isStringLike(aPathName)) {
+if (__isStringLike(encodedPathName)) {
 # ifdef TRACE_STAT_CALLS
-	printf("stat on '%s' for id\n", __stringVal(aPathName));
+printf("stat on '%s' for id\n", __stringVal(encodedPathName));
 # endif
-	__BEGIN_INTERRUPTABLE__
+__BEGIN_INTERRUPTABLE__
-	do {
+do {
-	    ret = stat((char *) __stringVal(aPathName), &buf);
+ret = stat((char *) __stringVal(encodedPathName), &buf);
-	} while (ret < 0 && errno == EINTR);
+} while (ret < 0 && errno == EINTR);
-	__END_INTERRUPTABLE__
+__END_INTERRUPTABLE__
-	if (ret >= 0) {
+if (ret >= 0) {
-	    ino = buf.st_ino;
+ino = buf.st_ino;
-	    retVal = __MKUINT(ino);
+retVal = __MKUINT(ino);
-	    RETURN (retVal);
+RETURN (retVal);
-	}
+}
-	@global(LastErrorNumber) = __mkSmallInteger(errno);
+@global(LastErrorNumber) = __mkSmallInteger(errno);
-	RETURN (nil);
+RETURN (nil);
 }
 RETURN (nil);
 %}.
 !
 This method here returns nil, if the OS does not provide a
 realPath library function.
 Notice: if symbolic links are involved, the result may look different
 from what you expect."
-|path|
 %{  /* UNLIMITEDSTACK */
 if (__isStringLike(pathName)) {
-if (strcmp(__stringVal(pathName), ".") == 0) {
-char nameBuffer[MAXPATHLEN + 1];
-if (@global(CurrentDirectory) == nil) {
-if (getcwd(nameBuffer, MAXPATHLEN)) {
-OBJ d;
-@global(CurrentDirectory) = d = __MKSTRING(nameBuffer);
-__GSTORE(d);
-}
-}
-RETURN (@global(CurrentDirectory));
-}
 #ifdef HAS_REALPATH
 {
 char nameBuffer[MAXPATHLEN+1];
 if (realpath(__stringVal(pathName), nameBuffer)) {
 RETURN ( __MKSTRING(nameBuffer) );
 }
-RETURN ( nil );
 }
 #endif /* ! HAS_REALPATH */
 }
 %}.
 ^ nil
 timeOfLastAccess:aPathName
 "return the time, when the file was last accessed.
 For nonexistent files, nil is returned."
 "could be implemented as:
-	(self infoOf:aPathName) accessed
+(self infoOf:aPathName) accessed
 "
-|osSeconds i|
+|osSeconds i encodedPathName|
+encodedPathName := self encodePath:aPathName.
 %{
 struct stat buf;
 time_t mtime;
 int ret;
-if (__isStringLike(aPathName)) {
+if (__isStringLike(encodedPathName)) {
 # ifdef TRACE_STAT_CALLS
-	printf("stat on '%s' for timeOfLastAccess\n", __stringVal(aPathName));
+printf("stat on '%s' for timeOfLastAccess\n", __stringVal(encodedPathName));
 # endif
-	__BEGIN_INTERRUPTABLE__
+__BEGIN_INTERRUPTABLE__
-	do {
+do {
-	    ret = stat((char *) __stringVal(aPathName), &buf);
+ret = stat((char *) __stringVal(encodedPathName), &buf);
-	} while (ret < 0 && errno == EINTR);
+} while (ret < 0 && errno == EINTR);
-	__END_INTERRUPTABLE__
+__END_INTERRUPTABLE__
-	if (ret < 0) {
+if (ret < 0) {
-	    @global(LastErrorNumber) = __mkSmallInteger(errno);
+@global(LastErrorNumber) = __mkSmallInteger(errno);
-	    RETURN (nil);
+RETURN (nil);
-	}
+}
-	osSeconds = __MKUINT(buf.st_atime);
+osSeconds = __MKUINT(buf.st_atime);
 }
 %}.
 osSeconds notNil ifTrue:[^ Timestamp fromOSTime:(osSeconds * 1000)].
 i := self infoOf:aPathName.
 timeOfLastChange:aPathName
 "return the time, when the file was last changed.
 For nonexistent files, nil is returned."
 "could be implemented as:
-	(self infoOf:aPathName) modified
+(self infoOf:aPathName) modified
 "
-|osSeconds i|
+|osSeconds i encodedPathName|
+encodedPathName := self encodePath:aPathName.
 %{
 struct stat buf;
 int ret;
 time_t mtime;
-if (__isStringLike(aPathName)) {
+if (__isStringLike(encodedPathName)) {
 # ifdef TRACE_STAT_CALLS
-	printf("stat on '%s' for timeOfLastChange\n", __stringVal(aPathName));
+printf("stat on '%s' for timeOfLastChange\n", __stringVal(encodedPathName));
 # endif
-	__BEGIN_INTERRUPTABLE__
+__BEGIN_INTERRUPTABLE__
-	do {
+do {
-	    ret = stat((char *) __stringVal(aPathName), &buf);
+ret = stat((char *) __stringVal(encodedPathName), &buf);
-	} while (ret < 0 && errno == EINTR);
+} while (ret < 0 && errno == EINTR);
-	__END_INTERRUPTABLE__
+__END_INTERRUPTABLE__
-	if (ret < 0) {
+if (ret < 0) {
-	    @global(LastErrorNumber) = __mkSmallInteger(errno);
+@global(LastErrorNumber) = __mkSmallInteger(errno);
-	    RETURN ( nil );
+RETURN ( nil );
-	}
+}
-	osSeconds = __MKUINT(buf.st_mtime);
+osSeconds = __MKUINT(buf.st_mtime);
 }
 %}.
 osSeconds notNil ifTrue:[^ Timestamp fromOSTime:(osSeconds * 1000)].
 i := self infoOf:aPathName.
 typeOf:aPathName
 "return the type of a file as a symbol; for nonexistent files,
 nil is returned.
 Notice: for symbolic links, the type of the pointed-to file is returned."
-|i|
+|i osSeconds encodedPathName|
+encodedPathName := self encodePath:aPathName.
 "
 this could have been implemented as:
-	(self infoOf:aPathName) type
+(self infoOf:aPathName) type
 but for huge directory searches the code below is faster
 "
 %{
 struct stat buf;
 int ret;
-if (__isStringLike(aPathName)) {
+if (__isStringLike(encodedPathName)) {
 # ifdef TRACE_STAT_CALLS
-	printf("stat on '%s' for type\n", __stringVal(aPathName));
+printf("stat on '%s' for type\n", __stringVal(encodedPathName));
 # endif
-	__BEGIN_INTERRUPTABLE__
+__BEGIN_INTERRUPTABLE__
-	do {
+do {
-	    ret = stat((char *) __stringVal(aPathName), &buf);
+ret = stat((char *) __stringVal(encodedPathName), &buf);
-	} while (ret < 0 && errno == EINTR);
+} while (ret < 0 && errno == EINTR);
-	__END_INTERRUPTABLE__
+__END_INTERRUPTABLE__
-	if (ret < 0) {
+if (ret < 0) {
-	    @global(LastErrorNumber) = __mkSmallInteger(errno);
+@global(LastErrorNumber) = __mkSmallInteger(errno);
-	    RETURN ( nil );
+RETURN ( nil );
-	}
+}
-	switch (buf.st_mode & S_IFMT) {
+switch (buf.st_mode & S_IFMT) {
-	    case S_IFDIR:
+case S_IFDIR:
-		RETURN ( @symbol(directory) );
+RETURN ( @symbol(directory) );
-	    case S_IFREG:
+case S_IFREG:
-		RETURN ( @symbol(regular) );
+RETURN ( @symbol(regular) );
 # ifdef S_IFCHR
-	    case S_IFCHR:
+case S_IFCHR:
-		RETURN ( @symbol(characterSpecial) );
+RETURN ( @symbol(characterSpecial) );
 # endif
 # ifdef S_IFBLK
-	    case S_IFBLK:
+case S_IFBLK:
-		RETURN ( @symbol(blockSpecial) );
+RETURN ( @symbol(blockSpecial) );
 # endif
 # ifdef S_IFLNK
-	    case S_IFLNK:
+case S_IFLNK:
-		RETURN ( @symbol(symbolicLink) );
+RETURN ( @symbol(symbolicLink) );
 # endif
 # ifdef S_IFSOCK
-	    case S_IFSOCK:
+case S_IFSOCK:
-		RETURN ( @symbol(socket) );
+RETURN ( @symbol(socket) );
 # endif
 # ifdef S_IFIFO
-	    case S_IFIFO:
+case S_IFIFO:
-		RETURN ( @symbol(fifo) );
+RETURN ( @symbol(fifo) );
 # endif
-	    default:
+default:
-		RETURN ( @symbol(unknown) );
+RETURN ( @symbol(unknown) );
-	}
+}
 }
 %}.
 i := self infoOf:aPathName.
 i notNil ifTrue:[^ i type].
 ^ nil.
 ! !
 !UnixOperatingSystem class methodsFor:'path queries'!
+decodePath:encodedPathName
+"decode the pathName as returned by system calls.
+E.g. linux system calls return sigle byte strings only,
+so the pathName has been UTF-8 decoded."
+"linux strings are in UTF8 (in contemporary linux versions)"
+encodedPathName notNil ifTrue:[
+[
+^ encodedPathName utf8Decoded.
+] on:InvalidEncodingError do:[:ex|
+"maybe there are old filenames in ISO8859-x,
+just keep them untranslated"
+].
+].
+^ encodedPathName
+!
 defaultSystemPath
 "add additional directories to the systemPath
 (but only, if the major version is the same)"
 |sysPath majorVersionNr releaseFile s v|
 ^ sysPath
 "
 OperatingSystem defaultSystemPath
 "
+!
+encodePath:pathName
+"encode the pathName for use with system calls.
+E.g. linux system calls accept sigle byte strings only,
+so the pathName has been UTF-8 encoded, before using it in a system call."
+^ pathName utf8Encoded
 ! !
 !UnixOperatingSystem class methodsFor:'private'!
 mountPointsFromProcFS
 ! !
 !UnixOperatingSystem class methodsFor:'documentation'!
 version
-^ '$Header: /cvs/stx/stx/libbasic/UnixOperatingSystem.st,v 1.289 2012-12-13 11:13:51 stefan Exp $'
+^ '$Header: /cvs/stx/stx/libbasic/UnixOperatingSystem.st,v 1.290 2012-12-13 13:20:12 stefan Exp $'
 !
 version_CVS
-^ '$Header: /cvs/stx/stx/libbasic/UnixOperatingSystem.st,v 1.289 2012-12-13 11:13:51 stefan Exp $'
+^ '$Header: /cvs/stx/stx/libbasic/UnixOperatingSystem.st,v 1.290 2012-12-13 13:20:12 stefan Exp $'
 ! !
 UnixOperatingSystem initialize!
 UnixOperatingSystem::FileDescriptorHandle initialize!

changeset 14568	ca342ae94cb7
parent 14564	2f373e43fd1a
child 14575	c696ca8d05bd