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

const char *vp_socket_read(char *args){    vp_stack_t stack;    int sock;    int nr;    int timeout;    struct timeval tv;    int n;    char buf[VP_READ_BUFSIZE];    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_num(&stack, "%d", &nr));    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);    vp_stack_push_str(&_result, ""); /* initialize */    while (nr != 0) {        n = select(0, &fdset, NULL, 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;        }        if (nr > 0)            n = recv(sock, buf,                    (VP_READ_BUFSIZE < nr) ? VP_READ_BUFSIZE : nr, 0);        else            n = recv(sock, buf, VP_READ_BUFSIZE, 0);        if (n == -1) {            return vp_stack_return_error(&_result, "recv() 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;    }    vp_stack_push_num(&_result, "%d", 0);    return vp_stack_return(&_result);}

const char *vp_pipe_read(char *args){    vp_stack_t stack;    int fd;    int nr;    int timeout;    DWORD n;    char buf[VP_READ_BUFSIZE];    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));    vp_stack_push_str(&_result, ""); /* initialize */    while (nr != 0) {        n = 0;        if (!PeekNamedPipe((HANDLE)_get_osfhandle(fd), buf,                (nr < 0) ? VP_READ_BUFSIZE : (VP_READ_BUFSIZE < nr) ? VP_READ_BUFSIZE : nr,                &n, NULL, NULL))        {            /* can be ERROR_HANDLE_EOF? */            if (GetLastError() == 0 || GetLastError() == ERROR_BROKEN_PIPE) {                /* error or eof */                if (n != 0) {                    /* decrease stack top for concatenate. */                    _result.top--;                    vp_stack_push_bin(&_result, buf, n);                }                vp_stack_push_num(&_result, "%d", 1);                return vp_stack_return(&_result);            }            return vp_stack_return_error(&_result, "PeekNamedPipe() error: %08X %s",                    GetLastError(), lasterror());        }        if (n == 0) {            break;        }        if (read(fd, buf, n) == -1)            return vp_stack_return_error(&_result, "read() error: %s",                    strerror(errno));        /* 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;    }    vp_stack_push_num(&_result, "%d", 0);    return vp_stack_return(&_result);}

const char *vp_file_read(char *args){    vp_stack_t stack;    int fd;    int nr;    int timeout;    DWORD ret;    int n;    char buf[VP_READ_BUFSIZE];    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));    vp_stack_push_str(&_result, ""); /* initialize */    while (nr != 0) {        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;        }        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;    }    vp_stack_push_num(&_result, "%d", 0);    return vp_stack_return(&_result);}

const char *vp_waitpid(char *args){    vp_stack_t stack;    pid_t pid;    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)) {        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);}

/* * Added by Richard Emberson * Check to see if a host exists. */const char *vp_host_exists(char *args){    vp_stack_t stack;    char *host;    struct hostent *hostent;    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    VP_RETURN_IF_FAIL(vp_stack_pop_str(&stack, &host));    if (sockets_number++ == 0)    {        WSADATA wsadata;        WSAStartup(2, &wsadata);    }    hostent = gethostbyname(host);    if (--sockets_number == 0)    {        WSACleanup();    }    if (hostent) {        vp_stack_push_num(&_result, "%d", 1);    } else {        vp_stack_push_num(&_result, "%d", 0);    }    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);}

const char *vp_file_open(char *args){    vp_stack_t stack;    char *path;    char *flags;    int mode;  /* used when flags have O_CREAT */    int oflag = 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));    oflag = str_to_oflag(flags);    if (oflag == -1)        return vp_stack_return_error(&_result, "open flag error.");    fd = open(path, oflag, 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_decode(char *args){    vp_stack_t stack;    size_t len;    char *str;    char *p, *q;    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    VP_RETURN_IF_FAIL(vp_stack_pop_str(&stack, &str));    len = strlen(str);    if (len % 2 != 0) {        return "vp_decode: invalid data length";    }    VP_RETURN_IF_FAIL(vp_stack_reserve(&_result,            (_result.top - _result.buf) + (len / 2) + sizeof(VP_EOV_STR)));    for (p = str, q = _result.top; p < str + len; ) {        char hb, lb;        hb = CHR2XD[(int)*(p++)];        lb = CHR2XD[(int)*(p++)];        if (hb != (char)-1 && lb != (char)-1) {            *(q++) = (hb << 4) | lb;        }    }    *(q++) = VP_EOV;    *q = '/0';    _result.top = q;    return vp_stack_return(&_result);}

/* 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_file_write(char *args){    vp_stack_t stack;    int fd;    char *buf;    size_t size;    int timeout;    size_t nleft;    int n;    struct pollfd pfd = {0, POLLOUT, 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", &timeout));    size = vp_decode_size(stack.top);    buf = stack.top + VP_HEADER_SIZE;    pfd.fd = fd;    nleft = 0;    while (nleft < size) {        n = poll(&pfd, 1, timeout);        if (n == -1) {            return vp_stack_return_error(&_result, "poll() error: %s",                    strerror(errno));        } else if (n == 0) {            /* timeout */            break;        }        if (pfd.revents & POLLOUT) {            n = write(fd, buf + nleft, 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;            continue;        } else if (pfd.revents & (POLLERR | POLLHUP)) {            /* eof or error */            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: %s",                pfd.revents);    }    vp_stack_push_num(&_result, "%zu", nleft);    return vp_stack_return(&_result);}

const char *vp_pty_open(char *args){    vp_stack_t stack;    int argc;    char *argv[VP_ARGC_MAX];    int fdm;    pid_t pid;    struct winsize ws = {0, 0, 0, 0};    struct termios ti;    int i;    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    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", &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 0    /* TODO: set termios parameter */    /* tcgetattr will fail when gvim is executed from gnome menu */    if (tcgetattr(STDIN_FILENO, &ti) < 0)        return vp_stack_return_error(&_result, "tcgetattr() error: %s",                strerror(errno));    pid = forkpty(&fdm, NULL, &ti, &ws);#else    pid = forkpty(&fdm, NULL, NULL, &ws);#endif    if (pid < 0) {        return vp_stack_return_error(&_result, "forkpty() error: %s",                strerror(errno));    } else if (pid == 0) {        /* child */        if (execv(argv[0], argv) < 0) {            /* error */            write(fdm, strerror(errno), strlen(strerror(errno)));            _exit(EXIT_FAILURE);        }    } else {        /* parent */        vp_stack_push_num(&_result, "%d", pid);        vp_stack_push_num(&_result, "%d", fdm);        /* XXX - ttyname(fdm) breaks in OS X */        vp_stack_push_str(&_result, "unused");        return vp_stack_return(&_result);    }    /* DO NOT REACH HERE */    return NULL;}

const char *vp_socket_open(char *args){    vp_stack_t stack;    char *host;    char *port;    int port_nr;    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));    if (sockets_number++ == 0)    {        WSADATA wsadata;        WSAStartup(2, &wsadata);    }    if (sscanf(port, "%d%n", &port_nr, &n) == 1 && port[n] == '/0') {        nport = htons((u_short)port_nr);    } else {        servent = getservbyname(port, NULL);        if (servent == NULL)            return vp_stack_return_error(&_result, "getservbyname() error: %s",                    port);        nport = servent->s_port;    }    sock = (int)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);}

/* push error message and return */static const char *vp_stack_return_error(vp_stack_t *stack, const char *fmt, ...){    va_list ap;    size_t needsize;    needsize = (stack->top - stack->buf) + VP_ERRMSG_SIZE;    if (vp_stack_reserve(stack, needsize) != NULL)        return fmt;    va_start(ap, fmt);    stack->top += vsnprintf(stack->top,            stack->size - (stack->top - stack->buf), fmt, ap);    va_end(ap);    return vp_stack_return(stack);}

const char *vp_dlopen(char *args){    vp_stack_t stack;    char *path;    HINSTANCE handle;    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    VP_RETURN_IF_FAIL(vp_stack_pop_str(&stack, &path));    handle = LoadLibrary(path);    if (handle == NULL)        return lasterror();    vp_stack_push_num(&_result, "%p", handle);    return vp_stack_return(&_result);}

const char *vp_dlopen(char *args){    vp_stack_t stack;    char *path;    void *handle;    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    VP_RETURN_IF_FAIL(vp_stack_pop_str(&stack, &path));    handle = dlopen(path, RTLD_LAZY);    if (handle == NULL)        return dlerror();    vp_stack_push_num(&_result, "%p", handle);    return vp_stack_return(&_result);}

const char *vp_pty_get_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));    if (ioctl(fd, TIOCGWINSZ, &ws) < 0)        return vp_stack_return_error(&_result, "ioctl() error: %s",                strerror(errno));    vp_stack_push_num(&_result, "%hu", ws.ws_col);    vp_stack_push_num(&_result, "%hu", ws.ws_row);    return vp_stack_return(&_result);}

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_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);}

/* * Added by Richard Emberson * Check to see if a host exists. */const char *vp_host_exists(char *args){    vp_stack_t stack;    char *host;    struct hostent *hostent;    VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));    VP_RETURN_IF_FAIL(vp_stack_pop_str(&stack, &host));    hostent = gethostbyname(host);    if (hostent) {        vp_stack_push_num(&_result, "%d", 1);    } else {        vp_stack_push_num(&_result, "%d", 0);    }    return vp_stack_return(&_result);}

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);}

/* * 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_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_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_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_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);}