efcode/engine/interface.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 (c) 2000 by Sun Microsystems, Inc.
 * All rights reserved.
 */

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

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

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

/*
 * the external start point for this goo
 */

void
push_ds(fcode_env_t *env, fstack_t d)
{
    PUSH(DS, d);
}

fstack_t
pop_ds(fcode_env_t *env)
{
    return (POP(DS));
}

void
push_rs(fcode_env_t *env, fstack_t d)
{
    PUSH(RS, d);
}

fstack_t
pop_rs(fcode_env_t *env)
{
    return (POP(RS));
}

/*
 * Pushes a C string on the stack.
 */
void
push_a_string(fcode_env_t *env, char *str)
{
    if (str) {
        PUSH(DS, (fstack_t)str);
        PUSH(DS, strlen(str));
    } else {
        PUSH(DS, 0);
        PUSH(DS, 0);
    }
}

/*
 * Pops a (potentially null) string off the stack.
 */
char *
pop_a_string(fcode_env_t *env, int *lenp)
{
    int len;
    char *str;

    len = POP(DS);
    str = (char *)POP(DS);
    if (len == 0)
        str = NULL;
    else if (str == NULL)
        len = 0;
    if (lenp)
        *lenp = len;
    return (str);
}

/*
 * Pops & strdup's a string off the stack, handles NULL strings.
 */
char *
pop_a_duped_string(fcode_env_t *env, int *lenp)
{
    char *str;

    str = pop_a_string(env, lenp);
    if (str)
        return (STRDUP(str));
    return (NULL);
}

/*
 * Push Forth Double type.
 */
void
push_double(fcode_env_t *env, dforth_t d)
{
    fstack_t lo, hi;

    lo = DFORTH_LO(d);
    hi = DFORTH_HI(d);
    PUSH(DS, lo);
    PUSH(DS, hi);
}

/*
 * Pop Forth Double type.
 */
dforth_t
pop_double(fcode_env_t *env)
{
    fstack_t lo, hi;

    hi = POP(DS);
    lo = POP(DS);
    return (MAKE_DFORTH(hi, lo));
}

/*
 * Peek at top of stack Forth Double type.
 */
dforth_t
peek_double(fcode_env_t *env)
{
    dforth_t a;

    a = pop_double(env);
    push_double(env, a);
    return (a);
}

void
run_fcode(fcode_env_t *env, uchar_t *buff, int len)
{
    int i;

    /*
     * Really just checking to see if buff is all ascii characters.
     * Fcode normally starts with 0xfd, so for fcode, this should be
     * a fast check.
     */
    for (i = 0; i < len; i++)
        if (buff[i] >= 0x80)
            break;
    PUSH(DS, (fstack_t)buff);
    if (i < len) {
        /* Non-ascii found, probably Fcode */
        PUSH(DS, (fstack_t)1);
        byte_load(env);
    } else {
        /* All ascii found, probably ascii */
        PUSH(DS, len);
        fevaluate(env);
    }
}

void
run_fcode_from_file(fcode_env_t *env, char *fname, int aout_flag)
{
    uchar_t *p;
    int len;

    push_a_string(env, fname);
    load_file(env);
    len = POP(DS);
    p = (uchar_t *)POP(DS);
    if (aout_flag) {
        p += 0x20;
        len -= 0x20;
    }
    run_fcode(env, p, len);
}

fcode_env_t *
clone_environment(fcode_env_t *src, void *private)
{
    fcode_env_t *env;

    if (!src) {
        src = initial_env;
        src->private = private;
        return (src);
    }

#if 0
    src->private = private;
    if (src->my_self || src->state) {
        log_message(MSG_WARN, "Can't clone an active instance or"
            " compile state!\n");
        return (NULL);
    }

    log_message(MSG_WARN, "Warning: Device-tree state is shared!\n");
#endif

    env = MALLOC(sizeof (fcode_env_t));
    memcpy(env, src, sizeof (fcode_env_t));

#if 0
    env->table = MALLOC((MAX_FCODE + 1) * sizeof (fcode_token));
    memcpy(env->table, src->table, (MAX_FCODE + 1) * sizeof (fcode_token));

    /*
     * Note that cloning the dictionary doesn't make sense unless the
     * ptrs + XT's in the dictionary are relative to BASE.
     */
    env->base = MALLOC(dict_size);
    memcpy(env->base, src->base, dict_size);

    env->here = src->base - (uchar_t *)src + env->base;
#endif

    env->ds0 = MALLOC(stack_size * sizeof (fstack_t));
    memcpy(env->ds0, src->ds0, stack_size * sizeof (fstack_t));
    env->ds = src->ds - src->ds0 + env->ds0;

    env->rs0 = MALLOC(stack_size * sizeof (fstack_t));
    memcpy(env->rs0, src->rs0, stack_size * sizeof (fstack_t));
    env->rs = src->rs - src->rs0 + env->rs0;

    env->order = MALLOC(MAX_ORDER * sizeof (token_t));
    memcpy(env->order, src->order, MAX_ORDER * sizeof (token_t));

    env->input = MALLOC(sizeof (input_typ));

    env->catch_frame = 0;

    IP = 0;

    return (env);
}

void
destroy_environment(fcode_env_t *env)
{
    FREE(env->input);
    FREE(env->order);
    FREE(env->ds0);
    FREE(env->rs0);
#if 0
    FREE(env->base);
    FREE(env->table);
#endif
    FREE(env);

    if (env == initial_env) {
        /* This call only happens internally */

        initial_env = NULL;
        /* You had better not exercise the engine anymore! */
    }
}