Subversion Repositories HelenOS

/*  $NetBSD: output.c,v 1.23 2001/01/07 23:39:07 lukem Exp $    */

/*-

 * Copyright (c) 1991, 1993

 *  The Regents of the University of California.  All rights reserved.

 *

 * This code is derived from software contributed to Berkeley by

 * Kenneth Almquist.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. All advertising materials mentioning features or use of this software

 *    must display the following acknowledgement:

 *  This product includes software developed by the University of

 *  California, Berkeley and its contributors.

 * 4. Neither the name of the University nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 */

#include <sys/cdefs.h>

#ifndef lint

#if 0

static char sccsid[] = "@(#)output.c    8.2 (Berkeley) 5/4/95";

#else

__RCSID("$NetBSD: output.c,v 1.23 2001/01/07 23:39:07 lukem Exp $");

#endif

#endif /* not lint */

/*

 * Shell output routines.  We use our own output routines because:

 *  When a builtin command is interrupted we have to discard

 *      any pending output.

 *  When a builtin command appears in back quotes, we want to

 *      save the output of the command in a region obtained

 *      via malloc, rather than doing a fork and reading the

 *      output of the command via a pipe.

 *  Our output routines may be smaller than the stdio routines.

 */

#include <sys/types.h>      /* quad_t */

#include <sys/param.h>      /* BSD4_4 */

#include <sys/ioctl.h>

#include <stdio.h>  /* defines BUFSIZ */

#include <string.h>

#include <errno.h>

#include <unistd.h>

#include <stdlib.h>

#if defined(_GNU_SOURCE) && !defined(__UCLIBC__)

#undef CEOF         /* get rid of the redefine warning */

#include <fcntl.h>

#endif

#include "shell.h"

#include "syntax.h"

#include "output.h"

#include "memalloc.h"

#include "error.h"

#define OUTBUFSIZ BUFSIZ

#define BLOCK_OUT -2        /* output to a fixed block of memory */

#define MEM_OUT -3      /* output to dynamically allocated memory */

#define OUTPUT_ERR 01       /* error occurred on output */

#if defined(_GNU_SOURCE) && !defined(__UCLIBC__)

struct output output = {NULL, NULL, 0, NULL, 0, 1, 0};

struct output errout = {NULL, NULL, 0, NULL, 0, 2, 0};

struct output memout = {NULL, NULL, 0, NULL, 0, MEM_OUT, 0};

#else

struct output output = {NULL, 0, NULL, OUTBUFSIZ, 1, 0};

struct output errout = {NULL, 0, NULL, 100, 2, 0};

struct output memout = {NULL, 0, NULL, 0, MEM_OUT, 0};

#endif

struct output *out1 = &output;

struct output *out2 = &errout;

#ifdef mkinit

INCLUDE "output.h"

INCLUDE "memalloc.h"

INIT {

#if defined(_GNU_SOURCE) && !defined(__UCLIBC__)

    initstreams();

#endif

}

RESET {

    out1 = &output;

    out2 = &errout;

#if defined(_GNU_SOURCE) && !defined(__UCLIBC__)

    if (memout.stream != NULL)

        closememout();

#endif

    if (memout.buf != NULL) {

        ckfree(memout.buf);

        memout.buf = NULL;

    }

}

#endif

#ifdef notdef   /* no longer used */

/*

 * Set up an output file to write to memory rather than a file.

 */

void

open_mem(block, length, file)

    char *block;

    int length;

    struct output *file;

    {

    file->nextc = block;

    file->nleft = --length;

    file->fd = BLOCK_OUT;

    file->flags = 0;

}

#endif

void

outstr(p, file)

    const char *p;

    struct output *file;

    {

#if defined(_GNU_SOURCE) && !defined(__UCLIBC__)

    fputs(p, file->stream);

#else

    while (*p)

        outc(*p++, file);

#endif

    if (file == out2)

        flushout(file);

}

#if !defined(_GNU_SOURCE) || defined(__UCLIBC__)

char out_junk[16];

void

emptyoutbuf(dest)

    struct output *dest;

    {

    int offset;

    if (dest->fd == BLOCK_OUT) {

        dest->nextc = out_junk;

        dest->nleft = sizeof out_junk;

        dest->flags |= OUTPUT_ERR;

    } else if (dest->buf == NULL) {

        INTOFF;

        dest->buf = ckmalloc(dest->bufsize);

        dest->nextc = dest->buf;

        dest->nleft = dest->bufsize;

        INTON;

    } else if (dest->fd == MEM_OUT) {

        offset = dest->bufsize;

        INTOFF;

        dest->bufsize <<= 1;

        dest->buf = ckrealloc(dest->buf, dest->bufsize);

        dest->nleft = dest->bufsize - offset;

        dest->nextc = dest->buf + offset;

        INTON;

    } else {

        flushout(dest);

    }

    dest->nleft--;

}

#endif

void

flushall() {

    flushout(&output);

    flushout(&errout);

}

#if !defined(_GNU_SOURCE) || defined(__UCLIBC__)

void

flushout(dest)

    struct output *dest;

    {

    if (dest->buf == NULL || dest->nextc == dest->buf || dest->fd < 0)

        return;

    if (xwrite(dest->fd, dest->buf, dest->nextc - dest->buf) < 0)

        dest->flags |= OUTPUT_ERR;

    dest->nextc = dest->buf;

    dest->nleft = dest->bufsize;

}

#endif

void

freestdout() {

    INTOFF;

    if (output.buf) {

        ckfree(output.buf);

        output.buf = NULL;

        output.nleft = 0;

    }

    INTON;

}

void

#ifdef __STDC__

outfmt(struct output *file, const char *fmt, ...)

#else

void

outfmt(va_alist)

    va_dcl

#endif

{

    va_list ap;

#ifndef __STDC__

    struct output *file;

    const char *fmt;

    va_start(ap);

    file = va_arg(ap, struct output *);

    fmt = va_arg(ap, const char *);

#else

    va_start(ap, fmt);

#endif

    doformat(file, fmt, ap);

    va_end(ap);

}

void

#ifdef __STDC__

out1fmt(const char *fmt, ...)

#else

out1fmt(va_alist)

    va_dcl

#endif

{

    va_list ap;

#ifndef __STDC__

    const char *fmt;

    va_start(ap);

    fmt = va_arg(ap, const char *);

#else

    va_start(ap, fmt);

#endif

    doformat(out1, fmt, ap);

    va_end(ap);

}

#if !defined(__GLIBC__) && !defined(__UCLIBC__)

void

#ifdef __STDC__

dprintf(const char *fmt, ...)

#else

dprintf(va_alist)

    va_dcl

#endif

{

    va_list ap;

#ifndef __STDC__

    const char *fmt;

    va_start(ap);

    fmt = va_arg(ap, const char *);

#else

    va_start(ap, fmt);

#endif

    doformat(out2, fmt, ap);

    va_end(ap);

    flushout(out2);

}

#endif

void

#ifdef __STDC__

fmtstr(char *outbuf, size_t length, const char *fmt, ...)

#else

fmtstr(va_alist)

    va_dcl

#endif

{

    va_list ap;

#if !defined(_GNU_SOURCE) || defined(__UCLIBC__)

    struct output strout;

#endif

#ifndef __STDC__

    char *outbuf;

    size_t length;

    const char *fmt;

    va_start(ap);

    outbuf = va_arg(ap, char *);

    length = va_arg(ap, size_t);

    fmt = va_arg(ap, const char *);

#else

    va_start(ap, fmt);

#endif

#if defined(_GNU_SOURCE) && !defined(__UCLIBC__)

    vsnprintf(outbuf, length, fmt, ap);

#else

    strout.nextc = outbuf;

    strout.nleft = length;

    strout.fd = BLOCK_OUT;

    strout.flags = 0;

    doformat(&strout, fmt, ap);

    outc('\0', &strout);

    if (strout.flags & OUTPUT_ERR)

        outbuf[length - 1] = '\0';

#endif

}

#if !defined(_GNU_SOURCE) || defined(__UCLIBC__)

/*

 * Formatted output.  This routine handles a subset of the printf formats:

 * - Formats supported: d, u, o, p, X, s, and c.

 * - The x format is also accepted but is treated like X.

 * - The l, ll and q modifiers are accepted.

 * - The - and # flags are accepted; # only works with the o format.

 * - Width and precision may be specified with any format except c.

 * - An * may be given for the width or precision.

 * - The obsolete practice of preceding the width with a zero to get

 *   zero padding is not supported; use the precision field.

 * - A % may be printed by writing %% in the format string.

 */

#define TEMPSIZE 24

static const char digit[] = "0123456789ABCDEF";

#ifdef BSD4_4

#define HAVE_VASPRINTF 1

#endif

void

doformat(dest, f, ap)

    struct output *dest;

    const char *f;      /* format string */

    va_list ap;

{

#if HAVE_VASPRINTF

    char *s;

    vasprintf(&s, f, ap);

    outstr(s, dest);

    free(s);    

#else   /* !HAVE_VASPRINTF */

    char c;

    char temp[TEMPSIZE];

    int flushleft;

    int sharp;

    int width;

    int prec;

    int islong;

    int isquad;

    char *p;

    int sign;

#ifdef BSD4_4

    quad_t l;

    u_quad_t num;

#else

    long l;

    u_long num;

#endif

    unsigned base;

    int len;

    int size;

    int pad;

    while ((c = *f++) != '\0') {

        if (c != '%') {

            outc(c, dest);

            continue;

        }

        flushleft = 0;

        sharp = 0;

        width = 0;

        prec = -1;

        islong = 0;

        isquad = 0;

        for (;;) {

            if (*f == '-')

                flushleft++;

            else if (*f == '#')

                sharp++;

            else

                break;

            f++;

        }

        if (*f == '*') {

            width = va_arg(ap, int);

            f++;

        } else {

            while (is_digit(*f)) {

                width = 10 * width + digit_val(*f++);

            }

        }

        if (*f == '.') {

            if (*++f == '*') {

                prec = va_arg(ap, int);

                f++;

            } else {

                prec = 0;

                while (is_digit(*f)) {

                    prec = 10 * prec + digit_val(*f++);

                }

            }

        }

        if (*f == 'l') {

            f++;

            if (*f == 'l') {

                isquad++;

                f++;

            } else

                islong++;

        } else if (*f == 'q') {

            isquad++;

            f++;

        }

        switch (*f) {

        case 'd':

#ifdef BSD4_4

            if (isquad)

                l = va_arg(ap, quad_t);

            else

#endif

            if (islong)

                l = va_arg(ap, long);

            else

                l = va_arg(ap, int);

            sign = 0;

            num = l;

            if (l < 0) {

                num = -l;

                sign = 1;

            }

            base = 10;

            goto number;

        case 'u':

            base = 10;

            goto uns_number;

        case 'o':

            base = 8;

            goto uns_number;

        case 'p':

            outc('0', dest);

            outc('x', dest);

            /*FALLTHROUGH*/

        case 'x':

            /* we don't implement 'x'; treat like 'X' */

        case 'X':

            base = 16;

uns_number:   /* an unsigned number */

            sign = 0;

#ifdef BSD4_4

            if (isquad)

                num = va_arg(ap, u_quad_t);

            else

#endif

            if (islong)

                num = va_arg(ap, unsigned long);

            else

                num = va_arg(ap, unsigned int);

number:       /* process a number */

            p = temp + TEMPSIZE - 1;

            *p = '\0';

            while (num) {

                *--p = digit[num % base];

                num /= base;

            }

            len = (temp + TEMPSIZE - 1) - p;

            if (prec < 0)

                prec = 1;

            if (sharp && *f == 'o' && prec <= len)

                prec = len + 1;

            pad = 0;

            if (width) {

                size = len;

                if (size < prec)

                    size = prec;

                size += sign;

                pad = width - size;

                if (flushleft == 0) {

                    while (--pad >= 0)

                        outc(' ', dest);

                }

            }

            if (sign)

                outc('-', dest);

            prec -= len;

            while (--prec >= 0)

                outc('0', dest);

            while (*p)

                outc(*p++, dest);

            while (--pad >= 0)

                outc(' ', dest);

            break;

        case 's':

            p = va_arg(ap, char *);

            pad = 0;

            if (width) {

                len = strlen(p);

                if (prec >= 0 && len > prec)

                    len = prec;

                pad = width - len;

                if (flushleft == 0) {

                    while (--pad >= 0)

                        outc(' ', dest);

                }

            }

            prec++;

            while (--prec != 0 && *p)

                outc(*p++, dest);

            while (--pad >= 0)

                outc(' ', dest);

            break;

        case 'c':

            c = va_arg(ap, int);

            outc(c, dest);

            break;

        default:

            outc(*f, dest);

            break;

        }

        f++;

    }

#endif  /* !HAVE_VASPRINTF */

}

#endif

/*

 * Version of write which resumes after a signal is caught.

 */

int

xwrite(fd, buf, nbytes)

    int fd;

    const char *buf;

    int nbytes;

    {

    int ntry;

    int i;

    int n;

    n = nbytes;

    ntry = 0;

    for (;;) {

        i = write(fd, buf, n);

        if (i > 0) {

            if ((n -= i) <= 0)

                return nbytes;

            buf += i;

            ntry = 0;

        } else if (i == 0) {

            if (++ntry > 10)

                return nbytes - n;

        } else if (errno != EINTR) {

            return -1;

        }

    }

}

#ifdef notdef

/*

 * Version of ioctl that retries after a signal is caught.

 * XXX unused function

 */

int

xioctl(fd, request, arg)

    int fd;

    unsigned long request;

    char * arg;

{

    int i;

    while ((i = ioctl(fd, request, arg)) == -1 && errno == EINTR);

    return i;

}

#endif

#if defined(_GNU_SOURCE) && !defined(__UCLIBC__)

void initstreams() {

    output.stream = stdout;

    errout.stream = stderr;

}

void

openmemout() {

    memout.stream = open_memstream(&memout.buf, &memout.bufsize);

}

void

closememout() {

    INTOFF;

    fclose(memout.stream);

    memout.stream = NULL;

    INTON;

}

#endif