/*
* 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
* 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 <stdlib.h>
#include <string.h>
#include <ctype.h>
int fcode_impl_count = 0;
{
return (byte);
}
{
}
return (token);
}
{
ushort_t u;
/*
* Logical or DOES NOT guarantee left to right evaluation...
*/
return (u | next_bytecode(env));
}
{
uint_t u;
/*
* Logical or DOES NOT guarantee left to right evaluation...
*/
}
void
{
name = "<unknown>";
}
void
{
} else {
}
}
void
{
}
void
{
env->interpretting = 0;
}
static void
{
env->interpretting = 0;
}
void
{
}
};
void
{
if (direction >= 0) {
if (doswap)
} else {
/*
* We look down the stack for a branch location
* that isn't pointing to zero (i.e. a forward branch label).
* We move the first one we find to the top of the stack,
* which is what gets compiled in with 'compile_comma'.
* Not finding a valid branch label is bad.
*/
if (branch_loc && *branch_loc) {
break;
}
}
"no branch loc on stack\n");
else {
/* Move branch_loc to top of data stack */
}
}
}
void
{
}
void
{
}
void
{
int len;
}
void
{
char *strptr;
while (count--)
*strptr++ = 0;
} else {
strptr = stringbuff;
while (count--)
*strptr = 0;
}
}
char *
{
char *name, *p;
int len;
char *cptr;
if (*fptr & FLAG_NONAME)
return (NULL);
return (NULL);
for (p = name; *p != '\0'; p++)
if (!isprint(*p))
return (NULL);
return (NULL);
return (name);
}
void
{
char *strptr;
/* Now form the entry in the dictionary */
if (len) {
*strptr-- = 0;
while (len)
} else {
dptr++;
flag |= FLAG_NONAME;
}
}
}
void
{
char *strptr, c;
if (headered) {
c = next_bytecode(env);
*strptr++ = c;
}
}
if (!visible)
len = 0;
*strptr = 0;
if (len) {
} else {
}
}
void
{
}
void
{
}
void
{
token_common(env, 0, 0);
}
void
{
}
void
{
}
void
{
}
void
{
}
void
{
}
void
{
}
void
{
}
static void
{
}
static void
{
}
void
{
}
static void
{
}
int
{
if (len <= 8) {
return (0);
}
return (0);
}
header[7];
return (0);
}
}
return (1);
}
void
{
int fcode_incr;
int offset_incr;
int fcode_xt;
int interpretting;
int depth;
int length;
int past_eob = 0;
int db;
/* save any existing interpret state */
/* Now init them */
if (fcode_xt != 1) {
}
while (env->interpretting) {
int token;
past_eob = 1;
}
"%s: %04x %03x %s (%x)",
"Compile" : "Execute",
if (db)
if (apf) {
/* Compile in references */
} else {
}
}
}
}
/* restore old state */
}
void
{
}
static void
{
int i = env->last_token;
if (get_interpreter_debug_level() & DEBUG_DUMP_TOKENS) {
else
}
}
void
{
}
}
void
{
}
void
{
if (*name) {
} else
*len = 0;
}
void
{
}
void
{
}
void
{
}
void
{
}
void
{
}
void
{
fstack_t *d;
TOS += *d;
}
void
{
}
void
{
} else {
}
}
void
{
}
void
{
if (immediate)
else
}
void
{
}
void
{
}
void
{
while (TOS) {
}
}
void
{
}
void
{
/* We are Version 3.0 */
}
void
{
if (!TOS) {
}
}
void
{
void *p;
FREE(p);
}
void
{
char *str;
int len;
lo = 0;
hi = 0;
if (len) {
}
}
}
void
{
if (TOS == 0) {
return;
}
len = 0;
break;
}
len++;
}
} else {
rlen = 0;
}
}
/*
* (is-user-word) ( name-str name-len xt -- )
*/
void
{
char *name;
int len;
}
void
{
#if 0
env->interpretting = 0;
env->last_fcode);
#else
#endif
}
static void
{
}
static void
_init(void)
{
/* Call it "old-dma-alloc" so no one gets confused */
}