dmake: do not set MAKEFLAGS=k

[unleashed/tickless.git] / usr / src / lib / efcode / engine / env.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I%     %E% SMI"

#include <ctype.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>

#include <fcode/private.h>
#include <fcode/log.h>


static variable_t verbose_emit;

void
do_verbose_emit(fcode_env_t *env)
{
        verbose_emit ^= 1;
}

/*
 * Internal "emit".
 * Note log_emit gathers up characters and issues a syslog or write to
 * error log file if enabled.
 */
void
do_emit(fcode_env_t *env, uchar_t c)
{
        if (verbose_emit)
                log_message(MSG_ERROR, "emit(%x)\n", c);

        if (c == '\n') {
                env->output_column = 0;
                env->output_line++;
        } else if (c == '\r')
                env->output_column = 0;
        else
                env->output_column++;
        if (isatty(fileno(stdout))) {
                if ((c >= 0x20 && c <= 0x7f) || c == '\n' || c == '\r' ||
                    c == '\b')
                        putchar(c);
                else if (c < 0x20)
                        printf("@%c", c + '@');
                else
                        printf("\\%x", c);
                fflush(stdout);
        }
        log_emit(c);
}

void
system_message(fcode_env_t *env, char *msg)
{
        throw_from_fclib(env, 1, msg);
}

void
emit(fcode_env_t *env)
{
        fstack_t d;

        CHECK_DEPTH(env, 1, "emit");
        d = POP(DS);
        do_emit(env, d);
}

#include <sys/time.h>

/*
 * 'key?' - abort if stdin is not a tty.
 */
void
keyquestion(fcode_env_t *env)
{
        struct timeval timeval;
        fd_set readfds;
        int ret;

        if (isatty(fileno(stdin))) {
                FD_ZERO(&readfds);
                FD_SET(fileno(stdin), &readfds);
                timeval.tv_sec = 0;
                timeval.tv_usec = 1000;
                ret = select(fileno(stdin) + 1, &readfds, NULL, NULL, &timeval);
                if (FD_ISSET(fileno(stdin), &readfds))
                        PUSH(DS, TRUE);
                else
                        PUSH(DS, FALSE);
        } else
                forth_abort(env, "'key?' called in non-interactive mode");
}

/*
 * 'key' - abort if stdin is not a tty, will block on read if char not avail.
 */
void
key(fcode_env_t *env)
{
        uchar_t c;

        if (isatty(fileno(stdin))) {
                read(fileno(stdin), &c, 1);
                PUSH(DS, c);
        } else
                forth_abort(env, "'key' called in non-interactive mode");
}

void
type(fcode_env_t *env)
{
        int len;
        char *ptr;

        CHECK_DEPTH(env, 2, "type");
        ptr = pop_a_string(env, &len);
        while (len--)
                do_emit(env, *ptr++);
}

void
paren_cr(fcode_env_t *env)
{
        do_emit(env, '\r');
}

void
fc_crlf(fcode_env_t *env)
{
        do_emit(env, '\n');
}

void
fc_num_out(fcode_env_t *env)
{
        PUSH(DS, (fstack_t)(&env->output_column));
}

void
fc_num_line(fcode_env_t *env)
{
        PUSH(DS, (fstack_t)(&env->output_line));
}

void
expect(fcode_env_t *env)
{
        char *buf, *rbuf;
        int len;

        CHECK_DEPTH(env, 2, "expect");
        buf = pop_a_string(env, &len);
        read_line(env);
        rbuf = pop_a_string(env, NULL);
        if (rbuf) {
                strcpy(buf, rbuf);
                env->span = strlen(buf);
        } else
                env->span = 0;
}

void
span(fcode_env_t *env)
{
        PUSH(DS, (fstack_t)&env->span);
}

void
do_ms(fcode_env_t *env)
{
        fstack_t d;
        timespec_t rqtp;

        CHECK_DEPTH(env, 1, "ms");
        d = POP(DS);
        if (d) {
                rqtp.tv_sec = 0;
                rqtp.tv_nsec = d*1000*1000;
                nanosleep(&rqtp, 0);
        }
}

void
do_get_msecs(fcode_env_t *env)
{
        struct timeval tp;
        long ms;
        timespec_t rqtp;

        gettimeofday(&tp, NULL);
        ms = (tp.tv_usec/1000) + (tp.tv_sec * 1000);
        PUSH(DS, (fstack_t)ms);
        rqtp.tv_sec = 0;
        rqtp.tv_nsec = 1000*1000;
        nanosleep(&rqtp, 0);
}

#define CMN_MSG_SIZE    256
#define CMN_MAX_DIGITS  3

typedef struct CMN_MSG_T cmn_msg_t;

struct CMN_MSG_T {
        char            buf[CMN_MSG_SIZE];
        int             level;
        int             len;
        cmn_msg_t       *prev;
        cmn_msg_t       *next;
};

typedef struct CMN_FMT_T cmn_fmt_t;

struct CMN_FMT_T {
        int     fwidth; /* format field width */
        int     cwidth; /* column width specified in format */
        char    format; /* format type */
};

static cmn_msg_t        *root = NULL;
static int              cmn_msg_level = 0;

/*
 *      validfmt()
 *
 * Called by fmt_str() function to validate and extract formatting
 * information from the supplied input buffer.
 *
 * Supported formats are:
 *      %c - character
 *      %d - signed decimal
 *      %x - unsigned hex
 *      %s - string
 *      %ld - signed 64 bit data
 *      %lx - unsigned 64 bit data
 *      %p - unsigned 64 bit data(pointer)
 *      %% - print as single "%" character
 *
 * Return values are:
 *      0  - valid formatting
 *      1  - invalid formatting found in the input buffer
 *      -1 - NULL pointer passed in for caller's receptacle
 *
 *
 * For valid formatting, caller's supplied cmn_fmt_t elements are
 * filled in:
 *      fwidth:
 *              > 0 - returned value is the field width
 *              < 0 - returned value is negation of field width for
 *                      64 bit data formats
 *      cwidth:
 *        formatted column width(if specified), otherwise 0
 *
 *      format:
 *        contains the formatting(single) character
 */
static int
validfmt(char *fmt, cmn_fmt_t *cfstr)
{
        int     isll = 0;
        int     *fwidth, *cwidth;
        char    *format;
        char    *dig1, *dig2;
        char    cdigs[CMN_MAX_DIGITS+1];

        if (cfstr == NULL)
                return (-1);

        fwidth = &cfstr->fwidth;
        cwidth = &cfstr->cwidth;
        format = &cfstr->format;
        *fwidth = *cwidth = 0;
        *format = NULL;
        dig1 = dig2 = NULL;

        /* check for left justification character */
        if (*fmt == '-') {
                fmt++;
                (*fwidth)++;

                /* check for column width specification */
                if (isdigit(*fmt))
                        dig1 = fmt;     /* save ptr to first digit */
                while (isdigit(*fmt)) {
                        fmt++;
                        (*fwidth)++;
                }
                /* if ljust specified w/o size, return format error */
                if (*fwidth == 1) {
                        return (1);
                }
                dig2 = fmt;             /* save ptr to last digit + 1 */
        } else {
                /* check for column width specification */
                if (isdigit(*fmt)) {
                        dig1 = fmt;     /* save ptr to first digit */
                        while (isdigit(*fmt)) {
                                fmt++;
                                (*fwidth)++;
                        }
                        dig2 = fmt;     /* save ptr to last digit + 1 */
                }
        }

        /* if a column width was specified, save it in caller's struct */
        if (dig1) {
                int nbytes;

                nbytes = dig2 - dig1;
                /* if too many digits in the width return error */
                if (nbytes > CMN_MAX_DIGITS)
                        return (1);
                strncpy(cdigs, dig1, nbytes);
                cdigs[nbytes] = 0;
                *cwidth = atoi(cdigs);
        }

        /* check for long format specifier */
        if (*fmt == 'l') {
                fmt++;
                (*fwidth)++;
                isll = 1;
        }

        /* process by specific format type */
        switch (*fmt) {
        case 'c':
        case 's':
        case '%':
                if (isll)
                        return (1);
        case 'd':
        case 'x':
                *format = *fmt;
                (*fwidth)++;
                break;
        case 'p':
                isll = 1;               /* uses 64 bit format */
                *format = *fmt;
                (*fwidth)++;
                break;
        default:
                return (1);             /* unknown format type */
        }
        if (isll) {
                *fwidth *= -1;
        }
        return (0);
}

/*
 *      fmt_args()
 *
 * Called by fmt_str() to setup arguments for subsequent snprintf()
 * calls.  For cases not involving column width limitations, processing
 * simply POPs the data stack as required to setup caller's arg(or
 * llarg, as appropriate). When a column width is specified for output,
 * a temporary buffer is constructed to contain snprintf() generated
 * output for the argument. Testing is then performed to determine if
 * the specified column width will require truncation of the output.
 * If so, truncation of least significant digits is performed as
 * necessary, and caller's arg(or llarg) is adjusted to obtain the
 * specified column width.
 *
 */

static void
fmt_args(fcode_env_t *env, int cw, int fw, char format, long *arg,
        long long *llarg)
{
        char    *cbuf;
        char    snf[3];
        int     cbsize;
        int     cnv = 10, ndigits = 0;

        if (fw > 0) {   /* check for normal (not long) formats */

                /* initialize format string for snprintf call */
                snf[0] = '%';
                snf[1] = format;
                snf[2] = 0;

                /* process by format type */
                switch (format) {
                case 'x':
                        cnv = 16;
                case 'd':
                case 'c':
                case 'p':
                        *arg = POP(DS);
                        break;
                case 's':
                        POP(DS);
                        *arg = POP(DS);
                        break;
                case '%':
                        return;
                default:
                        log_message(MSG_ERROR,
                                "fmt_args:invalid format type! (%s)\n",
                                        &format);
                        return;
                }

                /* check if a column width was specified */
                if (cw) {
                        /* allocate a scratch buffer */
                        cbsize = 2*(sizeof (long long)) + 1;
                        cbuf = MALLOC(cbsize);

                        if (snprintf(cbuf, cbsize, snf, *arg) < 0)
                                log_message(MSG_ERROR,
                                        "fmt_args: snprintf output error\n");
                        while ((cbuf[ndigits] != NULL) &&
                                (ndigits < cbsize))
                                ndigits++;

                        /* if truncation is necessary, do it */
                        if (ndigits > cw) {
                                cbuf[cw] = 0;
                                if (format == 's') {
                                        char *str;
                                        str = (char *)*arg;
                                        str[cw] = 0;
                                } else
                                        *arg = strtol(cbuf,
                                                (char **)NULL, cnv);
                        }
                        free(cbuf);
                }

        } else {        /* process long formats */

                *llarg = POP(DS);

                /* check if a column width was specified */
                if (cw) {
                        /* allocate a scratch buffer */
                        cbsize = 2*(sizeof (long long)) + 1;
                        cbuf = MALLOC(cbsize);

                        switch (format) {
                        case 'p':
                                cnv = 16;
                                if (snprintf(cbuf, cbsize, "%p", *llarg) < 0)
                                        log_message(MSG_ERROR,
                                                "fmt_args: snprintf error\n");
                                break;
                        case 'x':
                                cnv = 16;
                                if (snprintf(cbuf, cbsize, "%lx", *llarg) < 0)
                                        log_message(MSG_ERROR,
                                            "fmt_args: snprintf error\n");
                                break;
                        case 'd':
                                if (snprintf(cbuf, cbsize, "%ld", *llarg) < 0)
                                        log_message(MSG_ERROR,
                                                "fmt_args: snprintf error\n");
                                break;
                        default:
                                log_message(MSG_ERROR,
                                    "invalid long format type! (l%s)\n",
                                                &format);
                                free(cbuf);
                                return;
                        }
                        while ((cbuf[ndigits] != NULL) &&
                                (ndigits < cbsize)) {
                                ndigits++;
                        }
                        /* if truncation is necessary, do it */
                        if (ndigits > cw) {
                                cbuf[cw] = 0;
                                *llarg = strtoll(cbuf, (char **)NULL, cnv);
                        }
                        free(cbuf);
                }
        }
}

/*
 *      fmt_str()
 *
 * Extracts text from caller's input buffer, processes explicit
 * formatting as necessary, and outputs formatted text to caller's
 * receptacle.
 *
 *      env  - pointer to caller's fcode environment
 *      fmt  - pointer to caller's input buffr
 *      fmtbuf - ponter to caller's receptacle buffer
 *      bsize - size of caller's fmtbuf buffer
 *
 * This function performs an initial test to determine if caller's
 * input buffer contains formatting(specified by presence of "%")
 * in the buffer.  If so, validfmt() function is called to verify
 * the formatting, after which the buffer is processed according
 * to the field width specified by validfmt() output.  Special
 * processing is required when caller's buffer contains a double
 * "%" ("%%"), in which case the second "%" is accepted as normal
 * text.
 */

static void
fmt_str(fcode_env_t *env, char *fmt, char *fmtbuf, int bsize)
{
        char    tbuf[CMN_MSG_SIZE];
        char    *fmptr, *pct;
        int     l, cw, fw, bytes;
        long    arg;
        long long llarg;

        *fmtbuf = 0;
        if ((pct = strchr(fmt, '%')) != 0) {
                cmn_fmt_t       cfstr;
                int             vferr;

                l = strlen(pct++);
                vferr = validfmt(pct, &cfstr);
                if (!vferr) {
                        fw = cfstr.fwidth;
                        cw = cfstr.cwidth;
                        fmptr = &cfstr.format;
                } else {
                        if (vferr < 0) {
                        log_message(MSG_ERROR,
                            "fmt_str: NULL ptr supplied to validfmt()\n");
                        return;
                        }

                        bytes = pct - fmt;
                        strncpy(tbuf, fmt, bytes);
                        strncpy(tbuf+bytes, "%", 1);
                        strncpy(tbuf+bytes+1, fmt+bytes, 1);
                        bytes += 2;
                        tbuf[bytes] = 0;

                        log_message(MSG_ERROR,
                                "fmt_str: invalid format type! (%s)\n",
                                tbuf+bytes-3);

                        strncpy(fmtbuf, tbuf, bsize);
                        return;
                }

                if (fw > 0) {   /* process normal (not long) formats */
                        bytes = pct - fmt + fw;
                        strncpy(tbuf, fmt, bytes);
                        tbuf[bytes] = 0;
                } else {
                        /* if here, fw must be a long format */
                        if (*fmptr == 'p') {
                                bytes = pct - fmt - fw;
                                strncpy(tbuf, fmt, bytes);
                                tbuf[bytes] = 0;
                        } else {
                                bytes = pct - fmt - fw - 2;
                                strncpy(tbuf, fmt, bytes);
                                tbuf[bytes] = 'l';
                                strncpy(tbuf+bytes+1, fmt+bytes, 2);
                                tbuf[bytes+1+2] = 0;
                        }
                }

                /* if more input buffer to process, recurse */
                if ((l - abs(fw)) != 0) {
                    fmt_str(env, pct+abs(fw), (tbuf + strlen(tbuf)),
                                CMN_MSG_SIZE - strlen(tbuf));
                }

                /* call to extract args for snprintf() calls below */
                fmt_args(env, cw, fw, *fmptr, &arg, &llarg);

                if (fw > 0) {   /* process normal (not long) formats */
                        switch (*fmptr) {
                        case 'd':
                        case 'x':
                        case 'c':
                        case 's':
                        case 'p':
                                (void) snprintf(fmtbuf, bsize, tbuf, arg);
                                break;
                        case '%':
                                (void) snprintf(fmtbuf, bsize, tbuf);
                                break;
                        default:
                                log_message(MSG_ERROR,
                                    "fmt_str: invalid format (%s)\n",
                                        fmptr);
                                return;
                        }

                } else  /* process long formats */
                        (void) snprintf(fmtbuf, bsize, tbuf, llarg);

        } else
                strncpy(fmtbuf, fmt, bsize);
}

/*
 *      fc_cmn_append()
 *
 * Pops data stack to obtain message text, and calls fmt_str()
 * function to perform any message formatting necessary.
 *
 * This function is called from fc_cmn_end() or directly in
 * processing a cmn-append token.  Since a pre-existing message
 * context is assumed, initial checking is performed to verify
 * its existence.
 */

void
fc_cmn_append(fcode_env_t *env)
{
        int len;
        char *str;

        if (root == NULL) {
                log_message(MSG_ERROR,
                        "fc_cmn_append: no message context for append\n");
                return;
        }

        len = POP(DS);
        str = (char *)POP(DS);

        if ((root->len + len) < CMN_MSG_SIZE) {
                fmt_str(env, str, root->buf+root->len, CMN_MSG_SIZE -
                        root->len);
                root->len += len;
        } else
                log_message(MSG_ERROR,
                        "fc_cmn_append: append exceeds max msg size\n");
}

/*
 *      fc_cmn_end()
 *
 * Process ]cmn-end token to log the message initiated by a preceeding
 * fc_cmn_start() call.
 *
 * Since nested cmn-xxx[ calls are supported, a test is made to determine
 * if this is the final cmn-end of a nested sequence.  If so, or if
 * there was no nesting, log_message() is called with the appropriate
 * text buffer.  Otherwise, the root variable is adjusted to point to
 * the preceeding message in the sequence and links in the list are
 * updated. No logging is performed until the final ]cmn-end of the
 * sequence is processed; then, messages are logged in FIFO order.
 */
void
fc_cmn_end(fcode_env_t *env)
{
        cmn_msg_t *old;

        if (root == 0) {
                log_message(MSG_ERROR, "]cmn-end call w/o buffer\n");
                return;
        }

        fc_cmn_append(env);

        if (root->prev == 0) {
                cmn_msg_t *next;
                do {
                        log_message(root->level, "%s\n", root->buf);
                        next  = root->next;
                        free(root);
                        root = next;
                } while (root);
        } else {
                old = root->prev;
                old->next = root;
                root = old;
        }
}

/*
 *      fc_cmn_start()
 *
 * Generic function to begin a common message.
 *
 * Allocates a new cmn_msg_t to associate with the message, and sets
 * up initial text as specified by callers' inputs:
 *
 *      env  - pointer to caller's fcode environment
 *      head - pointer to initial text portion of the message
 *      path - flag to indicate if a device path is to be generated
 */
static void
fc_cmn_start(fcode_env_t *env, char *head, int path)
{
        cmn_msg_t *new;
        char            *dpath;

        new = MALLOC(sizeof (cmn_msg_t));
        new->prev = root;
        if (root != 0)
                root->next = new;
        strcpy(new->buf, head);
        new->len = strlen(head);
        if (path && env->current_device) {
                dpath = get_path(env, env->current_device);
                strcpy(new->buf+new->len, dpath);
                new->len += strlen(dpath);
                strncpy(new->buf+new->len++, ": ", 2);
                ++new->len;
                free(dpath);
        }
        new->level = cmn_msg_level;
        new->next = NULL;
        root = new;
}

/*
 *      fc_cmn_type()
 *
 * Process cmn-type[ token.
 *
 * Invokes fc_cmn_start() to create a message containing blank
 * header and no device path information.
 */
void
fc_cmn_type(fcode_env_t *env)
{
        cmn_msg_level = MSG_INFO;
        fc_cmn_start(env, "", 0);
}

/*
 *      fc_cmn_msg()
 *
 * Process cmn-msg[ token.
 *
 * Invokes fc_cmn_start() to create a message containing blank
 * header but specifying device path information.
 */
void
fc_cmn_msg(fcode_env_t *env)
{

        cmn_msg_level = MSG_INFO;
        fc_cmn_start(env, "", 1);
}

/*
 *      fc_cmn_note()
 *
 * Process cmn-note[ token.
 *
 * Invokes fc_cmn_start() to create a message with NOTICE stamping in
 * the header and specification of device path information.
 */
void
fc_cmn_note(fcode_env_t *env)
{
        cmn_msg_level = MSG_NOTE;
        fc_cmn_start(env, "NOTICE: ", 1);
}

/*
 *      fc_cmn_warn()
 *
 * Process cmn-warn[ token.
 *
 * Invokes fc_cmn_start() to create a message with WARNING stamping in
 * the header and specification of device path information.
 */
void
fc_cmn_warn(fcode_env_t *env)
{
        cmn_msg_level = MSG_WARN;
        fc_cmn_start(env, "WARNING: ", 1);
}

/*
 *      fc_cmn_error()
 *
 * Process cmn-error[ token.
 *
 * Invokes fc_cmn_start() to create a message with ERROR stamping in
 * the header and specification of device path information.
 */
void
fc_cmn_error(fcode_env_t *env)
{
        cmn_msg_level = MSG_ERROR;
        fc_cmn_start(env, "ERROR: ", 1);
}

/*
 *      fc_cmn_fatal()
 *
 * Process cmn-fatal[ token.
 *
 * Invokes fc_cmn_start() to create a message with FATAL stamping in
 * the header and specification of device path information.
 */
void
fc_cmn_fatal(fcode_env_t *env)
{
        cmn_msg_level = MSG_FATAL;
        fc_cmn_start(env, "FATAL: ", 1);
}

#pragma init(_init)

static void
_init(void)
{
        fcode_env_t *env = initial_env;
        ASSERT(env);
        NOTICE;

        ANSI(0x088, 0,          "span",                 span);
        ANSI(0x08a, 0,          "expect",               expect);

        ANSI(0x08d, 0,          "key?",                 keyquestion);
        ANSI(0x08e, 0,          "key",                  key);
        ANSI(0x08f, 0,          "emit",                 emit);
        ANSI(0x090, 0,          "type",                 type);
        ANSI(0x091, 0,          "(cr",                  paren_cr);
        ANSI(0x092, 0,          "cr",                   fc_crlf);
        ANSI(0x093, 0,          "#out",                 fc_num_out);
        ANSI(0x094, 0,          "#line",                fc_num_line);

        FCODE(0x125, 0,         "get-msecs",            do_get_msecs);
        FCODE(0x126, 0,         "ms",                   do_ms);

        FORTH(0,                "verbose-emit",         do_verbose_emit);
        FCODE(0x7e9, 0,         "cmn-fatal[",           fc_cmn_fatal);
        FCODE(0x7ea, 0,         "cmn-error[",           fc_cmn_error);
        FCODE(0x7eb, 0,         "cmn-warn[",            fc_cmn_warn);
        FCODE(0x7ec, 0,         "cmn-note[",            fc_cmn_note);
        FCODE(0x7ed, 0,         "cmn-type[",            fc_cmn_type);
        FCODE(0x7ee, 0,         "cmn-append",           fc_cmn_append);
        FCODE(0x7ef, 0,         "]cmn-end",             fc_cmn_end);
        FCODE(0x7f0, 0,         "cmn-msg[",             fc_cmn_msg);
}