/*
* tclUnixFile.c --
*
* This file contains wrappers around UNIX file handling functions.
* These wrappers mask differences between Windows and UNIX.
*
* Copyright (c) 1995 Sun Microsystems, Inc.
*
* See the file "license.terms" for information on usage and redistribution
* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
*
* SCCS: @(#) tclUnixFile.c 1.41 96/12/05 14:59:20
*/
#include "tclInt.h"
#include "tclPort.h"
/*
* The variable below caches the name of the current working directory
* in order to avoid repeated calls to getcwd. The string is malloc-ed.
* NULL means the cache needs to be refreshed.
*/
static int currentDirExitHandlerSet = 0;
/*
* The variable below is set if the exit routine for deleting the string
* containing the executable name has been registered.
*/
static int executableNameExitHandlerSet = 0;
/*
* Static routines for this file:
*/
/*
*----------------------------------------------------------------------
*
* Tcl_WaitPid --
*
* Implements the waitpid system call on Unix systems.
*
* Results:
* Result of calling waitpid.
*
* Side effects:
* Waits for a process to terminate.
*
*----------------------------------------------------------------------
*/
int
int pid;
int *statPtr;
int options;
{
int result;
while (1) {
return result;
}
}
}
/*
*----------------------------------------------------------------------
*
* FreeCurrentDir --
*
* Frees the string stored in the currentDir variable. This routine
* is registered as an exit handler and will be called during shutdown.
*
* Results:
* None.
*
* Side effects:
* Frees the memory occuppied by the currentDir value.
*
*----------------------------------------------------------------------
*/
/* ARGSUSED */
static void
{
if (currentDir != (char *) NULL) {
currentDir = (char *) NULL;
}
}
/*
*----------------------------------------------------------------------
*
* FreeExecutableName --
*
* Frees the string stored in the tclExecutableName variable. This
* routine is registered as an exit handler and will be called
* during shutdown.
*
* Results:
* None.
*
* Side effects:
* Frees the memory occuppied by the tclExecutableName value.
*
*----------------------------------------------------------------------
*/
/* ARGSUSED */
static void
{
if (tclExecutableName != (char *) NULL) {
tclExecutableName = (char *) NULL;
}
}
/*
*----------------------------------------------------------------------
*
* TclChdir --
*
* Change the current working directory.
*
* Results:
* The result is a standard Tcl result. If an error occurs and
* interp isn't NULL, an error message is left in interp->result.
*
* Side effects:
* The working directory for this application is changed. Also
* the cache maintained used by TclGetCwd is deallocated and
* set to NULL.
*
*----------------------------------------------------------------------
*/
int
char *dirName; /* Path to new working directory. */
{
if (currentDir != NULL) {
currentDir = NULL;
}
}
return TCL_ERROR;
}
return TCL_OK;
}
/*
*----------------------------------------------------------------------
*
* TclGetCwd --
*
* Return the path name of the current working directory.
*
* Results:
* The result is the full path name of the current working
* directory, or NULL if an error occurred while figuring it out.
* The returned string is owned by the TclGetCwd routine and must
* not be freed by the caller. If an error occurs and interp
* isn't NULL, an error message is left in interp->result.
*
* Side effects:
* The path name is cached to avoid having to recompute it
* on future calls; if it is already cached, the cached
* value is returned.
*
*----------------------------------------------------------------------
*/
char *
{
if (currentDir == NULL) {
if (!currentDirExitHandlerSet) {
}
} else {
"error getting working directory name: ",
}
}
return NULL;
}
}
return currentDir;
}
/*
*----------------------------------------------------------------------
*
* TclOpenFile --
*
* Implements a mechanism to open files on Unix systems.
*
* Results:
* The opened file.
*
* Side effects:
* May cause a file to be created on the file system.
*
*----------------------------------------------------------------------
*/
char *fname; /* The name of the file to open. */
int mode; /* In what mode to open the file? */
{
int fd;
if (fd != -1) {
}
return NULL;
}
/*
*----------------------------------------------------------------------
*
* TclCloseFile --
*
* Implements a mechanism to close a UNIX file.
*
* Results:
* Returns 0 on success, or -1 on error, setting errno.
*
* Side effects:
* The file is closed.
*
*----------------------------------------------------------------------
*/
int
{
int type;
int fd;
int result;
if (type != TCL_UNIX_FD) {
panic("Tcl_CloseFile: unexpected file type");
}
/*
* Refuse to close the fds for stdin, stdout and stderr.
*/
return 0;
}
return result;
}
/*
*----------------------------------------------------------------------
*
* TclReadFile --
*
* Implements a mechanism to read from files on Unix systems. Also
* simulates blocking behavior on non-blocking files when asked to.
*
* Results:
* The number of characters read from the specified file.
*
* Side effects:
* May consume characters from the file.
*
*----------------------------------------------------------------------
*/
/* ARGSUSED */
int
int shouldBlock; /* Not used. */
char *buf; /* The buffer to store input in. */
int toRead; /* Number of characters to read. */
{
if (type != TCL_UNIX_FD) {
panic("Tcl_ReadFile: unexpected file type");
}
}
/*
*----------------------------------------------------------------------
*
* TclWriteFile --
*
* Implements a mechanism to write to files on Unix systems.
*
* Results:
* The number of characters written to the specified file.
*
* Side effects:
* May produce characters on the file.
*
*----------------------------------------------------------------------
*/
/* ARGSUSED */
int
int shouldBlock; /* Not used. */
char *buf; /* Where output is stored. */
int toWrite; /* Number of characters to write. */
{
if (type != TCL_UNIX_FD) {
panic("Tcl_WriteFile: unexpected file type");
}
}
/*
*----------------------------------------------------------------------
*
* TclSeekFile --
*
* Sets the file pointer on the indicated UNIX file.
*
* Results:
* The new position at which the file will be accessed, or -1 on
* failure.
*
* Side effects:
* May change the position at which subsequent operations access the
* file designated by the file.
*
*----------------------------------------------------------------------
*/
int
int offset; /* How far to seek? */
int whence; /* And from where to seek? */
{
if (type != TCL_UNIX_FD) {
panic("Tcl_SeekFile: unexpected file type");
}
}
/*
*----------------------------------------------------------------------
*
* TclCreateTempFile --
*
* This function creates a temporary file initialized with an
* optional string, and returns a file handle with the file pointer
* at the beginning of the file.
*
* Results:
* A handle to a file.
*
* Side effects:
* None.
*
*----------------------------------------------------------------------
*/
#ifdef TKSH_V5
#else
#endif
char *contents; /* String to write into temp file, or NULL. */
#ifndef TKSH_V5
* DString that is filled with the name of
* the temp file that was created. */
#endif
{
while (1) {
break;
return NULL;
}
}
}
#ifndef TKSH_V5
}
#endif
return file;
}
/*
*----------------------------------------------------------------------
*
* Tcl_FindExecutable --
*
* This procedure computes the absolute path name of the current
* application, given its argv[0] value.
*
* Results:
* None.
*
* Side effects:
* The variable tclExecutableName gets filled in with the file
* name for the application, if we figured it out. If we couldn't
* figure it out, Tcl_FindExecutable is set to NULL.
*
*----------------------------------------------------------------------
*/
void
char *argv0; /* The value of the application's argv[0]. */
{
int length;
if (tclExecutableName != NULL) {
}
for (p = name; *p != 0; p++) {
if (*p == '/') {
/*
* The name contains a slash, so use the name directly
* without doing a path search.
*/
goto gotName;
}
}
p = getenv("PATH");
if (p == NULL) {
/*
* There's no PATH environment variable; use the default that
* is used by sh.
*/
}
/*
* Search through all the directories named in the PATH variable
* to see if argv[0] is in one of them. If so, use that file
* name.
*/
while (*p != 0) {
p++;
}
name = p;
while ((*p != ':') && (*p != 0)) {
p++;
}
Tcl_DStringSetLength(&buffer, 0);
if (p != name) {
if (p[-1] != '/') {
}
}
goto gotName;
}
p++;
}
goto done;
/*
* If the name starts with "/" then just copy it to tclExecutableName.
*/
if (name[0] == '/') {
goto done;
}
/*
* The name is relative to the current working directory. First
* strip off a leading "./", if any, then add the full path name of
* the current working directory.
*/
name += 2;
}
goto done;
}
tclExecutableName = (char *) ckalloc((unsigned)
done:
if (!executableNameExitHandlerSet) {
}
}
/*
*----------------------------------------------------------------------
*
* TclGetUserHome --
*
* This function takes the passed in user name and finds the
* corresponding home directory specified in the password file.
*
* Results:
* The result is a pointer to a static string containing
* the new name. If there was an error in processing the
* user name then the return value is NULL. Otherwise the
* result is stored in bufferPtr, and the caller must call
* Tcl_DStringFree(bufferPtr) to free the result.
*
* Side effects:
* Information may be left in bufferPtr.
*
*----------------------------------------------------------------------
*/
char *
char *name; /* User name to use to find home directory. */
* anything at the time of the call, and need
* not even be initialized. */
{
endpwent();
return NULL;
}
endpwent();
}
#if 0
/*
*----------------------------------------------------------------------
*
* TclMatchFiles --
*
* This routine is used by the globbing code to search a
* directory for all files which match a given pattern.
*
* Results:
* If the tail argument is NULL, then the matching files are
* added to the interp->result. Otherwise, TclDoGlob is called
* recursively for each matching subdirectory. The return value
* is a standard Tcl result indicating whether an error occurred
* in globbing.
*
* Side effects:
* None.
*
*---------------------------------------------------------------------- */
int
char *separators; /* Path separators to pass to TclDoGlob. */
char *pattern; /* Pattern to match against. */
char *tail; /* Pointer to end of pattern. */
{
char savedChar = 0; /* Initialization needed only to prevent
* compiler warning from gcc. */
DIR *d;
int matchHidden;
/*
* Make sure that the directory part of the name really is a
* directory. If the directory name is "", use the name "."
* instead, because some UNIX systems don't treat "" like "."
* automatically. Keep the "" for use in generating file names,
*/
dirName = ".";
} else {
}
return TCL_OK;
}
/*
* Check to see if the pattern needs to compare with hidden files.
*/
if ((pattern[0] == '.')
matchHidden = 1;
} else {
matchHidden = 0;
}
/*
* Now open the directory for reading and iterate over the contents.
*/
if (d == NULL) {
/*
* Strip off a trailing '/' if necessary, before reporting the error.
*/
if (baseLength > 0) {
if (savedChar == '/') {
}
}
if (baseLength > 0) {
}
return TCL_ERROR;
}
/*
* Clean up the end of the pattern and the tail pointer. Leave
* the tail pointing to the first character after the path separator
* following the pattern, or NULL. Also, ensure that the pattern
* is null-terminated.
*/
if (*tail == '\\') {
tail++;
}
if (*tail == '\0') {
} else {
tail++;
}
savedChar = *patternEnd;
*patternEnd = '\0';
while (1) {
break;
}
/*
* Don't match names starting with "." unless the "." is
* present in the pattern.
*/
continue;
}
/*
* Now check to see if the file matches. If there are more
* characters to be processed, then ensure matching files are
* directories before calling TclDoGlob. Otherwise, just add
* the file to the result.
*/
break;
}
}
}
}
*patternEnd = savedChar;
closedir(d);
return result;
}
#endif