自学教程：C++ vp_stack_return_error函数代码示例

/* http://www.syuhitu.org/other/dir.html */const char *vp_readdir(char *args){    vp_stack_t stack;    char *dirname;    char buf[1024];    WIN32_FIND_DATA fd;    HANDLE h;    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    VP_RETURN_IF_FAIL(vp_stack_pop_str(&stack, &dirname));    snprintf(buf, sizeof(buf), "%s//*", dirname);    /* Get handle. */    h = FindFirstFileEx(buf, FindExInfoStandard, &fd,        FindExSearchNameMatch, NULL, 0    );    if (h == INVALID_HANDLE_VALUE) {        return vp_stack_return_error(&_result, "FindFirstFileEx() error: %s",                GetLastError());    }    do {        snprintf(buf, sizeof(buf), "%s/%s", dirname, fd.cFileName);        vp_stack_push_str(&_result, buf);    } while (FindNextFile(h, &fd));    FindClose(h);    return vp_stack_return(&_result);}

const char *vp_readdir(char *args){    vp_stack_t stack;    char *dirname;    char buf[1024];    DIR *dir;    struct dirent *dp;    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    VP_RETURN_IF_FAIL(vp_stack_pop_str(&stack, &dirname));    if ((dir=opendir(dirname)) == NULL) {        return vp_stack_return_error(&_result, "opendir() error: %s",                strerror(errno));    }    for (dp = readdir(dir); dp != NULL; dp = readdir(dir)) {        snprintf(buf, sizeof(buf), "%s/%s", dirname, dp->d_name);        vp_stack_push_str(&_result, buf);    }    closedir(dir);    return vp_stack_return(&_result);}

const char *vp_kill(char *args){    vp_stack_t stack;    pid_t pid, pgid;    int sig;    int ret;    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &pid));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &sig));    ret = kill(pid, sig);    if (ret < 0)        return vp_stack_return_error(&_result, "kill() error: %s",                strerror(errno));    if (sig != 0) {        /* Kill by the process group. */        pgid = getpgid(pid);        if (pid == pgid) {            kill(-pgid, sig);        }    }    vp_stack_push_num(&_result, "%d", ret);    return vp_stack_return(&_result);}

/* * This is based on socket.diff.gz written by Yasuhiro Matsumoto. * see: http://marc.theaimsgroup.com/?l=vim-dev&m=105289857008664&w=2 */const char *vp_socket_open(char *args){    vp_stack_t stack;    char *host;    char *port;    char *p;    int n;    unsigned short nport;    int sock;    struct sockaddr_in sockaddr;    struct hostent *hostent;    struct servent *servent;    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    VP_RETURN_IF_FAIL(vp_stack_pop_str(&stack, &host));    VP_RETURN_IF_FAIL(vp_stack_pop_str(&stack, &port));    n = strtol(port, &p, 10);    if (p == port + strlen(port)) {        nport = htons(n);    } else {        servent = getservbyname(port, NULL);        if (servent == NULL)            return vp_stack_return_error(&_result, "getservbyname() error: %s",                    port);        nport = servent->s_port;    }    sock = socket(PF_INET, SOCK_STREAM, 0);    hostent = gethostbyname(host);    sockaddr.sin_family = AF_INET;    sockaddr.sin_port = nport;    sockaddr.sin_addr = *((struct in_addr*)*hostent->h_addr_list);    if (connect(sock, (struct sockaddr*)&sockaddr, sizeof(struct sockaddr_in))            == -1)        return vp_stack_return_error(&_result, "connect() error: %s",                strerror(errno));    vp_stack_push_num(&_result, "%d", sock);    return vp_stack_return(&_result);}

const char *vp_socket_write(char *args){    vp_stack_t stack;    int sock;    char *buf;    size_t size;    int timeout;    struct timeval tv;    size_t nleft;    int n;    fd_set fdset;    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &sock));    VP_RETURN_IF_FAIL(vp_stack_pop_bin(&stack, &buf, &size));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &timeout));    tv.tv_sec = timeout / 1000;    tv.tv_usec = (timeout - tv.tv_sec * 1000) * 1000;    FD_ZERO(&fdset);    FD_SET((unsigned)sock, &fdset);    nleft = 0;    while (nleft < size) {        n = select(0, NULL, &fdset, NULL, (timeout == -1) ? NULL : &tv);        if (n == SOCKET_ERROR) {            return vp_stack_return_error(&_result, "select() error: %d",                    WSAGetLastError());        } else if (n == 0) {            /* timeout */            break;        }        n = send(sock, buf + nleft, (int)(size - nleft), 0);        if (n == -1)            return vp_stack_return_error(&_result, "send() error: %s",                    strerror(errno));        nleft += n;        /* try write more bytes without waiting */        timeout = 0;    }    vp_stack_push_num(&_result, "%u", nleft);    return vp_stack_return(&_result);}

const char *vp_waitpid(char *args){    vp_stack_t stack;    pid_t pid, pgid;    pid_t n;    int status;    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &pid));    n = waitpid(pid, &status, WNOHANG | WUNTRACED);    if (n == -1)        return vp_stack_return_error(&_result, "waitpid() error: %s",                strerror(errno));    if (n == 0 || WIFCONTINUED(status)) {        vp_stack_push_str(&_result, "run");        vp_stack_push_num(&_result, "%d", 0);    } else if (WIFEXITED(status)) {        /* Kill by the process group. */        pgid = getpgid(pid);        if (pgid > 0) {            kill(-pgid, 15);        }        vp_stack_push_str(&_result, "exit");        vp_stack_push_num(&_result, "%d", WEXITSTATUS(status));    } else if (WIFSIGNALED(status)) {        vp_stack_push_str(&_result, "signal");        vp_stack_push_num(&_result, "%d", WTERMSIG(status));    } else if (WIFSTOPPED(status)) {        vp_stack_push_str(&_result, "stop");        vp_stack_push_num(&_result, "%d", WSTOPSIG(status));    } else {        return vp_stack_return_error(&_result,                "waitpid() unknown status: status=%d", status);    }    return vp_stack_return(&_result);}

const char *vp_file_write(char *args){    vp_stack_t stack;    int fd;    char *buf;    size_t size;    int timeout;    size_t nleft;    DWORD ret;    int n;    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &fd));    VP_RETURN_IF_FAIL(vp_stack_pop_bin(&stack, &buf, &size));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &timeout));    nleft = 0;    while (nleft < size) {        ret = WaitForSingleObject((HANDLE)_get_osfhandle(fd), timeout);        if (ret == WAIT_FAILED) {            return vp_stack_return_error(&_result, "WaitForSingleObject() error: %s",                    lasterror());        } else if (ret == WAIT_TIMEOUT) {            /* timeout */            break;        }        n = write(fd, buf + nleft, (unsigned int)(size - nleft));        if (n == -1) {            return vp_stack_return_error(&_result, "write() error: %s",                    strerror(errno));        }        nleft += n;        /* try write more bytes without waiting */        timeout = 0;    }    vp_stack_push_num(&_result, "%u", nleft);    return vp_stack_return(&_result);}

const char *vp_file_close(char *args){    vp_stack_t stack;    int fd;    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &fd));    if (close(fd) == -1)        return vp_stack_return_error(&_result, "close() error: %s",                strerror(errno));    return NULL;}

const char *vp_close_handle(char *args){    vp_stack_t stack;    HANDLE handle;    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%p", &handle));    if (!CloseHandle(handle))        return vp_stack_return_error(&_result,                "CloseHandle() error: %s", lasterror());    return NULL;}

const char *vp_pipe_close(char *args){    vp_stack_t stack;    int fd;    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &fd));    if (!CloseHandle((HANDLE)_get_osfhandle(fd)))        return vp_stack_return_error(&_result, "CloseHandle() error: %s",                lasterror());    return NULL;}

const char *vp_kill(char *args){    vp_stack_t stack;    HANDLE handle;    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%p", &handle));    if (!TerminateProcess(handle, 2) || !CloseHandle(handle))        return vp_stack_return_error(&_result, "kill() error: %s",                lasterror());    return NULL;}

const char *vp_kill(char *args){    vp_stack_t stack;    pid_t pid;    int sig;    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &pid));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &sig));    if (kill(pid, sig) == -1)        return vp_stack_return_error(&_result, "kill() error: %s",                strerror(errno));    return NULL;}

const char *vp_open(char *args){    vp_stack_t stack;    char *path;    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    VP_RETURN_IF_FAIL(vp_stack_pop_str(&stack, &path));    if ((size_t)ShellExecute(NULL, "open", path, NULL, NULL, SW_SHOWNORMAL) < 32) {        return vp_stack_return_error(&_result, "ShellExecute() error: %s",                lasterror());    }    return NULL;}

const char *vp_pty_set_winsize(char *args){    vp_stack_t stack;    int fd;    struct winsize ws = {0, 0, 0, 0};    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &fd));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%hu", &(ws.ws_col)));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%hu", &(ws.ws_row)));    if (ioctl(fd, TIOCSWINSZ, &ws) < 0)        return vp_stack_return_error(&_result, "ioctl() error: %s",                strerror(errno));    return NULL;}

const char *vp_waitpid(char *args){    vp_stack_t stack;    HANDLE handle;    DWORD exitcode;    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%p", &handle));    if (!GetExitCodeProcess(handle, &exitcode))        return vp_stack_return_error(&_result,                "GetExitCodeProcess() error: %s", lasterror());    vp_stack_push_str(&_result, (exitcode == STILL_ACTIVE) ? "run" : "exit");    vp_stack_push_num(&_result, "%u", exitcode);    return vp_stack_return(&_result);}

const char *vp_socket_close(char *args){    vp_stack_t stack;    int sock;    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &sock));    if (closesocket(sock) == SOCKET_ERROR) {        return vp_stack_return_error(&_result, "closesocket() error: %d",                WSAGetLastError());    }    if (--sockets_number == 0)    {        WSACleanup();    }    return NULL;}

const char *vp_kill(char *args){    vp_stack_t stack;    pid_t pid;    int sig;    int ret;    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &pid));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &sig));    ret = kill(pid, sig);    if (ret < 0)        return vp_stack_return_error(&_result, "kill() error: %s",                                     strerror(errno));    vp_stack_push_num(&_result, "%d", ret);    return vp_stack_return(&_result);}

const char *vp_decode(char *args){    vp_stack_t stack;    unsigned num = 0;    unsigned i = 0;    size_t length;    char *str;    char *buf;    char *p;    char *bp;    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    VP_RETURN_IF_FAIL(vp_stack_pop_str(&stack, &str));    length = strlen(str);    buf = (char *)malloc(length/2 + 2);    if (buf == NULL) {        return vp_stack_return_error(&_result, "malloc() error: %s",                "Memory cannot allocate");    }    p = str;    bp = buf;    for (i = 0; i < length; i++, p++) {        if (isdigit(*p))            num |= (*p & 15);        else            num |= (*p & 15) + 9;        if (i % 2) {            *bp++ = num;            num = 0;        } else {            num <<= 4;        }    }    *bp = '/0';    vp_stack_push_str(&_result, buf);    free(buf);    return vp_stack_return(&_result);}

const char *vp_delete_trash(char *args){    vp_stack_t stack;    char *filename;    char *buf;    size_t len;    SHFILEOPSTRUCT fs;    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    VP_RETURN_IF_FAIL(vp_stack_pop_str(&stack, &filename));    len = strlen(filename);    buf = malloc(len + 2);    if (buf == NULL) {        return vp_stack_return_error(&_result, "malloc() error: %s",                "Memory cannot allocate");    }    /* Copy filename + '/0/0' */    strcpy(buf, filename);    buf[len + 1] = 0;    ZeroMemory(&fs, sizeof(SHFILEOPSTRUCT));    fs.hwnd = NULL;    fs.wFunc = FO_DELETE;    fs.pFrom = buf;    fs.pTo = NULL;    fs.fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMATION | FOF_NOERRORUI | FOF_SILENT;    vp_stack_push_num(&_result, "%d", SHFileOperation(&fs));    free(buf);    return vp_stack_return(&_result);}

const char *vp_decode(char *args){    vp_stack_t stack;    unsigned num;    unsigned i, bi;    size_t length, max_buf;    char *str;    char *buf;    char *p;    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    VP_RETURN_IF_FAIL(vp_stack_pop_str(&stack, &str));    length = strlen(str);    max_buf = length/2 + 2;    buf = (char *)malloc(max_buf);    if (buf == NULL) {        return vp_stack_return_error(&_result, "malloc() error: %s",                "Memory cannot allocate");    }    p = str;    bi = 0;    num = 0;    for (i = 0; i < length; i++, p++) {        if (isdigit((int)*p))            num |= (*p & 15);        else            num |= (*p & 15) + 9;        if (i % 2 == 0) {            num <<= 4;            continue;        }        /* Write character. */        if (num == 0) {            /* Convert NULL character. */            max_buf += 1;            buf = (char *)realloc(buf, max_buf);            if (buf == NULL) {                return vp_stack_return_error(                        &_result, "realloc() error: %s",                        "Memory cannot allocate");            }            buf[bi] = '^';            bi++;            buf[bi] = '@';            bi++;        } else {            buf[bi] = num;            bi++;        }        num = 0;    }    buf[bi] = '/0';    vp_stack_push_str(&_result, buf);    free(buf);    return vp_stack_return(&_result);}

const char *vp_fd_read(char *args, int is_pty_pipe){#ifdef __linux__# define VP_POLLIN (POLLIN | POLLHUP)#else# define VP_POLLIN (POLLIN)#endif    vp_stack_t stack;    int fd;    int cnt;    int timeout;    int n;    char *buf;    char *eof;    unsigned int size = 0;    struct pollfd pfd = {0, POLLIN, 0};    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &fd));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &cnt));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &timeout));    if (cnt < 0 || VP_READ_BUFSIZE < cnt) {        cnt = VP_READ_BUFSIZE;    }    /* initialize buffer */    _result.top = _result.buf;    vp_stack_push_num(&_result, "%d", 0);   /* set eof to 0 */    eof = _result.top - 1;    buf = _result.top;    *(buf++) = VP_EOV;    buf += VP_HEADER_SIZE;    pfd.fd = fd;    while (cnt > 0) {        n = poll(&pfd, 1, timeout);        if (n == -1) {            /* eof or error */            *eof = '1';            break;        } else if (n == 0) {            /* timeout */            break;        }        if (pfd.revents & VP_POLLIN) {            n = read(fd, buf, cnt);            if (n == -1) {                if (pfd.revents & POLLERR                        || pfd.revents & POLLNVAL                        || pfd.revents & POLLWRNORM                        /* Cygwin(after ver.2.0) fails pty read and returns                         * POLLIN. */                        || (!is_pty_pipe && pfd.revents & POLLIN)                        ) {                    return vp_stack_return_error(&_result,                            "read() error: revents = %d, error = %s",                            pfd.revents, strerror(errno));                }                /* eof */                *eof = '1';                break;            } else if (n == 0) {                /* eof */                *eof = '1';                break;            }            /* decrease stack top for concatenate. */            cnt -= n;            buf += n;            size += n;            /* try read more bytes without waiting */            timeout = 0;            continue;        } else if (pfd.revents & (POLLERR | POLLHUP)) {            /* eof or error */            *eof = '1';            break;        } else if (pfd.revents & POLLNVAL) {            return vp_stack_return_error(&_result, "poll() POLLNVAL: %d",                    pfd.revents);        }        /* DO NOT REACH HERE */        return vp_stack_return_error(&_result, "poll() unknown status: %d",                pfd.revents);    }    vp_encode_size(size, _result.top + 1);    _result.top = buf;    return vp_stack_return(&_result);#undef VP_POLLIN}

const char *vp_pipe_open(char *args){#define VP_GOTO_ERROR(_fmt) do { errfmt = (_fmt); goto error; } while(0)    vp_stack_t stack;    int npipe, hstdin, hstderr, hstdout;    int argc;    int fd[3][2] = {{0}};    pid_t pid;    int dummy;    char *errfmt;    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &npipe));    if (npipe != 2 && npipe != 3)        return vp_stack_return_error(&_result, "npipe range error. wrong pipes.");    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &hstdin));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &hstdout));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &hstderr));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &argc));    if (hstdin > 0) {        fd[0][0] = hstdin;        fd[0][1] = 0;    } else {        if (pipe(fd[0]) < 0) {            VP_GOTO_ERROR("pipe() error: %s");        }    }    if (hstdout > 0) {        fd[1][1] = hstdout;        fd[1][0] = 0;    } else {        if (pipe(fd[1]) < 0) {            VP_GOTO_ERROR("pipe() error: %s");        }    }    if (hstderr > 0) {        fd[2][1] = hstderr;        fd[2][0] = 0;    } else if (npipe == 3 && hstderr == 0) {        if (pipe(fd[2]) < 0) {            VP_GOTO_ERROR("pipe() error: %s");        }    }    pid = fork();    if (pid < 0) {        VP_GOTO_ERROR("fork() error: %s");    } else if (pid == 0) {        /* child */        char **argv;        int i;        /* Set process group. */        setpgid(0, 0);        if (fd[0][1] > 0) {            close(fd[0][1]);        }        if (fd[1][0] > 0) {            close(fd[1][0]);        }        if (fd[2][0] > 0) {            close(fd[2][0]);        }        if (fd[0][0] > 0) {            if (dup2(fd[0][0], STDIN_FILENO) != STDIN_FILENO) {                goto child_error;            }            close(fd[0][0]);        }        if (fd[1][1] > 0) {            if (dup2(fd[1][1], STDOUT_FILENO) != STDOUT_FILENO) {                goto child_error;            }            close(fd[1][1]);        }        if (fd[2][1] > 0) {            if (dup2(fd[2][1], STDERR_FILENO) != STDERR_FILENO) {                goto child_error;            }            close(fd[2][1]);        } else if (npipe == 2) {            if (dup2(STDOUT_FILENO, STDERR_FILENO) != STDERR_FILENO) {                goto child_error;            }        }        {#ifndef TIOCNOTTY            setsid();#else            /* Ignore tty. */            char name[L_ctermid];            if (ctermid(name)[0] != '/0') {                int tfd;                if ((tfd = open(name, O_RDONLY)) != -1) {                    ioctl(tfd, TIOCNOTTY, NULL);                    close(tfd);//.........这里部分代码省略.........

const char *vp_pty_open(char *args){#define VP_GOTO_ERROR(_fmt) do { errfmt = (_fmt); goto error; } while(0)    vp_stack_t stack;    int argc;    int fd[3][2] = {{0}};    pid_t pid;    struct winsize ws = {0, 0, 0, 0};    int dummy;    int hstdin, hstderr, hstdout;    int fdm;    int npipe;    char *errfmt;    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &npipe));    if (npipe != 2 && npipe != 3)        return vp_stack_return_error(&_result, "npipe range error. wrong pipes.");    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%hu", &(ws.ws_col)));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%hu", &(ws.ws_row)));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &hstdin));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &hstdout));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &hstderr));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &argc));    /* Set pipe */    if (hstdin > 0) {        fd[0][0] = hstdin;        fd[0][1] = 0;    }    if (hstdout > 1) {        fd[1][1] = hstdout;        fd[1][0] = 0;    } else if (hstdout == 1) {        if (pipe(fd[1]) < 0) {            VP_GOTO_ERROR("pipe() error: %s");        }    }    if (hstderr > 1) {        fd[2][1] = hstderr;        fd[2][0] = 0;    } else if (npipe == 3) {        if (hstderr == 1){            if (pipe(fd[2]) < 0) {                VP_GOTO_ERROR("pipe() error: %s");            }        } else if (hstderr == 0) {            if (openpty(&fd[2][0], &fd[2][1], NULL, NULL, &ws) < 0) {                VP_GOTO_ERROR("openpty() error: %s");            }            VP_SET_NONBLOCK_IF_NEEDED(fd[2][0]);        }    }    pid = forkpty(&fdm, NULL, NULL, &ws);    if (pid < 0) {        VP_GOTO_ERROR("fork() error: %s");    } else if (pid == 0) {        /* child */        char **argv;        int i;        /* Close pipe */        if (fd[1][0] > 0) {            close(fd[1][0]);        }        if (fd[2][0] > 0) {            close(fd[2][0]);        }        if (fd[0][0] > 0) {            if (dup2(fd[0][0], STDIN_FILENO) != STDIN_FILENO) {                goto child_error;            }            close(fd[0][0]);        }        if (fd[1][1] > 0) {            if (dup2(fd[1][1], STDOUT_FILENO) != STDOUT_FILENO) {                goto child_error;            }            close(fd[1][1]);        }        if (fd[2][1] > 0) {            if (dup2(fd[2][1], STDERR_FILENO) != STDERR_FILENO) {                goto child_error;            }            close(fd[2][1]);        }        argv = malloc(sizeof(char *) * (argc+1));        if (argv == NULL) {            goto child_error;        }        for (i = 0; i < argc; ++i) {            if (vp_stack_pop_str(&stack, &(argv[i]))) {                free(argv);                goto child_error;//.........这里部分代码省略.........

/* * http://support.microsoft.com/kb/190351/ */const char *vp_pipe_open(char *args){    vp_stack_t stack;    int npipe, hstdin, hstderr, hstdout;    char *cmdline;    HANDLE hInputWrite = INVALID_HANDLE_VALUE, hInputRead;    HANDLE hOutputWrite, hOutputRead = INVALID_HANDLE_VALUE;    HANDLE hErrorWrite, hErrorRead = INVALID_HANDLE_VALUE;    SECURITY_ATTRIBUTES sa;    PROCESS_INFORMATION pi;    STARTUPINFO si;    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &npipe));    if (npipe != 2 && npipe != 3)        return vp_stack_return_error(&_result, "npipe range error");    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &hstdin));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &hstdout));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &hstderr));    VP_RETURN_IF_FAIL(vp_stack_pop_str(&stack, &cmdline));    sa.nLength = sizeof(SECURITY_ATTRIBUTES);    sa.lpSecurityDescriptor = NULL;    sa.bInheritHandle = TRUE;    if (hstdin) {        /* Get handle. */        hInputRead = (HANDLE)_get_osfhandle(hstdin);    } else {        HANDLE hInputWriteTmp;        /* Create pipe. */        if (!CreatePipe(&hInputRead, &hInputWriteTmp, &sa, 0))            return vp_stack_return_error(&_result, "CreatePipe() error: %s",                    lasterror());        if (!DuplicateHandle(GetCurrentProcess(),                    hInputWriteTmp,                    GetCurrentProcess(),                    &hInputWrite,                    0,                    FALSE,                    DUPLICATE_SAME_ACCESS))            return vp_stack_return_error(&_result, "DuplicateHandle() error: %s",                    lasterror());        if (!CloseHandle(hInputWriteTmp))            return vp_stack_return_error(&_result, "CloseHandle() error: %s",                    lasterror());    }    if (hstdout) {        /* Get handle. */        hOutputWrite = (HANDLE)_get_osfhandle(hstdout);    } else {        HANDLE hOutputReadTmp;        /* Create pipe. */        if (!CreatePipe(&hOutputReadTmp, &hOutputWrite, &sa, 0))            return vp_stack_return_error(&_result, "CreatePipe() error: %s",                    lasterror());        if (!DuplicateHandle(GetCurrentProcess(),                    hOutputReadTmp,                    GetCurrentProcess(),                    &hOutputRead,                    0,                    TRUE,                    DUPLICATE_SAME_ACCESS))            return vp_stack_return_error(&_result, "DuplicateHandle() error: %s",                    lasterror());        if (!CloseHandle(hOutputReadTmp))            return vp_stack_return_error(&_result, "CloseHandle() error: %s",                    lasterror());    }    if (npipe == 2) {        if (!DuplicateHandle(GetCurrentProcess(),                             hOutputWrite,                             GetCurrentProcess(),                             &hErrorWrite,                             0,                             TRUE,                             DUPLICATE_SAME_ACCESS))            return vp_stack_return_error(&_result, "DuplicateHandle() error: %s",                    lasterror());    } else {        if (hstderr) {            /* Get handle. */            hErrorWrite = (HANDLE)_get_osfhandle(hstderr);        } else {            HANDLE hErrorReadTmp;            /* Create pipe. */            if (!CreatePipe(&hErrorReadTmp, &hErrorWrite, &sa, 0))                return vp_stack_return_error(&_result, "CreatePipe() error: %s",                        lasterror());//.........这里部分代码省略.........

const char *vp_pty_open(char *args){    vp_stack_t stack;    int argc;    int fd[3][2];    pid_t pid;    struct winsize ws = {0, 0, 0, 0};    int dummy;    int hstdin, hstderr, hstdout;    int fdm;    int npipe;    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &npipe));    if (npipe != 2 && npipe != 3)        return vp_stack_return_error(&_result, "npipe range error. wrong pipes.");    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%hu", &(ws.ws_col)));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%hu", &(ws.ws_row)));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &hstdin));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &hstdout));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &hstderr));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &argc));    /* Set pipe */    if (hstdin) {        fd[0][0] = hstdin;        fd[0][1] = 0;    }    if (hstdout == 1) {        if (pipe(fd[1]) < 0) {            return vp_stack_return_error(&_result, "pipe() error: %s",                    strerror(errno));        }    } else if (hstdout) {        fd[1][1] = hstdout;        fd[1][0] = 0;    }    if (npipe == 3) {        if (hstderr == 1) {            if (pipe(fd[2]) < 0) {                return vp_stack_return_error(&_result, "pipe() error: %s",                        strerror(errno));            }        } else if (hstderr == 1) {            fd[2][1] = hstderr;            fd[2][0] = 0;        } else {            if (openpty(&fd[2][0], &fd[2][1], NULL, NULL, &ws) < 0) {                return vp_stack_return_error(&_result, "openpty() error: %s",                        strerror(errno));            }        }    }    pid = forkpty(&fdm, NULL, NULL, &ws);    if (hstdin == 0) {        fd[0][1] = fdm;    }    if (hstdout == 0) {        fd[1][0] = fdm;    }    if (hstdin == 0 && hstdout == 0) {        fd[1][0] = dup(fdm);    }    if (pid < 0) {        return vp_stack_return_error(&_result, "fork() error: %s",                strerror(errno));    } else if (pid == 0) {        /* child */        char **argv;        int i;        /* Close pipe */        if (hstdout == 1) {            close(fd[1][0]);        }        if (npipe == 3 && hstderr == 1) {            close(fd[2][0]);        }        if (hstdin && fd[0][0] != STDIN_FILENO) {            if (dup2(fd[0][0], STDIN_FILENO) != STDIN_FILENO) {                goto child_error;            }            close(fd[0][0]);        }        if (hstdout && fd[1][1] != STDOUT_FILENO) {            /* Set termios. */            if (dup2(fd[1][1], STDOUT_FILENO) != STDOUT_FILENO) {                goto child_error;            }            close(fd[1][1]);        }        if (npipe == 3 && fd[2][1] != STDERR_FILENO) {            if (dup2(fd[2][1], STDERR_FILENO) != STDERR_FILENO) {                goto child_error;//.........这里部分代码省略.........

const char *vp_pipe_open(char *args){    vp_stack_t stack;    int npipe, hstdin, hstderr, hstdout;    int argc;    int fd[3][2];    pid_t pid;    int dummy;    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &npipe));    if (npipe != 2 && npipe != 3)        return vp_stack_return_error(&_result, "npipe range error. wrong pipes.");    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &hstdin));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &hstdout));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &hstderr));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &argc));    if (hstdin) {        fd[0][0] = hstdin;        fd[0][1] = 0;    } else {        if (pipe(fd[0]) < 0) {            return vp_stack_return_error(&_result, "pipe() error: %s",                    strerror(errno));        }    }    if (hstdout) {        fd[1][1] = hstdout;        fd[1][0] = 0;    } else {        if (pipe(fd[1]) < 0) {            return vp_stack_return_error(&_result, "pipe() error: %s",                    strerror(errno));        }    }    if (npipe == 3) {        if (hstderr) {            fd[2][1] = hstderr;            fd[2][0] = 0;        } else {            if (pipe(fd[2]) < 0) {                return vp_stack_return_error(&_result, "pipe() error: %s",                        strerror(errno));            }        }    }    pid = fork();    if (pid < 0) {        return vp_stack_return_error(&_result, "fork() error: %s",                strerror(errno));    } else if (pid == 0) {        /* child */        char **argv;        int i;        if (!hstdin) {            close(fd[0][1]);        }        if (!hstdout) {            close(fd[1][0]);        }        if (npipe == 3 && !hstderr) {            close(fd[2][0]);        }        if (fd[0][0] != STDIN_FILENO) {            if (dup2(fd[0][0], STDIN_FILENO) != STDIN_FILENO) {                goto child_error;            }            close(fd[0][0]);        }        if (fd[1][1] != STDOUT_FILENO) {            if (dup2(fd[1][1], STDOUT_FILENO) != STDOUT_FILENO) {                goto child_error;            }            close(fd[1][1]);        }        if (npipe == 2) {            if (dup2(STDOUT_FILENO, STDERR_FILENO) != STDERR_FILENO) {                goto child_error;            }        } else if (fd[2][1] != STDERR_FILENO) {            if (dup2(fd[2][1], STDERR_FILENO) != STDERR_FILENO) {                goto child_error;            }            close(fd[2][1]);        }        argv = malloc(sizeof(char *) * (argc+1));        if (argv == NULL) {            goto child_error;        }        for (i = 0; i < argc; ++i) {            if (vp_stack_pop_str(&stack, &(argv[i]))) {                free(argv);                goto child_error;            }        }//.........这里部分代码省略.........

const char *vp_file_read(char *args){    vp_stack_t stack;    int fd;    int nr;    int timeout;    int n;    char buf[VP_READ_BUFSIZE];    struct pollfd pfd = {0, POLLIN, 0};    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &fd));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &nr));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &timeout));    pfd.fd = fd;    vp_stack_push_str(&_result, ""); /* initialize */    while (nr != 0) {        n = poll(&pfd, 1, timeout);        if (n == -1) {            /* eof or error */            vp_stack_push_num(&_result, "%d", 1);            return vp_stack_return(&_result);        } else if (n == 0) {            /* timeout */            break;        }        if (pfd.revents & POLLIN) {            if (nr > 0)                n = read(fd, buf,                        (VP_READ_BUFSIZE < nr) ? VP_READ_BUFSIZE : nr);            else                n = read(fd, buf, VP_READ_BUFSIZE);            if (n == -1) {                return vp_stack_return_error(&_result, "read() error: %s",                        strerror(errno));            } else if (n == 0) {                /* eof */                vp_stack_push_num(&_result, "%d", 1);                return vp_stack_return(&_result);            }            /* decrease stack top for concatenate. */            _result.top--;            vp_stack_push_bin(&_result, buf, n);            if (nr > 0)                nr -= n;            /* try read more bytes without waiting */            timeout = 0;            continue;        } else if (pfd.revents & (POLLERR | POLLHUP)) {            /* eof or error */            vp_stack_push_num(&_result, "%d", 1);            return vp_stack_return(&_result);        } else if (pfd.revents & POLLNVAL) {            return vp_stack_return_error(&_result, "poll() POLLNVAL: %d",                    pfd.revents);        }        /* DO NOT REACH HERE */        return vp_stack_return_error(&_result, "poll() unknown status: %d",                pfd.revents);    }    vp_stack_push_num(&_result, "%d", 0);    return vp_stack_return(&_result);}

const char *vp_file_open(char *args){    vp_stack_t stack;    char *path;    char *flags;    int mode;  /* used when flags have O_CREAT */    int f = 0;    int fd;    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    VP_RETURN_IF_FAIL(vp_stack_pop_str(&stack, &path));    VP_RETURN_IF_FAIL(vp_stack_pop_str(&stack, &flags));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &mode));#ifdef O_RDONLY    if (strstr(flags, "O_RDONLY"))      f |= O_RDONLY;#endif#ifdef O_WRONLY    if (strstr(flags, "O_WRONLY"))      f |= O_WRONLY;#endif#ifdef O_RDRW    if (strstr(flags, "O_RDRW"))        f |= O_RDWR;#endif#ifdef O_NONBLOCK    if (strstr(flags, "O_NONBLOCK"))    f |= O_NONBLOCK;#endif#ifdef O_APPEND    if (strstr(flags, "O_APPEND"))      f |= O_APPEND;#endif#ifdef O_CREAT    if (strstr(flags, "O_CREAT"))       f |= O_CREAT;#endif#ifdef O_EXCL    if (strstr(flags, "O_EXCL"))        f |= O_EXCL;#endif#ifdef O_TRUNC    if (strstr(flags, "O_TRUNC"))       f |= O_TRUNC;#endif#ifdef O_SHLOCK    if (strstr(flags, "O_SHLOCK"))      f |= O_SHLOCK;#endif#ifdef O_EXLOCK    if (strstr(flags, "O_EXLOCK"))      f |= O_EXLOCK;#endif#ifdef O_DIRECT    if (strstr(flags, "O_DIRECT"))      f |= O_DIRECT;#endif#ifdef O_FSYNC    if (strstr(flags, "O_FSYNC"))       f |= O_FSYNC;#endif#ifdef O_NOFOLLOW    if (strstr(flags, "O_NOFOLLOW"))    f |= O_NOFOLLOW;#endif#ifdef O_TEMPORARY    if (strstr(flags, "O_TEMPORARY"))   f |= O_TEMPORARY;#endif#ifdef O_RANDOM    if (strstr(flags, "O_RANDOM"))      f |= O_RANDOM;#endif#ifdef O_SEQUENTIAL    if (strstr(flags, "O_SEQENTIAL"))   f |= O_SEQUENTIAL;#endif#ifdef O_BINARY    if (strstr(flags, "O_BINARY"))      f |= O_BINARY;#endif#ifdef O_TEXT    if (strstr(flags, "O_TEXT"))        f |= O_TEXT;#endif#ifdef O_INHERIT    if (strstr(flags, "O_INHERIT"))     f |= O_INHERIT;#endif#ifdef _O_SHORT_LIVED    if (strstr(flags, "O_SHORT_LIVED")) f |= _O_SHORT_LIVED;#endif    fd = open(path, f, mode);    if (fd == -1)        return vp_stack_return_error(&_result, "open() error: %s",                strerror(errno));    vp_stack_push_num(&_result, "%d", fd);    return vp_stack_return(&_result);}

const char *vp_pipe_open(char *args){    vp_stack_t stack;    int npipe;    int argc;    char *argv[VP_ARGC_MAX];    int fd[3][2];    pid_t pid;    int i;    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &npipe));    if (npipe != 2 && npipe != 3)        return vp_stack_return_error(&_result, "npipe range error. wrong pipes.");    VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &argc));    if (argc < 1 || VP_ARGC_MAX <= argc)        return vp_stack_return_error(&_result, "argc range error. too many arguments. please use xargs.");    for (i = 0; i < argc; ++i)        VP_RETURN_IF_FAIL(vp_stack_pop_str(&stack, &(argv[i])));    argv[argc] = NULL;    if (pipe(fd[0]) < 0 || pipe(fd[1]) < 0 || (npipe == 3 && pipe(fd[2]) < 0))        return vp_stack_return_error(&_result, "pipe() error: %s",                strerror(errno));    pid = fork();    if (pid < 0) {        return vp_stack_return_error(&_result, "fork() error: %s",                strerror(errno));    } else if (pid == 0) {        /* child */        close(fd[0][1]);        close(fd[1][0]);        if (npipe == 3)            close(fd[2][0]);        if (fd[0][0] != STDIN_FILENO) {            if (dup2(fd[0][0], STDIN_FILENO) != STDIN_FILENO) {                write(fd[1][1], strerror(errno), strlen(strerror(errno)));                _exit(EXIT_FAILURE);            }            close(fd[0][0]);        }        if (fd[1][1] != STDOUT_FILENO) {            if (dup2(fd[1][1], STDOUT_FILENO) != STDOUT_FILENO) {                write(fd[1][1], strerror(errno), strlen(strerror(errno)));                _exit(EXIT_FAILURE);            }            close(fd[1][1]);        }        if (npipe == 2) {            if (dup2(STDOUT_FILENO, STDERR_FILENO) != STDERR_FILENO) {                write(STDOUT_FILENO, strerror(errno), strlen(strerror(errno)));                _exit(EXIT_FAILURE);            }        } else if (fd[2][1] != STDERR_FILENO) {            if (dup2(fd[2][1], STDERR_FILENO) != STDERR_FILENO) {                write(STDOUT_FILENO, strerror(errno), strlen(strerror(errno)));                _exit(EXIT_FAILURE);            }            close(fd[2][1]);        }        if (execv(argv[0], argv) < 0) {            /* error */            write(STDOUT_FILENO, strerror(errno), strlen(strerror(errno)));            _exit(EXIT_FAILURE);        }    } else {        /* parent */        close(fd[0][0]);        close(fd[1][1]);        if (npipe == 3)            close(fd[2][1]);        vp_stack_push_num(&_result, "%d", pid);        vp_stack_push_num(&_result, "%d", fd[0][1]);        vp_stack_push_num(&_result, "%d", fd[1][0]);        if (npipe == 3)            vp_stack_push_num(&_result, "%d", fd[2][0]);        return vp_stack_return(&_result);    }    /* DO NOT REACH HEAR */    return NULL;}