root/trunk/bevutils/file.d

// Written in the D programming language.

/**
 * Macros:
 *  WIKI = Phobos/StdFile
 */

/*
 *  Copyright (C) 2001-2004 by Digital Mars, www.digitalmars.com
 * Written by Walter Bright, Christopher E. Miller, Andre Fornacon
 *
 *  This software is provided 'as-is', without any express or implied
 *  warranty. In no event will the authors be held liable for any damages
 *  arising from the use of this software.
 *
 *  Permission is granted to anyone to use this software for any purpose,
 *  including commercial applications, and to alter it and redistribute it
 *  freely, subject to the following restrictions:
 *
 *  o  The origin of this software must not be misrepresented; you must not
 *     claim that you wrote the original software. If you use this software
 *     in a product, an acknowledgment in the product documentation would be
 *     appreciated but is not required.
 *  o  Altered source versions must be plainly marked as such, and must not
 *     be misrepresented as being the original software.
 *  o  This notice may not be removed or altered from any source
 *     distribution.
 */

module std.file;

private import std.c.stdio;
private import std.c.stdlib;
private import std.path;
private import std.string;
private import std.regexp;
private import std.gc;
private import std.stdio;

/* =========================== Win32 ======================= */

version (Win32)
{

private import std.c.windows.windows;
private import std.utf;
private import std.windows.syserror;
private import std.windows.charset;
private import std.date;

int useWfuncs = 1;

static this()
{
    // Win 95, 98, ME do not implement the W functions
    useWfuncs = (GetVersion() < 0x80000000);
}

/***********************************
 * Exception thrown for file I/O errors.
 */

class FileException : Exception
{

    uint errno;         // operating system error code

    this(char[] name)
    {
    this(name, "file I/O");
    }

    this(char[] name, char[] message)
    {
    super(name ~ ": " ~ message);
    }

    this(char[] name, uint errno)
    {
    this(name, sysErrorString(errno));
    this.errno = errno;
    }
}

/* **********************************
 * Basic File operations.
 */

/********************************************
 * Read file name[], return array of bytes read.
 * Throws:
 *  FileException on error.
 */

void[] read(char[] name)
{
    DWORD numread;
    HANDLE h;

    if (useWfuncs)
    {
    wchar* namez = std.utf.toUTF16z(name);
    h = CreateFileW(namez,GENERIC_READ,FILE_SHARE_READ,null,OPEN_EXISTING,
        FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,cast(HANDLE)null);
    }
    else
    {
    char* namez = toMBSz(name);
    h = CreateFileA(namez,GENERIC_READ,FILE_SHARE_READ,null,OPEN_EXISTING,
        FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,cast(HANDLE)null);
    }

    if (h == INVALID_HANDLE_VALUE)
    goto err1;

    auto size = GetFileSize(h, null);
    if (size == INVALID_FILE_SIZE)
    goto err2;

    auto buf = std.gc.malloc(size);
    if (buf)
    std.gc.hasNoPointers(buf.ptr);

    if (ReadFile(h,buf.ptr,size,&numread,null) != 1)
    goto err2;

    if (numread != size)
    goto err2;

    if (!CloseHandle(h))
    goto err;

    return buf[0 .. size];

err2:
    CloseHandle(h);
err:
    delete buf;
err1:
    throw new FileException(name, GetLastError());
}

/*********************************************
 * Write buffer[] to file name[].
 * Throws: FileException on error.
 */

void write(char[] name, void[] buffer)
{
    HANDLE h;
    DWORD numwritten;

    if (useWfuncs)
    {
    wchar* namez = std.utf.toUTF16z(name);
    h = CreateFileW(namez,GENERIC_WRITE,0,null,CREATE_ALWAYS,
        FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,cast(HANDLE)null);
    }
    else
    {
    char* namez = toMBSz(name);
    h = CreateFileA(namez,GENERIC_WRITE,0,null,CREATE_ALWAYS,
        FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,cast(HANDLE)null);
    }
    if (h == INVALID_HANDLE_VALUE)
    goto err;

    if (WriteFile(h,buffer.ptr,buffer.length,&numwritten,null) != 1)
    goto err2;

    if (buffer.length != numwritten)
    goto err2;
    
    if (!CloseHandle(h))
    goto err;
    return;

err2:
    CloseHandle(h);
err:
    throw new FileException(name, GetLastError());
}


/*********************************************
 * Append buffer[] to file name[].
 * Throws: FileException on error.
 */

void append(char[] name, void[] buffer)
{
    HANDLE h;
    DWORD numwritten;

    if (useWfuncs)
    {
    wchar* namez = std.utf.toUTF16z(name);
    h = CreateFileW(namez,GENERIC_WRITE,0,null,OPEN_ALWAYS,
        FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,cast(HANDLE)null);
    }
    else
    {
    char* namez = toMBSz(name);
    h = CreateFileA(namez,GENERIC_WRITE,0,null,OPEN_ALWAYS,
        FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,cast(HANDLE)null);
    }
    if (h == INVALID_HANDLE_VALUE)
    goto err;

    SetFilePointer(h, 0, null, FILE_END);

    if (WriteFile(h,buffer.ptr,buffer.length,&numwritten,null) != 1)
    goto err2;

    if (buffer.length != numwritten)
    goto err2;
    
    if (!CloseHandle(h))
    goto err;
    return;

err2:
    CloseHandle(h);
err:
    throw new FileException(name, GetLastError());
}


/***************************************************
 * Rename file from[] to to[].
 * Throws: FileException on error.
 */

void rename(char[] from, char[] to)
{
    BOOL result;

    if (useWfuncs)
    result = MoveFileW(std.utf.toUTF16z(from), std.utf.toUTF16z(to));
    else
    result = MoveFileA(toMBSz(from), toMBSz(to));
    if (!result)
    throw new FileException(to, GetLastError());
}


/***************************************************
 * Delete file name[].
 * Throws: FileException on error.
 */

void remove(char[] name)
{
    BOOL result;

    if (useWfuncs)
    result = DeleteFileW(std.utf.toUTF16z(name));
    else
    result = DeleteFileA(toMBSz(name));
    if (!result)
    throw new FileException(name, GetLastError());
}


/***************************************************
 * Get size of file name[].
 * Throws: FileException on error.
 */

ulong getSize(char[] name)
{
    HANDLE findhndl;
    uint resulth;
    uint resultl;

    if (useWfuncs)
    {
    WIN32_FIND_DATAW filefindbuf;

    findhndl = FindFirstFileW(std.utf.toUTF16z(name), &filefindbuf);
    resulth = filefindbuf.nFileSizeHigh;
    resultl = filefindbuf.nFileSizeLow;
    }
    else
    {
    WIN32_FIND_DATA filefindbuf;

    findhndl = FindFirstFileA(toMBSz(name), &filefindbuf);
    resulth = filefindbuf.nFileSizeHigh;
    resultl = filefindbuf.nFileSizeLow;
    }

    if (findhndl == cast(HANDLE)-1)
    {
    throw new FileException(name, GetLastError());
    }
    FindClose(findhndl);
    return (cast(ulong)resulth << 32) + resultl;
}

/*************************
 * Get creation/access/modified times of file name[].
 * Throws: FileException on error.
 */

void getTimes(char[] name, out d_time ftc, out d_time fta, out d_time ftm)
{
    HANDLE findhndl;

    if (useWfuncs)
    {
    WIN32_FIND_DATAW filefindbuf;

    findhndl = FindFirstFileW(std.utf.toUTF16z(name), &filefindbuf);
    ftc = std.date.FILETIME2d_time(&filefindbuf.ftCreationTime);
    fta = std.date.FILETIME2d_time(&filefindbuf.ftLastAccessTime);
    ftm = std.date.FILETIME2d_time(&filefindbuf.ftLastWriteTime);
    }
    else
    {
    WIN32_FIND_DATA filefindbuf;

    findhndl = FindFirstFileA(toMBSz(name), &filefindbuf);
    ftc = std.date.FILETIME2d_time(&filefindbuf.ftCreationTime);
    fta = std.date.FILETIME2d_time(&filefindbuf.ftLastAccessTime);
    ftm = std.date.FILETIME2d_time(&filefindbuf.ftLastWriteTime);
    }

    if (findhndl == cast(HANDLE)-1)
    {
    throw new FileException(name, GetLastError());
    }
    FindClose(findhndl);
}


/***************************************************
 * Does file name[] (or directory) exist?
 * Return 1 if it does, 0 if not.
 */

int exists(char[] name)
{
    uint result;

    if (useWfuncs)
    // http://msdn.microsoft.com/library/default.asp?url=/library/en-us/fileio/base/getfileattributes.asp
    result = GetFileAttributesW(std.utf.toUTF16z(name));
    else
    result = GetFileAttributesA(toMBSz(name));

    return (result == 0xFFFFFFFF) ? 0 : 1;
}

/***************************************************
 * Get file name[] attributes.
 * Throws: FileException on error.
 */

uint getAttributes(char[] name)
{
    uint result;

    if (useWfuncs)
    result = GetFileAttributesW(std.utf.toUTF16z(name));
    else
    result = GetFileAttributesA(toMBSz(name));
    if (result == 0xFFFFFFFF)
    {
    throw new FileException(name, GetLastError());
    }
    return result;
}

/****************************************************
 * Is name[] a file?
 * Throws: FileException if name[] doesn't exist.
 */

int isfile(char[] name)
{
    return (getAttributes(name) & FILE_ATTRIBUTE_DIRECTORY) == 0;
}

/****************************************************
 * Is name[] a directory?
 * Throws: FileException if name[] doesn't exist.
 */

int isdir(char[] name)
{
    return (getAttributes(name) & FILE_ATTRIBUTE_DIRECTORY) != 0;
}

/****************************************************
 * Change directory to pathname[].
 * Throws: FileException on error.
 */

void chdir(char[] pathname)
{   BOOL result;

    if (useWfuncs)
    result = SetCurrentDirectoryW(std.utf.toUTF16z(pathname));
    else
    result = SetCurrentDirectoryA(toMBSz(pathname));

    if (!result)
    {
    throw new FileException(pathname, GetLastError());
    }
}

/****************************************************
 * Make directory pathname[].
 * Throws: FileException on error.
 */

void mkdir(char[] pathname)
{   BOOL result;

    if (useWfuncs)
    result = CreateDirectoryW(std.utf.toUTF16z(pathname), null);
    else
    result = CreateDirectoryA(toMBSz(pathname), null);

    if (!result)
    {
    throw new FileException(pathname, GetLastError());
    }
}

/****************************************************
 * Remove directory pathname[].
 * Throws: FileException on error.
 */

void rmdir(char[] pathname)
{   BOOL result;

    if (useWfuncs)
    result = RemoveDirectoryW(std.utf.toUTF16z(pathname));
    else
    result = RemoveDirectoryA(toMBSz(pathname));

    if (!result)
    {
    throw new FileException(pathname, GetLastError());
    }
}

/****************************************************
 * Get current directory.
 * Throws: FileException on error.
 */

char[] getcwd()
{
    if (useWfuncs)
    {
    wchar c;

    auto len = GetCurrentDirectoryW(0, &c);
    if (!len)
        goto Lerr;
    auto dir = new wchar[len];
    len = GetCurrentDirectoryW(len, dir.ptr);
    if (!len)
        goto Lerr;
    return std.utf.toUTF8(dir[0 .. len]); // leave off terminating 0
    }
    else
    {
    char c;

    auto len = GetCurrentDirectoryA(0, &c);
    if (!len)
        goto Lerr;
    auto dir = new char[len];
    len = GetCurrentDirectoryA(len, dir.ptr);
    if (!len)
        goto Lerr;
    return dir[0 .. len];       // leave off terminating 0
    }

Lerr:
    throw new FileException("getcwd", GetLastError());
}

/***************************************************
 * Directory Entry
 */

struct DirEntry
{
    char[] name;            /// file or directory name
    ulong size = ~0UL;          /// size of file in bytes
    d_time creationTime = d_time_nan;   /// time of file creation
    d_time lastAccessTime = d_time_nan; /// time file was last accessed
    d_time lastWriteTime = d_time_nan;  /// time file was last written to
    uint attributes;        // Windows file attributes OR'd together

    void init(char[] path, WIN32_FIND_DATA *fd)
    {
    wchar[] wbuf;
    size_t clength;
    size_t wlength;
    size_t n;

    clength = std.string.strlen(fd.cFileName.ptr);

    // Convert cFileName[] to unicode
    wlength = MultiByteToWideChar(0,0,fd.cFileName.ptr,clength,null,0);
    if (wlength > wbuf.length)
        wbuf.length = wlength;
    n = MultiByteToWideChar(0,0,fd.cFileName.ptr,clength,cast(wchar*)wbuf,wlength);
    assert(n == wlength);
    // toUTF8() returns a new buffer
    name = std.path.join(path, std.utf.toUTF8(wbuf[0 .. wlength]));

    size = (cast(ulong)fd.nFileSizeHigh << 32) | fd.nFileSizeLow;
    creationTime = std.date.FILETIME2d_time(&fd.ftCreationTime);
    lastAccessTime = std.date.FILETIME2d_time(&fd.ftLastAccessTime);
    lastWriteTime = std.date.FILETIME2d_time(&fd.ftLastWriteTime);
    attributes = fd.dwFileAttributes;
    }

    void init(char[] path, WIN32_FIND_DATAW *fd)
    {
    size_t clength = std.string.wcslen(fd.cFileName.ptr);
    name = std.path.join(path, std.utf.toUTF8(fd.cFileName[0 .. clength]));
    size = (cast(ulong)fd.nFileSizeHigh << 32) | fd.nFileSizeLow;
    creationTime = std.date.FILETIME2d_time(&fd.ftCreationTime);
    lastAccessTime = std.date.FILETIME2d_time(&fd.ftLastAccessTime);
    lastWriteTime = std.date.FILETIME2d_time(&fd.ftLastWriteTime);
    attributes = fd.dwFileAttributes;
    }

    /****
     * Return !=0 if DirEntry is a directory.
     */
    uint isdir()
    {
    return attributes & FILE_ATTRIBUTE_DIRECTORY;
    }

    /****
     * Return !=0 if DirEntry is a file.
     */
    uint isfile()
    {
    return !(attributes & FILE_ATTRIBUTE_DIRECTORY);
    }
}


/***************************************************
 * Return contents of directory pathname[].
 * The names in the contents do not include the pathname.
 * Throws: FileException on error
 * Example:
 *  This program lists all the files and subdirectories in its
 *  path argument.
 * ----
 * import std.stdio;
 * import std.file;
 *
 * void main(char[][] args)
 * {
 *    auto dirs = std.file.listdir(args[1]);
 *
 *    foreach (d; dirs)
 *  writefln(d);
 * }
 * ----
 */

char[][] listdir(char[] pathname)
{
    char[][] result;
    
    bool listing(char[] filename)
    {
    result ~= filename;
    return true; // continue
    }
    
    listdir(pathname, &listing);
    return result;
}


/*****************************************************
 * Return all the files in the directory and its subdirectories
 * that match pattern or regular expression r.
 * Params:
 *  pathname = Directory name
 *  pattern = String with wildcards, such as $(RED "*.d"). The supported
 *      wildcard strings are described under fnmatch() in
 *      $(LINK2 std_path.html, std.path).
 *  r = Regular expression, for more powerful _pattern matching.
 * Example:
 *  This program lists all the files with a "d" extension in
 *  the path passed as the first argument.
 * ----
 * import std.stdio;
 * import std.file;
 *
 * void main(char[][] args)
 * {
 *    auto d_source_files = std.file.listdir(args[1], "*.d");
 *
 *    foreach (d; d_source_files)
 *  writefln(d);
 * }
 * ----
 * A regular expression version that searches for all files with "d" or
 * "obj" extensions:
 * ----
 * import std.stdio;
 * import std.file;
 * import std.regexp;
 *
 * void main(char[][] args)
 * {
 *    auto d_source_files = std.file.listdir(args[1], RegExp(r"\.(d|obj)$"));
 *
 *    foreach (d; d_source_files)
 *  writefln(d);
 * }
 * ----
 */

char[][] listthisdir(char[] pathname, char[] pattern) { return listdir(pathname, pattern, false); }
char[][] listdir(char[] pathname, char[] pattern) { return listdir(pathname, pattern, true); }

char[][] listdir(char[] pathname, char[] pattern, bool recurse)
{   char[][] result;
    
    bool callback(DirEntry* de)
    {
    if (de.isdir)
    {
        if (recurse)
            listdir(de.name, &callback);
    }
    else
    {   if (std.path.fnmatch(de.name, pattern))
        result ~= de.name;
    }
    return true; // continue
    }
    
    listdir(pathname, &callback);
    return result;
}

/** Ditto */
char[][] listthisdir(char[] pathname, RegExp r) { return listdir(pathname, r, false); }
char[][] listdir(char[] pathname, RegExp r) { return listdir(pathname, r, true); }

char[][] listdir(char[] pathname, RegExp r, bool recurse)
{   char[][] result;
    bool callback(DirEntry* de)
    {
    if (de.isdir)
    {
        if (recurse)
            listdir(de.name, &callback);
    }
    else
    {   
        if (r.test(de.name))
        result ~= de.name;
    }
    return true; // continue
    }
    
    listdir(pathname, &callback);
    return result;
}

/******************************************************
 * For each file and directory name in pathname[],
 * pass it to the callback delegate.
 * Params:
 *  callback =  Delegate that processes each
 *          filename in turn. Returns true to
 *          continue, false to stop.
 * Example:
 *  This program lists all the files in its
 *  path argument, including the path.
 * ----
 * import std.stdio;
 * import std.path;
 * import std.file;
 *
 * void main(char[][] args)
 * {
 *    auto pathname = args[1];
 *    char[][] result;
 *
 *    bool listing(char[] filename)
 *    {
 *      result ~= std.path.join(pathname, filename);
 *      return true; // continue
 *    }
 *
 *    listdir(pathname, &listing);
 *
 *    foreach (name; result)
 *      writefln("%s", name);
 * }
 * ----
 */

void listdir(char[] pathname, bool delegate(char[] filename) callback)
{
    bool listing(DirEntry* de)
    {
    return callback(std.path.getBaseName(de.name));
    }

    listdir(pathname, &listing);
}

/******************************************************
 * For each file and directory DirEntry in pathname[],
 * pass it to the callback delegate.
 * Params:
 *  callback =  Delegate that processes each
 *          DirEntry in turn. Returns true to
 *          continue, false to stop.
 * Example:
 *  This program lists all the files in its
 *  path argument and all subdirectories thereof.<