~ubuntu-branches/ubuntu/quantal/ruby1.9.1/quantal

static struct ChildRecord *CreateChild(const WCHAR *, const WCHAR *, SECURITY_ATTRIBUTES *, HANDLE, HANDLE, HANDLE);

DWORD

static FARPROC

get_proc_address(const char *module, const char *func, HANDLE *mh)

{

    HANDLE h;

    FARPROC ptr;

 

    if (mh)

        h = LoadLibrary(module);

    else

        h = GetModuleHandle(module);

    if (!h)

        return NULL;

 

    ptr = GetProcAddress(h, func);

    if (mh) {

        if (ptr)

            *mh = h;

        else

            FreeLibrary(h);

    }

    return ptr;

}

 

    typedef UINT WINAPI wgetdir_func(WCHAR*, UINT);

    FARPROC ptr =

        get_proc_address("kernel32", "GetSystemWindowsDirectoryW", NULL);

    if (ptr)

        return (*(wgetdir_func *)ptr)(path, len);

        cancel_io = (cancel_io_t)get_proc_address("kernel32", "CancelIo", NULL);

    if (c == '@')

        return 1;

#define STRNDUPV(ptr, v, src, len)                                      \

    (((char *)memcpy(((ptr) = ALLOCV((v), (len) + 1)), (src), (len)))[len] = 0)

CreateChild(const WCHAR *cmd, const WCHAR *prog, SECURITY_ATTRIBUTES *psa,

    STARTUPINFOW aStartupInfo;

    memset(&aStartupInfo, 0, sizeof(aStartupInfo));

    memset(&aProcessInformation, 0, sizeof(aProcessInformation));

    aStartupInfo.cb = sizeof(aStartupInfo);

        fRet = CreateProcessW(prog, (WCHAR *)cmd, psa, psa,

                              psa->bInheritHandle, dwCreationFlags, NULL, NULL,

                              &aStartupInfo, &aProcessInformation);

static UINT filecp(void);

static WCHAR *mbstr_to_wstr(UINT, const char *, int, long *);

static char *wstr_to_mbstr(UINT, const WCHAR *, int, long *);

#define acp_to_wstr(str, plen) mbstr_to_wstr(CP_ACP, str, -1, plen)

#define wstr_to_acp(str, plen) wstr_to_mbstr(CP_ACP, str, -1, plen)

#define filecp_to_wstr(str, plen) mbstr_to_wstr(filecp(), str, -1, plen)

#define wstr_to_filecp(str, plen) wstr_to_mbstr(filecp(), str, -1, plen)

#define utf8_to_wstr(str, plen) mbstr_to_wstr(CP_UTF8, str, -1, plen)

#define wstr_to_utf8(str, plen) wstr_to_mbstr(CP_UTF8, str, -1, plen)

 

    WCHAR *wcmd, *wshell;

    rb_pid_t ret;

    VALUE v = 0;

    VALUE v2 = 0;

            char *tmp = ALLOCV(v, strlen(shell) + strlen(cmd) + sizeof(" -c ") + 2);

            char *tmp = ALLOCV(v, strlen(shell) + strlen(cmd) + sizeof(" /c ") + (nt ? 2 : 0));

                    STRNDUPV(p, v2, cmd + 1, len);

                    STRNDUPV(p, v2, cmd, len);

                    STRNDUPV(p, v2, shell, len);

                    cmd = p = ALLOCV(v, len + alen + (quote ? 2 : 0) + 1);

    /* assume ACP */

    wcmd = cmd ? acp_to_wstr(cmd, NULL) : NULL;

    if (v) ALLOCV_END(v);

    wshell = shell ? acp_to_wstr(shell, NULL) : NULL;

    if (v2) ALLOCV_END(v2);

 

    ret = child_result(CreateChild(wcmd, wshell, NULL, NULL, NULL, NULL), mode);

    free(wshell);

    free(wcmd);

    return ret;

    WCHAR *wcmd, *wprog;

    rb_pid_t ret;

    VALUE v = 0;

            STRNDUPV(cmd, v, prog, len);

        cmd = ALLOCV(v, len);

        cmd = ALLOCV(v, len);

    /* assume ACP */

    wcmd = cmd ? acp_to_wstr(cmd, NULL) : NULL;

    if (v) ALLOCV_END(v);

    wprog = prog ? acp_to_wstr(prog, NULL) : NULL;

 

    ret = child_result(CreateChild(wcmd, wprog, NULL, NULL, NULL, NULL), mode);

    free(wprog);

    free(wcmd);

    return ret;

//

int

    // the processes argv), we'll do globing and then build the argument

    // The outer loop does one interation for each element seen.

                //

                // terminating close-quote. If it is, we're finished with

        // if it's an input vector element and it's enclosed by quotes,

    // Almost done!

    //

 

// return the pointer to the current file name.

    VALUE v;

    scanname = ALLOCV_N(WCHAR, v, len + sizeof(wildcard) / sizeof(WCHAR));

    ALLOCV_END(v);

opendir_internal(WCHAR *wpath, const char *filename)

    struct stati64 sbuf;

    WIN32_FIND_DATAW fd;

    HANDLE fh;

    //

    // check to see if we've got a directory

    //

    if (wstati64(wpath, &sbuf) < 0) {

        return NULL;

    }

    if (!(sbuf.st_mode & S_IFDIR) &&

        (!ISALPHA(filename[0]) || filename[1] != ':' || filename[2] != '\0' ||

         ((1 << ((filename[0] & 0x5f) - 'A')) & GetLogicalDrives()) == 0)) {

        errno = ENOTDIR;

        return NULL;

    }

    fh = open_dir_handle(wpath, &fd);

        len = lstrlenW(fd.cFileName) + 1;

        // new name and it's null terminator

        memcpy(&p->start[idx], fd.cFileName, len * sizeof(WCHAR));

        if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)

        if (fd.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)

    } while (FindNextFileW(fh, &fd));