kmx git

Commit fbd838552ddd282768775970d9bedc4afab148fa

2006-08-18T12:47:12
initial merge of David Paktor's fine work. I redid all of the Makefiles and fixed some minor issues with the code. git-svn-id: svn://coreboot.org/openbios/fcode-utils@76 f158a5a8-5612-0410-a976-696ce0be7e32
diff --git a/detok/Makefile b/detok/Makefile
index a63ced9..3d7b1c7 100644
--- a/detok/Makefile
+++ b/detok/Makefile
@@ -1,11 +1,12 @@
 #
-#                     OpenBIOS - free your system! 
-#                            ( detokenizer )
-#                          
-#  This program is part of a free implementation of the IEEE 1275-1994 
+#                     OpenBIOS - free your system!
+#                             ( Utilities )
+#
+#  This program is part of a free implementation of the IEEE 1275-1994
 #  Standard for Boot (Initialization Configuration) Firmware.
 #
-#  Copyright (C) 2001-2005 Stefan Reinauer, <stepan@openbios.org>
+#  Copyright (C) 2001-2006  Stefan Reinauer <stepan@openbios.org>
+#  Copyright (C) 2006 coresystems GmbH <info@coresystems.de>
 #
 #  This program is free software; you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
@@ -21,48 +22,37 @@
 #  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
 #
 
-ARCH     := $(shell uname -m | sed -e s/i.86/x86/ -e s/sun4u/sparc64/ -e s/arm.*/arm/ -e s/sa110/arm/ -e s/x86_64/amd64/ -e "s/Power Macintosh/ppc/")
-TOPDIR   := $(shell /bin/pwd)
-BUILDDIR ?= $(TOPDIR)/obj-$(ARCH)
+PROGRAM = detok
 
-VPATH    := $(BUILDDIR)
+CC      = gcc
+STRIP	= strip
+INCLUDES = -I../shared
+#CFLAGS  = -O2 -g -Wall 
+CFLAGS  = -Os -Wall -Wno-pointer-sign 
+LDFLAGS = 
 
+OBJS  = addfcodes.o decode.o detok.o dictionary.o pcihdr.o printformats.o \
+        stream.o ../shared/classcodes.o
 
-include $(TOPDIR)/Rules.make
+all: .dependencies $(PROGRAM)
 
+$(PROGRAM): $(OBJS)
+	$(CC) -o $(PROGRAM) $(OBJS) $(LDFLAGS)
+	$(STRIP) -s $(PROGRAM)
 
-CC	  =  gcc
-CFLAGS	  =  -O2 -Wall -ansi
+clean:
+	rm -f $(OBJS) *~
 
-# For debugging the indentation code of detok, define DEBUG_INDENT
-#CFLAGS	 :=  $(CFLAGS) -DDEBUG_INDENT
+distclean: clean
+	rm -f $(PROGRAM) .dependencies
+	
+.dependencies: *.c 
+	@$(CC) $(CFLAGS) $(INCLUDES) -MM *.c > .dependencies
 
-all: main detok
-	@echo -e "\nOpenBIOS detokenizer detok build finished\n"
+.PHONY: all clean distclean 
 
-main:
-	@echo -e "\nWelcome to the OpenBIOS detokenizer.."
-	@test -r $(BUILDDIR) || ( mkdir -p $(BUILDDIR); \
-	  echo -e "\nCreating build directory $(BUILDDIR)" )
-		
-detok: detok.o dictionary.o decode.o stream.o 
-	@echo -en "\nLinking fcode detokenizer detok..."
-	@cd $(BUILDDIR) && ( $(CC) $(CFLAGS) $^ -o $@; strip detok )
-	@echo -e "\tok"
-	
-clean:
-	@test ! -d $(BUILDDIR) && \
-		echo "Architecture $(ARCH) is already clean." || \
-		( 						 \
-			echo "Cleaning up architecture $(ARCH)"; \
-			rm -rf $(BUILDDIR)			 \
-			rm forth.dict.core			 \
-		)
+-include .dependencies
 
-distclean: clean
-	rm -f detok
+.c.o:
+	$(CC) -c $(CFLAGS) $(INCLUDES) $< -o $@ 
 
-detok.o:      detok.h stream.h detok.c
-stream.o:     detok.h stream.c
-decode.o:     detok.h stream.h decode.c Makefile
-dictionary.o: detok.h dictionary.c
diff --git a/detok/Rules.make b/detok/Rules.make
deleted file mode 100644
index db82ed6..0000000
--- a/detok/Rules.make
+++ /dev/null
@@ -1,17 +0,0 @@
-# tag: Makefile rules
-
-VPATH    := $(VPATH):.
-
-.S.o:
-	echo -n "  assembling $<... "
-	$(CC) -c -nostdlib $(INCLUDES) $(CFLAGS) $< -o $(BUILDDIR)/$@ && \
-		echo -e "    \t\tok" || \
-		echo -e "    \t\tfailed"
-
-.c.o:
-	@echo -n "  compiling $<... "
-	@$(CC) -c $(CFLAGS) $(INCLUDES) $< -o $(BUILDDIR)/$@ && \
-		echo -e "   \t\tok" || \
-		echo -e "   \t\failed"
-		
-
diff --git a/detok/addfcodes.c b/detok/addfcodes.c
new file mode 100644
index 0000000..f10f009
--- /dev/null
+++ b/detok/addfcodes.c
@@ -0,0 +1,343 @@
+/*
+ *                     OpenBIOS - free your system!
+ *                         ( FCode tokenizer )
+ *
+ *  This program is part of a free implementation of the IEEE 1275-1994
+ *  Standard for Boot (Initialization Configuration) Firmware.
+ *
+ *  Copyright (C) 2001-2005 Stefan Reinauer, <stepan@openbios.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ *
+ */
+
+/* **************************************************************************
+ *
+ *      Function(s) for entering Vendor-Specific FCodes to detokenizer.
+ *
+ *      (C) Copyright 2006 IBM Corporation.  All Rights Reserved.
+ *      Module Author:  David L. Paktor    dlpaktor@us.ibm.com
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      Functions Exported:
+ *          add_fcodes_from_list           Add Vendor-Specific FCodes from
+ *                                             the file whose name is supplied.
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      Revision History:
+ *          Tue, 25 Apr 2006 by David L. Paktor
+ *              Identified this need when working with in-house code,
+ *                  which uses some custom functions.  This solution
+ *                  is (hoped to be) general enough to cover all cases.
+ *
+ **************************************************************************** */
+
+
+/* **************************************************************************
+ *
+ *          Global Variables Imported
+ *              indata                Buffer into which the file will be read
+ *              stream_max            Size of the file buffer.
+ *
+ **************************************************************************** */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "detok.h"
+#include "stream.h"
+#include "addfcodes.h"
+
+/* **************************************************************************
+ *
+ *          Internal Static Variables
+ *     current_vfc_line       Line to be scanned in Vendor-FCodes buffer
+ *     vfc_remainder          Remainder of Vendor-FCodes buffer to be scanned
+ *     vfc_line_no            Number of current line in Vendor-FCodes buffer
+ *     vfc_buf_end            Pointer to end of Vendor-FCodes buffer
+ *
+ **************************************************************************** */
+
+static char *current_vfc_line;
+static char *vfc_remainder;
+static int vfc_line_no = 0;
+static char *vfc_buf_end;
+
+/* **************************************************************************
+ *
+ *      Function name:  skip_whitespace
+ *      Synopsis:       Advance the given string-pointer past blanks and tabs.
+ *                          (String is presumed to end before new-line)
+ *
+ *      Inputs:
+ *         Parameters:
+ *             string_line_ptr        Address of pointer to string
+ *
+ *      Outputs:
+ *         Returned Value:            None
+ *             *string_line_ptr       Advanced past blanks and tabs
+ *
+ **************************************************************************** */
+
+static void skip_whitespace( char **string_line_ptr)
+{
+    char *cur_char_ptr = *string_line_ptr;
+    for ( ; *cur_char_ptr != 0 ; cur_char_ptr++ )
+    {
+	if ( (*cur_char_ptr != '\t') && (*cur_char_ptr != ' ') )
+	{
+	    *string_line_ptr = cur_char_ptr;
+	    break;
+	}
+    }
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  get_next_vfc_line
+ *      Synopsis:       Advance to the next  vfc_line  to be processed.
+ *                      Skip blanks and comments.  Indicate when end reached.
+ *
+ *      Inputs:
+ *         Parameters:                    None
+ *         Local Static Variables:
+ *             vfc_remainder
+ *             vfc_buf_end
+ *
+ *      Outputs:
+ *         Returned Value:               FALSE if reached end of buffer
+ *         Local Static Variables:
+ *             current_vfc_line          Advanced to next line to be scanned
+ *             vfc_line_no               Kept in sync with line number in file
+ *
+ *      Process Explanation:
+ *          Comments begin with a pound-sign  ('#') or a backslash  ('\')
+ *          Comment-lines or blank or empty lines will be skipped. 
+ *
+ **************************************************************************** */
+
+static bool get_next_vfc_line( void )
+{
+    bool retval = FALSE;   /*  TRUE = not at end yet  */
+    while ( vfc_remainder < vfc_buf_end )
+    {
+	current_vfc_line = vfc_remainder;
+	vfc_remainder = strchr( current_vfc_line, '\n');
+	*vfc_remainder = 0;
+	vfc_remainder++;
+	vfc_line_no++;
+	skip_whitespace( &current_vfc_line);
+	if ( *current_vfc_line == 0 )  continue;  /*  Blank line */
+	if ( *current_vfc_line == '#' )  continue;  /*  Comment  */
+	if ( *current_vfc_line == '\\' )  continue;  /*  Comment  */
+	retval = TRUE;
+	break;  /*  Found something  */
+    }
+    return( retval);
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  vfc_splash
+ *      Synopsis:       Print a "splash" message to show that we
+ *                          are processing Vendor-Specific FCodes,
+ *                          but only once.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             vf_file_name            Vendor-Specific FCodes file name
+ *         Local Static Variables:
+ *             did_not_splash          Control printing; once only.
+ *
+ *      Outputs:
+ *         Returned Value:             None
+ *         Local Static Variables:
+ *             did_not_splash          FALSE after first call.
+ *         Printout:
+ *             "Splash" message...
+ *
+ **************************************************************************** */
+static bool did_not_splash = TRUE;
+static void vfc_splash( char *vf_file_name)
+{
+    if ( did_not_splash )
+    {
+	/*  Temporary substring buffer                */
+	/*  Guarantee that the malloc will be big enough.  */
+	char *strbfr = malloc( strlen( vf_file_name) +65 ) ;
+	sprintf( strbfr,
+	    "Reading additional FCodes from file:  %s\n",
+		vf_file_name);
+	printremark( strbfr);
+	free( strbfr);
+	did_not_splash = FALSE;
+    }
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  add_fcodes_from_list
+ *      Synopsis:       Add Vendor-Specific FCodes from the named file
+ *                          to the permanent resident dictionary.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             vf_file_name            Vendor-Specific FCodes file name
+ *         Global Variables:
+ *             verbose                 "Verbose" flag.
+ *             indata                  Start of file buffer
+ *             stream_max              Size of the file buffer.
+ *
+ *      Outputs:
+ *         Returned Value:             TRUE if FCodes have actually been added
+ *         Global Variables:
+ *             check_tok_seq           Cleared to FALSE, then restored to TRUE
+ *         Local Static Variables:
+ *             vfc_remainder           Initted to start of file buffer
+ *             vfc_buf_end             Initted to end of file buffer
+ *         Memory Allocated
+ *             Permanent copy of FCode Name
+ *         When Freed?
+ *             Never.  Rmeains until program termination.
+ *         Printout:
+ *             If verbose, "Splash" line and count of added entries.
+ *
+ *      Error Detection:
+ *          Fail to open or read Vendor-FCodes file -- Exit program
+ *          Improperly formatted input line -- print message and ignore
+ *          FCode value out of valid range -- print message and ignore
+ *          FCode value already in use -- print message and ignore
+ *
+ *      Process Explanation:
+ *          Valid lines are formatted with the FCode number first
+ *              and the name after, one entry per line.  Extra text
+ *              after the name will be ignored, so an extra "comment"
+ *              is permitted.  The FCode number must be in hex, with
+ *              an optional leading  0x  or  0X   For example:  0X407
+ *          The valid range is 0x010 to 0x7ff.  Numbers above 0x800
+ *              infringe upon the are reserved for FCodes generated
+ *              by the tokenization process.
+ *          Numbers already in use will be ignored.  A Message will be
+ *              printed even if the name matches the one on the line.
+ *
+ **************************************************************************** */
+
+bool add_fcodes_from_list( char *vf_file_name)
+{
+    bool retval = FALSE;
+    int added_fc_count = 0;
+    check_tok_seq = FALSE;
+
+    if ( verbose )  vfc_splash( vf_file_name);
+
+    if ( init_stream( vf_file_name) != 0 )
+    {
+	char *strbfr = malloc( strlen( vf_file_name) +65 );
+	sprintf( strbfr,
+	    "Could not open Additional FCodes file:  %s\n",
+		vf_file_name);
+	printremark( strbfr);
+	free( strbfr);
+	exit(1);
+    }
+    vfc_remainder = indata;
+    vfc_buf_end = indata + stream_max -1;
+
+    while (  get_next_vfc_line() )
+    {
+	char vs_fc_name[36];
+	int  vs_fc_number;
+	int  scan_result;
+	char *lookup_result;
+	char *fc_name_cpy;
+
+	scan_result = sscanf( current_vfc_line, "0x%x %32s",
+	     &vs_fc_number, vs_fc_name);
+
+	if ( scan_result != 2 )   /*  Allow a capital  0X   */
+	{
+	    scan_result = sscanf( current_vfc_line, "0X%x %32s",
+		&vs_fc_number, vs_fc_name);
+	}
+	if ( scan_result != 2 )   /*  Try it without the  0x   */
+	{
+	    scan_result = sscanf( current_vfc_line, "%x %32s",
+		&vs_fc_number, vs_fc_name);
+	}
+
+	if ( scan_result != 2 )   /*  That's it... */
+	{
+	    char *strbfr = malloc( strlen( current_vfc_line) +65 );
+	    vfc_splash( vf_file_name);
+	    sprintf( strbfr,
+		"Line #%d, invalid format.  Ignoring:  %s\n",
+		    vfc_line_no, current_vfc_line);
+	    printremark( strbfr);
+	    free( strbfr);
+	    continue;
+	}
+
+	if ( ( vs_fc_number < 0x10 ) || ( vs_fc_number > 0x7ff ) )
+	{
+	    char *strbfr = malloc( 85 );
+	    vfc_splash( vf_file_name);
+	    sprintf( strbfr,
+		"Line #%d, FCode number out of range:  0x%x  Ignoring.\n",
+		    vfc_line_no, vs_fc_number);
+	    printremark( strbfr);
+	    free( strbfr);
+	    continue;
+	}
+
+	lookup_result = lookup_token( (u16)vs_fc_number);
+	if ( strcmp( lookup_result, "ferror") != 0 )
+	{
+	    char *strbfr = malloc( strlen( lookup_result) + 85 );
+	    vfc_splash( vf_file_name);
+	    sprintf( strbfr,
+		"Line #%d.  FCode number 0x%x is already "
+		    "defined as %s  Ignoring.\n",
+			vfc_line_no, vs_fc_number, lookup_result);
+	    printremark( strbfr);
+	    free( strbfr);
+	    continue;
+	}
+
+	/*  We've passed all the tests!  */
+	fc_name_cpy = strdup( vs_fc_name);
+	add_token( (u16)vs_fc_number, fc_name_cpy);
+	added_fc_count++;
+	retval = TRUE;
+    }
+
+    if ( verbose )
+    {
+	char *strbfr = malloc( 85 );
+        sprintf( strbfr,
+	    "Added %d FCode numbers\n", added_fc_count);
+	printremark( strbfr);
+	free( strbfr);
+    }
+
+    close_stream();
+    check_tok_seq = TRUE;
+    return( retval);
+}
diff --git a/detok/addfcodes.h b/detok/addfcodes.h
new file mode 100644
index 0000000..2183c86
--- /dev/null
+++ b/detok/addfcodes.h
@@ -0,0 +1,48 @@
+#ifndef _DETOK_VSFCODES_H
+#define _DETOK_VSFCODES_H
+
+/*
+ *                     OpenBIOS - free your system!
+ *                         ( FCode tokenizer )
+ *
+ *  This program is part of a free implementation of the IEEE 1275-1994
+ *  Standard for Boot (Initialization Configuration) Firmware.
+ *
+ *  Copyright (C) 2001-2005 Stefan Reinauer, <stepan@openbios.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ *
+ */
+
+/* **************************************************************************
+ *
+ *      Header for function for entering Vendor-Specific FCodes
+ *          to detokenizer.
+ *
+ *      (C) Copyright 2006 IBM Corporation.  All Rights Reserved.
+ *      Module Author:  David L. Paktor    dlpaktor@us.ibm.com
+ *
+ **************************************************************************** */
+
+#include "types.h"
+
+/* ************************************************************************** *
+ *
+ *      Function Prototypes / Functions Exported:
+ *
+ **************************************************************************** */
+
+bool add_fcodes_from_list( char *vf_file_name);
+
+#endif   /*  _DETOK_VSFCODES_H    */
diff --git a/detok/decode.c b/detok/decode.c
index 1fee2b3..000e740 100644
--- a/detok/decode.c
+++ b/detok/decode.c
@@ -24,96 +24,322 @@
  *
  */
 
+/* **************************************************************************
+ *         Modifications made in 2005 by IBM Corporation
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Modifications Author:  David L. Paktor    dlpaktor@us.ibm.com
+ **************************************************************************** */
+
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <ctype.h>
+#include <setjmp.h>
 
 #include "detok.h"
 #include "stream.h"
 
-/* Dictionary function prototypes */
-char *lookup_token(u16 number);
-int  add_token(u16 number, char *name);
+static int indent;    /*  Current level of indentation   */
+
+/* **************************************************************************
+ *
+ *      Still to be done:
+ *          Handling of indent-level is not correct.  Branches should
+ *              balance with their resolvers; constructs like do..loop
+ *              case/of/endof/endcase are a few major examples.
+ *          This will be tricky; the rules need to be carefully thought
+ *              out, and the implementation might be more complex than
+ *              at first meets the eye...
+ *
+ **************************************************************************** */
 
-extern u16 fcode;
+static bool ended_okay = TRUE;    /*  FALSE if finished prematurely  */
 
 bool offs16=TRUE;
-int indent, verbose=0, decode_all=0, linenumbers=0, linenum;
-u32 fclen;
+unsigned int linenum;
+bool end_found=FALSE;
+unsigned int token_streampos;   /*  Streampos() of currently-gotten token  */
+u16 last_defined_token = 0;
+
+jmp_buf eof_exception;
 
-static u8 *unnamed=(u8 *)"(unnamed-fcode)";
+static int fclen;
+static const char *unnamed = "(unnamed-fcode)" ;
 
-void pretty_string(u8 *string)
+static void decode_indent(void) 
 {
-	u8 c;
-	unsigned int i;
-	bool qopen=TRUE;
+	int i;
+	if (indent<0) {
+#ifdef DEBUG_INDENT
+		printf("detok: error in indentation code.\n");
+#endif
+		indent=0;
+	}
+	for (i=0; i<indent; i++)
+		printf ("    ");
+}
 	
+/*  Print forth string ( [len] char[0] ... char[len] ) */
+static void pretty_print_string(void)
+{
+    u8 len;
+    u8 *strptr;
+    int indx;
+    bool in_parens = FALSE ;  /*  Are we already inside parentheses?  */
+
+    strptr = get_string( &len );
+
+    printf("( len=%s%x", len >= 10 ? "0x":"", len);
+    if ( len >= 10 )   printf(" [%d bytes]", len);
+    printf(" )\n");
+    if (show_linenumbers)  printf("        ");
+    decode_indent();
 	printf("\" ");
 
-	for (i=1; i<1+(unsigned int)string[0]; i++) {
-		c=string[i];
+    for ( indx = 0; indx < len; indx++ )
+    {
+	u8 c = *strptr++;
 		if (isprint(c)) {
-			if (!qopen) {
+	    if ( in_parens )
+	    {
 				printf(" )");
-				qopen=TRUE;
+		in_parens = FALSE;
 			}
 			printf("%c",c);
+	    /*  Quote-mark must escape itself  */
+	    if ( c == '"' ) printf("%c",c);
 		} else {
-			if (qopen) {
+	    if ( !in_parens )
+	    {
 				printf("\"(");
-				qopen=FALSE;
+		in_parens = TRUE;
 			}
 			printf(" %02x",c);
 		}
 	}
-	if (!qopen)
+    if ( in_parens )
 		printf(" )");
 	printf("\"");
 }
 
-static void decode_indent(void) 
+static void decode_lines(void)
 {
-	int i;
-#ifdef DEBUG_INDENT
-	if (indent<0) {
-		printf("detok: error in indentation code.\n");
-		indent=0;
+	if (show_linenumbers) {
+		printf("%6d: ",show_offsets ? token_streampos : linenum++);
 	}
-#endif
-	for (i=0; i<indent; i++)
-		printf ("    ");
 }
 
-static void decode_lines(void)
+/* **************************************************************************
+ *
+ *      Function name:  output_token_name
+ *      Synopsis:       Print the name of the token just retrieved
+ *                          along with any interesting related information...
+ *
+ *      Inputs:
+ *         Global/Static Variables:
+ *             fcode                  The token # just retrieved
+ *             last_defined_token     Used to screen invalid tokens.
+ *             token_streampos        Location of token just retrieved
+ *         Global/Static Constants:
+ *             unnamed                Namefield of headerless token 
+ *
+ *      Outputs:
+ *         Printout:
+ *             Print the function name (if known) and the FCode number,
+ *                  if interesting.
+ *             The fcode number is interesting if either
+ *                 a) the token has no name
+ *                           or
+ *                 b) verbose mode is in effect.
+ *             If the token is named, show its FCode number in
+ *                 the syntax of a FORTH Comment, otherwise, its
+ *                 FCode number -- in [brackets] -- acts as its name.
+ *
+ *      Error Detection:
+ *          If the token # is larger than the last defined token, it is
+ *              probably an artifact of an error that was allowed in the
+ *              tokenization; if it were treated normally, it would lead
+ *              to a cascade of failures.  Print a message, skip the first
+ *              byte, and return.
+ *
+ *      Revision History:
+ *          Refactored.  The line number or offset (if selected) and the
+ *              indent are printed in the  output_token()  routine, which
+ *              calls this one.
+ *          Add Error Detection
+ *          
+ *
+ **************************************************************************** */
+
+static void output_token_name(void)
 {
-	if (linenumbers) {
-		printf("%6d: ",linenumbers==1?linenum:get_streampos());
-		linenum++;
+	char *tname;
+
+	/*  Run error detection only if last_defined_token was assigned  */
+	if ( (fcode > last_defined_token) && (last_defined_token > 0) )
+	{
+	    char temp_buf[80];
+	    int buf_pos;
+	    u8 top_byte = fcode >> 8;
+	    printf ("Invalid token:  [0x%03x]\n", fcode);
+	    sprintf(temp_buf, "Backing up over first byte, which is ");
+	    buf_pos = strlen(temp_buf);
+	    if ( top_byte < 10 )
+	    {
+	        sprintf(&temp_buf[buf_pos], " %02x", top_byte);
+	    }else{
+	        sprintf( &temp_buf[buf_pos], "0x%02x ( =dec %d)",
+		    top_byte, top_byte);
 	}
+	    printremark(temp_buf);
+	    set_streampos(token_streampos+1);
+	    return;
 }
 
-static void output_token(void)
-{
-	u8 *tname=lookup_token(fcode);
 	
+	tname = lookup_token(fcode);
 	printf ("%s ", tname);
 
-	/* The fcode number is interesting if
-	 *  a) detok is in verbose mode
-	 *  b) the token has no name.
+	/* The fcode number is interesting
+	 *  if either
+	 *  a) the token has no name
+	 *            or
+	 *  b) detok is in verbose mode.
 	 */
-	if (verbose || tname == unnamed)
+       if ( tname == unnamed )
+       {
 		printf("[0x%03x] ", fcode);
+       } else {
+	    if ( verbose )
+	    {
+		/*  If the token is named,
+		 *  show its fcode number in
+		 *  the syntax of a FORTH Comment
+		 */
+		printf("( 0x%03x ) ", fcode);
+	    }
+	}
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  output_token
+ *      Synopsis:       Print the full line for the token just retrieved:
+ *                          line number, indentation and name.
+ *
+ *      Revision History:
+ *          Updated Mon, 11 Jul 2005 by David L. Paktor
+ *          Separate out  output_token_name()  for specific uses.
+ *          Incorporate calls to  decode_lines()  and   decode_indent()
+ *              to allow better control of indentation.
+ *
+ **************************************************************************** */
+
+static void output_token(void)
+{
+	decode_lines();
+	decode_indent();
+	output_token_name();
 }
 
+
+/* **************************************************************************
+ *
+ *      Function name:  decode_offset
+ *      Synopsis:       Gather and display an FCode-offset associated with
+ *                          a branch or suchlike function.
+ *
+ *      Inputs:
+ *         Parameters:                 NONE
+ *         Global/Static Variables:
+ *             show_offsets            Whether to show offsets in full detail
+ *             offs16                  Whether 16- (or 8-) -bit offsets
+ *             stream_max              Maximum valid destimation      
+ *         Local Static Variables:
+ *
+ *      Outputs:
+ *         Returned Value:             The offset, converted to signed 16-bit #
+ *         Global/Static Variables:
+ *             stream-position         Reset if invalid destination; otherwise,
+ *                                         advanced in the normal manner.
+ *         Printout:
+ *             The offset and destination, if display of offsets was specified
+ *                 or if the destination is invalid
+ *
+ *      Error Detection:
+ *          Crude and rudimentary:
+ *          If the target-destination is outside the theoretical limits,
+ *              it's obviously wrong.
+ *          Notification remark is printed and the stream-position reset
+ *              to the location of the offset, to allow it to be processed
+ *              in the manner of normal tokens.
+ *          If the offset is zero, that's obviously wrong, but don't reset
+ *              the stream-position:  zero gets processed as  end0  and that
+ *              is also wrong...
+ *
+ *      Still to be done:
+ *          More sophisticated error-checking for invalid offsets.  Look
+ *              at the type of branch, and what should be expected in the
+ *              vicinity of the destination.  (This might be best served
+ *              by a separate routine).
+ *         This might also help with handling the indent-level correctly...
+ *              Also, if indentation were to be handled in this routine,
+ *              there would be no need to return the value of the offset.
+ *
+ **************************************************************************** */
+
 static s16 decode_offset(void)
 {
         s16 offs;
+	int dest;
+	bool invalid_dest;
+	int streampos = get_streampos();
 
-        offs=get_offset();
 	output_token();
-	printf("0x%x\n",offs);
+        offs=get_offset();
+
+	/*  The target-destination is the source-byte offset
+	 *      at which the FCode-offset is found, plus
+	 *      the FCode-offset.
+	 */
+	dest = streampos + offs;
+
+	/*  A destination of zero is invalid because there must be a
+	 *      token -- such as  b(<mark)  or   b(do)  -- preceding
+	 *      the target of a backward branch.
+	 *  A destination at the end of the stream is unlikely but
+	 *      theoretically possible, so we'll treat it as valid.
+	 *  An offset of zero is also, of course, invalid.
+	 */
+	invalid_dest = BOOLVAL ( (dest <= 0)
+	                      || (dest > stream_max)
+	                      || (offs == 0) );
+
+	/*  Show the offset in hex and again as a signed decimal number.   */
+	if ( offs16 )
+	{
+	    printf("0x%04x (", (u16)(offs & 0xffff) );
+	}else{
+	    printf("0x%02x (",  (u8)(offs & 0x00ff) );
+	}
+	if ( (offs < 0) || (offs > 9) )  printf(" =dec %d", offs);
+	/*  If we're showing source-byte offsets, show targets of offsets  */
+	if ( show_offsets || invalid_dest )
+	{
+	    printf("  dest = %d ",dest);
+	}
+	printf(")\n");
+
+	if ( invalid_dest )
+	{
+	    if (offs == 0) 
+	    {
+	      printremark("Error:  Unresolved offset.");
+	    }else{
+	      printremark("Error:  Invalid offset.  Ignoring...");
+	      set_streampos( streampos);
+	    }
+	}
 	return offs;
 }
 
@@ -127,59 +353,39 @@ static void new_token(void)
 {
 	u16 token;
 	output_token();
-	token=get_token();
+	token = next_token();
 	printf("0x%03x\n",token);
-	add_token(token, unnamed);
+	add_token(token, (char *)unnamed);
 }
 
 static void named_token(void)
 {
 	u16 token;
+	u8 len;
 	u8* string;
 
 	output_token();
 	/* get forth string ( [len] [char0] ... [charn] ) */
-	string=get_string();
-	token=get_token();
-
-	printf("%s 0x%03x\n", string+1, token);
-	
-	add_token(token,string+1);
-}
-
-static void external_token(void)
-{
-	u16 token;
-	u8* string;
-
-	output_token();
-	/* get forth string ( [len] [char0] ... [charn] ) */
-	string=get_string();
-	token=get_token();
-
-	printf("%s 0x%03x\n", string+1, token);
-
-	add_token(token,string+1);
+	string=get_name(&len);
+	token = next_token();
+	printf("%s 0x%03x\n", string, token);
+	add_token(token,string);
 }
 
 static void bquote(void)
 {
-	u8 *string;
-
-	/* get forth string ( [len] [char0] ... [charn] ) */
-	string=get_string();
 	output_token();
-	pretty_string(string);
+	/* get forth string ( [len] [char0] ... [charn] ) */
+	pretty_print_string();
 	printf("\n");
-	free(string);
 }
 
 static void blit(void)
 {
 	u32 lit;
 
-	lit=get_num32();
 	output_token();
+	lit=get_num32();
 	printf("0x%x\n",lit);
 }
 
@@ -204,56 +410,81 @@ static void decode_two(void)
 	u16 token;
 
 	output_token();
-	token=get_token();
-	decode_default();
+	token = next_token();
+	output_token_name();
+	printf ("\n");
 }
 
+/* **************************************************************************
+ *
+ *      Function name:  decode_start
+ *      Synopsis:       Display the (known valid) FCode block Header
+ *
+ *      Outputs:
+ *         Global/Static Variables:    
+ *             fclen         Length of the FCode block as shown in its Header
+ *
+ **************************************************************************** */
+
 static void decode_start(void)
 {
 	u8  fcformat;
 	u16 fcchecksum, checksum=0;
-	long pos;
-	u32 i;
 
-	decode_default();
+	output_token();
+	printf("  ( %d-bit offsets)\n", offs16 ? 16 : 8 );
 	
+        token_streampos = get_streampos();
 	decode_lines();
         fcformat=get_num8();
 	printf("  format:    0x%02x\n", fcformat);
  
-	decode_lines();
-        fcchecksum=get_num16();
-        /* missing: check for checksum correctness. */
- 
-        fclen=get_num32(); /* skip len */
-	pos=get_streampos();
 	
-	for (i=0; i<fclen-pos; i++)
-		checksum+=get_num8();
+        /* Check for checksum correctness. */
 	
-	set_streampos(pos-4);
+        token_streampos = get_streampos();
+	decode_lines();
+        fcchecksum=get_num16();        /*  Read the stored checksum  */
+	checksum = calc_checksum();    /*  Calculate the actual checksum  */
 	
-	printf("  checksum:  0x%04x (%sOk)\n", fcchecksum,
-			fcchecksum==checksum?"":"not ");
+	if ( fcchecksum==checksum )
+	{
+		printf("  checksum:  0x%04x (Ok)\n", fcchecksum);
+	} else {
+		printf("  checksum should be:  0x%04x, but is 0x%04x\n",
+			checksum,fcchecksum);
+	}
 
+        token_streampos = get_streampos();
 	decode_lines();
 	fclen=get_num32();
-        printf("  len:       0x%x (%d bytes)\n", fclen, fclen);
+        printf("  len:       0x%04x ( %d bytes)\n", fclen, fclen);
 }
 
 
-void decode_token(u16 token)
+/* **************************************************************************
+ *
+ *      Function name: decode_token
+ *      Synopsis:      Display detokenization for one token.
+ *                     Handle complicated cases and dispatch simple ones.
+ *
+ *      Revision History:
+ *          Detect FCode-Starters in the middle of an FCode block.
+ *          Some tuning of adjustment of indent, particularly wrt branches...
+ *
+ **************************************************************************** */
+
+static void decode_token(u16 token)
 {
+    bool handy_flag = TRUE;
 	switch (token) {
 	case 0x0b5:
 		new_token();
 		break;
-	case 0x0b6:
+	case 0x0b6:    /*   Named Token  */
+	case 0x0ca:    /*   External Token  */
 		named_token();
 		break;
-	case 0x0ca:
-		external_token();
-		break;
 	case 0x012:
 		bquote();
 		break;
@@ -276,14 +507,14 @@ void decode_token(u16 token)
 	case 0x0c2: /* b(;) */
 	case 0x0b2: /* b(>resolve) */
 	case 0x0c5: /* b(endcase) */
-		decode_default();
 		indent--;
+		decode_default();
 		break;
 	case 0x015: /* b(loop) */
 	case 0x016: /* b(+loop) */
 	case 0x0c6: /* b(endof) */
-		decode_offset();
 		indent--;
+		decode_offset();
 		break;
 	case 0x017: /* b(do) */
 	case 0x018: /* b/?do) */
@@ -295,38 +526,274 @@ void decode_token(u16 token)
 	case 0x0c3: /* b(to) */
 		decode_two();
 		break;
+	case 0x0fd: /* version1 */
+		handy_flag = FALSE;
 	case 0x0f0: /* start0 */
 	case 0x0f1: /* start1 */
 	case 0x0f2: /* start2 */
 	case 0x0f3: /* start4 */
+		offs16 = handy_flag;
+		printremark("Unexpected FCode-Block Starter.");
 		decode_start();
+		printremark("  Ignoring length field.");
 		break;
+	case    0:  /* end0  */
+	case 0xff:  /* end1  */
+		end_found=TRUE;
+		decode_default();
+		break;
+	default:
+		decode_default();
+	}
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  decode_fcode_header
+ *      Synopsis:       Detokenize the FCode Header.
+ *                          Check for file corruption
+ *
+ *      Inputs:
+ *         Parameters:          NONE
+ *         Global/Static Variables:        
+ *             stream_max       Length of input stream
+ *
+ *      Outputs:
+ *         Returned Value:      NONE
+ *         Global/Static Variables:
+ *             offs16           FALSE if Starter was version1, else TRUE
+ *             fclen            On error, gets set to reach end of input stream
+ *                                  Otherwise, gets set by  decode_start() 
+ *         Printout:
+ *
+ *      Error Detection:
+ *          First byte not a valid FCode Start:  Print message, restore
+ *              input pointer to initial value, set fclen to [(end of
+ *              input stream) - (input pointer)], return FALSE.
+ *
+ *      Process Explanation:
+ *          This routine error-checks and dispatches to the routine that
+ *              does the actual printing.
+ *          Refrain from showing offset until correctness of starter-byte
+ *              has been confirmed.
+ *
+ **************************************************************************** */
+
+static void decode_fcode_header(void)
+{
+    long err_pos;
+    u16 token;
+
+    err_pos = get_streampos();
+    indent = 0;
+    token = next_token();
+    offs16=TRUE;
+    switch (token)
+    {
 	case 0x0fd: /* version1 */
-		decode_start();
 		offs16=FALSE;
+	case 0x0f0: /* start0 */
+	case 0x0f1: /* start1 */
+	case 0x0f2: /* start2 */
+	case 0x0f3: /* start4 */
+	    decode_start();
 		break;
 	default:
-		decode_default();
+	    {
+		char temp_bufr[128] = 
+			"Invalid FCode Start Byte.  Ignoring FCode header." ;
+		set_streampos( err_pos );
+		fclen = max - pc;
+		printf("\n");
+		if (show_linenumbers)
+		{
+		    sprintf( &(temp_bufr[strlen(temp_bufr)]),
+		    "  Remaining len = 0x%04x ( %d bytes)", fclen, fclen); 
+		}
+		printremark( temp_bufr );
 	}
 }
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  decode_fcode_block
+ *      Synopsis:       Detokenize one FCode block.
+ *
+ *      Inputs:
+ *         Parameters:                     NONE
+ *         Global/Static Variables:
+ *             fclen         Length of the FCode block as shown in its Header
+ *             end_found     Whether the END0 code was seen
+ *             decode_all    TRUE = continue even after END0
+ *
+ *      Outputs:
+ *         Returned Value:                 NONE
+ *         Global/Static Variables:
+ *             end_found     Whether the END0 code was seen
+ *         Printout:
+ *             A summary message at the end of FCode detokenization
+ *
+ *      Error Detection:
+ *          If the end of the FCode block, as calculated by its FCode length,
+ *              was reached without encountering END0, print a message.
+ *          Detect END0 that occurs before end of FCode block,
+ *              even if  decode_all  is in effect.
+ *
+ *      Process Explanation:
+ *          This routine dispatches to the routines that do the actual
+ *              printing of the detokenization.
+ *          The  end_found  flag is not a direct input, but more of an
+ *              intermediate input, so to speak...  Clear it at the start.
+ *          Detection of FCode-Starters in the middle of an FCode block
+ *              is handled by  decode_token()  routine.
+ *
+ **************************************************************************** */
 
-int detokenize(void)
+static void decode_fcode_block(void)
 {
 	u16 token;
+    unsigned int fc_block_start;
+    unsigned int fc_block_end;
 	
-	if (linenumbers)
-		linenum=1;
+    end_found = FALSE;
+    fc_block_start = get_streampos();
 	
-	do {
-		decode_lines();
-		decode_indent();
-		token=get_token();
+    decode_fcode_header();
+
+    fc_block_end = fc_block_start + fclen;
+    
+    while ( ( !end_found || decode_all )
+         && ( get_streampos() < fc_block_end  ) )
+    {
+	token = next_token();
 		decode_token(token);
-	} while ((token||decode_all) && ((get_streampos()-1)<=fclen));
+    }
+    if ( !end_found )
+    {
+	printremark("FCode-ender not found");
+    }
+    {
+	char temp_bufr[80];
+	/*  Don't use  fclen  here, in case it got corrupted
+	 *      by an "Unexpected FCode-Block Starter"
+	 */
+	if ( get_streampos() == fc_block_end  )
+	{
+	    sprintf( temp_bufr,
+		"Detokenization finished normally after %d bytes.",
+		     fc_block_end - fc_block_start );
+	}else{
+	    sprintf( temp_bufr,
+		"Detokenization finished prematurely after %d of %d bytes.",
+		     get_streampos() - fc_block_start,
+			 fc_block_end - fc_block_start );
+	    ended_okay = FALSE;
+	}
+	printremark( temp_bufr );
+    }
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  another_fcode_block
+ *      Synopsis:       Indicate whether there is a follow-on FCode block
+ *                      within the current PCI image.
+ *
+ *      Inputs:
+ *         Parameters:                     NONE
+ *         Global/Static Variables:
+ *             token_streampos             Streampos() of token just gotten
+ *             Next token in Input Stream
+ *
+ *      Outputs:
+ *         Returned Value:                  TRUE if next token shows the start
+ *                                              of a valid FCode-block
+ *         Printout:
+ *             Message if there is a follow-on FCode block
+ *
+ *      Error Detection:
+ *          If next token is neither a valid FCode-block starter nor the
+ *              start of a zero-fill field, print a message.
+ *
+ *      Process Explanation:
+ *          Extract the next token from the Input Stream but do not
+ *              consume it.  Then examine the token.
+ *
+ **************************************************************************** */
+
+static bool another_fcode_block(void)
+{
+    bool retval = FALSE;
+    u16 token;
+
+    token = next_token();
+    set_streampos( token_streampos );
+
+    switch (token)
+    {
+	case 0x0fd: /* version1 */
+	case 0x0f0: /* start0 */
+	case 0x0f1: /* start1 */
+	case 0x0f2: /* start2 */
+	case 0x0f3: /* start4 */
+	    retval = TRUE;
+	    printremark("Subsequent FCode Block detected.  Detokenizing.");
+	    break;
+	case 0:    /* Start of a zero-fill field  */
+	    /* retval already = FALSE .  Nothing else to be done.  */
+	    break;
+	default:
+	    {
+		char temp_bufr[80];
+		sprintf( temp_bufr,
+		    "Unexpected token, 0x%02x, after end of FCode block.",
+		    token);
+		printremark( temp_bufr);
+	    }
+    }
+    return ( retval );
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  detokenize
+ *      Synopsis:       Detokenize one input file 
+ *                      
+ *
+ *
+ **************************************************************************** */
+
+void detokenize(void)
+{
+    fclen = stream_max;
+
+    if ( setjmp(eof_exception) == 0 )
+    {
+	while ( more_to_go() )
+	{
+	    if ( ended_okay )
+	    {
+		init_fcode_block();
+	    }
+	    ended_okay = TRUE;
+
+	    adjust_for_pci_header();
+
+	    /*   Allow for multiple FCode Blocks within the PCI image.
+	     *   The first one had better be a valid block, but the
+	     *   next may or may not be...
+	     */
+	    do
+	    {
+		decode_fcode_block();
+	    }  while  ( another_fcode_block() );
+
+	    adjust_for_pci_filler();
+
+	}
+    }
 
-	decode_lines();
-	printf ("\\ detokenizing finished after %d of %d bytes.\n",
-			get_streampos(), fclen );
 
-	return 0;
 }
diff --git a/detok/detok.c b/detok/detok.c
index 1507a38..a69441e 100644
--- a/detok/detok.c
+++ b/detok/detok.c
@@ -24,58 +24,76 @@
  *
  */
 
+/* **************************************************************************
+ *         Modifications made in 2005 by IBM Corporation
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Modifications Author:  David L. Paktor    dlpaktor@us.ibm.com
+ **************************************************************************** */
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
+
 #ifdef __GLIBC__
 #define _GNU_SOURCE
 #include <getopt.h>
-#else
-/* Some systems seem to have an incomplete unistd.h.
- * We need to define getopt() and optind for them.
- */
-extern int optind;
-int getopt(int argc, char * const argv[], const char *optstring);
 #endif
 
 #include "detok.h"
 #include "stream.h"
+#include "addfcodes.h"
 
 #define DETOK_VERSION "0.6.1"
 
-/* prototypes for dictionary handling */
-void init_dictionary(void);
-void decode_token(u16 token);
-/* prototype for detokenizer function */
-int  detokenize(void);
+#define IBM_COPYR    "(C) Copyright 2005 IBM Corporation.  All Rights Reserved."
 
-extern unsigned int decode_all, verbose, linenumbers;
+bool verbose = FALSE ;
+bool decode_all = FALSE ;
+bool show_linenumbers = FALSE ;
+bool show_offsets = FALSE ;
 
-void print_copyright(void)
+/*   Param is FALSE when beginning to detokenize,
+ *       TRUE preceding error-exit   */
+static void print_copyright(bool is_error)
 {
-        printf( "Welcome to the OpenBIOS detokenizer v%s\ndetok Copyright"
+	typedef void (*vfunct)();  /*  Pointer to function returning void  */
+	vfunct pfunct ;
+	char buffr[512];
+
+	sprintf( buffr,
+		"Welcome to the OpenBIOS detokenizer v%s\ndetok Copyright"
 		"(c) 2001-2005 by Stefan Reinauer.\nWritten by Stefan "
 		"Reinauer, <stepan@openbios.org>\n" "This program is "
 		"free software; you may redistribute it under the terms of\n"
 		"the GNU General Public License.  This program has absolutely"
 					" no warranty.\n\n" ,DETOK_VERSION);
+
+	pfunct = ( is_error ? (vfunct)printf : printremark );
+
+        (*pfunct) ( buffr );
+
+        (*pfunct) ( IBM_COPYR "\n" );
 }
 
-void usage(char *name)
+static void usage(char *name)
 {
 	printf( "usage: %s [OPTION]... [FCODE-FILE]...\n\n"
 		"         -v, --verbose     print fcode numbers\n"
 		"         -a, --all         don't stop at end0\n"
 		"         -n, --linenumbers print line numbers\n"
 		"         -o, --offsets     print byte offsets\n"
+		"         -f, --fcodes      add FCodes from list-file\n"
 		"         -h, --help        print this help text\n\n", name);
 }
 
 int main(int argc, char **argv)
 {
 	int c;
-	const char *optstring="vhano?";
+	const char *optstring="vhanof:?";
+	int linenumbers = 0;
+	bool add_vfcodes = FALSE;
+	char *vfc_filnam = NULL;
 
 	while (1) {
 #ifdef __GLIBC__
@@ -86,6 +104,7 @@ int main(int argc, char **argv)
 			{ "all", 0, 0, 'a' },
 			{ "linenumbers", 0, 0, 'n' },
 			{ "offsets", 0, 0, 'o' },
+			{ "fcodes", 1, 0, 'f' },
 			{ 0, 0, 0, 0 }
 		};
 
@@ -99,24 +118,31 @@ int main(int argc, char **argv)
 
 		switch (c) {
 		case 'v':
-			verbose=1;
+			verbose=TRUE;
 			break;
 		case 'a':
-			decode_all=1;
+			decode_all=TRUE;
 			break;
 		case 'n':
 			linenumbers|=1;
+			show_linenumbers = TRUE;
 			break;
 		case 'o':
 			linenumbers|=2;
+			show_linenumbers = TRUE;
+			show_offsets = TRUE;
+			break;
+		case 'f':
+			add_vfcodes = TRUE;
+			vfc_filnam = optarg;
 			break;
 		case 'h':
 		case '?':
-			print_copyright();
+			print_copyright(TRUE);
 			usage(argv[0]);
 			return 0;		
 		default:
-			print_copyright();
+			print_copyright(TRUE);
 			printf ("%s: unknown option.\n",argv[0]);
 			usage(argv[0]);
 			return 1;
@@ -124,13 +150,14 @@ int main(int argc, char **argv)
 	}
 
 	if (verbose)
-		print_copyright();
+		print_copyright(FALSE);
 	
 	if (linenumbers>2)
-		printf("Line numbers will be disabled in favour of offsets.\n");
+		printremark(
+		    "Line numbers will be disabled in favour of offsets.\n");
 	
 	if (optind >= argc) {
-		print_copyright();
+		print_copyright(TRUE);
 		printf ("%s: filename missing.\n",argv[0]);
 		usage(argv[0]);
 		return 1;
@@ -138,6 +165,14 @@ int main(int argc, char **argv)
 	
 	init_dictionary();
 	
+	if ( add_vfcodes )
+	{
+	    if ( add_fcodes_from_list( vfc_filnam) )
+	    {
+	        freeze_dictionary();
+	    }
+	}
+
 	while (optind < argc) {
 		
 		if (init_stream(argv[optind])) {
diff --git a/detok/detok.h b/detok/detok.h
index 17c2b16..9e683cc 100644
--- a/detok/detok.h
+++ b/detok/detok.h
@@ -1,3 +1,6 @@
+#ifndef _UTILS_DETOK_DETOK_H
+#define _UTILS_DETOK_DETOK_H
+
 /*
  *                     OpenBIOS - free your system! 
  *                            ( detokenizer )
@@ -24,10 +27,49 @@
  *
  */
 
-#define u8 unsigned char
-#define u16 unsigned short
-#define u32 unsigned int
-#define s16 short
-#define bool int
-#define TRUE (-1)
-#define FALSE (0)
+/* **************************************************************************
+ *         Modifications made in 2005 by IBM Corporation
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Modifications Author:  David L. Paktor    dlpaktor@us.ibm.com
+ **************************************************************************** */
+
+#include "types.h"
+
+/*  Prototypes for functions exported from
+ *   detok.c  decode.c  printformats.c  pcihdr.c  and  dictionary.c
+ */
+
+void add_token(u16 number, char *name);
+void init_dictionary(void);
+void reset_dictionary(void);
+void freeze_dictionary(void);
+char *lookup_token(u16 number);
+
+void detokenize(void);
+
+void printremark(char *str);
+
+int handle_pci_header ( u8  *data_ptr );
+void handle_pci_filler(u8 *filler_ptr);
+
+
+/*  External declarations for variables defined in or used by
+ *   detok.c  decode.c  printformats.c  pcihdr.c  and  dictionary.c
+ */
+extern bool verbose;
+extern bool decode_all;
+extern bool show_linenumbers;
+extern bool show_offsets;
+
+extern bool check_tok_seq;
+
+extern u16 fcode;
+extern bool offs16;
+extern bool end_found;
+extern unsigned int linenum;
+
+extern u8 *pci_image_end;
+extern unsigned int token_streampos;
+extern u16 last_defined_token;
+
+#endif   /*  _UTILS_DETOK_DETOK_H    */
diff --git a/detok/dictionary.c b/detok/dictionary.c
index 46eff92..fe2ef33 100644
--- a/detok/dictionary.c
+++ b/detok/dictionary.c
@@ -24,20 +24,29 @@
  *
  */
 
+/* **************************************************************************
+ *         Modifications made in 2005 by IBM Corporation
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Modifications Author:  David L. Paktor    dlpaktor@us.ibm.com
+ **************************************************************************** */
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>
 
 #include "detok.h"
 
+bool check_tok_seq = TRUE;
+
 typedef struct token {
-	u8  *name;
+	char *name;
 	u16 fcode;
 	struct token *next;
 } token_t;
+#define TOKEN_ENTRY(num, name)   { name, (u16)num, (token_t *)NULL }
+static token_t *dictionary;   /*  Initialize dynamically to accommodate AIX  */
 
 static char *fcerror="ferror";
-token_t *dictionary=NULL;
 
 char *lookup_token(u16 number)
 {
@@ -53,7 +62,51 @@ char *lookup_token(u16 number)
 	return fcerror;
 }
 
-int add_token(u16 number, char *name)
+/* **************************************************************************
+ *
+ *      Function name:  add_token
+ *      Synopsis:       Add an entry to the FCode-Tokens vocabulary.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             number                      Numeric value of the FCode token
+ *             name                        Name of the function to display
+ *         Global/Static Variables:
+ *             dictionary                  Pointer to the "tail" of the
+ *                                             FCode-Tokens vocabulary.
+ *             check_tok_seq               TRUE = "Check Token Sequence"
+ *                                             A retro-fit to accommodate
+ *                                             adding Vendor FCodes
+ *
+ *      Outputs:
+ *         Returned Value:                 NONE
+ *         Global/Static Variables:
+ *             dictionary                  Updated to point to the new entry.
+ *             last_defined_token          Updated to the given FCode token
+ *         Memory Allocated
+ *             For the new entry.
+ *         When Freed?
+ *             Never.  Retained for duration of the program.
+ *
+ *      Error Detection:
+ *          Failure to allocate memory is a fatal error.
+ *          If the given FCode token is not exactly one larger than the
+ *              previous  last_defined_token , then there's something
+ *              odd going on; print a remark to alert the user.  The
+ *              value of  last_defined_token  will be used elsewhere
+ *              for additional error-checking.
+ *
+ *      Process Explanation:
+ *          The name field pointer is presumed to already point to a stable
+ *              memory-space.
+ *          Memory will be allocated for the entry itself; its fields will
+ *              be entered and the pointer-to-the-tail-of-the-vocabulary
+ *              will be updated to point to the new entry.
+ *          Error-check and update  last_defined_token  
+ *
+ **************************************************************************** */
+
+void add_token(u16 number, char *name)
 {
 	token_t *curr;
 
@@ -68,393 +121,451 @@ int add_token(u16 number, char *name)
 	curr->name=name;
 
 	dictionary=curr;
-	return 0;
+
+	if ( check_tok_seq )
+	{
+	    /*  Error-check, but not for first time.  */
+	    if ( (number == last_defined_token + 1)
+		   || (last_defined_token == 0) )
+	    {
+		last_defined_token = number;
+	    }else{
+		if ( number <= last_defined_token )
+		{
+		    printremark("Warning:  New token # might overlap "
+			"previously assigned token #(s).");
+		}else{
+		    printremark("Warning:  New token # out of sequence with "
+			"previously assigned token #(s).");
+		    /*  It's increasing; update it.  */
+		    last_defined_token = number;
+		}
 }
+	}
+
+}
+
+token_t detok_table[]  = {
+
+	TOKEN_ENTRY( 0x000, "end0" ),
+	TOKEN_ENTRY( 0x010, "b(lit)" ),
+	TOKEN_ENTRY( 0x011, "b(')" ),
+	TOKEN_ENTRY( 0x012, "b(\")" ),
+	TOKEN_ENTRY( 0x013, "bbranch" ),
+	TOKEN_ENTRY( 0x014, "b?branch" ),
+	TOKEN_ENTRY( 0x015, "b(loop)" ),
+	TOKEN_ENTRY( 0x016, "b(+loop)" ),
+	TOKEN_ENTRY( 0x017, "b(do)" ),
+	TOKEN_ENTRY( 0x018, "b(?do)" ),
+	TOKEN_ENTRY( 0x019, "i" ),
+	TOKEN_ENTRY( 0x01a, "j" ),
+	TOKEN_ENTRY( 0x01b, "b(leave)" ),
+	TOKEN_ENTRY( 0x01c, "b(of)" ),
+	TOKEN_ENTRY( 0x01d, "execute" ),
+	TOKEN_ENTRY( 0x01e, "+" ),
+	TOKEN_ENTRY( 0x01f, "-" ),
+	TOKEN_ENTRY( 0x020, "*" ),
+	TOKEN_ENTRY( 0x021, "/" ),
+	TOKEN_ENTRY( 0x022, "mod" ),
+	TOKEN_ENTRY( 0x023, "and" ),
+	TOKEN_ENTRY( 0x024, "or" ),
+	TOKEN_ENTRY( 0x025, "xor" ),
+	TOKEN_ENTRY( 0x026, "invert" ),
+	TOKEN_ENTRY( 0x027, "lshift" ),
+	TOKEN_ENTRY( 0x028, "rshift" ),
+	TOKEN_ENTRY( 0x029, ">>a" ),
+	TOKEN_ENTRY( 0x02a, "/mod" ),
+	TOKEN_ENTRY( 0x02b, "u/mod" ),
+	TOKEN_ENTRY( 0x02c, "negate" ),
+	TOKEN_ENTRY( 0x02d, "abs" ),
+	TOKEN_ENTRY( 0x02e, "min" ),
+	TOKEN_ENTRY( 0x02f, "max" ),
+	TOKEN_ENTRY( 0x030, ">r" ),
+	TOKEN_ENTRY( 0x031, "r>" ),
+	TOKEN_ENTRY( 0x032, "r@" ),
+	TOKEN_ENTRY( 0x033, "exit" ),
+	TOKEN_ENTRY( 0x034, "0=" ),
+	TOKEN_ENTRY( 0x035, "0<>" ),
+	TOKEN_ENTRY( 0x036, "0<" ),
+	TOKEN_ENTRY( 0x037, "0<=" ),
+	TOKEN_ENTRY( 0x038, "0>" ),
+	TOKEN_ENTRY( 0x039, "0>=" ),
+	TOKEN_ENTRY( 0x03a, "<" ),
+	TOKEN_ENTRY( 0x03b, ">" ),
+	TOKEN_ENTRY( 0x03c, "=" ),
+	TOKEN_ENTRY( 0x03d, "<>" ),
+	TOKEN_ENTRY( 0x03e, "u>" ),
+	TOKEN_ENTRY( 0x03f, "u<=" ),
+	TOKEN_ENTRY( 0x040, "u<" ),
+	TOKEN_ENTRY( 0x041, "u>=" ),
+	TOKEN_ENTRY( 0x042, ">=" ),
+	TOKEN_ENTRY( 0x043, "<=" ),
+	TOKEN_ENTRY( 0x044, "between" ),
+	TOKEN_ENTRY( 0x045, "within" ),
+	TOKEN_ENTRY( 0x046, "drop" ),
+	TOKEN_ENTRY( 0x047, "dup" ),
+	TOKEN_ENTRY( 0x048, "over" ),
+	TOKEN_ENTRY( 0x049, "swap" ),
+	TOKEN_ENTRY( 0x04A, "rot" ),
+	TOKEN_ENTRY( 0x04b, "-rot" ),
+	TOKEN_ENTRY( 0x04c, "tuck" ),
+	TOKEN_ENTRY( 0x04d, "nip" ),
+	TOKEN_ENTRY( 0x04e, "pick" ),
+	TOKEN_ENTRY( 0x04f, "roll" ),
+	TOKEN_ENTRY( 0x050, "?dup" ),
+	TOKEN_ENTRY( 0x051, "depth" ),
+	TOKEN_ENTRY( 0x052, "2drop" ),
+	TOKEN_ENTRY( 0x053, "2dup" ),
+	TOKEN_ENTRY( 0x054, "2over" ),
+	TOKEN_ENTRY( 0x055, "2swap" ),
+	TOKEN_ENTRY( 0x056, "2rot" ),
+	TOKEN_ENTRY( 0x057, "2/" ),
+	TOKEN_ENTRY( 0x058, "u2/" ),
+	TOKEN_ENTRY( 0x059, "2*" ),
+	TOKEN_ENTRY( 0x05a, "/c" ),
+	TOKEN_ENTRY( 0x05b, "/w" ),
+	TOKEN_ENTRY( 0x05c, "/l" ),
+	TOKEN_ENTRY( 0x05d, "/n" ),
+	TOKEN_ENTRY( 0x05e, "ca+" ),
+	TOKEN_ENTRY( 0x05f, "wa+" ),
+	TOKEN_ENTRY( 0x060, "la+" ),
+	TOKEN_ENTRY( 0x061, "na+" ),
+	TOKEN_ENTRY( 0x062, "char+" ),
+	TOKEN_ENTRY( 0x063, "wa1+" ),
+	TOKEN_ENTRY( 0x064, "la1+" ),
+	TOKEN_ENTRY( 0x065, "cell+" ),
+	TOKEN_ENTRY( 0x066, "chars" ),
+	TOKEN_ENTRY( 0x067, "/w*" ),
+	TOKEN_ENTRY( 0x068, "/l*" ),
+	TOKEN_ENTRY( 0x069, "cells" ),
+	TOKEN_ENTRY( 0x06a, "on" ),
+	TOKEN_ENTRY( 0x06b, "off" ),
+	TOKEN_ENTRY( 0x06c, "+!" ),
+	TOKEN_ENTRY( 0x06d, "@" ),
+	TOKEN_ENTRY( 0x06e, "l@" ),
+	TOKEN_ENTRY( 0x06f, "w@" ),
+	TOKEN_ENTRY( 0x070, "<w@" ),
+	TOKEN_ENTRY( 0x071, "c@" ),
+	TOKEN_ENTRY( 0x072, "!" ),
+	TOKEN_ENTRY( 0x073, "l!" ),
+	TOKEN_ENTRY( 0x074, "w!" ),
+	TOKEN_ENTRY( 0x075, "c!" ),
+	TOKEN_ENTRY( 0x076, "2@" ),
+	TOKEN_ENTRY( 0x077, "2!" ),
+	TOKEN_ENTRY( 0x078, "move" ),
+	TOKEN_ENTRY( 0x079, "fill" ),
+	TOKEN_ENTRY( 0x07a, "comp" ),
+	TOKEN_ENTRY( 0x07b, "noop" ),
+	TOKEN_ENTRY( 0x07c, "lwsplit" ),
+	TOKEN_ENTRY( 0x07d, "wljoin" ),
+	TOKEN_ENTRY( 0x07e, "lbsplit" ),
+	TOKEN_ENTRY( 0x07f, "bljoin" ),
+	TOKEN_ENTRY( 0x080, "wbflip" ),
+	TOKEN_ENTRY( 0x081, "upc" ),
+	TOKEN_ENTRY( 0x082, "lcc" ),
+	TOKEN_ENTRY( 0x083, "pack" ),
+	TOKEN_ENTRY( 0x084, "count" ),
+	TOKEN_ENTRY( 0x085, "body>" ),
+	TOKEN_ENTRY( 0x086, ">body" ),
+	TOKEN_ENTRY( 0x087, "fcode-revision" ),
+	TOKEN_ENTRY( 0x088, "span" ),
+	TOKEN_ENTRY( 0x089, "unloop" ),
+	TOKEN_ENTRY( 0x08a, "expect" ),
+	TOKEN_ENTRY( 0x08b, "alloc-mem" ),
+	TOKEN_ENTRY( 0x08c, "free-mem" ),
+	TOKEN_ENTRY( 0x08d, "key?" ),
+	TOKEN_ENTRY( 0x08e, "key" ),
+	TOKEN_ENTRY( 0x08f, "emit" ),
+	TOKEN_ENTRY( 0x090, "type" ),
+	TOKEN_ENTRY( 0x091, "(cr" ),
+	TOKEN_ENTRY( 0x092, "cr" ),
+	TOKEN_ENTRY( 0x093, "#out" ),
+	TOKEN_ENTRY( 0x094, "#line" ),
+	TOKEN_ENTRY( 0x095, "hold" ),
+	TOKEN_ENTRY( 0x096, "<#" ),
+	TOKEN_ENTRY( 0x097, "u#>" ),
+	TOKEN_ENTRY( 0x098, "sign" ),
+	TOKEN_ENTRY( 0x099, "u#" ),
+	TOKEN_ENTRY( 0x09a, "u#s" ),
+	TOKEN_ENTRY( 0x09b, "u." ),
+	TOKEN_ENTRY( 0x09c, "u.r" ),
+	TOKEN_ENTRY( 0x09d, "." ),
+	TOKEN_ENTRY( 0x09e, ".r" ),
+	TOKEN_ENTRY( 0x09f, ".s" ),
+	TOKEN_ENTRY( 0x0a0, "base" ),
+	TOKEN_ENTRY( 0x0a1, "convert" ),
+	TOKEN_ENTRY( 0x0a2, "$number" ),
+	TOKEN_ENTRY( 0x0a3, "digit" ),
+	TOKEN_ENTRY( 0x0a4, "-1" ),
+	TOKEN_ENTRY( 0x0a5, "0" ),
+	TOKEN_ENTRY( 0x0a6, "1" ),
+	TOKEN_ENTRY( 0x0a7, "2" ),
+	TOKEN_ENTRY( 0x0a8, "3" ),
+	TOKEN_ENTRY( 0x0a9, "bl" ),
+	TOKEN_ENTRY( 0x0aa, "bs" ),
+	TOKEN_ENTRY( 0x0ab, "bell" ),
+	TOKEN_ENTRY( 0x0ac, "bounds" ),
+	TOKEN_ENTRY( 0x0ad, "here" ),
+	TOKEN_ENTRY( 0x0ae, "aligned" ),
+	TOKEN_ENTRY( 0x0af, "wbsplit" ),
+	TOKEN_ENTRY( 0x0b0, "bwjoin" ),
+	TOKEN_ENTRY( 0x0b1, "b(<mark)" ),
+	TOKEN_ENTRY( 0x0b2, "b(>resolve)" ),
+	TOKEN_ENTRY( 0x0b3, "set-token-table" ),
+	TOKEN_ENTRY( 0x0b4, "set-table" ),
+	TOKEN_ENTRY( 0x0b5, "new-token" ),
+	TOKEN_ENTRY( 0x0b6, "named-token" ),
+	TOKEN_ENTRY( 0x0b7, "b(:)" ),
+	TOKEN_ENTRY( 0x0b8, "b(value)" ),
+	TOKEN_ENTRY( 0x0b9, "b(variable)" ),
+	TOKEN_ENTRY( 0x0ba, "b(constant)" ),
+	TOKEN_ENTRY( 0x0bb, "b(create)" ),
+	TOKEN_ENTRY( 0x0bc, "b(defer)" ),
+	TOKEN_ENTRY( 0x0bd, "b(buffer:)" ),
+	TOKEN_ENTRY( 0x0be, "b(field)" ),
+	TOKEN_ENTRY( 0x0bf, "b(code)" ),
+	TOKEN_ENTRY( 0x0c0, "instance" ),
+	TOKEN_ENTRY( 0x0c2, "b(;)" ),
+	TOKEN_ENTRY( 0x0c3, "b(to)" ),
+	TOKEN_ENTRY( 0x0c4, "b(case)" ),
+	TOKEN_ENTRY( 0x0c5, "b(endcase)" ),
+	TOKEN_ENTRY( 0x0c6, "b(endof)" ),
+	TOKEN_ENTRY( 0x0c7, "#" ),
+	TOKEN_ENTRY( 0x0c8, "#s" ),
+	TOKEN_ENTRY( 0x0c9, "#>" ),
+	TOKEN_ENTRY( 0x0ca, "external-token" ),
+	TOKEN_ENTRY( 0x0cb, "$find" ),
+	TOKEN_ENTRY( 0x0cc, "offset16" ),
+	TOKEN_ENTRY( 0x0cd, "evaluate" ),
+	TOKEN_ENTRY( 0x0d0, "c," ),
+	TOKEN_ENTRY( 0x0d1, "w," ),
+	TOKEN_ENTRY( 0x0d2, "l," ),
+	TOKEN_ENTRY( 0x0d3, "," ),
+	TOKEN_ENTRY( 0x0d4, "um*" ),
+	TOKEN_ENTRY( 0x0d5, "um/mod" ),
+	TOKEN_ENTRY( 0x0d8, "d+" ),
+	TOKEN_ENTRY( 0x0d9, "d-" ),
+	TOKEN_ENTRY( 0x0da, "get-token" ),
+	TOKEN_ENTRY( 0x0db, "set-token" ),
+	TOKEN_ENTRY( 0x0dc, "state" ),
+	TOKEN_ENTRY( 0x0dd, "compile" ),
+	TOKEN_ENTRY( 0x0de, "behavior" ),
+	TOKEN_ENTRY( 0x0f0, "start0" ),
+	TOKEN_ENTRY( 0x0f1, "start1" ),
+	TOKEN_ENTRY( 0x0f2, "start2" ),
+	TOKEN_ENTRY( 0x0f3, "start4" ),
+	TOKEN_ENTRY( 0x0fc, "ferror" ),
+	TOKEN_ENTRY( 0x0fd, "version1" ),
+	TOKEN_ENTRY( 0x0fe, "4-byte-id" ),
+	TOKEN_ENTRY( 0x0ff, "end1" ),
+	TOKEN_ENTRY( 0x101, "dma-alloc" ),
+	TOKEN_ENTRY( 0x102, "my-address" ),
+	TOKEN_ENTRY( 0x103, "my-space" ),
+	TOKEN_ENTRY( 0x104, "memmap" ),
+	TOKEN_ENTRY( 0x105, "free-virtual" ),
+	TOKEN_ENTRY( 0x106, ">physical" ),
+	TOKEN_ENTRY( 0x10f, "my-params" ),
+	TOKEN_ENTRY( 0x110, "property" ),
+	TOKEN_ENTRY( 0x111, "encode-int" ),
+	TOKEN_ENTRY( 0x112, "encode+" ),
+	TOKEN_ENTRY( 0x113, "encode-phys" ),
+	TOKEN_ENTRY( 0x114, "encode-string" ),
+	TOKEN_ENTRY( 0x115, "encode-bytes" ),
+	TOKEN_ENTRY( 0x116, "reg" ),
+	TOKEN_ENTRY( 0x117, "intr" ),
+	TOKEN_ENTRY( 0x118, "driver" ),
+	TOKEN_ENTRY( 0x119, "model" ),
+	TOKEN_ENTRY( 0x11a, "device-type" ),
+	TOKEN_ENTRY( 0x11b, "parse-2int" ),
+	TOKEN_ENTRY( 0x11c, "is-install" ),
+	TOKEN_ENTRY( 0x11d, "is-remove" ),
+	TOKEN_ENTRY( 0x11e, "is-selftest" ),
+	TOKEN_ENTRY( 0x11f, "new-device" ),
+	TOKEN_ENTRY( 0x120, "diagnostic-mode?" ),
+	TOKEN_ENTRY( 0x121, "display-status" ),
+	TOKEN_ENTRY( 0x122, "memory-test-issue" ),
+	TOKEN_ENTRY( 0x123, "group-code" ),
+	TOKEN_ENTRY( 0x124, "mask" ),
+	TOKEN_ENTRY( 0x125, "get-msecs" ),
+	TOKEN_ENTRY( 0x126, "ms" ),
+	TOKEN_ENTRY( 0x127, "finish-device" ),
+	TOKEN_ENTRY( 0x128, "decode-phys" ),
+	TOKEN_ENTRY( 0x12b, "interpose" ),
+	TOKEN_ENTRY( 0x130, "map-low" ),
+	TOKEN_ENTRY( 0x131, "sbus-intr>cpu" ),
+	TOKEN_ENTRY( 0x150, "#lines" ),
+	TOKEN_ENTRY( 0x151, "#columns" ),
+	TOKEN_ENTRY( 0x152, "line#" ),
+	TOKEN_ENTRY( 0x153, "column#" ),
+	TOKEN_ENTRY( 0x154, "inverse?" ),
+	TOKEN_ENTRY( 0x155, "inverse-screen?" ),
+	TOKEN_ENTRY( 0x156, "frame-buffer-busy?" ),
+	TOKEN_ENTRY( 0x157, "draw-character" ),
+	TOKEN_ENTRY( 0x158, "reset-screen" ),
+	TOKEN_ENTRY( 0x159, "toggle-cursor" ),
+	TOKEN_ENTRY( 0x15a, "erase-screen" ),
+	TOKEN_ENTRY( 0x15b, "blink-screen" ),
+	TOKEN_ENTRY( 0x15c, "invert-screen" ),
+	TOKEN_ENTRY( 0x15d, "insert-characters" ),
+	TOKEN_ENTRY( 0x15e, "delete-characters" ),
+	TOKEN_ENTRY( 0x15f, "insert-lines" ),
+	TOKEN_ENTRY( 0x160, "delete-lines" ),
+	TOKEN_ENTRY( 0x161, "draw-logo" ),
+	TOKEN_ENTRY( 0x162, "frame-buffer-adr" ),
+	TOKEN_ENTRY( 0x163, "screen-height" ),
+	TOKEN_ENTRY( 0x164, "screen-width" ),
+	TOKEN_ENTRY( 0x165, "window-top" ),
+	TOKEN_ENTRY( 0x166, "window-left" ),
+	TOKEN_ENTRY( 0x16a, "default-font" ),
+	TOKEN_ENTRY( 0x16b, "set-font" ),
+	TOKEN_ENTRY( 0x16c, "char-height" ),
+	TOKEN_ENTRY( 0x16d, "char-width" ),
+	TOKEN_ENTRY( 0x16e, ">font" ),
+	TOKEN_ENTRY( 0x16f, "fontbytes" ),
+	TOKEN_ENTRY( 0x170, "fb1-draw-character" ),
+	TOKEN_ENTRY( 0x171, "fb1-reset-screen" ),
+	TOKEN_ENTRY( 0x172, "fb1-toggle-cursor" ),
+	TOKEN_ENTRY( 0x173, "fb1-erase-screen" ),
+	TOKEN_ENTRY( 0x174, "fb1-blink-screen" ),
+	TOKEN_ENTRY( 0x175, "fb1-invert-screen" ),
+	TOKEN_ENTRY( 0x176, "fb1-insert-characters" ),
+	TOKEN_ENTRY( 0x177, "fb1-delete-characters" ),
+	TOKEN_ENTRY( 0x178, "fb1-insert-lines" ),
+	TOKEN_ENTRY( 0x179, "fb1-delete-lines" ),
+	TOKEN_ENTRY( 0x17a, "fb1-draw-logo" ),
+	TOKEN_ENTRY( 0x17b, "fb1-install" ),
+	TOKEN_ENTRY( 0x17c, "fb1-slide-up" ),
+	TOKEN_ENTRY( 0x180, "fb8-draw-character" ),
+	TOKEN_ENTRY( 0x181, "fb8-reset-screen" ),
+	TOKEN_ENTRY( 0x182, "fb8-toggle-cursor" ),
+	TOKEN_ENTRY( 0x183, "fb8-erase-screen" ),
+	TOKEN_ENTRY( 0x184, "fb8-blink-screen" ),
+	TOKEN_ENTRY( 0x185, "fb8-invert-screen" ),
+	TOKEN_ENTRY( 0x186, "fb8-insert-characters" ),
+	TOKEN_ENTRY( 0x187, "fb8-delete-characters" ),
+	TOKEN_ENTRY( 0x188, "fb8-insert-lines" ),
+	TOKEN_ENTRY( 0x189, "fb8-delete-lines" ),
+	TOKEN_ENTRY( 0x18a, "fb8-draw-logo" ),
+	TOKEN_ENTRY( 0x18b, "fb8-install" ),
+	TOKEN_ENTRY( 0x1a0, "return-buffer" ),
+	TOKEN_ENTRY( 0x1a1, "xmit-packet" ),
+	TOKEN_ENTRY( 0x1a2, "poll-packet" ),
+	TOKEN_ENTRY( 0x1a4, "mac-address" ),
+	TOKEN_ENTRY( 0x201, "device-name" ),
+	TOKEN_ENTRY( 0x202, "my-args" ),
+	TOKEN_ENTRY( 0x203, "my-self" ),
+	TOKEN_ENTRY( 0x204, "find-package" ),
+	TOKEN_ENTRY( 0x205, "open-package" ),
+	TOKEN_ENTRY( 0x206, "close-package" ),
+	TOKEN_ENTRY( 0x207, "find-method" ),
+	TOKEN_ENTRY( 0x208, "call-package" ),
+	TOKEN_ENTRY( 0x209, "$call-parent" ),
+	TOKEN_ENTRY( 0x20a, "my-parent" ),
+	TOKEN_ENTRY( 0x20b, "ihandle>phandle" ),
+	TOKEN_ENTRY( 0x20d, "my-unit" ),
+	TOKEN_ENTRY( 0x20e, "$call-method" ),
+	TOKEN_ENTRY( 0x20f, "$open-package" ),
+	TOKEN_ENTRY( 0x210, "processor-type" ),
+	TOKEN_ENTRY( 0x211, "firmware-version" ),
+	TOKEN_ENTRY( 0x212, "fcode-version" ),
+	TOKEN_ENTRY( 0x213, "alarm" ),
+	TOKEN_ENTRY( 0x214, "(is-user-word)" ),
+	TOKEN_ENTRY( 0x215, "suspend-fcode" ),
+	TOKEN_ENTRY( 0x216, "abort" ),
+	TOKEN_ENTRY( 0x217, "catch" ),
+	TOKEN_ENTRY( 0x218, "throw" ),
+	TOKEN_ENTRY( 0x219, "user-abort" ),
+	TOKEN_ENTRY( 0x21a, "get-my-property" ),
+	TOKEN_ENTRY( 0x21b, "decode-int" ),
+	TOKEN_ENTRY( 0x21c, "decode-string" ),
+	TOKEN_ENTRY( 0x21d, "get-inherited-property" ),
+	TOKEN_ENTRY( 0x21e, "delete-property" ),
+	TOKEN_ENTRY( 0x21f, "get-package-property" ),
+	TOKEN_ENTRY( 0x220, "cpeek" ),
+	TOKEN_ENTRY( 0x221, "wpeek" ),
+	TOKEN_ENTRY( 0x222, "lpeek" ),
+	TOKEN_ENTRY( 0x223, "cpoke" ),
+	TOKEN_ENTRY( 0x224, "wpoke" ),
+	TOKEN_ENTRY( 0x225, "lpoke" ),
+	TOKEN_ENTRY( 0x226, "lwflip" ),
+	TOKEN_ENTRY( 0x227, "lbflip" ),
+	TOKEN_ENTRY( 0x228, "lbflips" ),
+	TOKEN_ENTRY( 0x229, "adr-mask" ),
+	TOKEN_ENTRY( 0x230, "rb@" ),
+	TOKEN_ENTRY( 0x231, "rb!" ),
+	TOKEN_ENTRY( 0x232, "rw@" ),
+	TOKEN_ENTRY( 0x233, "rw!" ),
+	TOKEN_ENTRY( 0x234, "rl@" ),
+	TOKEN_ENTRY( 0x235, "rl!" ),
+	TOKEN_ENTRY( 0x236, "wbflips" ),
+	TOKEN_ENTRY( 0x237, "lwflips" ),
+	TOKEN_ENTRY( 0x238, "probe" ),
+	TOKEN_ENTRY( 0x239, "probe-virtual" ),
+	TOKEN_ENTRY( 0x23b, "child" ),
+	TOKEN_ENTRY( 0x23c, "peer" ),
+	TOKEN_ENTRY( 0x23d, "next-property" ),
+	TOKEN_ENTRY( 0x23e, "byte-load" ),
+	TOKEN_ENTRY( 0x23f, "set-args" ),
+	TOKEN_ENTRY( 0x240, "left-parse-string" ),
+
+	/* FCodes from 64bit extension addendum */
+	TOKEN_ENTRY( 0x22e, "rx@" ),
+	TOKEN_ENTRY( 0x22f, "rx!" ),
+	TOKEN_ENTRY( 0x241, "bxjoin" ),
+	TOKEN_ENTRY( 0x242, "<l@" ),
+	TOKEN_ENTRY( 0x243, "lxjoin" ),
+	TOKEN_ENTRY( 0x244, "wxjoin" ),
+	TOKEN_ENTRY( 0x245, "x," ),
+	TOKEN_ENTRY( 0x246, "x@" ),
+	TOKEN_ENTRY( 0x247, "x!" ),
+	TOKEN_ENTRY( 0x248, "/x" ),
+	TOKEN_ENTRY( 0x249, "/x*" ),
+	TOKEN_ENTRY( 0x24a, "xa+" ),
+	TOKEN_ENTRY( 0x24b, "xa1+" ),
+	TOKEN_ENTRY( 0x24c, "xbflip" ),
+	TOKEN_ENTRY( 0x24d, "xbflips" ),
+	TOKEN_ENTRY( 0x24e, "xbsplit" ),
+	TOKEN_ENTRY( 0x24f, "xlflip" ),
+	TOKEN_ENTRY( 0x250, "xlflips" ),
+	TOKEN_ENTRY( 0x251, "xlsplit" ),
+	TOKEN_ENTRY( 0x252, "xwflip" ),
+	TOKEN_ENTRY( 0x253, "xwflips" ),
+	TOKEN_ENTRY( 0x254, "xwsplit" ),
+};
+
+static const int dictionary_indx_max = (sizeof(detok_table)/sizeof(token_t)) ;
+
+static token_t *dictionary_reset_position;
 
 void init_dictionary(void) 
 {
-	add_token( 0x000, "end0" );
-	add_token( 0x010, "b(lit)" );
-	add_token( 0x011, "b(')" );
-	add_token( 0x012, "b(\")" );
-	add_token( 0x013, "bbranch" );
-	add_token( 0x014, "b?branch" );
-	add_token( 0x015, "b(loop)" );
-	add_token( 0x016, "b(+loop)" );
-	add_token( 0x017, "b(do)" );
-	add_token( 0x018, "b(?do)" );
-	add_token( 0x019, "i" );
-	add_token( 0x01a, "j" );
-	add_token( 0x01b, "b(leave)" );
-	add_token( 0x01c, "b(of)" );
-	add_token( 0x01d, "execute" );
-	add_token( 0x01e, "+" );
-	add_token( 0x01f, "-" );
-	add_token( 0x020, "*" );
-	add_token( 0x021, "/" );
-	add_token( 0x022, "mod" );
-	add_token( 0x023, "and" );
-	add_token( 0x024, "or" );
-	add_token( 0x025, "xor" );
-	add_token( 0x026, "invert" );
-	add_token( 0x027, "lshift" );
-	add_token( 0x028, "rshift" );
-	add_token( 0x029, ">>a" );
-	add_token( 0x02a, "/mod" );
-	add_token( 0x02b, "u/mod" );
-	add_token( 0x02c, "negate" );
-	add_token( 0x02d, "abs" );
-	add_token( 0x02e, "min" );
-	add_token( 0x02f, "max" );
-	add_token( 0x030, ">r" );
-	add_token( 0x031, "r>" );
-	add_token( 0x032, "r@" );
-	add_token( 0x033, "exit" );
-	add_token( 0x034, "0=" );
-	add_token( 0x035, "0<>" );
-	add_token( 0x036, "0<" );
-	add_token( 0x037, "0<=" );
-	add_token( 0x038, "0>" );
-	add_token( 0x039, "0>=" );
-	add_token( 0x03a, "<" );
-	add_token( 0x03b, ">" );
-	add_token( 0x03c, "=" );
-	add_token( 0x03d, "<>" );
-	add_token( 0x03e, "u>" );
-	add_token( 0x03f, "u<=" );
-	add_token( 0x040, "u<" );
-	add_token( 0x041, "u>=" );
-	add_token( 0x042, ">=" );
-	add_token( 0x043, "<=" );
-	add_token( 0x044, "between" );
-	add_token( 0x045, "within" );
-	add_token( 0x046, "drop" );
-	add_token( 0x047, "dup" );
-	add_token( 0x048, "over" );
-	add_token( 0x049, "swap" );
-	add_token( 0x04A, "rot" );
-	add_token( 0x04b, "-rot" );
-	add_token( 0x04c, "tuck" );
-	add_token( 0x04d, "nip" );
-	add_token( 0x04e, "pick" );
-	add_token( 0x04f, "roll" );
-	add_token( 0x050, "?dup" );
-	add_token( 0x051, "depth" );
-	add_token( 0x052, "2drop" );
-	add_token( 0x053, "2dup" );
-	add_token( 0x054, "2over" );
-	add_token( 0x055, "2swap" );
-	add_token( 0x056, "2rot" );
-	add_token( 0x057, "2/" );
-	add_token( 0x058, "u2/" );
-	add_token( 0x059, "2*" );
-	add_token( 0x05a, "/c" );
-	add_token( 0x05b, "/w" );
-	add_token( 0x05c, "/l" );
-	add_token( 0x05d, "/n" );
-	add_token( 0x05e, "ca+" );
-	add_token( 0x05f, "wa+" );
-	add_token( 0x060, "la+" );
-	add_token( 0x061, "na+" );
-	add_token( 0x062, "char+" );
-	add_token( 0x063, "wa1+" );
-	add_token( 0x064, "la1+" );
-	add_token( 0x065, "cell+" );
-	add_token( 0x066, "chars" );
-	add_token( 0x067, "/w*" );
-	add_token( 0x068, "/l*" );
-	add_token( 0x069, "cells" );
-	add_token( 0x06a, "on" );
-	add_token( 0x06b, "off" );
-	add_token( 0x06c, "+!" );
-	add_token( 0x06d, "@" );
-	add_token( 0x06e, "l@" );
-	add_token( 0x06f, "w@" );
-	add_token( 0x070, "<w@" );
-	add_token( 0x071, "c@" );
-	add_token( 0x072, "!" );
-	add_token( 0x073, "l!" );
-	add_token( 0x074, "w!" );
-	add_token( 0x075, "c!" );
-	add_token( 0x076, "2@" );
-	add_token( 0x077, "2!" );
-	add_token( 0x078, "move" );
-	add_token( 0x079, "fill" );
-	add_token( 0x07a, "comp" );
-	add_token( 0x07b, "noop" );
-	add_token( 0x07c, "lwsplit" );
-	add_token( 0x07d, "wljoin" );
-	add_token( 0x07e, "lbsplit" );
-	add_token( 0x07f, "bljoin" );
-	add_token( 0x080, "wbflip" );
-	add_token( 0x081, "upc" );
-	add_token( 0x082, "lcc" );
-	add_token( 0x083, "pack" );
-	add_token( 0x084, "count" );
-	add_token( 0x085, "body>" );
-	add_token( 0x086, ">body" );
-	add_token( 0x087, "fcode-revision" );
-	add_token( 0x088, "span" );
-	add_token( 0x089, "unloop" );
-	add_token( 0x08a, "expect" );
-	add_token( 0x08b, "alloc-mem" );
-	add_token( 0x08c, "free-mem" );
-	add_token( 0x08d, "key?" );
-	add_token( 0x08e, "key" );
-	add_token( 0x08f, "emit" );
-	add_token( 0x090, "type" );
-	add_token( 0x091, "(cr" );
-	add_token( 0x092, "cr" );
-	add_token( 0x093, "#out" );
-	add_token( 0x094, "#line" );
-	add_token( 0x095, "hold" );
-	add_token( 0x096, "<#" );
-	add_token( 0x097, "u#>" );
-	add_token( 0x098, "sign" );
-	add_token( 0x099, "u#" );
-	add_token( 0x09a, "u#s" );
-	add_token( 0x09b, "u." );
-	add_token( 0x09c, "u.r" );
-	add_token( 0x09d, "." );
-	add_token( 0x09e, ".r" );
-	add_token( 0x09f, ".s" );
-	add_token( 0x0a0, "base" );
-	add_token( 0x0a1, "convert" );
-	add_token( 0x0a2, "$number" );
-	add_token( 0x0a3, "digit" );
-	add_token( 0x0a4, "-1" );
-	add_token( 0x0a5, "0" );
-	add_token( 0x0a6, "1" );
-	add_token( 0x0a7, "2" );
-	add_token( 0x0a8, "3" );
-	add_token( 0x0a9, "bl" );
-	add_token( 0x0aa, "bs" );
-	add_token( 0x0ab, "bell" );
-	add_token( 0x0ac, "bounds" );
-	add_token( 0x0ad, "here" );
-	add_token( 0x0ae, "aligned" );
-	add_token( 0x0af, "wbsplit" );
-	add_token( 0x0b0, "bwjoin" );
-	add_token( 0x0b1, "b(<mark)" );
-	add_token( 0x0b2, "b(>resolve)" );
-	add_token( 0x0b3, "set-token-table" );
-	add_token( 0x0b4, "set-table" );
-	add_token( 0x0b5, "new-token" );
-	add_token( 0x0b6, "named-token" );
-	add_token( 0x0b7, "b(:)" );
-	add_token( 0x0b8, "b(value)" );
-	add_token( 0x0b9, "b(variable)" );
-	add_token( 0x0ba, "b(constant)" );
-	add_token( 0x0bb, "b(create)" );
-	add_token( 0x0bc, "b(defer)" );
-	add_token( 0x0bd, "b(buffer:)" );
-	add_token( 0x0be, "b(field)" );
-	add_token( 0x0bf, "b(code)" );
-	add_token( 0x0c0, "instance" );
-	add_token( 0x0c2, "b(;)" );
-	add_token( 0x0c3, "b(to)" );
-	add_token( 0x0c4, "b(case)" );
-	add_token( 0x0c5, "b(endcase)" );
-	add_token( 0x0c6, "b(endof)" );
-	add_token( 0x0c7, "#" );
-	add_token( 0x0c8, "#s" );
-	add_token( 0x0c9, "#>" );
-	add_token( 0x0ca, "external-token" );
-	add_token( 0x0cb, "$find" );
-	add_token( 0x0cc, "offset16" );
-	add_token( 0x0cd, "evaluate" );
-	add_token( 0x0d0, "c," );
-	add_token( 0x0d1, "w," );
-	add_token( 0x0d2, "l," );
-	add_token( 0x0d3, "," );
-	add_token( 0x0d4, "um*" );
-	add_token( 0x0d5, "um/mod" );
-	add_token( 0x0d8, "d+" );
-	add_token( 0x0d9, "d-" );
-	add_token( 0x0da, "get-token" );
-	add_token( 0x0db, "set-token" );
-	add_token( 0x0dc, "state" );
-	add_token( 0x0dd, "compile" );
-	add_token( 0x0de, "behavior" );
-	add_token( 0x0f0, "start0" );
-	add_token( 0x0f1, "start1" );
-	add_token( 0x0f2, "start2" );
-	add_token( 0x0f3, "start4" );
-	add_token( 0x0fc, "ferror" );
-	add_token( 0x0fd, "version1" );
-	add_token( 0x0fe, "4-byte-id" );
-	add_token( 0x0ff, "end1" );
-	add_token( 0x101, "dma-alloc" );
-	add_token( 0x102, "my-address" );
-	add_token( 0x103, "my-space" );
-	add_token( 0x104, "memmap" );
-	add_token( 0x105, "free-virtual" );
-	add_token( 0x106, ">physical" );
-	add_token( 0x10f, "my-params" );
-	add_token( 0x110, "property" );
-	add_token( 0x111, "encode-int" );
-	add_token( 0x112, "encode+" );
-	add_token( 0x113, "encode-phys" );
-	add_token( 0x114, "encode-string" );
-	add_token( 0x115, "encode-bytes" );
-	add_token( 0x116, "reg" );
-	add_token( 0x117, "intr" );
-	add_token( 0x118, "driver" );
-	add_token( 0x119, "model" );
-	add_token( 0x11a, "device-type" );
-	add_token( 0x11b, "parse-2int" );
-	add_token( 0x11c, "is-install" );
-	add_token( 0x11d, "is-remove" );
-	add_token( 0x11e, "is-selftest" );
-	add_token( 0x11f, "new-device" );
-	add_token( 0x120, "diagnostic-mode?" );
-	add_token( 0x121, "display-status" );
-	add_token( 0x122, "memory-test-issue" );
-	add_token( 0x123, "group-code" );
-	add_token( 0x124, "mask" );
-	add_token( 0x125, "get-msecs" );
-	add_token( 0x126, "ms" );
-	add_token( 0x127, "finish-device" );
-	add_token( 0x128, "decode-phys" );
-	add_token( 0x12b, "interpose" );
-	add_token( 0x130, "map-low" );
-	add_token( 0x131, "sbus-intr>cpu" );
-	add_token( 0x150, "#lines" );
-	add_token( 0x151, "#columns" );
-	add_token( 0x152, "line#" );
-	add_token( 0x153, "column#" );
-	add_token( 0x154, "inverse?" );
-	add_token( 0x155, "inverse-screen?" );
-	add_token( 0x156, "frame-buffer-busy?" );
-	add_token( 0x157, "draw-character" );
-	add_token( 0x158, "reset-screen" );
-	add_token( 0x159, "toggle-cursor" );
-	add_token( 0x15a, "erase-screen" );
-	add_token( 0x15b, "blink-screen" );
-	add_token( 0x15c, "invert-screen" );
-	add_token( 0x15d, "insert-characters" );
-	add_token( 0x15e, "delete-characters" );
-	add_token( 0x15f, "insert-lines" );
-	add_token( 0x160, "delete-lines" );
-	add_token( 0x161, "draw-logo" );
-	add_token( 0x162, "frame-buffer-adr" );
-	add_token( 0x163, "screen-height" );
-	add_token( 0x164, "screen-width" );
-	add_token( 0x165, "window-top" );
-	add_token( 0x166, "window-left" );
-	add_token( 0x16a, "default-font" );
-	add_token( 0x16b, "set-font" );
-	add_token( 0x16c, "char-height" );
-	add_token( 0x16d, "char-width" );
-	add_token( 0x16e, ">font" );
-	add_token( 0x16f, "fontbytes" );
-	add_token( 0x170, "fb1-draw-character" );
-	add_token( 0x171, "fb1-reset-screen" );
-	add_token( 0x172, "fb1-toggle-cursor" );
-	add_token( 0x173, "fb1-erase-screen" );
-	add_token( 0x174, "fb1-blink-screen" );
-	add_token( 0x175, "fb1-invert-screen" );
-	add_token( 0x176, "fb1-insert-characters" );
-	add_token( 0x177, "fb1-delete-characters" );
-	add_token( 0x178, "fb1-insert-lines" );
-	add_token( 0x179, "fb1-delete-lines" );
-	add_token( 0x17a, "fb1-draw-logo" );
-	add_token( 0x17b, "fb1-install" );
-	add_token( 0x17c, "fb1-slide-up" );
-	add_token( 0x180, "fb8-draw-character" );
-	add_token( 0x181, "fb8-reset-screen" );
-	add_token( 0x182, "fb8-toggle-cursor" );
-	add_token( 0x183, "fb8-erase-screen" );
-	add_token( 0x184, "fb8-blink-screen" );
-	add_token( 0x185, "fb8-invert-screen" );
-	add_token( 0x186, "fb8-insert-characters" );
-	add_token( 0x187, "fb8-delete-characters" );
-	add_token( 0x188, "fb8-insert-lines" );
-	add_token( 0x189, "fb8-delete-lines" );
-	add_token( 0x18a, "fb8-draw-logo" );
-	add_token( 0x18b, "fb8-install" );
-	add_token( 0x1a0, "return-buffer" );
-	add_token( 0x1a1, "xmit-packet" );
-	add_token( 0x1a2, "poll-packet" );
-	add_token( 0x1a4, "mac-address" );
-	add_token( 0x201, "device-name" );
-	add_token( 0x202, "my-args" );
-	add_token( 0x203, "my-self" );
-	add_token( 0x204, "find-package" );
-	add_token( 0x205, "open-package" );
-	add_token( 0x206, "close-package" );
-	add_token( 0x207, "find-method" );
-	add_token( 0x208, "call-package" );
-	add_token( 0x209, "$call-parent" );
-	add_token( 0x20a, "my-package" );
-	add_token( 0x20b, "ihandle>phandle" );
-	add_token( 0x20d, "my-unit" );
-	add_token( 0x20e, "$call-method" );
-	add_token( 0x20f, "$open-package" );
-	add_token( 0x210, "processor-type" );
-	add_token( 0x211, "firmware-version" );
-	add_token( 0x212, "fcode-version" );
-	add_token( 0x213, "alarm" );
-	add_token( 0x214, "(is-user-word)" );
-	add_token( 0x215, "suspend-fcode" );
-	add_token( 0x216, "abort" );
-	add_token( 0x217, "catch" );
-	add_token( 0x218, "throw" );
-	add_token( 0x219, "user-abort" );
-	add_token( 0x21a, "get-my-property" );
-	add_token( 0x21b, "decode-int" );
-	add_token( 0x21c, "decode-string" );
-	add_token( 0x21d, "get-inherited-property" );
-	add_token( 0x21e, "delete-property" );
-	add_token( 0x21f, "get-package-property" );
-	add_token( 0x220, "cpeek" );
-	add_token( 0x221, "wpeek" );
-	add_token( 0x222, "lpeek" );
-	add_token( 0x223, "cpoke" );
-	add_token( 0x224, "wpoke" );
-	add_token( 0x225, "lpoke" );
-	add_token( 0x226, "lwflip" );
-	add_token( 0x227, "lbflip" );
-	add_token( 0x228, "lbflips" );
-	add_token( 0x229, "adr-mask" );
-	add_token( 0x230, "rb@" );
-	add_token( 0x231, "rb!" );
-	add_token( 0x232, "rw@" );
-	add_token( 0x233, "rw!" );
-	add_token( 0x234, "rl@" );
-	add_token( 0x235, "rl!" );
-	add_token( 0x236, "wbflips" );
-	add_token( 0x237, "lwflips" );
-	add_token( 0x238, "probe" );
-	add_token( 0x239, "probe-virtual" );
-	add_token( 0x23b, "child" );
-	add_token( 0x23c, "peer" );
-	add_token( 0x23d, "next-property" );
-	add_token( 0x23e, "byte-load" );
-	add_token( 0x23f, "set-args" );
-	add_token( 0x240, "left-parse-string" );
+   int  indx;
 
-	/* FCodes from 64bit extension addendum */
-	add_token( 0x22e, "rx@" );
-	add_token( 0x22f, "rx!" );
-	add_token( 0x241, "bxjoin" );
-	add_token( 0x242, "<l@" );
-	add_token( 0x243, "lxjoin" );
-	add_token( 0x244, "wxjoin" );
-	add_token( 0x245, "x," );
-	add_token( 0x246, "x@" );
-	add_token( 0x247, "x!" );
-	add_token( 0x248, "/x" );
-	add_token( 0x249, "/x*" );
-	add_token( 0x24a, "xa+" );
-	add_token( 0x24b, "xa1+" );
-	add_token( 0x24c, "xbflip" );
-	add_token( 0x24d, "xbflips" );
-	add_token( 0x24e, "xbsplit" );
-	add_token( 0x24f, "xlflip" );
-	add_token( 0x250, "xlflips" );
-	add_token( 0x251, "xlsplit" );
-	add_token( 0x252, "xwflip" );
-	add_token( 0x253, "xwflips" );
-	add_token( 0x254, "xwsplit" );
+   dictionary = &detok_table[dictionary_indx_max-1];
+   dictionary_reset_position = dictionary;
+
+   for (indx = 1; indx < dictionary_indx_max ; indx++ )
+   {
+       detok_table[indx].next = &detok_table[indx-1];
+   }
+}
+
+void reset_dictionary(void) 
+{
+    token_t *next_t;
+
+    next_t = dictionary;
+    while ( next_t != dictionary_reset_position )
+    {
+        next_t = dictionary->next ;
+	free( dictionary->name );
+	free( dictionary );
+	dictionary = next_t ;
+    }
+}
+
+/*  If FCodes have been added by User, we need to update reset-position  */
+void freeze_dictionary(void)
+{
+   dictionary_reset_position = dictionary;
 }
diff --git a/detok/pcihdr.c b/detok/pcihdr.c
new file mode 100644
index 0000000..b4155db
--- /dev/null
+++ b/detok/pcihdr.c
@@ -0,0 +1,478 @@
+/*
+ *                     OpenBIOS - free your system!
+ *                         ( FCode tokenizer )
+ *
+ *  This program is part of a free implementation of the IEEE 1275-1994
+ *  Standard for Boot (Initialization Configuration) Firmware.
+ *
+ *  Copyright (C) 2001-2005 Stefan Reinauer, <stepan@openbios.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ *
+ */
+
+/* **************************************************************************
+ *
+ *      Support function for de-tokenizer.
+ *
+ *      Identify and process PCI header at beginning of FCode binary file.
+ *      "Processing" consists of recognizing the PCI Header and Data Structure,
+ *      optionally printing a description thereof, and (mainly) allowing
+ *      the given pointer to be bumped to the start of the actual FCode.
+ *
+ *
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Module Author:  David L. Paktor    dlpaktor@us.ibm.com
+ *
+ *      Revision History:
+ *
+ *      Updated Mon, 23 May 2005 by David L. Paktor
+ *          Identify "Not Last" header.
+ *      Updated Thu, 24 Feb 2005 by David L. Paktor
+ *          Per notes after Code Review.
+ *      Updated Fri, 04 Feb 2005 by David L. Paktor
+ *      Updated Wed, 08 Jun 2005 by David L. Paktor
+ *         Added support for multiple-PCI-image files.
+ *
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      Functions Eported:
+ *          handle_pci_header
+ *              Handle all activities connected with presence of
+ *              PCI Header/Data at beginning of FCode file, and
+ *              facilitate "skipping" over to actual FCode data.
+ *
+ *          handle_pci_filler
+ *          Skip past "filler" between blocks in multi-PCI-image files.
+ *              
+ *
+ **************************************************************************** */
+
+
+/* **************************************************************************
+ *
+ *      Still to be done:
+ *          Print (as remarks) full descriptions of headers' fields
+ *          Error check for wrong "Format"
+ *          Skip past non-FCode blocks, thru multiple data-blocks
+ *          Recognize PCI header in unexpected place or out-of-place
+ *
+ **************************************************************************** */
+
+#include "pcihdr.h"
+#include <stdio.h>
+
+#include "detok.h"
+
+
+/* **************************************************************************
+ *
+ *          Global Variables Exported
+ *      pci_image_end           Pointer to just after end of current PCI image
+ *
+ **************************************************************************** */
+
+u8 *pci_image_end = NULL;
+
+/* **************************************************************************
+ *
+ *          Internal Static Variables
+ *      pci_image_len           Length (in bytes) of current PCI image
+ *
+ **************************************************************************** */
+
+static int pci_image_len = 0;
+
+
+/* **************************************************************************
+ *
+ *      Function name:  is_pci_header ( rom_header_t *pci_rom_hdr )
+ *      Synopsis:   Indicate whether given pointer is pointing to
+ *                  something that might be a valid PCI header
+ *      
+ *      Inputs:
+ *          Parameters:     
+ *              pci_rom_hdr    pointer to start of data-stream to examine.
+ *                          Treat as pointer to rom_header_t
+ *
+ *      Outputs:
+ *          Returned Value: An integer.
+ *               0                  Definitely *NOT* a PCI header
+ *              Positive Number     Appears to be a valid PCI header;
+ *                                      value is offset to PCI Data Structure.
+ *              Negative Number     Appears to be a PCI header, but
+ *                                      with errors. (Not Implemented Yet.
+ *                                      See under "Still to be done".)
+ *
+ *      Error Detection:
+ *              (See under "Still to be done".)
+ *
+ *      Process Explanation:
+ *          Examine "signature" location for known value  0x55aa
+ *          If a match, return value of "dptr" (Data-pointer offset) field.
+ *
+ *      Revision History:
+ *          Created Tue, 01 Feb 2005 by David L. Paktor
+ *
+ *      Still to be done:
+ *          Error-check; look for inconsistencies:
+ *              Return a Negative Number if data-stream appears to be a PCI
+ *              header, but has erroneous or inconsistent sub-field contents.
+ *              Value and meaning of the Negative Number yet to be defined.
+ *
+ **************************************************************************** */
+
+static int is_pci_header ( rom_header_t *pci_rom_hdr )
+{
+    const u16 pci_header_signature = 0x55aa;
+    int retval ;
+
+    retval = 0;
+
+    if ( BIG_ENDIAN_WORD_FETCH(pci_rom_hdr->signature) == pci_header_signature )
+    {
+        retval = LITTLE_ENDIAN_WORD_FETCH(pci_rom_hdr->data_ptr);
+    }
+    return(retval);
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  is_pci_data_struct ( pci_data_t *pci_data_ptr )
+ *      Synopsis:       Indicate whether given pointer is pointing to
+ *                      a valid PCI Data Structure
+ *      
+ *      Inputs:
+ *          Parameters:     
+ *              pci_data_ptr    pointer to start of data-stream to examine.
+ *                          Treat as pointer to pci_data_t 
+ *
+ *      Outputs:
+ *          Returned Value: An integer.
+ *                   0                  Definitely *NOT* a PCI Data Structure
+ *              Positive Number         Appears to be valid PCI Data Structure;
+ *                                      value is length of PCI Data Structure,
+ *                                      (presumably, offset to start of FCode).
+ *              Negative Number         Appears to be a PCI Data Structure,
+ *                                      but with errors. (Not Implemented Yet.
+ *                                      See under "Still to be done".)
+ *
+ *          Global/Static Variables:
+ *              Does not alter the poiner passed-in;
+ *              does not alter any Global/Static Variables
+ *          Printout:       NONE
+ *
+ *      Error Detection:        (Condition)     (Action)
+ *              (See under "Still to be done".)
+ *
+ *      Process Explanation:
+ *          Examine "signature" location for known value "PCIR"
+ *          If a match, return value of "dlen" (Data Structure Length) field.
+ *      
+ *      Revision History:
+ *          Created Tue, 01 Feb 2005 by David L. Paktor
+ *
+ *      Still to be done:
+ *          Error-check; look for wrong "Code Type" or other inconsistencies:
+ *              Return a Negative Number if data-stream appears to be a
+ *              valid PCI Data Structure, but has erroneous or inconsistent
+ *              sub-field contents.
+ *              Value and meaning of the Negative Number yet to be defined.
+ *          Skip past non-FCode data-blocks, even multiple blocks
+ *
+ **************************************************************************** */
+
+static int is_pci_data_struct ( pci_data_t *pci_data_ptr )
+{
+    int retval ;
+
+    retval = 0;
+
+    if (BIG_ENDIAN_LONG_FETCH(pci_data_ptr->signature) == PCI_DATA_HDR)
+    {
+        retval = LITTLE_ENDIAN_WORD_FETCH(pci_data_ptr->dlen);
+    }
+    return(retval);
+}
+ 
+
+/* **************************************************************************
+ *
+ *      Function name:  announce_pci_hdr ( rom_header_t *pci_rom_hdr )
+ *      Synopsis:       Print indication that the PCI header was found,
+ *                      and other details, formatted as FORTH remarks.
+ *      
+ *      Inputs:
+ *              Parameters:
+ *                      pci_rom_hdr        Pointer to start of PCI header.
+ *
+ *      Outputs:
+ *              Returned Value: NONE
+ *              Printout:       Announcement.  Size of  data_ptr  field.
+ *
+ **************************************************************************** */
+
+static void announce_pci_hdr ( rom_header_t *pci_rom_hdr )
+{
+    char temp_buf[80];
+    u32  temp;
+
+    printremark ( "PCI Header identified");
+    temp=(u32)LITTLE_ENDIAN_WORD_FETCH(pci_rom_hdr->data_ptr);
+    sprintf(temp_buf, "  Offset to Data Structure = 0x%04x (%d)\n",
+        temp, temp);
+    printremark ( temp_buf );
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  announce_pci_data_struct ( pci_data_t *pci_data_ptr )
+ *      Synopsis:       Print indication that the PCI Data Structure
+ *                      was found, and some additional details.
+ *                      Format as FORTH remarks.
+ *      
+ *      Inputs:
+ *          Parameters:
+ *              pci_data_ptr        Pointer to start of PCI Data Structure.
+ *
+ *      Outputs:
+ *          Returned Value: NONE    
+ *          Global/Static Variables:    
+ *              pci_image_len      Updated to byte-length of current PCI image
+ *          Printout:       (See Synopsis)
+ *      
+ *      Process Explanation:
+ *          Extract some details, format and print them,
+ *              using the syntax of FORTH remarks.
+ *
+ *      Revision History:
+ *          Created Tue, 01 Feb 2005 by David L. Paktor
+ *          Updated Wed, 25 May 2005 by David L. Paktor
+ *               Added printout of several fields...
+ *
+ **************************************************************************** */
+
+static void announce_pci_data_struct ( pci_data_t *pci_data_ptr )
+{
+    char temp_buf[80];
+    u32  temp;
+
+    printremark ( "PCI Data Structure identified");
+
+    temp=(u32)LITTLE_ENDIAN_WORD_FETCH(pci_data_ptr->dlen);
+    sprintf(temp_buf, "  Data Structure Length = 0x%04x (%d)\n", temp, temp);
+    printremark ( temp_buf );
+
+    sprintf(temp_buf, "  Vendor ID: 0x%04x\n",
+            LITTLE_ENDIAN_WORD_FETCH(pci_data_ptr->vendor));
+    printremark ( temp_buf );
+
+    sprintf(temp_buf, "  Device ID: 0x%04x\n",
+            LITTLE_ENDIAN_WORD_FETCH(pci_data_ptr->device));
+    printremark ( temp_buf );
+
+    temp=(u32)CLASS_CODE_FETCH(pci_data_ptr->class_code);
+    sprintf(temp_buf, "  Class Code: 0x%06x  (%s)",
+            temp,  pci_device_class_name(temp));
+    printremark ( temp_buf );
+
+    temp=(u32)LITTLE_ENDIAN_WORD_FETCH(pci_data_ptr->vpd);
+    if ( temp != 0 )
+    {
+	sprintf(temp_buf, "  Vital Prod Data: 0x%02x\n", temp);
+	printremark ( temp_buf );
+    }
+
+    temp=(u32)LITTLE_ENDIAN_WORD_FETCH(pci_data_ptr->irevision);
+    if ( temp != 0 )
+    {
+	sprintf(temp_buf, "  Image Revision: 0x%02x\n", temp);
+	printremark ( temp_buf );
+    }
+
+    sprintf(temp_buf, "  Code Type: 0x%02x (%s)\n", pci_data_ptr->code_type,
+             pci_code_type_name(pci_data_ptr->code_type) );
+    printremark ( temp_buf );
+
+    temp=(u32)LITTLE_ENDIAN_WORD_FETCH(pci_data_ptr->ilen);
+    pci_image_len = temp*512;
+    sprintf(temp_buf, "  Image Length: 0x%04x blocks (%d bytes)\n",
+                    temp, pci_image_len);
+    printremark ( temp_buf );
+
+    sprintf(temp_buf, "  %sast PCI Image.\n",
+        pci_data_ptr->last_image_flag&&0x80 != 0 ? "L" : "Not l");
+    printremark ( temp_buf );
+
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  handle_pci_header
+ *      Synopsis:       Handle PCI Header/Data at beginning of FCode file;
+ *                      facilitate "skipping" over to actual FCode data.
+ *      
+ *      Inputs:
+ *          Parameters:     
+ *              data_ptr           Pointer to start of data-stream to examine.
+ *          Global/Static Variables:        
+ *              pci_image_len      Length (in bytes) of current PCI image
+ *
+ *      Outputs:
+ *          Returned Value:
+ *              Positive Number.        Offset to start of FCode.
+ *              Zero                    If no PCI header; may be treated as
+ *                                          a valid offset.
+ *              Negative Number         PCI header or PCI Data Structure test
+ *                                          returned error indication.
+ *                                         (Not Implemented Yet.  See
+ *                                          under "Still to be done".)
+ *          Global/Static Variables:        
+ *              pci_image_end           Pointer to just after the end of
+ *                                          the current PCI image
+ *          Printout:       As FORTH remarks, print indications that the
+ *                          PCI header was found, and maybe later more data.
+ *
+ *      Error Detection:        (Condition)     (Action)
+ *              (See under "Still to be done".)
+ *      
+ *      Process Explanation:
+ *          Use the various support routines defined below.
+ *      
+ *      
+ *      Revision History:
+ *
+ *      Updated Wed, 09 Feb 2005 by David L. Paktor
+ *          Extracted assignments from within  if( )  statements.
+ *
+ *      Created Tue, 01 Feb 2005 by David L. Paktor
+ *
+ *      Still to be done:
+ *          Handle error cases.  At present, neither  is_pci_header()
+ *              nor  is_pci_data_struct()  returns a negative number,
+ *              but when they are modified to do so, we must handle it.
+ *
+ **************************************************************************** */
+
+int handle_pci_header ( u8  *data_ptr )
+{
+    int hdrlen;
+    int data_struc_len;
+    /*  int retval;  */  /*  Not needed until we handle error cases...  */
+
+    data_struc_len = 0;
+
+    hdrlen = is_pci_header( (rom_header_t *)data_ptr );
+    /*  retval = hdrlen;  */  /*  Not needed yet...  */
+    if ( hdrlen < 0 )
+    {
+        /*  Handle error case...  */
+        /*  Leave null for now...  */
+        /*  It might need to do a premature EXIT here...  */
+    } else {
+        /* if hdrlen == 0 then we don't need to check a Data Structure  */
+        if ( hdrlen > 0 )
+        {
+            announce_pci_hdr ( (rom_header_t *)data_ptr );
+            data_struc_len = is_pci_data_struct(
+                        (pci_data_t *) &data_ptr[hdrlen] );
+            /*
+             *  A Data Structure Length of Zero would be an error
+             *  that could be detected by  is_pci_data_struct()
+             */ 
+            if ( data_struc_len <= 0 )
+            {
+                /*  Handle error case...  */
+                /*  Leave null for now...  */
+                /*  It might need to do a premature EXIT here...  */
+                /*  retval = -1;   */  /*  Not needed yet...  */
+            } else {
+                announce_pci_data_struct ( (pci_data_t *) &data_ptr[hdrlen] );
+		pci_image_end = data_ptr + pci_image_len;
+                /* retval = hdrlen+data_struc_len; */ /*  Not needed yet... */
+            }
+        }
+    }
+    return (hdrlen+data_struc_len);
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  handle_pci_filler
+ *      Synopsis:       Examine and report on the "filler" padding after the
+ *                      end of an FCode-block but still within a PCI-image
+ *
+ *      Inputs:
+ *         Parameters:
+ *             filler_ptr         Pointer to start of PCI-filler in data-stream
+ *         Global/Static Variables:    
+ *             pci_image_end      Pointer to just after the end of
+ *                                          the current PCI image
+ *
+ *      Outputs:
+ *         Returned Value:        NONE
+ *         Printout:
+ *             Descriptive message.
+ *
+ *      Error Detection:
+ *          Non-zero filler field.  Different message.
+ *
+ *      Process Explanation:
+ *          The calling routine has checked that there was, indeed, a PCI
+ *              header present, so we know that pci_image_end is valid.
+ *          If the entire filler is zero-bytes, print a simple message and
+ *              we're out'a here!
+ *          If there are non-zero bytes, identify loc'n of first non-zero.
+ *
+ *      Still to be done:
+ *          Come up with something more elegant for non-zero filler.
+ *
+ **************************************************************************** */
+
+void handle_pci_filler(u8 *filler_ptr)
+{
+    u8 *scan_ptr;
+    int filler_len;
+    char temp_buf[80];
+    bool all_zero = TRUE;
+    u8 filler_byte = *filler_ptr;
+
+    filler_len = pci_image_end - filler_ptr;
+
+    for ( scan_ptr = filler_ptr;
+        scan_ptr < pci_image_end;
+	    filler_byte = *(++scan_ptr) )
+    {
+	if ( filler_byte != 0 )
+	{
+	    all_zero = FALSE;
+	    break;
+	}    
+    }
+    
+    if ( all_zero )
+    {
+	sprintf(temp_buf, "PCI Image padded with %d bytes of zero", filler_len);
+    }else{
+	sprintf(temp_buf, "PCI Image padding-field of %d bytes "
+	    "had first non-zero byte at offset %ld",
+		 filler_len, scan_ptr - filler_ptr );
+    }
+    printremark ( temp_buf );
+}
diff --git a/detok/printformats.c b/detok/printformats.c
new file mode 100644
index 0000000..baa64dd
--- /dev/null
+++ b/detok/printformats.c
@@ -0,0 +1,140 @@
+/*
+ *                     OpenBIOS - free your system!
+ *                         ( FCode tokenizer )
+ *
+ *  This program is part of a free implementation of the IEEE 1275-1994
+ *  Standard for Boot (Initialization Configuration) Firmware.
+ *
+ *  Copyright (C) 2001-2005 Stefan Reinauer, <stepan@openbios.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ *
+ */
+
+/* **************************************************************************
+ *
+ *      Print, in various controlled formats, for the detokenizer.
+ *
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Module Author:  David L. Paktor    dlpaktor@us.ibm.com
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      Ultimately, our goal is to produce output that can be run back
+ *      through the tokenizer and produce the same binary.  So, any
+ *      extra text will have to be in a form that the tokenizer will
+ *      treat as comments.
+ *
+ **************************************************************************** */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "detok.h"
+
+
+/* **************************************************************************
+ *
+ *      Function name:  printremark ( string )
+ *      Synopsis:       Print the given string as a series of "Remark" lines,
+ *                      (i.e., preceded by backslash-space)
+ *      
+ *      Inputs:
+ *          Parameters:     
+ *              str     Pointer to the start of the string,
+ *                      however long it may be.  The string
+ *                      may have any number of embedded new-lines.
+ *
+ *      Outputs:
+ *          Returned Value: *** NONE***
+ *          Printout:    Each line of the string will be preceded by
+ *                       a backslash and two spaces.  Backslash-space
+ *                       is the standard delimiter for a "remark", i.e.
+ *                       the entire line is ignored as a comment.  The
+ *                       second space is "just" for aesthetics.
+ *      
+ *      Process Explanation:
+ *          Parse the input string for new-lines.  Print each separately.
+ *          Do not alter the input string.
+ *      
+ *
+ *      Still to be done:
+ *          Define a routine, call it  PrintComment , to print the given
+ *              string surrounded by open-paren-space ... space-close-paren
+ *          Define a single central routine, call it  safe_malloc ,
+ *              to do the test for null and print "No Memory" and exit.
+ *          Define a single central routine, call it  PrintError , to:
+ *              Print the given error message
+ *              Show the input file and line number
+ *              Collect error-flags for failure-exit at end of operation.
+ *
+ **************************************************************************** */
+
+void printremark ( char *str)
+{
+    char *strtmp ;          /*  Temporary pointer to current substring    */
+    int substrlen ;         /*  Length of current substring               */
+    char *substrend ;       /*  Pointer to end of current substring       */
+    char *strend ;          /*  Pointer to end of given string            */
+
+    char *strbfr ;          /*  Temporary substring buffer                */
+
+    /*  Guarantee that the malloc will be big enough.  */
+    strbfr = (char *)malloc(strlen((char *)str)+1);
+    if ( !strbfr )
+    {
+        printf ("No memory.\n");
+        exit(-1);
+    }
+
+
+    strtmp = str;
+    strend = &str[strlen(str)];
+
+    /* ******************************************************************
+     *
+     *      Isolate the current substring; allow that the given
+     *      string might not be terminated with a new-line. 
+     *
+     *      The  strend  pointer provides a convenient means to
+     *      test for when we've reached the end.
+     *
+     ******************************************************************** */
+
+   while ( strtmp < strend  )
+    {
+        substrend = strchr(strtmp , '\n');
+        substrlen = ( substrend ? (substrend-strtmp) : strlen(strtmp) );
+
+        strncpy (strbfr, strtmp, substrlen);
+        /* **********************************************************
+         * 
+         *  strncpy() does not append a terminating null character,
+         *  so we have to.
+         *
+         ************************************************************ */
+        strbfr[substrlen] = (char)0;
+
+        printf("\\  %s\n",strbfr);
+
+        strtmp = &strtmp[ substrlen + ( substrend ? 1 : 0 ) ] ;
+
+    }
+
+    free(strbfr) ;
+}
+
diff --git a/detok/stream.c b/detok/stream.c
index cbdc595..401d1a4 100644
--- a/detok/stream.c
+++ b/detok/stream.c
@@ -24,19 +24,59 @@
  *
  */
 
+/* **************************************************************************
+ *         Modifications made in 2005 by IBM Corporation
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Modifications Author:  David L. Paktor    dlpaktor@us.ibm.com
+ **************************************************************************** */
+
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <sys/stat.h>
+#include <setjmp.h>
 
+#include "stream.h"
 #include "detok.h"
+#include "pcihdr.h"
+
+extern jmp_buf eof_exception;
 
-extern bool offs16;
-extern u32  fcpos;
+/* **************************************************************************
+ *
+ *      Global Variables Exported:
+ *        Name            Value
+ *      fcode          The FCode-token last read.  Not necessarily the byte
+ *                          last read, if its function has in-line parameters
+ *      stream_max     The maximum position -- length -- of the input stream
+ *      pc             Pointer to "Current byte" in the input-data image.
+ *      max            Just after the end of the input-data image.
+ *                         This is *NOT* a byte-count.
+ *
+ **************************************************************************** */
 
 u16 fcode;
-u8  inbyte;
+unsigned int stream_max;
+u8 *pc;
+u8 *max;
+
+/* **************************************************************************
+ *
+ *      Local/Static Variables:
+ *        Name            Pointer to:
+ *      indata          Start of input-data image taken from input file.
+ *                          This memory was "malloc"ed; keep it around
+ *                          for when we "free" that memory.
+ *      fc_start        Start of the FCode.  This might not be the same
+ *                          as the start of the input file data, especially
+ *                          if the input file data starts with a PCI header.
+ *      pci_image_found     TRUE iff a valid PCI header was found
+ *
+ **************************************************************************** */
+u8 *indata;
+static u8 *fc_start;
+static bool pci_image_found = FALSE;
 
-static u8 *indata, *pc, *max;
 
 int init_stream(char *name)
 {
@@ -62,119 +102,455 @@ int init_stream(char *name)
 	fclose(infile);
        
 	pc=indata; 
+	fc_start = indata;
 	max=pc+finfo.st_size;
 	
+	stream_max = finfo.st_size;
+	
 	return 0;
 }
 
-int close_stream(void)
+/* **************************************************************************
+ *
+ *      Function name:  init_fcode_block
+ *      Synopsis:       Initialize all pointers and variables, etcetera,
+ *                          for an FCode-block.
+ *
+ **************************************************************************** */
+
+void init_fcode_block(void)
+{
+	fc_start = pc;
+	linenum = 1 ;
+}
+
+
+void close_stream(void)
 {
 	free(indata);
-	return 0;	
+	stream_max = 0;
 }
 
 int get_streampos(void)
 {
-	return (int)((long)pc-(long)indata);
+	return (int)( pc - fc_start );
 }
 
-void set_streampos(long pos)
+void set_streampos(int pos)
 {
-	pc=indata+pos;
+	pc = fc_start + pos;
 }
 
-static int get_byte(void)
+
+/* **************************************************************************
+ *
+ *      Function name:  throw_eof
+ *      Synopsis:       Analyze and print the cause of the end-of-file
+ *                      and throw an exception.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             premature              TRUE iff end-of-file was out-of-sync 
+ *         Global/Static Variables:        
+ *                  end_found         Indicates if normal end of fcode was read.
+ *                  eof_exception     Long-Jump environment to which to jump.
+ *
+ *      Outputs:                      Does a Long-Jump
+ *         Returned Value:            NONE
+ *         Printout:
+ *             "End-of-file" message, along with a descriptor, if applicable:
+ *                 Premature, Unexpected.
+ *          The calling routine notifies us if the number of bytes requested
+ *              overflowed the input buffer, by passing us a TRUE for the
+ *              input parameter.  That is a "Premature" end-of-file.
+ *          If  end_found  is FALSE, it means the normal end of FCode
+ *               wasn't seen.  That is an "Unexpected" end-of-file.
+ *
+ **************************************************************************** */
+
+static void throw_eof(bool premature)
 {
-	inbyte=*pc;
-	pc++;
+    char yoo = 'U';
+    char eee = 'E';
+    if ( premature)
+    {
+        printf("Premature ");
+	yoo = 'u';
+	eee = 'e';
+    }
+    if ( ! end_found )
+    {
+        printf("%cnexpected ",yoo);
+	eee = 'e';
+    }
+    printf("%cnd of file.\n",eee);
+    longjmp(eof_exception, -1);
+}
 	
-        if (pc>max) {
-                printf ("\nUnexpected end of file.\n");
-                return 0;
+/* **************************************************************************
+ *
+ *      Function name:  get_bytes
+ *      Synopsis:       Return the next string of bytes, as requested, from
+ *                      the FCode input-stream.  Detect end-of-file
+ *
+ *      Inputs:
+ *         Parameters:
+ *             nbytes            The number of bytes requested
+ *         Global/Static Variables:
+ *             pc                Pointer to "where we are" in the FCode
+ *             max               Pointer to just after end of input file data.
+ *
+ *      Outputs:
+ *         Returned Value:
+ *             Pointer to the requested bytes in the FCode input-stream.
+ *         Global/Static Variables:
+ *             pc                Incremented by the number of bytes requested
+ *
+ *      Exception:
+ *          When end-of-file is reached, or is about to be exceeded,    
+ *              throw an end-of-file exception.
+ *
+ *      Process Explanation:
+ *          End-of-file is not exactly an error, so its detection is more
+ *              a part of normal processing.
+ *          If we entered this routine with PC pointing exactly at MAX,
+ *              we are probably at the end the way we expect to be, so we
+ *              call our EOF-handling routine with a "non-premature" flag.
+ *          If the requested number of bytes puts us just even with MAX,
+ *              we have neither reached nor over-run the input stream, so
+ *              there's no call to our EOF-handling routine needed at all.
+ *          Only if the requested number of bytes puts us past MAX have we 
+ *              over-run our input stream with a "premature" condition.
+ *
+ *      Extraneous Remarks:
+ *          This is another one where it was easier to write the code
+ *              than the explanation ...  ;-}
+ *
+ **************************************************************************** */
+
+static u8 *get_bytes(int nbytes)
+{
+   u8 *retval = pc;
+   if ( pc == max )
+   {
+       throw_eof(FALSE);
+   }
+   if ( pc + nbytes > max )
+   {
+       throw_eof(TRUE);
+   }
+   pc += nbytes;
+   return( retval);
         }
 
-	return 1;
+
+/* **************************************************************************
+ *
+ *       Function name:  more_to_go
+ *       Synopsis:       Return FALSE when the last byte has been
+ *                           read from the input-stream.
+ *
+ **************************************************************************** */
+
+bool more_to_go(void)
+{
+    bool retval;
+    retval = INVERSE( pc == max );
+    return( retval);
 }
  
-u16 get_token(void)
+
+/* **************************************************************************
+ *
+ *      Function name:  next_token
+ *      Synopsis:       Retrieve the next FCode-token from the input-stream.
+ *
+ *      Inputs:
+ *         Parameters:                     NONE
+ *
+ *      Outputs:
+ *         Returned Value:                 The next FCode-token
+ *         Global/Static Variables:
+ *             fcode                       The FCode-token last read.
+ *             token_streampos             Streampos() of token just gotten
+ *
+ **************************************************************************** */
+ 
+u16 next_token(void)
 {
         u16 tok;
-        get_byte();
-        tok=inbyte;
-        if (tok != 0x00 && tok < 0x10) {
-                get_byte();
+        token_streampos = get_streampos();
+        tok = *(get_bytes(1));
+	if ( tok != 0x00 &&  tok < 0x10)
+	{
                 tok<<=8;
-                tok|=inbyte;
+              tok |= *(get_bytes(1));     
         }
         fcode=tok;
-        return tok;
+    return(tok);
 }
 
 u32 get_num32(void)
 {
-        u32 ret;
+        u32 retval;
+	u8 *num_str;
  
-        get_byte();
-        ret=inbyte<<24;
-        get_byte();
-        ret|=(inbyte<<16);
-        get_byte();
-        ret|=(inbyte<<8);
-        get_byte();
-        ret|=inbyte;
+	num_str = get_bytes(4);
+	retval = BIG_ENDIAN_LONG_FETCH(num_str);
  
-        return ret;
+        return ( retval);
 }
 
 u16 get_num16(void)
 {
-        u16 ret;
+        u16 retval;
+	u8 *num_str;
  
-        get_byte();
-        ret=inbyte<<8;
-        get_byte();
-        ret|=inbyte;
+        num_str = get_bytes(2);
+	retval = BIG_ENDIAN_WORD_FETCH(num_str);
  
-        return ret;
+        return ( retval);
 }
  
 u8 get_num8(void)
 {
-        get_byte();
+        u8  inbyte;
+
+	inbyte = *(get_bytes(1));
         return(inbyte);
 }
 
-u16 get_offset(void)
+s16 get_offset(void)
 {
+        s16 retval;
         if (offs16)
-                return (get_num16());
+        {
+	    retval = (s16)get_num16();
+	}else{
+	    retval = (s16)get_num8();
+	    /*  Make sure it's sign-extended  */
+	    retval |= ( retval & 0x80 ) ? 0xff00 : 0 ;
+	}
+ 
+        return (retval);
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  get_string
+ *      Synopsis:       Return a pointer to a Forth-Style string within the
+ *                          input stream.  Note: this cannot be used to create
+ *                          a new token-name; use  get_name()  for that.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             *len                       Pointer to where the length will go
+ *
+ *      Outputs:
+ *         Returned Value:
+ *             Pointer to the string within the input stream.
+ *         Supplied Pointers:
+ *             *len                      Length of the string
+ *
+ *      Process Explanation:
+ *          Get one byte representing the length of the FORTH-style string.
+ *          Get as many bytes as the length indicates.
+ *          That's the string.  The pointer returned by  get_bytes()  is
+ *              our return value.
+ *
+ **************************************************************************** */
+
+u8 *get_string(u8 *len)
+{
+    char *retval;
+
+    *len = get_num8();
+    retval = get_bytes((int)*len);
  
-        return (get_num8());
+    return (retval); 
 }
 
 
-int scnt=0;
-u8 *get_string(void)
+/* **************************************************************************
+ *
+ *      Function name:  get_name
+ *      Synopsis:       Retrieve a copy of the next string in the input-stream
+ *                      when it is expected to be a new function-name.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             *len                       Pointer to where the length will go
+ *         Global/Static Variables:
+ *             pc                        "Where we are" in the file-stream
+ *
+ *      Outputs:
+ *         Returned Value: 
+ *             Pointer to allocated memory containing a copy of the string
+ *         Supplied Pointers:
+ *             *len                      Length of the name
+ *         Memory Allocated
+ *             Memory for the copy of the string is allocated by  strdup()
+ *         When Freed?
+ *             Never.  Retained for duration of the program.
+ *
+ *      Process Explanation:
+ *          Get the FORTH-style string.
+ *          At this point, PC points to the byte that follows the string;
+ *              we are going to save that byte and replace it with a zero,
+ *              thus creating a C-style string.
+ *          We will pass that C-style string as an argument to  strdup() ,
+ *              which will give us our return value.
+ *          Then, of course, we restore the byte we so rudely zeroed, and
+ *              proceed merrily on our way.
+ *
+ **************************************************************************** */
+
+char *get_name(u8 *len)
 {
-        u8 *data;
-        u8 size;
-        unsigned int i;
+    char *str_start;
+    char *retval;
+    u8 sav_byt;
  
-        get_byte();
-        size=inbyte;
+    str_start = get_string( len );
 
-	scnt++;
+    sav_byt = *pc;
+    *pc = 0;
 
-        data=malloc(size+2);
-	if (!data) printf ("No more memory.\n");
-        data[0]=size;
+    retval = strdup(str_start);
+    *pc = sav_byt;
  
-        for (i=1; i<size+1; i++) {
-                get_byte();
-                data[i]=inbyte;
+    return (retval);
         }
-        data[i]=0;
-        return data;
  
+/* **************************************************************************
+ *
+ *      Function name:  calc_checksum
+ *      Synopsis:       Calculate the checksum.
+ *                          Leave the input position unchanged.
+ *
+ *      Inputs:
+ *         Parameters:             NONE
+ *         Global/Static Variables:     
+ *             pc      Pointer to "where we are" in the file-stream
+ *
+ *      Outputs:
+ *         Returned Value:        Calculated checksum.
+ *         Global/Static Variables:  
+ *             pc     Reset to value upon entry
+ *
+ *      Process Explanation:
+ *          When this routine is entered, the PC is presumed to be pointing
+ *              just after the stored checksum, and just before the length
+ *              field in the FCode header.  This is the point at which we
+ *              will preserve the PC
+ *          Extract the length from the FCode header.  It includes the eight
+ *              bytes of the FCode header, so we will need to adjust for that.
+ *          The first byte after the FCode header is where the checksum
+ *              calculation begins.
+ *
+ **************************************************************************** */
+
+u16 calc_checksum(void)
+{
+    u16 retval = 0;
+    u8 *cksmptr;
+    u8 *save_pc;
+    u32 fc_blk_len;
+    int indx;
+
+    save_pc = pc;
+
+    fc_blk_len = get_num32();            /* Read len */
+    cksmptr = get_bytes(fc_blk_len-8);   /*  Make sure we have all our data  */
+
+    for ( indx = 8; indx < fc_blk_len; indx++)
+    {
+	retval += *cksmptr++;
+}
+
+    pc = save_pc;
+    return( retval);
+} 
+
+
+/* **************************************************************************
+ *
+ *      Function name:  adjust_for_pci_header
+ *      Synopsis:   Skip the PCI Header.  Adjust the pointer to 
+ *                  the start of FCode in the file-stream,
+ *                  and our pointer to "where we are" in the FCode,
+ *                  by the size of the PCI header.
+ *      
+ *      Inputs:
+ *              Parameters:     NONE
+ *              Global/Static Variables:    (Pointer to:)
+ *                  pc                     "where we are" in the file-stream
+ *                  fc_start               start of FCode in the file-stream
+ *
+ *      Outputs:
+ *              Returned Value: NONE
+ *              Global/Static Variables:
+ *                  pc                     Advanced past PCI header
+ *                  fc_start               Likewise.
+ *                  pci_image_found        Set or cleared as appropriate.
+ *                  last_defined_token     Re-initialized
+ *      
+ *      Process Explanation:
+ *          Call handle_pci_header to get the size of the PCI header,
+ *              if any, and increment  pc  and  fc_start  by the number
+ *              of bytes it returns; also, set  pci_image_found  based
+ *              on whether the "size of the PCI header" was non-zero.
+ *          (Re-)Initialize overlap detection here.  Images with multiple
+ *              PCI blocks can safely re-cycle FCode numbers; this is
+ *              not necessarily  true of multiple FCode blocks within
+ *              the same PCI block...
+ *
+ **************************************************************************** */
+
+void adjust_for_pci_header(void)
+{
+	int pci_header_size;
+	
+	pci_header_size = handle_pci_header(pc);
+	pci_image_found = pci_header_size > 0 ? TRUE : FALSE;
+	pc += pci_header_size;
+	fc_start += pci_header_size;
+	last_defined_token = 0;
 }
 
+/* **************************************************************************
+ *
+ *      Function name:  adjust_for_pci_filler
+ *      Synopsis:       Dispatch call to pci-filler-handler
+ *
+ *      Inputs:
+ *         Parameters:                    NONE
+ *         Global/Static Variables:
+ *             pci_image_found           Whether to proceed...
+ *             pci_image_end             Pointer to just after the end of
+ *                                           the current PCI image
+ *
+ *      Outputs:
+ *          Returned Value:                NONE
+ *          Global/Static Variables:
+ *              pci_image_found            Reset to FALSE
+ *
+ *      Error Detection:
+ *          Confirm that the data-stream has the complete filler,
+ *              via a call to get_bytes()
+ *
+ **************************************************************************** */
+
+void adjust_for_pci_filler(void)
+{
+    if ( pci_image_found )
+    {
+        int pci_filler_len;
+	u8 *pci_filler_ptr;
+
+	pci_filler_len = pci_image_end - pc;
+	pci_filler_ptr = get_bytes(pci_filler_len);
+	handle_pci_filler( pci_filler_ptr );
+	pci_image_found = FALSE;
+    }
+}
diff --git a/detok/stream.h b/detok/stream.h
index a6c69b0..8c88de6 100644
--- a/detok/stream.h
+++ b/detok/stream.h
@@ -1,3 +1,6 @@
+#ifndef _UTILS_DETOK_STREAM_H
+#define _UTILS_DETOK_STREAM_H
+
 /*
  *                     OpenBIOS - free your system! 
  *                            ( detokenizer )
@@ -24,16 +27,42 @@
  *
  */
 
+/* **************************************************************************
+ *         Modifications made in 2005 by IBM Corporation
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Modifications Author:  David L. Paktor    dlpaktor@us.ibm.com
+ **************************************************************************** */
+
+#include "types.h"
+
+/*  Prototypes for functions exported from  stream.c     */
+
+
 int init_stream(char *name);
-int close_stream(void);
+void close_stream(void);
+bool more_to_go(void);
+
+void adjust_for_pci_header(void);
+void adjust_for_pci_filler(void);
+void init_fcode_block(void);
 
 int  get_streampos(void);
-void set_streampos(long pos);
+void set_streampos(int pos);
 
-u16 get_token(void);
+u16 next_token(void);
 u8  get_num8(void);
 u16 get_num16(void);
 u32 get_num32(void);
-u16 get_offset(void);
-u8 *get_string(void);
+s16 get_offset(void);
+u8 *get_string(u8 *len);
+char *get_name(u8 *len);
+u16 calc_checksum(void);
+
+/*  External declarations for variables defined in   stream.c   */
+
+extern unsigned int stream_max;
+extern u8 *indata;
+extern u8 *pc;
+extern u8 *max;
 
+#endif   /*  _UTILS_DETOK_STREAM_H    */
diff --git a/romheaders/Makefile b/romheaders/Makefile
index 242cea1..3794aeb 100644
--- a/romheaders/Makefile
+++ b/romheaders/Makefile
@@ -21,20 +21,21 @@
 #  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
 #
 
-
 CC  = gcc
-CFLAGS= -O2 -Wall -W -ansi
+CFLAGS= -O2 -Wall -W -ansi -I../shared
+
+SOURCES = romheaders.c ../shared/classcodes.c
 
-.SUFFIXES: .c .o
+.SUFFIXES: .c
 
 all: romheaders
 
-romheaders: romheaders.o
-	$(CC) $(CFLAGS) romheaders.o -o romheaders
+romheaders: $(SOURCES)
+	$(CC) $(CFLAGS) $(SOURCES) -o $@
 	strip romheaders
 	
 clean:
-	rm -f *.o
+	rm -f *~
 
 distclean: clean
 	rm -f romheaders
diff --git a/romheaders/romheaders.c b/romheaders/romheaders.c
index e2d3646..dc47e0e 100644
--- a/romheaders/romheaders.c
+++ b/romheaders/romheaders.c
@@ -23,6 +23,11 @@
  *
  */
 
+/* **************************************************************************
+ *         Modifications made in 2005 by IBM Corporation
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Modifications Author:  David L. Paktor    dlpaktor@us.ibm.com
+ **************************************************************************** */
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -30,60 +35,32 @@
 #include <sys/stat.h>
 #include <unistd.h>
 
-#define u8  unsigned char
-#define u16 unsigned short
-#define u32 unsigned int
-
-#define PCI_DATA_HDR (u32) ( ('R' << 24) | ('I' << 16) | ('C' << 8) | 'P' )
-
-typedef struct {
-	u16	signature;
-	u8	reserved[0x16];
-	u16	dptr;
-} rom_header_t;
-
-typedef struct {
-	u32	signature;
-	u16	vendor;
-	u16	device;
-	u16	reserved_1;
-	u16	dlen;
-	u8	drevision;
-	u8	class_hi;
-	u16	class_lo;
-	u16	ilen;
-	u16	irevision;
-	u8	type;
-	u8	indicator;
-	u16	reserved_2;
-} pci_data_t;
+#include "pcihdr.h"
 
 char *rom=NULL;
 size_t romlen=0;
 
-/* make this endian safe without fancy system headers */
-static u16 little_word(u16 val)
-{
-	u8 *ptr=(u8 *)&val;
-	return (ptr[0]|(ptr[1]<<8));
-}
+/*  Prototypes for functions exported from  shared/classcodes.c   */
 
-static u16 little_dword(u16 val)
-{
-	u8 *ptr=(u8 *)&val;
-	return (ptr[0]|(ptr[1]<<8)|(ptr[2]<<16)|(ptr[3]<<24));
-}
+char *pci_device_class_name(u32 code);
+char *pci_code_type_name(unsigned char code);
+
+/*  Functions local to this file:
+	    int dump_rom_header(rom_header_t *data);
+	    int dump_pci_data(pci_data_t *data);
+	    void dump_platform_extensions(u8 type, rom_header_t *data);
+ */
 
-/* dump the rom headers */
 static int dump_rom_header(rom_header_t *data)
-{
-	u16 sig=little_word(data->signature);
+{   /*  Return TRUE for "no problem"  */
+	const u16 pci_header_signature = 0x55aa;
+	u16 sig=BIG_ENDIAN_WORD_FETCH(data->signature);
 	int i;
 	
 	printf ("PCI Expansion ROM Header:\n");
 	
-	printf ("  Signature: 0x%02x%02x (%s)\n", 
-			sig&0xff,sig>>8,sig==0xaa55?"Ok":"Not Ok");
+	printf ("  Signature: 0x%04x (%s)\n", 
+			sig, sig == pci_header_signature ? "Ok":"Not Ok");
 	
 	printf ("  CPU unique data:");
 	for (i=0;i<16;i++) {
@@ -92,97 +69,41 @@ static int dump_rom_header(rom_header_t *data)
 	}
 	
 	printf ("\n  Pointer to PCI Data Structure: 0x%04x\n\n",
-						little_word(data->dptr));
+				LITTLE_ENDIAN_WORD_FETCH(data->data_ptr));
 
-	return (sig==0xaa55);
+	return (sig == pci_header_signature);
 }
 
 static int dump_pci_data(pci_data_t *data)
-{
-	u32 sig=little_dword(data->signature);
-	u32 classcode=(data->class_hi<<16)|(little_word(data->class_lo));
+{   /*  Return TRUE for "no problem"  */
+	const u32 pci_data_hdr = PCI_DATA_HDR ;
+
+	u32 sig      = BIG_ENDIAN_LONG_FETCH(data->signature);
+	u32 classcode= CLASS_CODE_FETCH(data->class_code);
+	u32 dlen     = (u32)LITTLE_ENDIAN_WORD_FETCH(data->dlen);
+	u32 ilen     = (u32)LITTLE_ENDIAN_WORD_FETCH(data->ilen);
 	
 	printf("PCI Data Structure:\n");
-	printf("  Signature: '%c%c%c%c' (%s)\n", sig&0xff,(sig>>8)&0xff,
-			(sig>>16)&0xff, sig>>24, sig==PCI_DATA_HDR?"Ok":"Not Ok");
-	printf("  Vendor ID: 0x%04x\n", little_word(data->vendor));
-	printf("  Device ID: 0x%04x\n", little_word(data->device));
-	printf("  Reserved: 0x%04x\n", little_word(data->reserved_1));
-	printf("  PCI Data Structure Length: 0x%04x (%d bytes)\n", 
-			little_word(data->dlen), little_word(data->dlen));
+	printf("  Signature: 0x%04x '%c%c%c%c' ", sig,
+			sig>>24,(sig>>16)&0xff, (sig>>8)&0xff, sig&0xff);
+	printf("(%s)\n", sig == pci_data_hdr ?"Ok":"Not Ok");
+
+	printf("  Vendor ID: 0x%04x\n", LITTLE_ENDIAN_WORD_FETCH(data->vendor));
+	printf("  Device ID: 0x%04x\n", LITTLE_ENDIAN_WORD_FETCH(data->device));
+	printf("  Vital Product Data:  0x%04x\n",
+	                                   LITTLE_ENDIAN_WORD_FETCH(data->vpd));
+	printf("  PCI Data Structure Length: 0x%04x (%d bytes)\n", dlen, dlen);
 	printf("  PCI Data Structure Revision: 0x%02x\n", data->drevision);
-	printf("  Class Code: 0x%06x (",classcode);
-	switch (classcode) {
-	case 0x0100:
-		printf("SCSI Storage");
-		break;
-	case 0x0101:
-		printf("IDE Storage");
-		break;
-	case 0x0103:
-		printf("IPI Storage");
-		break;
-	case 0x0104:
-		printf("RAID Storage");
-		break;
-	case 0x0180:
-		printf("Storage");
-		break;
-		
-	case 0x0200:
-		printf("Ethernet");
-		break;
-	case 0x0201:
-		printf("Token Ring");
-		break;
-	case 0x0202:
-		printf("FDDI");
-		break;
-	case 0x0203:
-		printf("ATM");
-		break;
-	case 0x0280:
-		printf("Network");
-		
-	case 0x0300:
-		printf("VGA Display");
-		break;
-	case 0x0301:
-		printf("XGA Display");
-		break;
-	case 0x0302:
-		printf("3D Display");
-		break;
-	case 0x0380:
-		printf("Display");
-		break;
-		
-	default:
-		printf("unkown");
-	}
-	printf(")\n  Image Length: 0x%04x blocks (%d bytes)\n", 
-			little_word(data->ilen), little_word(data->ilen)*512);
+	printf("  Class Code: 0x%06x (%s)\n",classcode,
+					 pci_device_class_name(classcode));
+	printf("  Image Length: 0x%04x blocks (%d bytes)\n", ilen, ilen*512);
 	printf("  Revision Level of Code/Data: 0x%04x\n",
-			little_word(data->irevision));
-	printf("  Code Type: 0x%02x (", data->type);
-	switch (data->type) {
-	case 0:
-		printf("Intel x86");
-		break;
-	case 1: 
-		printf("Open Firmware");
-		break;
-	case 2:
-		printf("HP PA Risc");
-		break;
-	case 3:
-		printf("Intel EFI (unofficial)");
-		break;
-	default:
-		printf("unknown as of PCI specs 2.2");
-	}
-	printf(")\n  Indicator: 0x%02x %s\n", data->indicator,
-			data->indicator&0x80?"(last image in rom)":"");
+			(u32)LITTLE_ENDIAN_WORD_FETCH(data->irevision));
+	printf("  Code Type: 0x%02x (%s)\n", data->code_type,
+					  pci_code_type_name(data->code_type) );
+	printf("  Last-Image Flag: 0x%02x (%slast image in rom)\n",
+			data->last_image_flag,
+			data->last_image_flag&0x80?"":"not ");
 	printf("  Reserved: 0x%04x\n\n", little_word(data->reserved_2));
 
 	return (sig==PCI_DATA_HDR);
@@ -225,7 +146,7 @@ static void dump_platform_extensions(u8 type, rom_header_t *data)
 			printf( "  Entry point for INIT function:"
 				" 0x%x\n\n",entry);
 		} else
-			printf( "  Unable to determin entry point for INIT"
+			printf( "  Unable to determine entry point for INIT"
 				" function. Please report.\n\n");
 		
 		break;
@@ -252,9 +173,9 @@ int main(int argc, char **argv)
 
 	if (argc!=2) {
 		printf ("\nUsage: %s <romimage.img>\n",argv[0]);
-		printf ("\nromheaders dumps pci option rom headers "
+		printf ("\n  romheaders dumps pci option rom headers "
 				"according to PCI \n"
-				"specs 2.2 in human readable form\n\n");
+				"  specs 2.2 in human readable form\n\n");
 		return -1;
 	}
 	
@@ -290,23 +211,25 @@ int main(int argc, char **argv)
 	do {
 		printf("\nImage %d:\n",i);
 		if (!dump_rom_header(rom_header)) {
-			printf("Error occured. Bailing out.\n");
+			printf("Rom Header error occured. Bailing out.\n");
 			break;
 		}
 		
-		pci_data=(pci_data_t *)(rom+little_word(rom_header->dptr));
+		pci_data = (pci_data_t *)((char *)rom_header +
+			     LITTLE_ENDIAN_WORD_FETCH(rom_header->data_ptr));
 		
 		if (!dump_pci_data(pci_data)) {
-			printf("Error occured. Bailing out.\n");
+			printf("PCI Data error occured. Bailing out.\n");
 			break;
 		}
 		
-		dump_platform_extensions(pci_data->type, rom_header);
+		dump_platform_extensions(pci_data->code_type, rom_header);
 		
-		rom_header+=little_word(pci_data->ilen)*512;
+		rom_header = (rom_header_t *)((char *)rom_header +
+				LITTLE_ENDIAN_WORD_FETCH(pci_data->ilen)*512);
 		i++;
-	} while ((pci_data->indicator&0x80)!=0x80 &&
-			romlen<(unsigned long)rom_header-(unsigned long)romlen);
+	} while ((pci_data->last_image_flag&0x80)!=0x80 &&
+			(char *)rom_header < rom+(int)romlen );
 
 	return 0;
 }
diff --git a/toke/Makefile b/toke/Makefile
index 547a889..110d75f 100644
--- a/toke/Makefile
+++ b/toke/Makefile
@@ -1,11 +1,12 @@
 #
-#                     OpenBIOS - free your system! 
-#                         ( FCode tokenizer )
-#                          
-#  This program is part of a free implementation of the IEEE 1275-1994 
+#                     OpenBIOS - free your system!
+#                             ( Utilities )
+#
+#  This program is part of a free implementation of the IEEE 1275-1994
 #  Standard for Boot (Initialization Configuration) Firmware.
 #
-#  Copyright (C) 2001-2005  Stefan Reinauer, <stepan@openbios.org>
+#  Copyright (C) 2001-2006  Stefan Reinauer <stepan@openbios.org>
+#  Copyright (C) 2006 coresystems GmbH <info@coresystems.de>
 #
 #  This program is free software; you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
@@ -21,52 +22,39 @@
 #  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
 #
 
-ARCH     := $(shell uname -m | sed -e s/i.86/x86/ -e s/sun4u/sparc64/ -e s/arm.*/arm/ -e s/sa110/arm/ -e s/x86_64/amd64/)
-TOPDIR   := $(shell /bin/pwd)
-BUILDDIR ?= $(TOPDIR)/obj-$(ARCH)
-VPATH    := $(BUILDDIR)
+PROGRAM = toke
+
+CC      = gcc
+STRIP	= strip
+INCLUDES = -I../shared
+#CFLAGS  = -O2 -g -Wall 
+CFLAGS  = -Os -Wall -Wno-pointer-sign -DSYS_IS_GNU_Linux
+LDFLAGS = 
 
-include $(TOPDIR)/Rules.make
+OBJS  = clflags.o conditl.o devnode.o dictionary.o emit.o errhandler.o     \
+        flowcontrol.o macros.o nextfcode.o parselocals.o scanner.o stack.o \
+	stream.o strsubvocab.o ticvocab.o toke.o tokzesc.o tracesyms.o     \
+	usersymbols.o ../shared/classcodes.o
 
-CC     = gcc
-CFLAGS = -O2 -Wall -W -ansi -pedantic
-# CFLAGS = -O -g -Wall -ansi -pedantic
+all: .dependencies $(PROGRAM)
 
-# CFLAGS := $(CFLAGS) -DDEBUG_SCANNER
-# CFLAGS := $(CFLAGS) -DDEBUG_DSTACK
+$(PROGRAM): $(OBJS)
+	$(CC) -o $(PROGRAM) $(OBJS) $(LDFLAGS)
+	$(STRIP) -s $(PROGRAM)
 
-OBJECTS= toke.o stack.o stream.o dictionary.o macros.o scanner.o emit.o
+clean:
+	rm -f $(OBJS) *~
 
-.SUFFIXES: .c .o
+distclean: clean
+	rm -f $(PROGRAM) .dependencies
+	
+.dependencies: *.c 
+	@$(CC) $(CFLAGS) $(INCLUDES) -MM *.c > .dependencies
 
-all: main toke
-	@cd $(BUILDDIR) && strip toke
-	@echo -e "\nOpenBIOS tokenizer toke build finished\n"
+.PHONY: all clean distclean 
 
-# main should go to rules.make
-main:
-	@echo -e "\nWelcome to toke, the OpenBIOS fcode tokenizer.."
-	@test -r $(BUILDDIR) || ( mkdir -p $(BUILDDIR); \
-	  echo -e "\nCreating build directory $(BUILDDIR)" )
+-include .dependencies
 
-toke: $(OBJECTS)
-	@echo -n "  linking tokenizer executable... "
-	@cd $(BUILDDIR) && $(CC) $(CFLAGS) -o $@ $^
-	@echo -e "\tok"
-	
-clean:
-	@test ! -d $(BUILDDIR) && \
-		echo "Architecture $(ARCH) is already clean." || \
-		( 						 \
-			echo "Cleaning up architecture $(ARCH)"; \
-			rm -rf $(BUILDDIR)			 \
-			rm forth.dict.core			 \
-		)
+.c.o:
+	$(CC) -c $(CFLAGS) $(INCLUDES) $< -o $@ 
 
-toke.o:       toke.c toke.h stack.h stream.h emit.h
-dictionary.o: dictionary.c toke.h dictionary.h
-emit.o:       emit.c toke.h stack.h
-macros.o:     macros.c toke.h
-scanner.o:    scanner.c toke.h stack.h stream.h dictionary.h
-stack.o:      stack.c toke.h stack.h
-stream.o:     stream.c toke.h
diff --git a/toke/Rules.make b/toke/Rules.make
deleted file mode 100644
index db82ed6..0000000
--- a/toke/Rules.make
+++ /dev/null
@@ -1,17 +0,0 @@
-# tag: Makefile rules
-
-VPATH    := $(VPATH):.
-
-.S.o:
-	echo -n "  assembling $<... "
-	$(CC) -c -nostdlib $(INCLUDES) $(CFLAGS) $< -o $(BUILDDIR)/$@ && \
-		echo -e "    \t\tok" || \
-		echo -e "    \t\tfailed"
-
-.c.o:
-	@echo -n "  compiling $<... "
-	@$(CC) -c $(CFLAGS) $(INCLUDES) $< -o $(BUILDDIR)/$@ && \
-		echo -e "   \t\tok" || \
-		echo -e "   \t\failed"
-		
-
diff --git a/toke/clflags.c b/toke/clflags.c
new file mode 100644
index 0000000..19cea65
--- /dev/null
+++ b/toke/clflags.c
@@ -0,0 +1,729 @@
+/*
+ *                     OpenBIOS - free your system!
+ *                         ( FCode tokenizer )
+ *
+ *  This program is part of a free implementation of the IEEE 1275-1994
+ *  Standard for Boot (Initialization Configuration) Firmware.
+ *
+ *  Copyright (C) 2001-2005 Stefan Reinauer, <stepan@openbios.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ *
+ */
+
+/* **************************************************************************
+ *
+ *      Command-Line Flags are used to control certain non-Standard
+ *          variant behaviors of the Tokenizer.
+ *      Support Functions for setting, clearing, displaying, etc.
+ *      Call them "Special-Feature Flags" in messages to the User
+ *
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Module Author:  David L. Paktor    dlpaktor@us.ibm.com
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *          For a given CLFlag name, the user may enter either:
+ *
+ *                   -f CLFlagName
+ *              or
+ *                   -f noCLFlagName
+ *
+ *          to either enable or disable the associated function
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      Functions Exported:
+ *          set_cl_flag                 Set (or clear) a CL Flag Variable
+ *          show_all_cl_flag_settings   Show CL Flags' settings unconditionally.
+ *          list_cl_flag_settings       Display CL Flags' settings if changed.
+ *          list_cl_flag_names          Display just the names of the CL Flags.
+ *          cl_flags_help               Help Message for CL Flags
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      Revision History:
+ *          Updated Mon, 08 Aug 2005 by David L. Paktor
+ *          They're not just for setting from the Command-Line anymore,
+ *              but let's still keep these names for internal use....
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *          The CL_FLAGS data structure has a field for the CLFlagName,
+ *          one for a text explanation of the function it controls, and
+ *          one for the address of the boolean variable ("flag")
+ *
+ **************************************************************************** */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "clflags.h"
+#include "errhandler.h"
+
+
+/* **************************************************************************
+ *
+ *          Global Variables Exported
+ *              (The "flags" controlled by this means)
+ *
+ **************************************************************************** */
+
+bool ibm_locals = FALSE ;
+bool ibm_locals_legacy_separator = TRUE ;
+bool ibm_legacy_separator_message = TRUE ;
+bool enable_abort_quote = TRUE ;
+bool sun_style_abort_quote = TRUE ;
+bool abort_quote_throw = TRUE ;
+bool string_remark_escape = TRUE ;
+bool hex_remark_escape = TRUE ;
+bool c_style_string_escape = TRUE ;
+bool always_headers = FALSE ;
+bool always_external = FALSE ;
+bool verbose_dup_warning = TRUE ;
+bool obso_fcode_warning = TRUE ;
+bool trace_conditionals = FALSE ;
+bool big_end_pci_image_rev = FALSE ;
+
+/*  And one to trigger a "help" message  */
+bool clflag_help = FALSE;
+
+/* **************************************************************************
+ *
+ *     The addition of the "upper/lower-case-tokens" flags introduces
+ *         some complications.  These are the variables we will actually
+ *         be exporting:
+ *
+ **************************************************************************** */
+
+bool force_tokens_case       = FALSE ;
+bool force_lower_case_tokens = FALSE ;
+
+/* **************************************************************************
+ *
+ *         but we will be entering two static variables into the table,
+ *         and keep two more to detect when a change is made...
+ *
+ **************************************************************************** */
+static bool upper_case_tokens = FALSE ;
+static bool lower_case_tokens = FALSE ;
+static bool was_upper_case_tk = FALSE ;
+static bool was_lower_case_tk = FALSE ;
+
+/* **************************************************************************
+ *
+ *              Internal Static Variables
+ *     cl_flag_change        A change was made to any of the CL Flags
+ *              Internal Static Constants
+ *     cl_flags_list         List of CL Flags and their data.
+ *
+ **************************************************************************** */
+
+static bool cl_flag_change = FALSE;
+
+static const cl_flag_t cl_flags_list[] = {
+  /*  The clflag_tabs field takes at least one tab.
+   *  If the name has fewer than 16 characters,
+   *  stick in an extra tab, and yet another tab
+   *  if the name is shorter than 8 characters
+   *  to make the formatting of the "explanation"
+   *  come out prettier.
+   */
+  { "Local-Values",
+        &ibm_locals,
+	"\t\t",
+	    "Support IBM-style Local Values (\"LV\"s)"     } ,
+
+  { "LV-Legacy-Separator",
+        &ibm_locals_legacy_separator,
+	"\t",
+	    "Allow Semicolon for Local Values Separator (\"Legacy\")"     } ,
+
+  { "LV-Legacy-Message",
+        &ibm_legacy_separator_message,
+	"\t",
+	    "Display a Message when Semicolon is used as the "
+		"Local Values Separator" } ,
+
+  { "ABORT-Quote",
+        &enable_abort_quote,
+	"\t\t",
+	    "Allow ABORT\" macro"     } ,
+
+  { "Sun-ABORT-Quote",
+        &sun_style_abort_quote,
+	"\t\t",
+	    "ABORT\" with implicit IF ... THEN"     } ,
+
+  { "ABORT-Quote-Throw",
+        &abort_quote_throw,
+	"\t",
+	    "Use -2 THROW in an Abort\" phrase, rather than ABORT"     } ,
+
+  { "String-remark-escape",
+        &string_remark_escape,
+	"\t",
+	    "Allow \"\\ (Quote-Backslash) to interrupt string parsing"     } ,
+
+  { "Hex-remark-escape",
+        &hex_remark_escape,
+	"\t",
+	    "Allow \\ (Backslash) to interrupt "
+		"hex-sequence parsing within a string"     } ,
+
+  { "C-Style-string-escape",
+        &c_style_string_escape ,
+	"\t",
+	    "Allow \\n \\t and \\xx\\ for special chars in string parsing"  } ,
+
+  { "Always-Headers",
+        &always_headers ,
+	"\t\t",
+	    "Override \"headerless\" and force to \"headers\"" } ,
+
+  { "Always-External",
+        &always_external ,
+	"\t\t",
+	    "Override \"headerless\" and \"headers\" and "
+		"force to \"external\"" } ,
+
+  { "Warn-if-Duplicate",
+        &verbose_dup_warning ,
+	"\t",
+	    "Display a WARNING message when a duplicate definition is made" } ,
+
+  { "Obsolete-FCode-Warning",
+        &obso_fcode_warning ,
+	"\t",
+	    "Display a WARNING message when an \"obsolete\" "
+		"(per the Standard) FCode is used" } ,
+
+  { "Trace-Conditionals",
+        &trace_conditionals,
+	"\t",
+	    "Display ADVISORY messages about the state of "
+		"Conditional Tokenization" } ,
+
+  { "Upper-Case-Token-Names",
+        &upper_case_tokens,
+	"\t",
+	    "Convert Token-Names to UPPER-Case" } ,
+
+
+  { "Lower-Case-Token-Names",
+        &lower_case_tokens,
+	"\t",
+	    "Convert Token-Names to lower-Case" } ,
+
+
+  { "Big-End-PCI-Rev-Level",
+        &big_end_pci_image_rev,
+	"\t",
+	    "Save the Vendor's Rev Level field of the PCI Header"
+		" in Big-Endian format" } ,
+
+
+  /*  Keep the "help" pseudo-flag last in the list  */
+  { "help",
+        &clflag_help,
+	    /*  Two extra tabs if the name is shorter than 8 chars  */
+	"\t\t\t",
+	    "Print this \"Help\" message for the Special-Feature Flags" }
+
+};
+
+static const int number_of_cl_flags =
+	 sizeof(cl_flags_list)/sizeof(cl_flag_t);
+
+
+/* **************************************************************************
+ *
+ *          CL Flags whose settings are changed in the source file should
+ *              not stay in effect for the duration of the entire batch of
+ *              tokenizations (i.e., if multiple input files are named on
+ *              the command line) the way command-line settings should.
+ *          To accomplish this we will collect the state of the flags into
+ *              a bit-mapped variable after the command line has been parsed
+ *              and restore them to their collected saved state before an
+ *              input file is processed.
+ *
+ **************************************************************************** */
+
+static long int cl_flags_bit_map;
+/*  If the number of CL Flags ever exceeds the number of bits in a long
+ *      (presently 32), we will need to change both this variable and
+ *      the routines that use it.  Of course, if the number of CL Flags
+ *      ever gets that high, it will be *seriously* unwieldy...   ;-}
+ */
+
+/* **************************************************************************
+ *
+ *      Function name:  adjust_case_flags
+ *      Synopsis:       If the last CL Flag Variable setting changed one of
+ *                          the "upper/lower-case-tokens" flags, make the 
+ *                          appropriate adjustments.
+ *
+ *      Inputs:
+ *         Parameters:                NONE
+ *         Local Static Variables:
+ *             was_upper_case_tk      State of "upper-case-tokens" flag before
+ *                                        last CL Flag Variable was processed
+ *             was_lower_case_tk      State of "lower-case-tokens" flag, before
+ *             upper_case_tokens      State of "upper-case-tokens" flag after
+ *                                        last CL Flag V'ble was processed
+ *             lower_case_tokens      State of "lower-case-tokens" flag, after
+ *         Global Variables:
+ *
+ *      Outputs:
+ *         Returned Value:            NONE
+ *         Global Variables:
+ *             force_tokens_case          TRUE if "upper/lower-case-tokens"
+ *                                            flag is in effect
+ *             force_lower_case_tokens    If force_tokens_case is TRUE, then
+ *                                            this switches between "upper"
+ *                                            or "lower" case
+ *
+ *      Process Explanation:
+ *          We cannot come out of this with both  upper_case_tokens  and
+ *               lower_case_tokens  being TRUE, though they may both be FALSE.
+ *          If neither has changed state, we need not do anything here.
+ *              If one has gone to TRUE, we must force the other to FALSE and
+ *                  we will set  force_tokens_case  to TRUE.
+ *              If one has gone to FALSE, turn  force_tokens_case  to FALSE.
+ *              If  force_tokens_case  is TRUE after all this, we must adjust
+ *                   force_lower_case_tokens  according to  lower_case_tokens
+ *
+ **************************************************************************** */
+
+static void adjust_case_flags( void)
+{
+    static bool *case_tokens[2] = { &upper_case_tokens, &lower_case_tokens };
+    static bool *was_case_tk[2] = { &was_upper_case_tk, &was_lower_case_tk };
+    int the_one = 0;
+    int the_other = 1;
+
+    for ( ; the_one < 2 ; the_one++ , the_other-- )
+    {
+	/*  If one has changed state   */
+	if ( *(case_tokens[the_one]) != *(was_case_tk[the_one]) )
+	{
+	    if ( *(case_tokens[the_one]) )
+	    {
+	        /*  If it has gone to TRUE, force the other to FALSE.  */
+		*(case_tokens[the_other]) = FALSE;
+	        /*      and set  force_tokens_case  to TRUE  */
+		force_tokens_case = TRUE;
+	    }else{
+		/*  If it has gone to FALSE turn  force_tokens_case FALSE  */
+		force_tokens_case = FALSE;
+	    }
+	    if ( force_tokens_case )
+	    {
+	        force_lower_case_tokens = lower_case_tokens;
+	    }
+	    break;  /*  Only one can have changed state.   */
+	}
+    }
+}
+
+
+
+
+/* **************************************************************************
+ *
+ *      Function name:  set_cl_flag
+ *      Synopsis:       Set (or clear) the named CL Flag Variable
+ *
+ *      Inputs:
+ *         Parameters:
+ *             flag_name           The name as supplied by the user
+ *             from_src            TRUE if called from source-input file
+ *         Static Constants:
+ *             cl_flags_list
+ *             number_of_cl_flags
+ *
+ *      Outputs:
+ *         Returned Value:         TRUE if supplied name is not valid
+ *         Global Variables:
+ *             The CL Flag Variable associated with the supplied name will
+ *                 be set or cleared according to the leading "no"
+ *         Local Static Variables:
+ *             cl_flag_change      TRUE if associated variable has changed
+ *         Printout:
+ *             If  from_src  is TRUE, print "En" or "Dis" abling:
+ *                 followed by the explanation
+ *
+ *      Error Detection:
+ *          If the supplied name is not a valid CL Flag name, or if
+ *              it's too short to be a valid CL Flag name, return TRUE.
+ *          Print a message;  either a simple print if this function was
+ *              called from a command-line argument, or an ERROR if it
+ *              was called from a line in the from source-input file.
+ *
+ *      Process Explanation:
+ *          Save the current state of the "upper/lower-case-tokens" flags
+ *          If the given name has a leading "no", make note of that fact
+ *              and remove the leading "no" from the comparison.
+ *          Compare with the list of valid CL Flag names.
+ *          If no match was found, Error.  See under Error Detection.
+ *          If a match:
+ *              Change the associated variable according to the leading "no"
+ *              Set  cl_flag_change  to TRUE  unless the variable is the one
+ *                  associated with the "help" flag; this permits the
+ *                  "Default" vs "Setting" part of  cl_flags_help() to
+ *                  work properly...
+ *              Do the conditional Printout (see above)
+ *          Adjust the "upper/lower-case-tokens" flags if one has changed.
+ *
+ **************************************************************************** */
+static bool first_err_msg = TRUE;  /*  Need extra carr-ret for first err msg  */
+bool set_cl_flag(char *flag_name, bool from_src)
+{
+    bool retval = TRUE;
+
+    was_upper_case_tk = upper_case_tokens;
+    was_lower_case_tk = lower_case_tokens;
+
+    if ( strlen(flag_name) > 3 )
+    {
+	int indx;
+	bool flagval = TRUE;
+	char *compar = flag_name;
+
+	if ( strncasecmp( flag_name, "no", 2) == 0 )
+	{
+	    flagval = FALSE;
+	    compar += 2;
+	}
+	for ( indx = 0 ; indx < number_of_cl_flags ; indx++ )
+	{
+	    if ( strcasecmp( compar, cl_flags_list[indx].clflag_name ) == 0 )
+	    {
+		retval = FALSE;
+		*(cl_flags_list[indx].flag_var) = flagval;
+
+		/*  The "help" flag is the last one in the list  */
+		if ( indx != number_of_cl_flags - 1 )
+		{
+		    cl_flag_change = TRUE;
+		}
+		if ( from_src )
+		{
+		    tokenization_error(INFO,
+		    "%sabling:  %s\n",
+		    flagval ? "En" : "Dis", cl_flags_list[indx].clflag_expln);
+		}
+		break;
+	    }
+	}
+    }
+
+    if ( retval )
+    {
+       const char* msg_txt = "Unknown Special-Feature Flag:  %s\n" ;
+       if ( from_src )
+       {
+           tokenization_error( TKERROR, (char *)msg_txt, flag_name);
+       }else{
+	   if ( first_err_msg )
+	   {
+	       printf( "\n");
+	       first_err_msg = FALSE;
+	   }
+	   printf( msg_txt, flag_name);
+       }
+    }
+
+    adjust_case_flags();
+
+    return ( retval );
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  show_all_cl_flag_settings
+ *      Synopsis:       Display the settings of the CL Flags, (except "help")
+ *                          regardless of whether they have been changed.
+ *
+ *      Associated Tokenizer directive(s):        [FLAGS]
+ *                                                #FLAGS
+ *                                                [#FLAGS]
+ *                                                SHOW-FLAGS
+ *          This routine may also be invoked by a combination of
+ *              options on the command-line.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             from_src                TRUE if called from source-input file
+ *         Macro:
+ *             ERRMSG_DESTINATION        Error message destination;
+ *                                           (Development-time switch)
+ *         Static Constants:
+ *             cl_flags_list
+ *             number_of_cl_flags
+ *
+ *      Outputs:
+ *         Returned Value:                  NONE
+ *         Printout:    Directed to  stdout or to stderr 
+ *                          (see definition of ERRMSG_DESTINATION)
+ *             A header line, followed by the names of the CL Flags,
+ *                  with "No" preceding name if value is FALSE, one to a line.
+ *
+ *      Process Explanation:
+ *          If from_src is TRUE, print the header line as a Message, and
+ *              then direct output to  ERRMSG_DESTINATION .
+ *          Don't print the "help" trigger (the last flag in the array).
+ *
+ **************************************************************************** */
+
+void show_all_cl_flag_settings(bool from_src)
+{
+    const char* hdr_txt = "Special-Feature Flag settings:" ;
+    int indx;
+
+    if ( from_src )
+    {
+	tokenization_error(MESSAGE, (char *)hdr_txt);
+    }else{
+	printf("\n%s\n", hdr_txt);
+    }
+
+    for ( indx = 0 ; indx < (number_of_cl_flags - 1) ; indx++ )
+    {
+	fprintf( from_src ? ERRMSG_DESTINATION : stdout ,
+	    "\t%s%s\n",
+		*(cl_flags_list[indx].flag_var) ? "  " : "No" ,
+		    cl_flags_list[indx].clflag_name );
+    }
+    if ( from_src )   fprintf( ERRMSG_DESTINATION, "\n");
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  list_cl_flag_settings
+ *      Synopsis:       Display the settings of the CL Flags, (except "help")
+ *                          if any of them have been changed
+ *
+ *      Inputs:
+ *         Parameters:                 NONE
+ *         Local Static Variables:        
+ *             cl_flag_change          TRUE if a Flag setting has been changed.
+ *
+ *      Outputs:
+ *         Returned Value:             NONE
+ *         Printout:
+ *             Settings of the CL Flags.  See   show_all_cl_flag_settings()
+ *
+ *      Process Explanation:
+ *          Don't print anything if  cl_flag_change  is not TRUE
+ *
+ **************************************************************************** */
+
+void list_cl_flag_settings(void)
+{
+
+    if ( cl_flag_change )
+    {
+	show_all_cl_flag_settings( FALSE);
+    }
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  list_cl_flag_names
+ *      Synopsis:       Display just the names of the CL Flags
+ *                      for the Usage message
+ *
+ *      Inputs:
+ *         Parameters:                      NONE
+ *         Static Constants:
+ *             cl_flags_list                
+ *             number_of_cl_flags           
+ *
+ *      Outputs:
+ *         Returned Value:                  NONE
+ *         Printout:
+ *             A header line, followed by the names of the CL Flags,
+ *
+ **************************************************************************** */
+
+void list_cl_flag_names(void)
+{
+    int indx;
+
+    printf("Valid Special-Feature Flags are:\n");
+    for ( indx = 0 ; indx < number_of_cl_flags ; indx++ )
+    {
+        printf("\t%s\n", cl_flags_list[indx].clflag_name );
+    }
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  cl_flags_help
+ *      Synopsis:       Display Usage of the CL Flags and their defaults
+ *                      
+ *
+ *      Inputs:
+ *         Parameters::                      NONE
+ *         Static Constants:
+ *             cl_flags_list
+ *             number_of_cl_flags
+ *         Local Static Variables:
+ *             cl_flag_change                TRUE if setting has been changed.
+ *
+ *      Outputs:
+ *         Returned Value:                   NONE
+ *         Printout:
+ *             A few lines of header, followed by the default, the name
+ *             and the "explanation" of each of the CL Flags, one to a line.
+ *
+ *      Extraneous Remarks:
+ *          We take advantage of the facts that this routine is called
+ *              (1) only from the command-line, before any settings
+ *              have been changed, and (2) via changing the flag for
+ *              "help" to TRUE.  (Technically, I suppose, the default
+ *              for the "help" feature is "no", but showing will, I
+ *              think be more confusing than enlightening to the user.)
+ *          Also, I suppose a perverse user could change setting(s) on
+ *              the same command-line with a "-f help" request; we cannot
+ *              stop users from aiming at their boot and pulling the
+ *              trigger.  As my buddies in Customer Support would say:
+ *              "KMAC YOYO"  (Approximately, "You're On Your Own, Clown")...
+ *
+ *      Revision History:
+ *          Oh, all right.  If the user changed setting(s), we can do
+ *              them the minor courtesy of printing "Setting" instead
+ *              of "Default".
+ *
+ *
+ **************************************************************************** */
+
+void cl_flags_help(void )
+{
+    int indx;
+
+    printf("\n"
+           "Special-Feature Flags usage:\n"
+           "  -f   FlagName   to enable the feature associated with FlagName,\n"
+           "or\n"
+           "  -f noFlagName   to disable the feature.\n\n"
+                "%s   Flag-Name\t\t  Feature:\n\n",
+	            cl_flag_change ? "Setting" : "Default" );
+
+   for ( indx = 0 ; indx < number_of_cl_flags ; indx++ )
+    {
+	printf("  %s    %s%s%s\n",
+	    *(cl_flags_list[indx].flag_var) ? "  " : "no" ,
+	    cl_flags_list[indx].clflag_name,
+	    cl_flags_list[indx].clflag_tabs,
+	    cl_flags_list[indx].clflag_expln);
+    }
+
+}
+
+
+
+/* **************************************************************************
+ *
+ *      Function name:  save_cl_flags
+ *      Synopsis:       Collect the state of the CL Flags
+ *
+ *      Inputs:
+ *         Parameters:                     NONE
+ *         Local Static Variables:
+ *             cl_flags_list
+ *         Static Constants:
+ *             number_of_cl_flags
+ *
+ *      Outputs:
+ *         Returned Value:                 NONE
+ *         Local Static Variables:
+ *             cl_flags_bit_map            Will be set to reflect the state
+ *                                             of the CL Flags in the list.
+ *
+ *      Process Explanation:
+ *          The correspondence of bits to the list is that the first item
+ *              in the list corresponds to the low-order bit, and so on
+ *              moving toward the high-order with each successive item.
+ *          Do not save the "help" flag (last item on the list).
+ *          This routine is called after the command line has been parsed.
+ *
+ **************************************************************************** */
+
+void save_cl_flags(void)
+{
+    int indx;
+    long int moving_bit = 1;
+
+    cl_flags_bit_map = 0;
+    for ( indx = 0 ; indx < (number_of_cl_flags - 1) ; indx++ )
+    {
+	if ( *(cl_flags_list[indx].flag_var) )
+	{
+	    cl_flags_bit_map |= moving_bit;  /*  The moving finger writes,  */
+	}
+	moving_bit <<= 1;                    /*  and having writ, moves on. */
+    }
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  reset_cl_flags
+ *      Synopsis:       Restore the CL Flags to the state that was saved.
+ *
+ *      Inputs:
+ *         Parameters:                     NONE
+ *         Local Static Variables:
+ *             cl_flags_bit_map            Reflects the state of the CL Flags
+ *         Static Constants:
+ *             number_of_cl_flags
+ *
+ *      Outputs:
+ *         Returned Value:                  NONE
+ *         Local Static Variables:
+ *             cl_flags_list
+ *         Global Variables:
+ *             The CL Flag Variables will be set or cleared
+ *                 to their saved state
+ *
+ *      Process Explanation:
+ *          This routine is called before starting a new input file.
+ *              Any changes made in the source file will not stay
+ *              in effect for the next tokenization.
+ *
+ **************************************************************************** */
+
+void reset_cl_flags(void)
+{
+    int indx;
+    long int moving_bit = 1;
+
+    for ( indx = 0 ; indx < (number_of_cl_flags - 1) ; indx++ )
+    {
+	*(cl_flags_list[indx].flag_var) =
+	    BOOLVAL( cl_flags_bit_map & moving_bit) ;
+	moving_bit <<= 1;
+    }
+}
diff --git a/toke/clflags.h b/toke/clflags.h
new file mode 100644
index 0000000..26f923d
--- /dev/null
+++ b/toke/clflags.h
@@ -0,0 +1,144 @@
+#ifndef _TOKE_CLFLAGS_H
+#define _TOKE_CLFLAGS_H
+
+/*
+ *                     OpenBIOS - free your system!
+ *                         ( FCode tokenizer )
+ *
+ *  This program is part of a free implementation of the IEEE 1275-1994
+ *  Standard for Boot (Initialization Configuration) Firmware.
+ *
+ *  Copyright (C) 2001-2005 Stefan Reinauer, <stepan@openbios.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ *
+ */
+
+/* **************************************************************************
+ *
+ *      Function Prototypes and External declarations
+ *          for Command-Line Flags Support
+ *
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Module Author:  David L. Paktor    dlpaktor@us.ibm.com
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      Structure-Types:
+ *          cl_flag_t            Data for recognizing and setting Command-Line
+ *                                   Flags, and for displaying the help message
+ *
+ *      Function Prototypes / Functions Exported:
+ *          set_cl_flag
+ *          list_cl_flag_settings
+ *          list_cl_flag_names          Display just the names of the CL Flags
+ *          cl_flags_help
+ *
+ *      Global Variables Exported
+ *                (These flags, which are set by the set_cl_flag() routine,
+ *                     are used throughout the Tokenizer to control certain
+ *                     non-Standard variant behaviors.)
+ *          ibm_locals
+ *          ibm_locals_legacy_separator
+ *          ibm_legacy_separator_message
+ *          enable_abort_quote
+ *          sun_style_abort_quote
+ *          string_remark_escape
+ *          hex_remark_escape
+ *          c_style_string_escape
+ *          always_headers
+ *          always_external
+ *          verbose_dup_warning
+ *          obso_fcode_warning
+ *          trace_conditionals
+ *          force_tokens_case
+ *          force_lower_case_tokens
+ *          big_end_pci_image_rev
+ *          clflag_help
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *          Structure-Type Name:    cl_flag_t
+ *               Data for recognizing and setting Command-Line Flags,
+ *                   and for displaying the help message
+ *
+ *   Fields:
+ *       clflag_name     *char          CL Flag name, as entered by the user
+ *       flag_var        *bool          Address of boolean ("flag") variable
+ *       clflag_tabs     *char          Tabs to align the explanations, in
+ *                                          the help message display
+ *       clflag_expln    *char          Explanation, used in help message
+ *
+ *   Since this structure will be initialized by the program, and will not
+ *       be added-to, we can structure it as purely an array, and have no
+ *       need to treat it as a linked list, hence no link-field.
+ *
+ **************************************************************************** */
+
+#include "types.h"
+
+typedef struct cl_flag
+    {
+	char             *clflag_name;
+	bool             *flag_var;
+	char             *clflag_tabs;
+	char             *clflag_expln;
+    }  cl_flag_t ;
+
+
+/* **************************************************************************
+ *
+ *          Exported Global Variables
+ *
+ **************************************************************************** */
+
+extern bool ibm_locals;
+extern bool ibm_locals_legacy_separator;
+extern bool ibm_legacy_separator_message;
+extern bool enable_abort_quote;
+extern bool sun_style_abort_quote;
+extern bool abort_quote_throw;
+extern bool string_remark_escape;
+extern bool hex_remark_escape;
+extern bool c_style_string_escape;
+extern bool always_headers;
+extern bool always_external;
+extern bool verbose_dup_warning;
+extern bool obso_fcode_warning;
+extern bool trace_conditionals;
+extern bool big_end_pci_image_rev;
+
+extern bool force_tokens_case;
+extern bool force_lower_case_tokens;
+
+extern bool clflag_help;
+
+/* **************************************************************************
+ *
+ *          Exported Functions
+ *
+ **************************************************************************** */
+
+bool set_cl_flag(char *flag_name, bool print_message);
+void cl_flags_help(void);
+void list_cl_flag_names(void);
+void show_all_cl_flag_settings(bool from_src);
+void list_cl_flag_settings(void);
+void save_cl_flags(void);
+void reset_cl_flags(void);
+
+#endif   /*  _TOKE_CLFLAGS_H    */
diff --git a/toke/conditl.c b/toke/conditl.c
new file mode 100644
index 0000000..669494c
--- /dev/null
+++ b/toke/conditl.c
@@ -0,0 +1,772 @@
+/*
+ *                     OpenBIOS - free your system!
+ *                         ( FCode tokenizer )
+ *
+ *  This program is part of a free implementation of the IEEE 1275-1994
+ *  Standard for Boot (Initialization Configuration) Firmware.
+ *
+ *  Copyright (C) 2001-2005 Stefan Reinauer, <stepan@openbios.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ *
+ */
+
+/* **************************************************************************
+ *
+ *      Conditional-Compilation support for Tokenizer
+ *
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Module Author:  David L. Paktor    dlpaktor@us.ibm.com
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      Functions Exported:
+ *          init_conditionals_vocab    Initialize the "Conditionals" Vocabulary.
+ *          handle_conditional         Confirm whether a given name is a valid
+ *                                         Conditional, and, if so, perform its
+ *                                         function and return an indication.
+ *          create_conditional_alias   Add an alias to "Conditionals" vocab
+ *          reset_conditionals         Reset the "Conditionals" Vocabulary
+ *                                         to its "Built-In" position.
+ *
+ **************************************************************************** */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <string.h>
+#include <errno.h>
+
+#include "scanner.h"
+#include "errhandler.h"
+#include "ticvocab.h"
+#include "conditl.h"
+#include "stack.h"
+#include "dictionary.h"
+#include "vocabfuncts.h"
+#include "usersymbols.h"
+#include "stream.h"
+#include "clflags.h"
+
+/* **************************************************************************
+ *
+ *          Global Variables Imported
+ *              statbuf               Start of input-source buffer
+ *              pc                    Input-source Scanning pointer
+ *              iname                 Current Input File name
+ *              lineno                Current Line Number in Input File
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *              Local Static Variables
+ *      already_ignoring      Location from which to pass a parameter,
+ *                            called "alr_ign" to the main routine.  Each
+ *                            "Conditional" will have an associated routine
+ *                            that takes the pointer to this as its argument.
+ *                            The pointer to this will satisfy the "param-field"
+ *                            requirement of a TIC_HDR-style "Vocabulary"-list.
+ *      conditionals_tbl      TIC_HDR-style "Vocabulary"-list table, initialized
+ *                            as an array.
+ *      conditionals          Pointer to "tail" of Conditionals Vocabulary-list
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      The lists of synonymous forms of the #ELSE and #THEN operators
+ *          are incorporated into the "Shared Words" Vocabulary.
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      Function name:  is_a_then  /  is_an_else
+ *      Synopsis:       Indicate whether the given name is one of the
+ *                      [then] / [else]  synonyms
+ *      
+ *      Inputs:
+ *         Parameters:
+ *             a_word                        Word to test
+ *
+ *      Outputs:
+ *         Returned Value:       TRUE if the given name is one of the synonyms
+ *
+ *      Process Explanation:
+ *          The functions are twins, hence bundling them like this...
+ *
+ **************************************************************************** */
+
+
+/* **************************************************************************
+ *
+ *      Support function:  is_a_type
+ *      Synopsis:          Indicate whether the given name is a "shared word"
+ *                         whose FWord Token matches the one given
+ *
+ *      Inputs:
+ *         Parameters:
+ *             tname                        Target name to look for
+ *             fw_type                      The FWord Token type to match
+ *
+ *      Outputs:
+ *         Returned Value:                  TRUE if it matches
+ *
+ **************************************************************************** */
+
+
+static bool is_a_type( char *tname, fwtoken fw_type)
+{
+    bool retval = FALSE;
+    tic_fwt_hdr_t *found = (tic_fwt_hdr_t *)lookup_shared_f_exec_word( tname );
+    if ( found != NULL )
+    {
+        if ( found->pfield.fw_token == fw_type )  retval = TRUE;
+    }
+    return ( retval );
+}
+
+static bool is_a_then( char *a_word)
+{
+    bool retval = is_a_type( a_word, CONDL_ENDER);
+    return ( retval );
+}
+
+static bool is_an_else( char *a_word)
+{
+    bool retval = is_a_type( a_word, CONDL_ELSE);
+    return ( retval );
+}
+
+/* **************************************************************************
+ *
+ *     This is a somewhat roundabout way of passing an "already ignoring"
+ *         parameter to the various Conditional Operators.  Each operator's
+ *         Parameter-Field Pointer points to this.  The calling routine
+ *         must set it (or rely on the default); the routine that handles
+ *         nesting of Conditionals must save and restore a local copy.
+ *
+ **************************************************************************** */
+
+static bool already_ignoring = FALSE;
+
+/* **************************************************************************
+ *
+ *      Further down, will define and initialize a word-list table with
+ *          all the functions that implement the Conditional Operators,
+ *          and we'll link it in with the "Global Vocabulary" pointer.
+ *
+ *      We'll call the word-list the "Conditionals Vocabulary Table",
+ *          and refer to its entries as the "Conditionals Vocabulary",
+ *          even though it isn't really a separate vocabulary...
+ * 
+ **************************************************************************** */
+
+
+/* **************************************************************************
+ *
+ *      We also need a few common routines to pass as "Ignoring" functions
+ *          for a few occasional words that take another word or two from
+ *          the input stream as their arguments.  For example, if the user
+ *          were to write:   alias [otherwise] [else]   and that were to
+ *          occur within a segment already being ignored, we need to make
+ *          sure that this doesn't get processed as an occurrence of  [else]
+ *          Similarly with macro-definitions.
+ *
+ *      Since we are using the term "ignore a word" to mean "look it up and
+ *          process it in Ignoring-state", we need a different term to name
+ *          this class of routine; let's use the term "skip a word" where
+ *          the "word" is strictly an input token, delimited by whitespace.
+ *
+ **************************************************************************** */
+ 
+/* **************************************************************************
+ *
+ *      Function name:  skip_a_word
+ *      Synopsis:       Consume one input-token ("word") from the
+ *                          Input Stream, with no processing
+ *
+ *      Inputs:
+ *         Parameters:
+ *             pfield             "Parameter field" pointer, to satisfy
+ *                                    the calling convention, but not used
+ *
+ *      Outputs:
+ *         Returned Value:        NONE
+ *
+ **************************************************************************** */
+
+void skip_a_word( tic_bool_param_t pfield )
+{
+    /* signed long wlen = */ get_word();
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  skip_a_word_in_line
+ *      Synopsis:       Consume one input-token ("word") on the same line
+ *                          as the current line of input, from the Input
+ *                          Stream, with no processing.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             pfield             "Parameter field" pointer, to satisfy
+ *                                    the calling convention, but not used
+ *         Global Variables:
+ *             statbuf            The word being processed, which expects
+ *                                    another word on the same line; used
+ *                                    for the Error message.
+ *
+ *      Outputs:
+ *         Returned Value:        NONE
+ *
+ *      Error Detection:
+ *          get_word_in_line() will check and report if no word on same line.
+ *
+ **************************************************************************** */
+void skip_a_word_in_line( tic_bool_param_t pfield )
+{
+    /* bool isokay = */ get_word_in_line( statbuf);
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  skip_two_words_in_line
+ *      Synopsis:       Consume two input-tokens ("words") on the same line
+ *                          as the current line of input, from the Input
+ *                          Stream, with no processing.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             pfield             "Parameter field" pointer, to satisfy
+ *                                    the calling convention, but not used
+ *         Global Variables:
+ *             statbuf            The word being processed, which expects
+ *                                    two words on the same line; used for
+ *                                    the Error message.
+ *
+ *      Outputs:
+ *         Returned Value:         NONE
+ *         Memory Allocated
+ *             Copy of  statbuf  for Error message.
+ *         When Freed?
+ *             End of this routine
+ *
+ *      Error Detection:
+ *          get_word_in_line() will check and report
+ *
+ **************************************************************************** */
+
+void skip_two_words_in_line( tic_bool_param_t pfield )
+{
+    char *func_cpy = strupr( strdup( statbuf));
+    if ( get_word_in_line( func_cpy) )
+    {
+        /* bool isokay = */ get_word_in_line( func_cpy);
+    }
+    free( func_cpy);
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  ignore_one_word
+ *      Synopsis:       Handle a word that needs processing while "ignoring"
+ *                          Ignore the rest.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             tname                  Target name to test
+ *         Local Static Variables:
+ *             already_ignoring       The "Already Ignoring" flag
+ *
+ *      Outputs:
+ *         Returned Value:            NONE
+ *         Global Variables:
+ *             tic_found              Set to the TIC-entry that has just been
+ *                                        found, in case it's a Macro.
+ *         Local Static Variables:
+ *             already_ignoring       Intermediately set to TRUE, then
+ *                                        returned to former state.
+ *
+ *      Process Explanation:
+ *          When we are ignoring source input, we still need to be
+ *              sensitive to the nesting of Conditional Operators, to
+ *              consume comments and user -message text-bodies, and to
+ *              expand Macros, among other things.
+ *         Rather than create special cases here for each one, we have
+ *              added an "ign_funct" pointer to those words where this
+ *              is relevant, including Conditional Operators. 
+ *          Save the state of  already_ignoring  and set it to TRUE
+ *              Execute the "Ignoring" Function associated with the entry
+ *              Restore  already_ignoring  to its previous state.
+ *          This is necessary if the word is a Conditional Operator and
+ *              is harmless otherwise.
+ *
+ **************************************************************************** */
+
+static void ignore_one_word( char *tname)
+{
+    tic_bool_hdr_t *found = (tic_bool_hdr_t *)lookup_word( tname, NULL, NULL);
+    if ( found != NULL )
+    {
+        if ( found->ign_func != NULL )
+	{
+	    bool save_already_ignoring = already_ignoring;
+	    already_ignoring = TRUE ;
+	    tic_found = (tic_hdr_t *)found;
+
+	    found->ign_func( found->pfield);
+
+	    already_ignoring = save_already_ignoring;
+	}
+    }
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  conditionally_tokenize
+ *      Synopsis:       Conduct tokenization while a Conditional-Tokenization
+ *                          operator is in effect.  This is the core of the
+ *                          implementation of Conditional-Tokenization.
+ *      
+ *      Inputs:
+ *         Parameters:
+ *             cond             The state of the Condition-Flag that the
+ *                                  immediate Conditional Operator acquired.
+ *                                  TRUE means "do not ignore".  Its sense
+ *                                  is reversed when [ELSE] is encountered.
+ *             alr_ign          TRUE means we are Already Ignoring source input,
+ *                                  except for Conditional Operators...
+ *         Global Variables:
+ *             statbuf       The symbol (word) just retrieved from input stream.
+ *             iname         Current Input File name (for Error Messages)
+ *             lineno        Current Line Number in Input File (ditto)
+ *             trace_conditionals   Whether to issue ADVISORY messages about
+ *                                      the state of Conditional Tokenization.
+ *
+ *      Outputs:
+ *         Returned Value:       NONE
+ *         Global Variables:
+ *             statbuf           Will be advanced to the balancing [THEN] op'r.
+ *             already_ignoring  Set to TRUE if nested Conditional encountered;
+ *                                  restored to previous state when done.
+ *         Memory Allocated
+ *             Duplicate of Input File name, for Error Messages
+ *         When Freed?
+ *             Just prior to exit from routine.
+ *         Printout:
+ *             ADVISORY messages, if "Trace-Conditionals" flag was selected.
+ *             
+ *         Global Behavior:
+ *            Tokenization happens, or inputs are ignored, as necessary.
+ *
+ *      Error Detection:
+ *          End-of-file encountered on reading a word    
+ *              ERROR.  Conditional Operators must be balanced within a file
+ *          More than one [ELSE] encountered:  ERROR if processing segment;
+ *              if ignoring, WARNING.
+ *
+ *      Process Explanation:
+ *          Read a word at a time.   Allow Macros to "pop" transparently,
+ *              but not source files.
+ *          If the word is a [THEN], we are done.
+ *          If the word is an [ELSE], then, if we are not Already Ignoring,
+ *                  invert the sense of whether we are ignoring source input. 
+ *              If this is not the only [ELSE] in the block, report an Error
+ *                  and disregard it.
+ *          If we are ignoring source input, for whatever reason, we still
+ *              need to be sensitive to the nesting of Conditional Operators:
+ *              If the word is a Conditional Operator, activate it with the
+ *                  "Already Ignoring" parameter set to TRUE; doing so will
+ *                  result in a nested call to this routine.
+ *              Otherwise, i.e., if the word is not a Conditional Operator,
+ *                  we may still need to process it in "ignoring" mode:
+ *                  we need, for instance, to consume strings, comments
+ *                  and the text-bodies of user-messages in their entirety,
+ *                  in case there is a reference to an [ELSE] or suchlike.
+ *                  The words that need processing while "ignoring" will
+ *                  have a valid function-pointer in their ign_func field.
+ *          If we are not ignoring source input, pass the word along to the
+ *              tokenize_one_word routine and process it.  If the word is
+ *              a Conditional Operator, it will be handled in the context
+ *              of normal (i.e., non-ignored) tokenization, and, again, a
+ *              nested call to this routine will result...
+ *
+ *      Revision History:
+ *          Updated Thu, 23 Feb 2006 by David L. Paktor
+ *              Conditional Blocks may begin with a Conditional Operator in
+ *                  a Macro definition and do not need to be concluded in
+ *                  the body of the Macro.
+ *          Updated Fri, 10 Mar 2006 by David L. Paktor
+ *              Recognize aliased string, comment and user-message delimiters
+ *                  in a segment that is being ignored; Conditional Operators
+ *                  within the text body of any of these are always consumed
+ *                  and never unintentionally processed.  Macros are always
+ *                  processed; Conditional Operators inside a Macro body are
+ *                  recognized, so the Macro continues to function as intended.
+ *
+ **************************************************************************** */
+
+static void conditionally_tokenize( bool cond, bool alr_ign )
+{
+    
+    signed long wlen;
+
+    /*  Note:  The following variables *must* remain within
+     *      the scope of this routine; a distinct instance
+     *      is needed each time this routine is re-entered
+     *     (aka "a nested call").
+     */
+    bool ignoring;
+    bool first_else = TRUE;  /*  The "else" we see is the first.  */
+    bool not_done = TRUE;
+    unsigned int cond_strt_lineno = lineno;
+    char *cond_strt_ifile_nam = strdup( iname);
+
+    ignoring = BOOLVAL( ( cond == FALSE ) || ( alr_ign != FALSE ) );
+
+    if ( trace_conditionals )
+    {
+        char *cond_val = cond ? "True" : "False" ;
+	char *cond_junct = alr_ign ? ", but Already " : "; ";
+	char *processg = ignoring ? "Ignoring" : "Processing" ;
+	tokenization_error( INFO,
+	    "Tokenization-Condition is %s%s%s.\n",
+		cond_val, cond_junct, processg);
+    }
+
+    while ( not_done )
+    {
+        wlen = get_word();
+	if ( wlen == 0 )
+	{
+	    continue;
+	}
+
+	if ( wlen < 0 )
+	{
+	    tokenization_error( TKERROR,
+	        "Conditional without conclusion; started");
+	    just_where_started( cond_strt_ifile_nam, cond_strt_lineno);
+	    not_done = FALSE ;
+	    continue;
+	}
+
+	if ( is_a_then ( statbuf ) )
+	{
+	    if ( trace_conditionals )
+	    {
+		tokenization_error( INFO,
+		    "Concluding Conditional");
+		just_started_at( cond_strt_ifile_nam, cond_strt_lineno);
+	    }
+	    not_done = FALSE ;
+	    continue;
+	}
+
+	if ( is_an_else( statbuf ) )
+	{
+	    if ( ! alr_ign )
+	    {
+		if ( first_else )
+		{
+		    ignoring = INVERSE( ignoring);
+		}
+	    }
+
+	    if ( ! first_else )
+	    {
+		int severity = ignoring ? WARNING : TKERROR ;
+		char *the_scop = ignoring ? "(ignored)" : "the" ;
+		tokenization_error( severity, "Multiple %s directives "
+		    "within %s scope of the Conditional",
+			 strupr(statbuf), the_scop);
+		just_started_at( cond_strt_ifile_nam, cond_strt_lineno);
+	    }else{
+		first_else = FALSE;
+		if ( trace_conditionals )
+		{
+		    char *when_enc = alr_ign ? "While already" : "Now" ;
+		    char *processg = alr_ign ? "ignoring" :
+				    ignoring ? "Ignoring" : "Processing" ;
+		    char *enc       = alr_ign ? ", e" : ".  E" ;
+
+		    tokenization_error( INFO,
+			"%s %s%sncountered %s belonging to Conditional",
+			    when_enc, processg, enc, strupr(statbuf) );
+		    just_started_at( cond_strt_ifile_nam, cond_strt_lineno);
+		}
+	    }
+
+	    continue;
+	}
+
+	/*  If we are ignoring source input, for whatever reason, we still
+	 *      need to be sensitive to the nesting of Conditional Operators
+	 *      and some other commands and directives, as indicated...
+	 */
+	if ( ignoring )
+	{
+	    ignore_one_word( statbuf );
+	}else{
+	    /*  And if we're not ignoring source input, process it! */
+	    tokenize_one_word ( wlen );
+	}
+    }
+}
+
+/* **************************************************************************
+ *
+ *      We will now define a series of fairly simple functions that
+ *          will be performed by the various Conditional Operators in
+ *          the "Conditionals Vocabulary".
+ *
+ *      Each one takes, as an argument, the "parameter field" pointer,
+ *          which, in all cases, points to the local  already_ignoring 
+ *          flag, passed as an int to satisfy C's strong-typing.  The
+ *          routine will internally recast it as a  bool .
+ *
+ *      If it is TRUE, the routine will bypass the test for its particular
+ *          type of condition, and go directly to  conditionally_tokenize
+ *          In most cases, testing for the condition would be harmless,
+ *          but in the case where the test is for an item on the stack,
+ *          it would be harmful because the sequence that put the item
+ *          on the stack was also being ignored...
+ *
+ *      We'll give these functions short prologs.  Synonyms will simply
+ *          have separate entries in the Vocabulary Table, associated
+ *          with the same function.
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      But first, a support routine...
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      Function name:  conditional_word_in_line
+ *      Synopsis:       Common code for the types of conditionals that
+ *                          require a word on the same line.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             alr_ign         TRUE if we are already ignoring
+ *             exist_test      TRUE if the test is for "existence" of the word
+ *             exist_funct     Name of the function to call for the test
+ *         Global Variables:
+ *             stat_word       Word for which to test
+ *
+ *      Outputs:
+ *         Returned Value:     NONE
+ *
+ *      Error Detection:
+ *          The word in question must appear on the same line as the directive;
+ *              the call to  get_word_in_line()  checks for that and reports.
+ *          If the word did not appear on the same line, then the directive
+ *              will be disregarded and processing will proceed as though it
+ *              were absent.  This may lead to a cascade of errors...
+ *
+ *      Process Explanation:
+ *          The supplied  exist_funct()  will test for the existence of
+ *              the word, now read into  statbuf , in the appropriate 
+ *              venue.
+ *          We only call the  exist_funct()  if we are not already ignoring.
+ *
+ **************************************************************************** */
+
+static void conditional_word_in_line( bool alr_ign,
+                                          bool exist_test,
+                                              bool (*exist_funct)() )
+{
+    if ( get_word_in_line( statbuf) )
+    {
+    	bool cond = FALSE;
+	if ( INVERSE( alr_ign) )
+	{
+	    bool exists = exist_funct( statbuf);
+	    cond = BOOLVAL( exists == exist_test);
+	}
+	conditionally_tokenize( cond, alr_ign );
+    }
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  if_exists
+ *      Synopsis:       Test for existence of a given word, in the dictionary.
+ *
+ *      Associated Tokenizer directives:        [ifexist]
+ *                                              #ifexist
+ *                                              [#ifexist]
+ *                                              [ifexists]
+ *                                              #ifexists
+ *                                              [#ifexists]
+ *        (Note variants with and without final 's'
+ *
+ **************************************************************************** */
+
+static void if_exists( tic_param_t pfield )
+{
+    bool alr_ign = *pfield.bool_ptr;
+    conditional_word_in_line( alr_ign, TRUE, exists_in_current );
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  if_not_exist
+ *      Synopsis:       Test for Non-existence, in the appropriate dictionary,)
+ *                          of the given word.
+ *
+ *      Associated Tokenizer directives:        [ifnexist]
+ *                                              #ifnexist
+ *                                              [#ifnexist]
+ *        (Note:  Variants with final 's' didn't make sense here.)
+ *
+ *      Explanatory Notes:
+ *          This is the exact inverse of  if_exists
+ *
+ **************************************************************************** */
+
+static void if_not_exist( tic_bool_param_t pfield )
+{
+    bool alr_ign = *pfield.bool_ptr;
+    conditional_word_in_line( alr_ign, FALSE, exists_in_current );
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  if_defined
+ *      Synopsis:       Test for existence of a user-defined symbol
+ *
+ *      Associated Tokenizer directives:        [ifdef]
+ *                                              #ifdef
+ *                                              [#ifdef]
+ *
+ **************************************************************************** */
+
+static void if_defined( tic_bool_param_t pfield )
+{
+    bool alr_ign = *pfield.bool_ptr;
+    conditional_word_in_line( alr_ign, TRUE, exists_as_user_symbol );
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  if_not_defined
+ *      Synopsis:       Test for NON-existence of a user-defined symbol
+ *
+ *      Associated Tokenizer directives:        [ifndef]
+ *                                              #ifndef
+ *                                              [#ifndef]
+ *
+ **************************************************************************** */
+
+static void if_not_defined( tic_bool_param_t pfield )
+{
+    bool alr_ign = *pfield.bool_ptr;
+    conditional_word_in_line( alr_ign, FALSE, exists_as_user_symbol );
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  if_from_stack
+ *      Synopsis:       Test the number on top of the run-time stack
+ *
+ *      Associated Tokenizer directive:         [if]
+ *
+ *      Process Explanation:
+ *          When we are ignoring source input, and we still need to be
+ *              sensitive to the nesting of Conditional Operators, we
+ *              will not consume the number on the stack; this function
+ *              is after all, being ignored and should not perform any
+ *              action other than making sure the [else]s and [then]s
+ *              get properly counted.
+ *
+ **************************************************************************** */
+
+static void if_from_stack( tic_bool_param_t pfield )
+{
+    bool alr_ign = *pfield.bool_ptr;
+    bool cond = FALSE;
+
+    if ( ! alr_ign )
+    {
+        long num = dpop();
+	if (num != 0)
+	{
+	    cond = TRUE;
+	}
+    }
+    conditionally_tokenize( cond, alr_ign );
+}
+
+/*  For future functions, use  conditl.BlankTemplate.c  */
+
+/* **************************************************************************
+ *
+ *      Here, at long last, we define and initialize the structure containing
+ *          all the functions we support for Conditional Operators.
+ *
+ **************************************************************************** */
+
+#define ADD_CONDL(str, func )   BUILTIN_BOOL_TIC(str, func, already_ignoring )
+
+static tic_bool_hdr_t conditionals_vocab_tbl[] = {
+    ADD_CONDL ("[ifexist]"   , if_exists      ) ,
+    ADD_CONDL ("[ifexists]"  , if_exists      ) ,
+    ADD_CONDL ("#ifexist"    , if_exists      ) ,
+    ADD_CONDL ("#ifexists"   , if_exists      ) ,
+    ADD_CONDL ("[#ifexist]"  , if_exists      ) ,
+    ADD_CONDL ("[#ifexists]" , if_exists      ) ,
+    ADD_CONDL ("[ifnexist]"  , if_not_exist   ) ,
+    ADD_CONDL ("#ifnexist"   , if_not_exist   ) ,
+    ADD_CONDL ("[#ifnexist]" , if_not_exist   ) ,
+    ADD_CONDL ("[ifdef]"     , if_defined     ) ,
+    ADD_CONDL ("#ifdef"      , if_defined     ) ,
+    ADD_CONDL ("[#ifdef]"    , if_defined     ) ,
+    ADD_CONDL ("[ifndef]"    , if_not_defined ) ,
+    ADD_CONDL ("#ifndef"     , if_not_defined ) ,
+    ADD_CONDL ("[#ifndef]"   , if_not_defined ) ,
+    ADD_CONDL ("[if]"        , if_from_stack  )
+};
+
+
+/* **************************************************************************
+ *
+ *      Function name:  init_conditionals_vocab
+ *      Synopsis:       Initialize the "Conditionals Vocabulary Table"
+ *                          link-pointers dynamically, and link it in
+ *                          with the given ("Global") Vocabulary pointer.
+ *
+ **************************************************************************** */
+
+void init_conditionals_vocab( tic_hdr_t **tic_vocab_ptr )
+{
+    static const int conditionals_vocab_max_indx =
+	 sizeof(conditionals_vocab_tbl)/sizeof(tic_bool_hdr_t);
+
+    init_tic_vocab( (tic_hdr_t *)conditionals_vocab_tbl,
+                        conditionals_vocab_max_indx,
+                            tic_vocab_ptr );
+}
+
diff --git a/toke/conditl.h b/toke/conditl.h
new file mode 100644
index 0000000..cfb1db5
--- /dev/null
+++ b/toke/conditl.h
@@ -0,0 +1,46 @@
+#ifndef _TOKE_CONDITL_H
+#define _TOKE_CONDITL_H
+
+/*
+ *                     OpenBIOS - free your system!
+ *                         ( FCode tokenizer )
+ *
+ *  This program is part of a free implementation of the IEEE 1275-1994
+ *  Standard for Boot (Initialization Configuration) Firmware.
+ *
+ *  Copyright (C) 2001-2005 Stefan Reinauer, <stepan@openbios.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ *
+ */
+
+/* **************************************************************************
+ *
+ *      Function Prototypes for Conditional-Compilation support for Tokenizer
+ *
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Module Author:  David L. Paktor    dlpaktor@us.ibm.com
+ *
+ **************************************************************************** */
+
+#include "types.h"
+#include "ticvocab.h"
+
+void init_conditionals_vocab( tic_hdr_t **tic_vocab_ptr );
+
+void skip_a_word( tic_bool_param_t pfield );
+void skip_a_word_in_line( tic_bool_param_t pfield );
+void skip_two_words_in_line( tic_bool_param_t pfield );
+
+#endif   /* _TOKE_CONDITL_H    */
diff --git a/toke/devnode.c b/toke/devnode.c
new file mode 100644
index 0000000..54ec03f
--- /dev/null
+++ b/toke/devnode.c
@@ -0,0 +1,595 @@
+/*
+ *                     OpenBIOS - free your system!
+ *                         ( FCode tokenizer )
+ *
+ *  This program is part of a free implementation of the IEEE 1275-1994
+ *  Standard for Boot (Initialization Configuration) Firmware.
+ *
+ *  Copyright (C) 2001-2005 Stefan Reinauer, <stepan@openbios.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ *
+ */
+
+/* **************************************************************************
+ *
+ *      Support routines for managing device-node vocabularies
+ *
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Module Author:  David L. Paktor    dlpaktor@us.ibm.com
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      The vocabulary that is created for a device-node must not remain
+ *          available outside of that node.  Also, nodes may be nested,
+ *          child within parent.
+ *      An attempt within a child-node to access directly a method defined
+ *          in the parent must be flagged as an error.  (Consider what would
+ *          happen if the method in the parent-node used instance data, and
+ *          the child-node has an instance of its own.)
+ *      The correct way is to invoke the method via "$call-parent" or the like.
+ *
+ *      We will, however, allow the user to specify a group of exceptions,
+ *          words whose scope will be "global" within the tokenization.
+ *          When "global" scope is initiated, definitions will be made to
+ *          the "core" vocabulary until "device" scope is resumed.
+ *          That will (mostly) all be handled in  dictionary.c 
+ *
+ **************************************************************************** */
+
+
+/* **************************************************************************
+ *
+ *      Functions Exported:
+ *          new_device_vocab        Create the new device-node's data-structure
+ *          delete_device_vocab     Remove device-node's data-structure
+ *          finish_device_vocab     Remove struct and give messages when
+ *                                      device is "finish"ed.
+ *          exists_in_ancestor      Issue a Message if the given word exists
+ *                                      in an ancestor of the current dev-node.
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      Still to be done:
+ *          Add a pair of fields to the data-structure for the Input File and
+ *              Line Number where "finish-device" occurred.  When a device-node
+ *              is "finish"ed, do not delete it, but instead fill in those
+ *              fields and the move the node to a separate linked-list.
+ *          When looking whether a word exists in an ancestor-node, also
+ *              check whether it was in a device-node that was finished and
+ *              print both where it was started and where it was finished.
+ *
+ **************************************************************************** */
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#include "devnode.h"
+#include "errhandler.h"
+#include "scanner.h"
+#include "vocabfuncts.h"
+#include "flowcontrol.h"
+#include "stream.h"
+#include "ticvocab.h"
+
+
+/* **************************************************************************
+ *
+ *      Tokenization starts with an implicit "new-device" in effect.
+ *          The top-level device-node is never removed.
+ *
+ *      Initialize it here
+ *
+ **************************************************************************** */
+char default_top_dev_ifile_name[] = "Start of tokenization";
+
+static device_node_t top_level_dev_node = {
+     	NULL ,                          /*  parent_node    */
+	default_top_dev_ifile_name ,	/*  ifile_name.
+					 *     Something to show, Just In Case
+					 */
+	0 ,                             /*  line_no        */
+	NULL ,                          /*  tokens_vocab   */
+};
+
+/* **************************************************************************
+ *
+ *          Global Variables Exported.
+ *                                  Pointers to:
+ *     current_device_node      data-structure of current device-node
+ *     current_definitions      vocab into which to add def'ns.
+ *
+ **************************************************************************** */
+
+device_node_t *current_device_node = &top_level_dev_node;
+tic_hdr_t **current_definitions = &(top_level_dev_node.tokens_vocab);
+
+
+/* **************************************************************************
+ *
+ *          Internal Static Variables
+ *               These are used to support the routines  in_what_node() 
+ *                   and  show_node_start() , which are used to facilitate
+ *                   certain kinds of Messaging, as described later.
+ *
+ *     in_what_buffr       Buffer for the  in_what_node()  string
+ *     show_where          TRUE if the string needs to be followed-up
+ *     show_which          TRUE if follow-up should be  just_where_started()
+ *                             rather than  just_started_at()
+ *     in_what_line        Line Number to use in the follow-up
+ *     in_what_file        File Name to use in the follow-up
+ *
+ **************************************************************************** */
+
+static char in_what_buffr[50];   /*  Ought to be more than enough.  */
+static bool show_where = FALSE;
+static bool show_which;
+static int in_what_line;
+static char *in_what_file;
+
+
+/* **************************************************************************
+ *
+ *      Function name:  dev_vocab_control_struct_check
+ *      Synopsis:       Issue Warnings for unresolved flow-control constructs
+ *                          at start or end of a device-node.
+ *
+ *      Inputs:
+ *         Parameters:                     NONE
+ *         Global Variables:
+ *             statbuf                     The command being processed.
+ *
+ *      Outputs:
+ *         Returned Value:                 NONE
+ *         Printout:
+ *             Handled by  announce_control_structs() routine
+ *
+ *      Error Detection:
+ *          Handled by  announce_control_structs()  routine
+ *
+ *      Process Explanation:
+ *          Set up a buffer with the error message, based on  statbuf
+ *              and pass it to  announce_control_structs()
+ *          Release it when done.
+ *
+ **************************************************************************** */
+
+static void dev_vocab_control_struct_check( void)
+{
+    char *ccs_messg;
+
+    ccs_messg = safe_malloc(strlen(statbuf) + 32,
+        "Device-Node control-structure check");
+    
+    strcpy( ccs_messg, statbuf );
+    strupr( ccs_messg);
+    strcat( ccs_messg, " encountered");
+    announce_control_structs( WARNING, ccs_messg, 0 );
+    free( ccs_messg);
+}
+
+
+
+/* **************************************************************************
+ *
+ *      Function name:  new_device_vocab
+ *      Synopsis:       Create and initialize the data-structure for a
+ *                      new device-node when a "new-device" is created,
+ *                      with messages as appropriate.
+ *
+ *      Inputs:
+ *         Parameters:                     NONE
+ *         Global Variables:
+ *             statbuf                     The word that was just read.
+ *             iname                       Current Input-File Name
+ *             lineno                      Current line-number
+ *
+ *      Outputs:
+ *         Returned Value:                 NONE
+ *         Global Variables:
+ *             current_device_node         Will point to the new data-structure
+ *         Memory Allocated
+ *             Space for the new  device_node_t  data-structure
+ *             Space for a copy of the current input file name
+ *         When Freed?
+ *             By delete_device_vocab(), when the device-node is "finish"ed.
+ *         Printout:
+ *             Advisory message.
+ *
+ *      Error Detection:
+ *          In immediate-execution mode, Control Structures that have not
+ *              been completed are questionable;  Issue WARNINGS via the
+ *               dev_vocab_control_struct_check()  routine.
+ *
+ *      Process Explanation:
+ *          This routine is called when "new-device" is invoked, but only
+ *              if we are in immediate-execution mode.
+ *          Later on, in ERROR- or INFOrmative messages, we will want to
+ *              be able to refer to the file and line-number in which this
+ *              was encountered, so we include them in the structure.
+ *
+ **************************************************************************** */
+
+void new_device_vocab( void )
+{
+    device_node_t *new_node_data;
+
+    dev_vocab_control_struct_check();
+
+    /*  Advisory message will mention previous device-node
+     *      if there was one.  Either way starts out the same:
+     */
+#define NEW_DEV_MSG_START  "Encountered %s.  Starting new device-node."
+
+    if ( current_device_node == &top_level_dev_node )
+    {
+	tokenization_error(INFO, NEW_DEV_MSG_START "\n", statbuf );
+    }else{
+	tokenization_error(INFO, NEW_DEV_MSG_START
+	    "  Suspending definitions of parent-device node", statbuf );
+	started_at( current_device_node->ifile_name,
+	     current_device_node->line_no );
+    }
+
+    /*  Now to business...   */
+    new_node_data = safe_malloc( sizeof(device_node_t),
+        "creating new-device vocab data" );
+    new_node_data->parent_node = current_device_node;
+    new_node_data->ifile_name = strdup(iname);
+    new_node_data->line_no = lineno;
+    new_node_data->tokens_vocab = NULL;
+
+    current_device_node = new_node_data;
+    
+    current_definitions = &(current_device_node->tokens_vocab);
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  delete_device_vocab
+ *      Synopsis:       Remove the vocabularies of the current device-node,
+ *                          along with its data-structure, when the device
+ *                          is "finish"ed; do not print messages.
+ *                      Do not remove the top-level device-node data-struct.
+ *
+ *      Associated FORTH words:              FINISH_DEVICE  (interpretive state)
+ *                                           END0  END1
+ *      Associated Tokenizer directives:     RESET-SYMBOLS  (in "Normal" mode)
+ *                                           FCODE-END
+ *
+ *      Inputs:
+ *         Parameters:                    NONE
+ *         Global Variables:
+ *             current_device_node        Points to current device's struct
+ *                                            Leads to chain of dev-node structs
+ *
+ *      Outputs:
+ *         Returned Value: 
+ *         Global Variables:
+ *             current_device_node        Parent-device's struct becomes current
+ *         Memory Freed
+ *             All that was allocated for the tokens and the definers
+ *                 vocabs in the current device-node
+ *             The copy of the input file name, except the top-level
+ *             The current_device_node data-structure, except the top-level
+ *
+ **************************************************************************** */
+
+void delete_device_vocab( void )
+{
+    reset_tic_vocab( current_definitions, NULL );
+
+    if ( current_device_node != &top_level_dev_node )
+    {
+	device_node_t *temp_node = current_device_node;
+	current_device_node = current_device_node->parent_node;
+	free( temp_node->ifile_name );
+	free(temp_node);
+    }
+
+    current_definitions = &(current_device_node->tokens_vocab);
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  finish_device_vocab
+ *      Synopsis:       Remove the device-node data-structure and all its
+ *                          vocabularies when the device is "finish"ed,
+ *                          with appropriate messages.
+ *                      Do not remove the top-level device node data-struct.
+ *
+ *      Associated FORTH word:                 FINISH_DEVICE
+ *
+ *      Inputs:
+ *         Parameters:                    NONE
+ *         Global Variables:
+ *             current_device_node        Current device's struct pointer
+ *
+ *      Outputs:
+ *         Returned Value:                NONE
+ *         Global Variables:
+ *             current_device_node        Parent-device's struct becomes current
+ *         Printout:
+ *             Advisory message.
+ *
+ *      Error Detection:
+ *          If current_device_node is already pointing at the top-level
+ *              device node, it means there was no corresponding NEW-DEVICE
+ *              Issue an ERROR.
+ *          In immediate-execution mode, Control Structures that have not
+ *              been completed are questionable;  Issue WARNINGS via the
+ *               dev_vocab_control_struct_check()  routine.
+ *
+ *      Process Explanation:
+ *          This routine is called when "finish-device" is invoked, but only
+ *              if we are in immediate-execution mode.
+ *
+ **************************************************************************** */
+
+void finish_device_vocab( void )
+{
+    bool at_top_level;
+
+    dev_vocab_control_struct_check();
+
+    /*   We never remove the top-level device-node vocabulary,
+     *       so we need to test whether we're about to.
+     */
+
+    at_top_level = BOOLVAL( current_device_node == &top_level_dev_node );
+    if ( at_top_level )
+    {
+        tokenization_error( TKERROR,
+	    "Encountered %s without corresponding NEW-DEVICE.  "
+	    "Resetting definitions since start of tokenization.\n",
+		statbuf );
+    }else{    
+	tokenization_error(INFO,
+	    "Encountered %s.  Resetting definitions of device node",
+		statbuf );
+	started_at( current_device_node->ifile_name,
+	     current_device_node->line_no );
+    }
+
+    /*  Now to business...   */
+    delete_device_vocab();
+
+    /*   Did we just get to the top-level device-node vocabulary
+     *       when we weren't before?
+     */
+    if ( INVERSE(at_top_level) )
+    {
+	if ( current_device_node == &top_level_dev_node )
+	{
+	    tokenization_error(INFO,
+		"Resuming definitions since start of tokenization.\n" );
+	}else{
+	    tokenization_error(INFO,
+		"Resuming definitions of parent device-node" );
+	    started_at( current_device_node->ifile_name,
+		 current_device_node->line_no );
+	}
+    }
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  in_what_node
+ *      Synopsis:       Format a string for use in a Message that might
+ *                          identify the start of the given device-node.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             the_node               The device-node vocabulary about which
+ *                                        to construct the identifying phrase.
+ *         Local Static Variables:
+ *             in_what_buffr          Buffer in which to format the string.
+ *         Global Variables:
+ *             current_definitions    Device-node vocabulary currently
+ *                                        in effect.
+ *
+ *      Outputs:
+ *         Returned Value:           Pointer to buffer w/ formatted string
+ *         Local Static Variables:
+ *             in_what_buffr         Will contain the formatted string.
+ *             show_where            TRUE if the string needs to be followed-up
+ *                                        (i.e., did not contain a terminating
+ *                                        new-line) by  just_where_started()
+ *                                        or by  just_started_at()
+ *             show_which            TRUE if the follow-up call should be
+ *                                       to  just_where_started()  rather 
+ *                                       than to  just_started_at() 
+ *             in_what_line          Copy of line_no field from the_node
+ *             in_what_file          Copy of ifile_name field from the_node
+ *
+ *      Process Explanation:
+ *          Calling routine must ascertain that Global-scope is not in effect.
+ *          The returned phrase can be used as a string argument in a Message.
+ *          Set  show_where  TRUE if the_node->line_no is non-zero.
+ *          Set  show_which  TRUE if the_node is either the Current or the
+ *              Top-Level device-node
+ *          If the originating line-number in the given Node structure is zero,
+ *              the returned phrase will contain a terminating new-line.
+ *              (This only happens if the given Node is the top-level Node,
+ *              and it's the Current Node, and the "official" starting-point
+ *              hasn't yet been established by an "FCode-Starter" such as 
+ *               FCODE-VERSION2 .  Once that command has been given, even
+ *              definitions that were made prior to it belong to the Node
+ *              that started there.)
+ *          Otherwise,  show_where  is returned TRUE, and  show_which  becomes
+ *              relevant.  If the given node is the Current or the Top-Level
+ *              node, text about the originating file-name and line-number
+ *              merely describes a node that is already uniquely identified,
+ *              so the message appended to the buffer will have the phrase
+ *              "which began" (which introduces what is known in grammar as
+ *              an Appositive Subordinate Clause) and  show_which  will be
+ *              returned TRUE.  If the given node is not uniquely identifiable
+ *              without the file- and line- phrase, then the Subordinate Clause
+ *              is Indicative, and should be introduced with "that" (and no
+ *              comma); in that case, we will return  show_which  as FALSE.
+ *          After the calling routine displays the message in which the
+ *              returned phrase is used, it must call  show_node_start()
+ *              to display the followe-up message, if any.
+ *
+ **************************************************************************** */
+
+char *in_what_node(device_node_t *the_node)
+{
+    bool top_node    = BOOLVAL( the_node == &top_level_dev_node);
+    bool curr_node   = BOOLVAL( the_node == current_device_node);
+    bool known_node  = BOOLVAL( top_node || curr_node );
+    bool no_line     = BOOLVAL( the_node->line_no == 0);
+
+    show_where   = INVERSE( no_line  );
+    show_which   = known_node;
+    in_what_line = the_node->line_no;
+    in_what_file = the_node->ifile_name;
+
+    sprintf( in_what_buffr, "in the%s device-node%s",
+	INVERSE( known_node )  ? ""
+	        :  top_node    ?    " top-level"   :  " current" ,
+	
+	no_line                ?  ".\n"
+	        :  known_node  ?  ", which began"  :   ""         );
+
+    
+    return( in_what_buffr);
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  show_node_start
+ *      Synopsis:       Follow-up to the  in_what_node()  call.  Print out,
+ *                          if applicable, the text about the originating
+ *                          file-name and line-number
+ *
+ *      Inputs:
+ *         Parameters:             NONE
+ *         Local Static Variables:
+ *             show_where          Nothing to do if not TRUE
+ *             show_which          TRUE if should call  just_where_started()
+ *                                     rather than  just_started_at()
+ *             in_what_line        Line Number to use in the follow-up
+ *             in_what_file        File Name to use in the follow-up
+ *
+ *      Outputs:
+ *         Returned Value:         NONE
+ *         Local Static Variables:
+ *             show_where          Force to FALSE
+ *         Printout:
+ *             Follow-up to  the in_what_node() call.  Applicable text
+ *                 about the originating file-name and line-number.
+ *
+ *      Process Explanation:
+ *          By forcing  show_where  to FALSE after this is called, we
+ *              can safely allow routines that might or might not have
+ *              called  in_what_node()  to call this routine, without
+ *              needing any additional "bookkeeping".
+ *
+ **************************************************************************** */
+
+void show_node_start( void)
+{
+    if ( show_where)
+    {
+	if ( show_which )
+	{
+	    just_where_started( in_what_file, in_what_line);
+	}else{
+	    just_started_at( in_what_file, in_what_line);
+	}
+	show_where = FALSE;
+    }
+}
+
+
+
+/* **************************************************************************
+ *
+ *      Function name:  exists_in_ancestor
+ *      Synopsis:       Issue a Message and return an indication if
+ *                          the given word exists in an ancestor of
+ *                          the current device-node.
+ *                      Used for additional error-message information.
+ *                      
+ *
+ *      Inputs:
+ *         Parameters:
+ *             m_name                   "Method" name
+ *         Global Variables:
+ *             current_device_node      Leads to chain of dev-node data-structs
+ *             scope_is_global          TRUE if "global" scope is in effect
+ *
+ *      Outputs:
+ *         Returned Value:              TRUE if word found
+ *         Printout:
+ *             If  m_name  exists in an ancestor-node, print an ADVISORY
+ *                 giving the location where the ancestor originated.
+ *
+ *      Error Detection:
+ *          None here.  Calling routine detected error; see below.
+ *
+ *      Process Explanation:
+ *          This routine was called as the result of detecting an error:
+ *              viz.,  m_name  was not found in either the current node
+ *              or the base vocabulary.  (Except:  If "global" scope is
+ *              in effect, we didn't search the current device-node).
+ *
+ **************************************************************************** */
+
+bool exists_in_ancestor( char *m_name)
+{
+    tic_hdr_t *found;
+    bool retval = FALSE;
+    if ( current_device_node != NULL )
+    {
+	device_node_t *grandpa = current_device_node->parent_node;
+
+	if ( scope_is_global )    grandpa = current_device_node;
+
+	for ( ; grandpa != NULL; grandpa = grandpa->parent_node )
+	{
+	    found = lookup_tic_entry( m_name, grandpa->tokens_vocab);
+	    if ( found != NULL )
+	    {
+		retval = TRUE;
+		break;
+	    }
+	}
+	if ( grandpa != NULL )
+	{
+	    char as_what_buf[32] = "";
+	    if ( as_a_what( found->fword_defr, as_what_buf) )
+	    {
+		strcat( as_what_buf, " ");
+	    }
+	    tokenization_error(INFO, "%s is defined %s%s", m_name,
+		as_what_buf, in_what_node( grandpa) );
+	    show_node_start();
+	}
+    }
+
+    return(retval );
+}
diff --git a/toke/devnode.h b/toke/devnode.h
new file mode 100644
index 0000000..0a11035
--- /dev/null
+++ b/toke/devnode.h
@@ -0,0 +1,86 @@
+#ifndef _TOKE_DEVNODE_H
+#define _TOKE_DEVNODE_H
+
+/*
+ *                     OpenBIOS - free your system!
+ *                         ( FCode tokenizer )
+ *
+ *  This program is part of a free implementation of the IEEE 1275-1994
+ *  Standard for Boot (Initialization Configuration) Firmware.
+ *
+ *  Copyright (C) 2001-2005 Stefan Reinauer, <stepan@openbios.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ *
+ */
+
+/* **************************************************************************
+ *
+ *      External/Prototype/Structure definitions for device-node management
+ *
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Module Author:  David L. Paktor    dlpaktor@us.ibm.com
+ *
+ **************************************************************************** */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "types.h"
+#include "ticvocab.h"
+
+/* **************************************************************************
+ *          Structure Name:    device_node_t
+ *                        Data for managing a device node; pointers
+ *                            to vocabs, data for messaging.
+ *                            
+ *   Fields:
+ *       parent_node         Pointer to similar data for parent node 
+ *       line_no             Copy of Line Number where "new-device" was invoked
+ *       ifile_name          Name of Input File where "new-device" was invoked
+ *       tokens_vocab        Pointer to vocab for this device's tokens
+ *
+ **************************************************************************** */
+
+typedef struct device_node {
+        struct device_node *parent_node ;
+	char *ifile_name ;
+	unsigned int line_no ;
+	tic_hdr_t *tokens_vocab ;
+} device_node_t;
+
+
+/* ************************************************************************** *
+ *
+ *      Global Variables Exported
+ *
+ **************************************************************************** */
+
+extern char default_top_dev_ifile_name[];
+extern device_node_t *current_device_node;
+extern tic_hdr_t **current_definitions;
+
+/* ************************************************************************** *
+ *
+ *      Function Prototypes / Functions Exported:
+ *
+ **************************************************************************** */
+void new_device_vocab( void );
+void delete_device_vocab( void );
+void finish_device_vocab( void );
+char *in_what_node(device_node_t *the_node);
+void show_node_start( void);
+bool exists_in_ancestor( char *m_name);
+
+#endif   /*  _TOKE_DEVNODE_H    */
diff --git a/toke/dictionary.c b/toke/dictionary.c
index 112c3c2..a662a4d 100644
--- a/toke/dictionary.c
+++ b/toke/dictionary.c
@@ -24,6 +24,12 @@
  *
  */
 
+/* **************************************************************************
+ *         Modifications made in 2005 by IBM Corporation
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Modifications Author:  David L. Paktor    dlpaktor@us.ibm.com
+ **************************************************************************** */
+
 #include <stdio.h>
 #include <stdlib.h>
 #if defined(__linux__) && ! defined(__USE_BSD)
@@ -32,543 +38,2008 @@
 #include <string.h>
 #include <errno.h>
 
-#include "toke.h"
+#include "emit.h"
+#include "macros.h"
+#include "scanner.h"
+#include "ticvocab.h"
 #include "dictionary.h"
+#include "vocabfuncts.h"
+#include "devnode.h"
+#include "clflags.h"
+#include "parselocals.h"
+#include "errhandler.h"
+#include "tokzesc.h"
+#include "conditl.h"
+
+/* **************************************************************************
+ *
+ *      Revision History:
+ *          Updated Fri, 29 Jul 2005 by David L. Paktor
+ *          Retrofit to handle "Current Device" as a separate vocabulary;
+ *              if one is in effect, searches through it occur first, as
+ *              do definitions to it, ahead of the general vocabulary.  This
+ *              is to support managing device-node vocabularies correctly.
+ *          Updated Mon, 12 Dec 2005 by David L. Paktor
+ *          Allow the user to specify a group of exceptions, words whose
+ *              scope will be "global" within the tokenization.  Under "global"
+ *              scope, definitions will be made to the "core" vocabulary.
+ *
+ *          Wed, 14 Dec 2005 by David L. Paktor
+ *          Found a problem with the current approach.  Need to be able to
+ *              temporarily suspend meaning of "instance".  Define:  (1) an
+ *              alias for  INSTANCE  called  GENERIC_INSTANCE  (2) a macro
+ *              called  INSTANCE  that effectively no-ops it out; and, when
+ *              it is time to restore "INSTANCE" to normal functionality,
+ *              (3) an alias for  GENERIC_INSTANCE  called  INSTANCE .
+ *          Problem is that macros are treated as a separate vocabulary
+ *              from FWords (and their aliases) and searching one before the
+ *              other (either way) renders the second one searched unable to
+ *              supercede the first one:  If macros are searched first, (2)
+ *              will be found ahead of the built-in FWord (which is what we
+ *              want) but later, when we search for (3) among the FWords, it
+ *              will not be found ahead of (2).  If, on the other hand, we
+ *              search FWords first, the macro defined in (2) will never be
+ *              found.
+ *          We need a way to define both (all?) types of definitions in a
+ *              single vocabulary that will honor the LIFO order of def'ns.
+ *
+ *          Mon, 19 Dec 2005 by David L. Paktor
+ *          Begin development of implementation of a way to define both (all?)
+ *              types of definitions in a single  tic_hdr_t  type vocabulary.
+ *
+ **************************************************************************** */
+
+
+
+/* **************************************************************************
+ *
+ *      We will be creating several different lists of initial built-in
+ *          definitions; together, they constitute the Global Vocabulary.
+ *          (We will avoid the term "dictionary", since, in classical
+ *          Forth terminology, it refers to the complete collection of
+ *          vocabularies in an application.)  The usage of the pointer
+ *          to the Global Vocabulary is central to the operation of this
+ *          program and the maintenance programmer needs to understand it.
+ *          We may also refer to the Global Vocabulary as the "core" vocab.
+ *
+ *      Each initial list will be created as an array of TIC-header entries.
+ *          Because the global vocabulary is expandable by the user,
+ *          we will not be searching the lists as arrays but rather as
+ *          linked-lists; the run-time initialization routine will fill
+ *          in their link-fields and also will link the various lists
+ *          together, so we can group their initial declarations according
+ *          to our convenience.
+ *
+ *      A single pointer, called the "Global Vocabulary Dictionary Pointer"
+ *          (okay, so classical Forth terminology isn't completely rigorous...)
+ *          and abbreviated GV_DP, will point to the "tail" of the "thread".
+ *          Similar vocabularies will be created for the device-nodes; look
+ *          in the file  devnode.fth  for a more detailed discussion of those.
+ *
+ *      The "FC-Tokens" list contains the names and FCode numeric tokens
+ *          of the straightforward FORTH words that simply write a token
+ *          directly to the tokenized output.  We need to access these
+ *          without being confused by aliases or other distractions, so
+ *          we will keep a pointer to them especially for that purpose.
+ *      Therefore it is IMPORTANT:  that the "FC-Tokens" list MUST be the
+ *          first table linked by the initialization routine, so that its
+ *          last-searched entry's link-field is NULL.
+ *
+ *      The "FWords" list contains FORTH words that require additional
+ *          special action at tokenization-time.  Their numeric values
+ *          are derived from the  fword_token  enumeration declaration,
+ *          and are used as the control-expression for a SWITCH statement
+ *          with a large number of CASE labels in the  handle_internal()
+ *          function.
+ *
+ *      The "Shared Words" list contains FORTH words that can be executed
+ *          similarly both during "Tokenizer Escape" mode (i.e., the scope
+ *          of the special brackets:  tokenizer[  ...   ]tokenizer ) and
+ *          also within "Normal Tokenization" mode.  Their numeric values
+ *          are derived and used the same way as the "FWords".  Since we
+ *          will be needing to do a separate search through them at times,
+ *          we will also need a lower-bracket pointer for them.  (An upper
+ *          bracket is irrelevant for these, because aliases can be added.
+ *          This is not the case for the "FC-Tokens" list, because searches
+ *          through those will be conducted from within this program.)
+ *
+ *      The "definer" field in the TIC-header structure is primarily used to
+ *          detect attempts to apply the  TO  directive to an inappropriate
+ *          target.  Its numeric values are a subset of the "FWord tokens".
+ *          Certain "FC-Token" names are specified to be valid  TO  targets;
+ *          their entries' "definer" fields will be initialized accordingly.
+ *          Entries in FWord Token lists that are "shared" between "Normal
+ *          Tokenization" and "Tokenizer Escape" modes will have their
+ *          "definer" fields initialized to  COMMON_FWORD .  All other
+ *          entries' "definer" fields will be initialized to  UNSPECIFIED .
+ *
+ *      Other files maintain and support additional lists with the same
+ *          structure, which need to be linked together with the lists
+ *          declared here.  We prefer to keep the  GV_DP  private to this
+ *          file, so it will be passed as a parameter where needed.  (I'm
+ *          not pleased to note, however, that it can't be kept completely
+ *          private; it's needed for add_user_macro() and possibly other
+ *          functions outside this file.)
+ *
+ *      The words that can only be used during "Tokenizer Escape" mode and
+ *          the IBM-style "Locals", as well as the device-node vocabularies,
+ *          will need to be separate and will not be linked together with
+ *          the Global Vocabulary.
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      We'll be initializing the lists later, but will be referencing
+ *          the pointers sooner, so we need to declare the pointers here.
+ *
+ *      We will keep all of these pointers private to this file.
+ *
+ **************************************************************************** */
+
+static tic_hdr_t *global_voc_dict_ptr  = NULL;  /*  The Global Vocabulary    */
+static tic_hdr_t *fc_tokens_list_ender = NULL;  /*  Tokens search ends here  */
+static tic_hdr_t *fc_tokens_list_start = NULL;  /*  Start the search here    */
+static tic_hdr_t *shared_fwords_ender  = NULL;  /*  Shared FWords search end */
+static tic_hdr_t *global_voc_reset_ptr = NULL;  /*  Reset-point for G.V.     */
 
-typedef struct token {
-	u8  *name;
-	u16 fcode;
-	struct token *next;
-} token_t;
 
-static token_t *dictionary=NULL;
-static token_t *forthwords=NULL;
+/* **************************************************************************
+ *
+ *      Function name:  lookup_core_word
+ *      Synopsis:       Return a pointer to the data-structure of the named
+ *                      word in the "Global" Vocabulary
+ *
+ *      Inputs:
+ *         Parameters:
+ *             tname                     The name to look up
+ *         Local Static Variables:
+ *             global_voc_dict_ptr       "Tail" of Global Vocabulary
+ *
+ *      Outputs:
+ *         Returned Value:                Pointer to the data-structure, or
+ *                                            NULL if not found.
+ *
+ **************************************************************************** */
 
-static u16 lookup_token_dict(char *name, token_t *dict)
+tic_hdr_t *lookup_core_word( char *tname)
 {
-	token_t *curr;
-	
-	for (curr=dict; curr!=NULL; curr=curr->next)
-		if (!strcasecmp(name,(char *)curr->name))
-			break;
+    tic_hdr_t *found ;
 
-	if (curr)
-		return curr->fcode;
-#ifdef DEBUG_TOKE
-	printf("warning: token '%s' does not exist.\n", name);
-#endif
-	return 0xffff;
+    found = lookup_tic_entry( tname, global_voc_dict_ptr);
+    return ( found ) ;
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  exists_in_core
+ *      Synopsis:       Confirm whether the given name exists in the
+ *                      Global (aka "core") Vocabulary.  Search the
+ *                      Global Vocabulary exclusively.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             name                      The name for which to look
+ *         Local Static Variables:
+ *             global_voc_dict_ptr       "Tail" of Global Vocabulary
+ *
+ *      Outputs:
+ *         Returned Value:               TRUE if name is found.
+ *
+ **************************************************************************** */
+
+bool exists_in_core( char *name)
+{
+    return exists_in_tic_vocab( name, global_voc_dict_ptr );
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  handle_core_word
+ *      Synopsis:       Perform a function in the "Global" Vocabulary and
+ *                      indicate whether the name is valid.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             tname                     The name to handle
+ *         Local Static Variables:
+ *             global_voc_dict_ptr       "Tail" of Global Vocabulary
+ *
+ *      Outputs:
+ *         Returned Value:   TRUE if the given name is valid in Global Vocab
+ *
+ *      Error Detection:
+ *          If the name is not in the "Global" Vocabulary, let the calling
+ *              routine determine whether to print an error message or to
+ *              try it out as a number.
+ *
+ **************************************************************************** */
+
+bool handle_core_word( char *tname )
+{
+    bool retval;
+
+    retval = handle_tic_vocab( tname, global_voc_dict_ptr );
+
+    return ( retval ) ;
 }
 
-u16 lookup_token(char *name)
+
+/* **************************************************************************
+ *
+ *      Function name:  create_core_alias
+ *      Synopsis:       Create, in the "Global" ("core") Vocabulary, an entry
+ *                          for NEW_NAME that behaves the same as the latest
+ *                          definition of OLD_NAME, and whose behavior will
+ *                          not change even if a new definition of OLD_NAME
+ *                          is overlaid.  Indicate if successful.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             new_name          The name for the new alias to be created
+ *             old_name          The name of the old function to be duplicated
+ *         Local Static Variables:
+ *             global_voc_dict_ptr        "Tail" of Global Vocabulary
+ *
+ *      Outputs:
+ *         Returned Value:                TRUE if OLD_NAME was found.
+ *         Local Static Variables:
+ *             global_voc_dict_ptr        Updated with the new entry
+ *         Memory Allocated
+ *             By support routine.
+ *
+ *      Process Explanation:
+ *          Both the "old" and "new" names are presumed to already point to
+ *              stable, freshly allocated memory-spaces.
+ *
+ **************************************************************************** */
+
+bool create_core_alias( char *new_name, char *old_name)
+{
+    bool retval = create_tic_alias( new_name, old_name, &global_voc_dict_ptr);
+    return ( retval );
+}
+
+/* **************************************************************************
+ *
+ *      The functions that go into the various lists' FUNCT field may be
+ *           defined below, or might be defined externally.
+ *
+ *      Often, we will need a function that merely recasts the type of the
+ *           parameter field before passing it to the function that does
+ *           the actual work.
+ *
+ *      Prologs will be brief or even non-existent.
+ *
+ *      Initialization macro definitions will accompany the functions.
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      For the "FCode-Tokens" list, simply generate the token directly.
+ *      We need this layer for param type conversion.
+ *      In case we're ever able to eliminate it, (or just on General
+ *          Principles) we'll invoke it via a macro...
+ *
+ **************************************************************************** */
+
+static void emit_fc_token( tic_param_t pfield)
+{
+    u16 fc_tok = (u16)pfield.deflt_elem;
+    emit_fcode( fc_tok);
+}
+
+#define FC_TOKEN_FUNC  emit_fc_token
+
+#define BUILTIN_FCODE( tok, nam)   \
+     VALPARAM_TIC(nam, FC_TOKEN_FUNC, tok , UNSPECIFIED )
+
+/*  Built-in FCodes with known definers:  */
+#define BI_FCODE_VALUE( tok, nam)   \
+     VALPARAM_TIC(nam, FC_TOKEN_FUNC, tok , VALUE )
+
+#define BI_FCODE_VRBLE( tok, nam)   \
+     VALPARAM_TIC(nam, FC_TOKEN_FUNC, tok , VARIABLE )
+
+#define BI_FCODE_DEFER( tok, nam)   \
+     VALPARAM_TIC(nam, FC_TOKEN_FUNC, tok , DEFER )
+
+#define BI_FCODE_CONST( tok, nam)   \
+     VALPARAM_TIC(nam, FC_TOKEN_FUNC, tok , CONST )
+
+/* **************************************************************************
+ *
+ *      The "FCode-Tokens" list includes tokens that are identified
+ *         in the Standard as Obsolete.  We will define a function
+ *         that issues a WARNING before generating the token, and
+ *         assign it to those elements of the list.
+ *
+ *      Control the message via a command-line flag.
+ *
+ **************************************************************************** */
+
+static void obsolete_warning( void)
+{
+    if ( obso_fcode_warning )
+    {
+	tokenization_error( WARNING, "%s is an Obsolete FCode.\n",
+	    strupr(statbuf) );
+    }
+}
+
+static void obsolete_fc_token( tic_param_t pfield)
+{
+    obsolete_warning();
+    emit_fc_token( pfield);
+}
+
+#define OBSO_FC_FUNC  obsolete_fc_token
+
+#define OBSOLETE_FCODE( tok, nam)   \
+     VALPARAM_TIC(nam, OBSO_FC_FUNC, tok , UNSPECIFIED )
+
+#define OBSOLETE_VALUE( tok, nam)   \
+     VALPARAM_TIC(nam, OBSO_FC_FUNC, tok , VALUE )
+
+
+/* **************************************************************************
+ *
+ *      The function for most of the "FWords" list,  handle_internal() ,
+ *          is defined externally, but not exported in a  .h  file,
+ *          because we want to keep it as private as possible.
+ *      We will declare its prototype here.
+ *
+ *      Initialization macros for both "Normal Mode"-only and
+ *          "Shared" entries are also defined here.
+ *
+ *   Arguments:
+ *       fwt      (fword_token)    Value of the FWord Token (from Enum list)
+ *       nam      (string)         Name of the entry as seen in the source
+ *
+ **************************************************************************** */
+
+void handle_internal( tic_param_t pfield);
+/*  "Skip-a-string when Ignoring" function.  Same args and limited-proto ...  */
+void skip_string( tic_param_t pfield);
+
+#define FWORD_EXEC_FUNC  handle_internal
+
+#define BUILTIN_FWORD( fwt, nam)   \
+     FWORD_TKN_TIC(nam, FWORD_EXEC_FUNC, fwt, BI_FWRD_DEFN )
+
+#define SHARED_FWORD( fwt, nam)   \
+     FWORD_TKN_TIC(nam, FWORD_EXEC_FUNC, fwt, COMMON_FWORD )
+
+/*  Variants:  When Ignoring, SKip One Word  */
+#define SHR_FWD_SKOW( fwt, nam)   \
+     DUALFUNC_FWT_TIC(nam, FWORD_EXEC_FUNC, fwt, skip_a_word, COMMON_FWORD )
+
+/*  Variants:  When Ignoring, SKip one Word in line  */
+#define SH_FW_SK_WIL( fwt, nam)   \
+     DUALFUNC_FWT_TIC(nam, FWORD_EXEC_FUNC, fwt,     \
+         skip_a_word_in_line, COMMON_FWORD )
+
+/*  When Ignoring, SKip Two Words in line  */
+#define SH_FW_SK2WIL( fwt, nam)   \
+     DUALFUNC_FWT_TIC(nam, FWORD_EXEC_FUNC, fwt,     \
+         skip_two_words_in_line, COMMON_FWORD )
+
+/* **************************************************************************
+ *
+ *      Some of the entries in the "FWords" list -- both "Normal" (Built-in)
+ *          and "Shared" also act as an "Ignore-handler".
+ *          
+ *   Arguments:
+ *       nam      (string)         Name of the entry as seen in the source
+ *       afunc    (routine-name)   Name of internal "active" function
+ *       pval     (integer)        The "param field" item
+ *       ifunc    (routine-name)   Name of "ignore-handling" function
+ *
+ **************************************************************************** */
+
+#define SHARED_IG_HDLR(nam, afunc, pval, ifunc)     \
+    DUFNC_FWT_PARM(nam, afunc, pval, ifunc, COMMON_FWORD )
+
+/*  A "Shared" entry that uses the same routine for both of its functions  */
+#define SHR_SAMIG_FWRD( fwt, nam)   \
+    DUFNC_FWT_PARM(nam, FWORD_EXEC_FUNC, fwt, FWORD_EXEC_FUNC, COMMON_FWORD )
+
+/* **************************************************************************
+ *
+ *     But the "Normal" (Built-in) FWord Ignore-handler uses the same
+ *          routine as the  BUILTIN_FWORD for both of its functions.
+ *
+ *   Arguments:
+ *       fwt      (fword_token)    Value of the FWord Token (from Enum list)
+ *       nam      (string)         Name of the entry as seen in the source
+ *
+ **************************************************************************** */
+#define BI_IG_FW_HDLR( fwt, nam)   \
+    DUALFUNC_FWT_TIC(nam, FWORD_EXEC_FUNC, fwt, FWORD_EXEC_FUNC, BI_FWRD_DEFN )
+
+/*  A variant:  A "Built-In FWorD that SKiPs One Word", when Ignoring  */
+#define BI_FWD_SKP_OW( fwt, nam)   \
+     DUALFUNC_FWT_TIC(nam, FWORD_EXEC_FUNC, fwt, skip_a_word, BI_FWRD_DEFN )
+
+/*  Another variant:  A "Built-In FWorD String".  skip_string when Ignoring  */
+#define BI_FWD_STRING( fwt, nam)   \
+     DUALFUNC_FWT_TIC(nam, FWORD_EXEC_FUNC, fwt, skip_string, BI_FWRD_DEFN )
+
+/* **************************************************************************
+ *
+ *      In order to protect device-nodes' methods from being accessed 
+ *          by other device-nodes (with the attendant potential for
+ *          disastrous consequences), we must establish a few rules:
+ *
+ *      Each device-node has a separate vocabulary for its methods.
+ *          New definitions are made to the "current" device's vocabulary.
+ *          Searches for names go through the "current" device-node's
+ *              vocabulary first, then through the core dictionary.
+ *
+ *      A new-device (in interpretation-mode) creates a new device-node
+ *          vocabulary.  The node that had been current (presumably its
+ *          parent) remains in memory but inactive.
+ *
+ *      A finish-device (again, only in interpretation-mode) removes the
+ *          current device-node's vocabulary from memory; its presumed
+ *          parent once again becomes current.
+ *
+ *      Tokenization starts with an implicit "new-device" in effect.
+ *          The top-level device-node is never removed.
+ *
+ *      The Global Variable  current_definitions  points to the vocabulary
+ *          to which we will add and through which we will search first.
+ *
+ *      If "global" scope is in effect, then  current_definitions  will
+ *           point to the "Global" (also called "core") vocabulary.
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      Support for operations in "current" -- i.e., "global" vis-a-vis
+ *          "device" -- scope.
+ *      "Global" scope will not recognize words defined in "device" scope,
+ *           but "device" scope will recognize "global" words.
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      Functions to enter "global" scope and resume "device" scope.
+ *
+ **************************************************************************** */
+
+static tic_hdr_t **save_device_definitions;
+/* Export the indication that "global" scope is in effect  */
+bool scope_is_global = FALSE;
+
+
+void enter_global_scope( void )
+{
+    if ( scope_is_global )
 {
-	return lookup_token_dict(name, dictionary);
+	tokenization_error( WARNING,
+	    "%s -- Global Scope already in effect; ignoring.\n",
+		strupr(statbuf) );
+    }else{
+	tokenization_error( INFO,
+	    "Initiating Global Scope definitions.\n" );
+	scope_is_global = TRUE;
+	save_device_definitions = current_definitions;
+	current_definitions = &global_voc_dict_ptr;
+    }
 }
 
-u16 lookup_fword(char *name)
+void resume_device_scope( void )
 {
-	return lookup_token_dict(name, forthwords);
+    if ( scope_is_global )
+    {
+	tokenization_error( INFO,
+	    "Terminating Global Scope definitions; "
+		"resuming Device-node definitions.\n" );
+	current_definitions = save_device_definitions;
+	scope_is_global = FALSE;
+    }else{
+	tokenization_error( WARNING,
+	    "%s -- Device-node Scope already in effect; ignoring.\n",
+		strupr(statbuf) );
+    }
+
 }
 
-static int add_token_dict(u16 number, char *name, token_t **dict)
+/* **************************************************************************
+ *
+ *      Function name:  lookup_current
+ *      Synopsis:       Return a pointer to the data-structure of the named
+ *                          word, either in the Current Device-Node vocab,
+ *                          or in the Global ("core") Vocabulary.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             tname                     The name to look for
+ *         Global Variables:
+ *             current_definitions       Current vocabulary:  Device-Node, or
+ *                                           "core" if "global" scope in effect.
+ *             scope_is_global           TRUE if "global" scope is in effect
+ *         Local Static Variables:
+ *             global_voc_dict_ptr       "Tail" of Global Vocabulary
+ *
+ *      Outputs:
+ *         Returned Value:               Pointer to the data-structure, or
+ *                                           NULL if not found.
+ *
+ *      Process Explanation:
+ *          If a current Device-Node Vocabulary in effect, search through it.
+ *          If the given name was not found, and "global" scope is not in
+ *              effect (i.e., "core" was not already searched), make a
+ *              separate search through the Global ("core") Vocabulary
+ *
+ *      Extraneous Remarks:
+ *          This is the central routine for doing general word-searches that
+ *              make use of the "normal"-mode search-list.
+ *
+ **************************************************************************** */
+
+tic_hdr_t *lookup_current( char *tname)
+{
+    /*  Search Current Device Vocabulary ahead of global (core) vocabulary  */
+    tic_hdr_t *retval;
+    retval = lookup_tic_entry( tname, *current_definitions);
+    if ( (retval == NULL) && INVERSE(scope_is_global) )
 {
-	token_t *curr;
+	retval = lookup_core_word( tname);
+    }
+    return ( retval );
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  exists_in_current
+ *      Synopsis:       Confirm whether the given name exists either
+ *                          in the Current Device-Node vocab,
+ *                          or in the Global ("core") Vocabulary,
+ *                          or in Tokenizer Escape Mode, if that's current.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             tname                     The name to look for
+ *
+ *      Outputs:
+ *         Returned Value:               TRUE if name is found
+ *
+ **************************************************************************** */
 
-	curr=malloc(sizeof(token_t));
-	if(!curr) {
-		printf("Out of memory while adding token.\n");
-		exit(-ENOMEM);
+bool exists_in_current( char *tname)
+{
+    tic_hdr_t *found = lookup_word( tname, NULL, NULL);
+    bool retval = BOOLVAL ( found != NULL);
+    return( retval);
 	}
 
-	curr->next=*dict;
-	curr->fcode=number;
-	curr->name=(u8 *)name;
 
-	*dict=curr;
-	return 0;
+/* **************************************************************************
+ *
+ *      Function name:  handle_current
+ *      Synopsis:       Perform a function in the current device-node vocab,
+ *                      if one is in effect, or in the "Global" Vocabulary.
+ *                      Indicate whether the name is valid.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             tname                      The name to handle
+ *         Global Variables:
+ *             current_definitions        Device-Node (or Global) Vocabulary
+ *                                            currently in effect.
+ *             scope_is_global            TRUE if "global" scope is in effect
+ *         Local Static Variables:
+ *
+ *      Outputs:
+ *         Returned Value:                TRUE if the given name is valid
+ *
+ **************************************************************************** */
+
+bool handle_current( char *tname )
+{
+    bool retval = handle_tic_vocab( tname, *current_definitions );
+
+    if ( INVERSE(retval) && INVERSE(scope_is_global) )
+    {
+	retval = handle_core_word( tname );
+    }
+    return ( retval );
+
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  lookup_in_dev_node
+ *      Synopsis:       Return a pointer to the data-structure of the
+ *                          named word in the Current device node, if
+ *                          in "Device" scope.  Used for error-reporting.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             tname                     The name to look for
+ *         Global Variables:
+ *             current_definitions        Device-Node (or Global) Vocabulary
+ *                                            currently in effect.
+ *             scope_is_global            FALSE if "Device" scope is in effect
+ *
+ *      Outputs:
+ *         Returned Value:                Pointer to the data-structure, or
+ *                                            NULL if not found.
+ *
+ **************************************************************************** */
+
+tic_hdr_t *lookup_in_dev_node( char *tname)
+{
+    tic_hdr_t *retval = NULL;
+
+    if ( INVERSE(scope_is_global) )
+{
+	retval = lookup_tic_entry( tname, *current_definitions);
+}
+    return ( retval );
+}
+
+
+/* **************************************************************************
+ *
+ *     In order to avoid unintentional "recursive"-ness, we need a way
+ *          to render a newly created colon-definition non-findable
+ *          until it's completed.
+ *
+ *      We will accomplish this by saving and reverting the pointer to
+ *          the newest entry, when we call the  hide_last_colon() , and
+ *          by restoring the pointer when we call  reveal_last_colon()
+ *
+ *      We need, therefore, to save the pointer to the last entry before
+ *          we create the new entry.
+ *
+ **************************************************************************** */
+
+/*  Update this each time a new definition is entered  */
+static tic_hdr_t *save_current = NULL;
+
+/* **************************************************************************
+ *
+ *      Function name:  add_to_current
+ *      Synopsis:       Add a new entry to the "current" scope of definitions,
+ *                          which may be either the Global Vocabulary or the
+ *                          current Device-Node Vocabulary.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             name                      The name of the new entry
+ *             fc_token                  The new entry's assigned FCode-number
+ *             fw_definer                The new entry's definer
+ *             define_token              If FALSE, suppress adding the entry,
+ *                                           but preserve the side-effect of
+ *                                           setting  save_current 
+ *         Global Variables:
+ *             current_definitions       Pointer to pointer to "tail" of the
+ *                                           Vocabulary currently in effect;
+ *                                           either Device-node or Global.
+ *
+ *      Outputs:
+ *         Returned Value:               NONE
+ *         Global Variables:
+ *             *current_definitions    Updated with the new entry
+ *         Local Static Variables:
+ *             save_current            Pointer to previous entry
+ *         Memory Allocated
+ *             For the new entry's copy of the name.
+ *         When Freed?
+ *             When the Device-Node is "finish"ed or the Global Vocabulary
+ *                 is reset, or when the program exits.
+ *
+ *      Process Explanation:
+ *          Because  current_definitions  points to the Global Vocabulary
+ *              pointer during "global" scope, this routine is extremely
+ *              straightforward.
+ *          All user-defined words have the same action, i.e., emitting
+ *              the assigned FCode-number.  The new entry's "parameter
+ *              field" size is, of course, zero; the "ignore-function"
+ *              is NULL.
+ *
+ *      Extraneous Remarks:
+ *          The  define_token  parameter is a late addition, necessitated
+ *              by the decision to continue processing after an erroneous
+ *              attempt to create a definition inside a control-structure,
+ *              in order to catch other errors. 
+ *            
+ *
+ **************************************************************************** */
+
+void add_to_current( char *name,
+                           TIC_P_DEFLT_TYPE fc_token,
+			       fwtoken definer,
+			           bool define_token)
+{
+    save_current = *current_definitions;
+    if ( define_token )
+{
+	char *nu_name = strdup( name);
+	add_tic_entry( nu_name, FC_TOKEN_FUNC, fc_token,
+			   definer, 0 , NULL, current_definitions );
+    }
+}
+
+
+void hide_last_colon ( void )
+{
+    tic_hdr_t *temp_vocab;
+
+    /*  The  add_to_current()  function will have been called before this
+     *      one when a new colon-definition is created, so  save_current
+     *      will have been set to point to the entry that had been made
+     *      just before the newest one, which we are hiding here.
+     */
+
+    temp_vocab = save_current ;
+    save_current = *current_definitions;
+    *current_definitions = temp_vocab;
+
 }
 
-int add_token(u16 number, char *name)
+void reveal_last_colon ( void )
 {
-	return add_token_dict(number, name, &dictionary);
+    /*  We call this function either when the colon-definition is
+     *      completed, or when "recursive"-ness is intentional.
+     */
+    *current_definitions = save_current ;
 }
 
-static int add_special(u16 number, char *name)
+
+/* **************************************************************************
+ *
+ *      Function name:  create_current_alias
+ *      Synopsis:       Create an alias for OLD_NAME, called NEW_NAME, in
+ *                          the "current" scope of definitions, which may
+ *                          be either the Global ("core") Vocabulary or the
+ *                          current Device-Node Vocabulary.  Indicate if
+ *                          successful (i.e., OLD_NAME was valid).
+ *                      This is actually a little trickier than it may at
+ *                          first appear; read the Rules in the Process
+ *                          Explanation for full details...
+ *
+ *      Inputs:
+ *         Parameters:
+ *             new_name          The name for the new alias to be created
+ *             old_name          The name of the old function to be duplicated
+ *         Global Variables:
+ *             current_definitions        Device-node vocabulary currently
+ *                                            in effect.
+ *             scope_is_global            TRUE if "global" scope is in effect
+ *         Local Static Variables:
+ *             global_voc_dict_ptr        "Tail" of Global Vocabulary
+ *
+ *      Outputs:
+ *         Returned Value:                TRUE if OLD_NAME was found.
+ *         Global Variables:
+ *             *current_definitions      Updated with the new entry 
+ *         Memory Allocated
+ *             By support routine.
+ *         When Freed?
+ *             When RESET-SYMBOLS is issued (if "global" scope is in effect)
+ *                 or when the device-node is "finish"ed.
+ *         Printout:
+ *             Advisory message if Rule 3 (see below) is invoked.
+ *
+ *      Process Explanation:
+ *          Both the "old" and "new" names are presumed to already point to
+ *              stable, freshly allocated memory-spaces.
+ *          Rules:
+ *          (1)
+ *          If "global" scope is in effect, and the "old" name is found in
+ *              the Global Vocabulary, then the "new" name will be created
+ *              in the Global Vocabulary.
+ *          (2)
+ *          Similarly, if "device" scope is in effect, and the "old" name is
+ *              found in the current device-node's vocabulary, the "new" name
+ *              will be created in the current device-node's vocabulary.
+ *          (3)
+ *          BUT!:  If "device" scope is in effect, and the "old" name is found
+ *              in the Global Vocabulary, then the "new" name will be created
+ *              in the current device-node's vocabulary.  It will only be
+ *              recognized in the scope of that device-node, and will be
+ *              removed from memory when the device-node is "finish"ed.
+ *          And, yes, it *is* supposed to work that way...   ;-)
+ *
+ *          Again, because  current_definitions  points to the Global Vocab
+ *              pointer during "global" scope, the first two rules of this
+ *              routine are extremely straightforward; it's Rule 3 that you
+ *              have to watch out for...  ;-)
+ *
+ *          And one other thing:
+ *              We will always make the alias's  pfld_size  zero.  See the
+ *              prolog for  create_tic_alias()  in  ticvocab.c  for details...
+ *
+ *      Extraneous Remarks:
+ *          I will stretch the rules of well-structured code here, too.
+ *
+ **************************************************************************** */
+
+bool create_current_alias( char *new_name, char *old_name )
 {
-	return add_token_dict(number, name, &forthwords);
+    bool retval = FALSE;
+
+    if ( create_tic_alias( new_name, old_name, current_definitions) )
+    {
+	 return ( TRUE );
+    }
+    
+    if ( INVERSE(scope_is_global) )
+    {
+	tic_hdr_t *found = lookup_core_word( old_name );
+	if ( found != NULL )
+	{
+	    add_tic_entry( new_name, found->funct,
+			       found->pfield.deflt_elem,
+				   found->fword_defr,
+				       0, found->ign_func,
+					   current_definitions );
+	    retval = TRUE;
+	    {
+		tokenization_error( INFO,
+		   "%s is a Global definition, but its alias, %s, "
+		       "will only be defined %s",
+			   strupr( old_name), new_name,
+			       in_what_node( current_device_node) );
+		show_node_start();
+	    }
+	}
+    }
+
+    return ( retval );
 }
 
-void init_dictionary(void) 
-{
-	add_token( 0x000, "end0" );
-	add_token( 0x010, "b(lit)" );
-	add_token( 0x011, "b(')" );
-	add_token( 0x012, "b(\")" );
-	add_token( 0x013, "bbranch" );
-	add_token( 0x014, "b?branch" );
-	add_token( 0x015, "b(loop)" );
-	add_token( 0x016, "b(+loop)" );
-	add_token( 0x017, "b(do)" );
-	add_token( 0x018, "b(?do)" );
-	add_token( 0x019, "i" );
-	add_token( 0x01a, "j" );
-	add_token( 0x01b, "b(leave)" );
-	add_token( 0x01c, "b(of)" );
-	add_token( 0x01d, "execute" );
-	add_token( 0x01e, "+" );
-	add_token( 0x01f, "-" );
-	add_token( 0x020, "*" );
-	add_token( 0x021, "/" );
-	add_token( 0x022, "mod" );
-	add_token( 0x023, "and" );
-	add_token( 0x024, "or" );
-	add_token( 0x025, "xor" );
-	add_token( 0x026, "invert" );
-	add_token( 0x027, "lshift" );
-	add_token( 0x028, "rshift" );
-	add_token( 0x029, ">>a" );
-	add_token( 0x02a, "/mod" );
-	add_token( 0x02b, "u/mod" );
-	add_token( 0x02c, "negate" );
-	add_token( 0x02d, "abs" );
-	add_token( 0x02e, "min" );
-	add_token( 0x02f, "max" );
-	add_token( 0x030, ">r" );
-	add_token( 0x031, "r>" );
-	add_token( 0x032, "r@" );
-	add_token( 0x033, "exit" );
-	add_token( 0x034, "0=" );
-	add_token( 0x035, "0<>" );
-	add_token( 0x036, "0<" );
-	add_token( 0x037, "0<=" );
-	add_token( 0x038, "0>" );
-	add_token( 0x039, "0>=" );
-	add_token( 0x03a, "<" );
-	add_token( 0x03b, ">" );
-	add_token( 0x03c, "=" );
-	add_token( 0x03d, "<>" );
-	add_token( 0x03e, "u>" );
-	add_token( 0x03f, "u<=" );
-	add_token( 0x040, "u<" );
-	add_token( 0x041, "u>=" );
-	add_token( 0x042, ">=" );
-	add_token( 0x043, "<=" );
-	add_token( 0x044, "between" );
-	add_token( 0x045, "within" );
-	add_token( 0x046, "drop" );
-	add_token( 0x047, "dup" );
-	add_token( 0x048, "over" );
-	add_token( 0x049, "swap" );
-	add_token( 0x04A, "rot" );
-	add_token( 0x04b, "-rot" );
-	add_token( 0x04c, "tuck" );
-	add_token( 0x04d, "nip" );
-	add_token( 0x04e, "pick" );
-	add_token( 0x04f, "roll" );
-	add_token( 0x050, "?dup" );
-	add_token( 0x051, "depth" );
-	add_token( 0x052, "2drop" );
-	add_token( 0x053, "2dup" );
-	add_token( 0x054, "2over" );
-	add_token( 0x055, "2swap" );
-	add_token( 0x056, "2rot" );
-	add_token( 0x057, "2/" );
-	add_token( 0x058, "u2/" );
-	add_token( 0x059, "2*" );
-	add_token( 0x05a, "/c" );
-	add_token( 0x05b, "/w" );
-	add_token( 0x05c, "/l" );
-	add_token( 0x05d, "/n" );
-	add_token( 0x05e, "ca+" );
-	add_token( 0x05f, "wa+" );
-	add_token( 0x060, "la+" );
-	add_token( 0x061, "na+" );
-	add_token( 0x062, "char+" );
-	add_token( 0x063, "wa1+" );
-	add_token( 0x064, "la1+" );
-	add_token( 0x065, "cell+" );
-	add_token( 0x066, "chars" );
-	add_token( 0x067, "/w*" );
-	add_token( 0x068, "/l*" );
-	add_token( 0x069, "cells" );
-	add_token( 0x06a, "on" );
-	add_token( 0x06b, "off" );
-	add_token( 0x06c, "+!" );
-	add_token( 0x06d, "@" );
-	add_token( 0x06e, "l@" );
-	add_token( 0x06f, "w@" );
-	add_token( 0x070, "<w@" );
-	add_token( 0x071, "c@" );
-	add_token( 0x072, "!" );
-	add_token( 0x073, "l!" );
-	add_token( 0x074, "w!" );
-	add_token( 0x075, "c!" );
-	add_token( 0x076, "2@" );
-	add_token( 0x077, "2!" );
-	add_token( 0x078, "move" );
-	add_token( 0x079, "fill" );
-	add_token( 0x07a, "comp" );
-	add_token( 0x07b, "noop" );
-	add_token( 0x07c, "lwsplit" );
-	add_token( 0x07d, "wljoin" );
-	add_token( 0x07e, "lbsplit" );
-	add_token( 0x07f, "bljoin" );
-	add_token( 0x080, "wbflip" );
-	add_token( 0x081, "upc" );
-	add_token( 0x082, "lcc" );
-	add_token( 0x083, "pack" );
-	add_token( 0x084, "count" );
-	add_token( 0x085, "body>" );
-	add_token( 0x086, ">body" );
-	add_token( 0x087, "fcode-revision" );
-	add_token( 0x088, "span" );
-	add_token( 0x089, "unloop" );
-	add_token( 0x08a, "expect" );
-	add_token( 0x08b, "alloc-mem" );
-	add_token( 0x08c, "free-mem" );
-	add_token( 0x08d, "key?" );
-	add_token( 0x08e, "key" );
-	add_token( 0x08f, "emit" );
-	add_token( 0x090, "type" );
-	add_token( 0x091, "(cr" );
-	add_token( 0x092, "cr" );
-	add_token( 0x093, "#out" );
-	add_token( 0x094, "#line" );
-	add_token( 0x095, "hold" );
-	add_token( 0x096, "<#" );
-	add_token( 0x097, "u#>" );
-	add_token( 0x098, "sign" );
-	add_token( 0x099, "u#" );
-	add_token( 0x09a, "u#s" );
-	add_token( 0x09b, "u." );
-	add_token( 0x09c, "u.r" );
-	add_token( 0x09d, "." );
-	add_token( 0x09e, ".r" );
-	add_token( 0x09f, ".s" );
-	add_token( 0x0a0, "base" );
-	add_token( 0x0a1, "convert" );
-	add_token( 0x0a2, "$number" );
-	add_token( 0x0a3, "digit" );
-	add_token( 0x0a4, "-1" );
-	add_token( 0x0a5, "0" );
-	add_token( 0x0a6, "1" );
-	add_token( 0x0a7, "2" );
-	add_token( 0x0a8, "3" );
-	add_token( 0x0a9, "bl" );
-	add_token( 0x0aa, "bs" );
-	add_token( 0x0ab, "bell" );
-	add_token( 0x0ac, "bounds" );
-	add_token( 0x0ad, "here" );
-	add_token( 0x0ae, "aligned" );
-	add_token( 0x0af, "wbsplit" );
-	add_token( 0x0b0, "bwjoin" );
-	add_token( 0x0b1, "b(<mark)" );
-	add_token( 0x0b2, "b(>resolve)" );
-	add_token( 0x0b3, "set-token-table" );
-	add_token( 0x0b4, "set-table" );
-	add_token( 0x0b5, "new-token" );
-	add_token( 0x0b6, "named-token" );
-	add_token( 0x0b7, "b(:)" );
-	add_token( 0x0b8, "b(value)" );
-	add_token( 0x0b9, "b(variable)" );
-	add_token( 0x0ba, "b(constant)" );
-	add_token( 0x0bb, "b(create)" );
-	add_token( 0x0bc, "b(defer)" );
-	add_token( 0x0bd, "b(buffer:)" );
-	add_token( 0x0be, "b(field)" );
-	add_token( 0x0bf, "b(code)" );
-	add_token( 0x0c0, "instance" );
-	add_token( 0x0c2, "b(;)" );
-	add_token( 0x0c3, "b(to)" );
-	add_token( 0x0c4, "b(case)" );
-	add_token( 0x0c5, "b(endcase)" );
-	add_token( 0x0c6, "b(endof)" );
-	add_token( 0x0c7, "#" );
-	add_token( 0x0c8, "#s" );
-	add_token( 0x0c9, "#>" );
-	add_token( 0x0ca, "external-token" );
-	add_token( 0x0cb, "$find" );
-	add_token( 0x0cc, "offset16" );
-	add_token( 0x0cd, "evaluate" );
-	add_token( 0x0d0, "c," );
-	add_token( 0x0d1, "w," );
-	add_token( 0x0d2, "l," );
-	add_token( 0x0d3, "," );
-	add_token( 0x0d4, "um*" );
-	add_token( 0x0d5, "um/mod" );
-	add_token( 0x0d8, "d+" );
-	add_token( 0x0d9, "d-" );
-	add_token( 0x0da, "get-token" );
-	add_token( 0x0db, "set-token" );
-	add_token( 0x0dc, "state" );
-	add_token( 0x0dd, "compile" );
-	add_token( 0x0de, "behavior" );
-	add_token( 0x0f0, "start0" );
-	add_token( 0x0f1, "start1" );
-	add_token( 0x0f2, "start2" );
-	add_token( 0x0f3, "start4" );
-	add_token( 0x0fc, "ferror" );
-	add_token( 0x0fd, "version1" );
-	add_token( 0x0fe, "4-byte-id" );
-	add_token( 0x0ff, "end1" );
-	add_token( 0x101, "dma-alloc" );
-	add_token( 0x102, "my-address" );
-	add_token( 0x103, "my-space" );
-	add_token( 0x104, "memmap" );
-	add_token( 0x105, "free-virtual" );
-	add_token( 0x106, ">physical" );
-	add_token( 0x10f, "my-params" );
-	add_token( 0x110, "property" );
-	add_token( 0x111, "encode-int" );
-	add_token( 0x112, "encode+" );
-	add_token( 0x113, "encode-phys" );
-	add_token( 0x114, "encode-string" );
-	add_token( 0x115, "encode-bytes" );
-	add_token( 0x116, "reg" );
-	add_token( 0x117, "intr" );
-	add_token( 0x118, "driver" );
-	add_token( 0x119, "model" );
-	add_token( 0x11a, "device-type" );
-	add_token( 0x11b, "parse-2int" );
-	add_token( 0x11c, "is-install" );
-	add_token( 0x11d, "is-remove" );
-	add_token( 0x11e, "is-selftest" );
-	add_token( 0x11f, "new-device" );
-	add_token( 0x120, "diagnostic-mode?" );
-	add_token( 0x121, "display-status" );
-	add_token( 0x122, "memory-test-issue" );
-	add_token( 0x123, "group-code" );
-	add_token( 0x124, "mask" );
-	add_token( 0x125, "get-msecs" );
-	add_token( 0x126, "ms" );
-	add_token( 0x127, "finish-device" );
-	add_token( 0x128, "decode-phys" );
-	add_token( 0x12b, "interpose" );
-	add_token( 0x130, "map-low" );
-	add_token( 0x131, "sbus-intr>cpu" );
-	add_token( 0x150, "#lines" );
-	add_token( 0x151, "#columns" );
-	add_token( 0x152, "line#" );
-	add_token( 0x153, "column#" );
-	add_token( 0x154, "inverse?" );
-	add_token( 0x155, "inverse-screen?" );
-	add_token( 0x156, "frame-buffer-busy?" );
-	add_token( 0x157, "draw-character" );
-	add_token( 0x158, "reset-screen" );
-	add_token( 0x159, "toggle-cursor" );
-	add_token( 0x15a, "erase-screen" );
-	add_token( 0x15b, "blink-screen" );
-	add_token( 0x15c, "invert-screen" );
-	add_token( 0x15d, "insert-characters" );
-	add_token( 0x15e, "delete-characters" );
-	add_token( 0x15f, "insert-lines" );
-	add_token( 0x160, "delete-lines" );
-	add_token( 0x161, "draw-logo" );
-	add_token( 0x162, "frame-buffer-adr" );
-	add_token( 0x163, "screen-height" );
-	add_token( 0x164, "screen-width" );
-	add_token( 0x165, "window-top" );
-	add_token( 0x166, "window-left" );
-	add_token( 0x16a, "default-font" );
-	add_token( 0x16b, "set-font" );
-	add_token( 0x16c, "char-height" );
-	add_token( 0x16d, "char-width" );
-	add_token( 0x16e, ">font" );
-	add_token( 0x16f, "fontbytes" );
-	add_token( 0x170, "fb1-draw-character" );
-	add_token( 0x171, "fb1-reset-screen" );
-	add_token( 0x172, "fb1-toggle-cursor" );
-	add_token( 0x173, "fb1-erase-screen" );
-	add_token( 0x174, "fb1-blink-screen" );
-	add_token( 0x175, "fb1-invert-screen" );
-	add_token( 0x176, "fb1-insert-characters" );
-	add_token( 0x177, "fb1-delete-characters" );
-	add_token( 0x178, "fb1-insert-lines" );
-	add_token( 0x179, "fb1-delete-lines" );
-	add_token( 0x17a, "fb1-draw-logo" );
-	add_token( 0x17b, "fb1-install" );
-	add_token( 0x17c, "fb1-slide-up" );
-	add_token( 0x180, "fb8-draw-character" );
-	add_token( 0x181, "fb8-reset-screen" );
-	add_token( 0x182, "fb8-toggle-cursor" );
-	add_token( 0x183, "fb8-erase-screen" );
-	add_token( 0x184, "fb8-blink-screen" );
-	add_token( 0x185, "fb8-invert-screen" );
-	add_token( 0x186, "fb8-insert-characters" );
-	add_token( 0x187, "fb8-delete-characters" );
-	add_token( 0x188, "fb8-insert-lines" );
-	add_token( 0x189, "fb8-delete-lines" );
-	add_token( 0x18a, "fb8-draw-logo" );
-	add_token( 0x18b, "fb8-install" );
-	add_token( 0x1a0, "return-buffer" );
-	add_token( 0x1a1, "xmit-packet" );
-	add_token( 0x1a2, "poll-packet" );
-	add_token( 0x1a4, "mac-address" );
-	add_token( 0x201, "device-name" );
-	add_token( 0x202, "my-args" );
-	add_token( 0x203, "my-self" );
-	add_token( 0x204, "find-package" );
-	add_token( 0x205, "open-package" );
-	add_token( 0x206, "close-package" );
-	add_token( 0x207, "find-method" );
-	add_token( 0x208, "call-package" );
-	add_token( 0x209, "$call-parent" );
-	add_token( 0x20a, "my-package" );
-	add_token( 0x20b, "ihandle>phandle" );
-	add_token( 0x20d, "my-unit" );
-	add_token( 0x20e, "$call-method" );
-	add_token( 0x20f, "$open-package" );
-	add_token( 0x210, "processor-type" );
-	add_token( 0x211, "firmware-version" );
-	add_token( 0x212, "fcode-version" );
-	add_token( 0x213, "alarm" );
-	add_token( 0x214, "(is-user-word)" );
-	add_token( 0x215, "suspend-fcode" );
-	add_token( 0x216, "abort" );
-	add_token( 0x217, "catch" );
-	add_token( 0x218, "throw" );
-	add_token( 0x219, "user-abort" );
-	add_token( 0x21a, "get-my-property" );
-	add_token( 0x21b, "decode-int" );
-	add_token( 0x21c, "decode-string" );
-	add_token( 0x21d, "get-inherited-property" );
-	add_token( 0x21e, "delete-property" );
-	add_token( 0x21f, "get-package-property" );
-	add_token( 0x220, "cpeek" );
-	add_token( 0x221, "wpeek" );
-	add_token( 0x222, "lpeek" );
-	add_token( 0x223, "cpoke" );
-	add_token( 0x224, "wpoke" );
-	add_token( 0x225, "lpoke" );
-	add_token( 0x226, "lwflip" );
-	add_token( 0x227, "lbflip" );
-	add_token( 0x228, "lbflips" );
-	add_token( 0x229, "adr-mask" );
-	add_token( 0x230, "rb@" );
-	add_token( 0x231, "rb!" );
-	add_token( 0x232, "rw@" );
-	add_token( 0x233, "rw!" );
-	add_token( 0x234, "rl@" );
-	add_token( 0x235, "rl!" );
-	add_token( 0x236, "wbflips" );
-	add_token( 0x237, "lwflips" );
-	add_token( 0x238, "probe" );
-	add_token( 0x239, "probe-virtual" );
-	add_token( 0x23b, "child" );
-	add_token( 0x23c, "peer" );
-	add_token( 0x23d, "next-property" );
-	add_token( 0x23e, "byte-load" );
-	add_token( 0x23f, "set-args" );
-	add_token( 0x240, "left-parse-string" );
+/* **************************************************************************
+ *
+ *      Support functions specific to the lists will be defined
+ *          after the lists are created.
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *     Create the initial list (or "Table") of FCode-Tokens.
+ *
+ *     Most Standard FCode tokens are not specified as to their definition
+ *         type, but a few have a definer specified as either a VALUE, a
+ *         VARIABLE or a DEFER; we will enter them with the appropriate macro.
+ *
+ **************************************************************************** */
+
+static tic_hdr_t tokens_table[] =
+{
+	BUILTIN_FCODE( 0x000, "end0" ) ,
+	BUILTIN_FCODE( 0x010, "b(lit)" ) ,
+	BUILTIN_FCODE( 0x011, "b(')" ) ,
+	BUILTIN_FCODE( 0x012, "b(\")" ) ,
+	BUILTIN_FCODE( 0x013, "bbranch" ) ,
+	BUILTIN_FCODE( 0x014, "b?branch" ) ,
+	BUILTIN_FCODE( 0x015, "b(loop)" ) ,
+	BUILTIN_FCODE( 0x016, "b(+loop)" ) ,
+	BUILTIN_FCODE( 0x017, "b(do)" ) ,
+	BUILTIN_FCODE( 0x018, "b(?do)" ) ,
+	BUILTIN_FCODE( 0x019, "i" ) ,
+	BUILTIN_FCODE( 0x01a, "j" ) ,
+	BUILTIN_FCODE( 0x01b, "b(leave)" ) ,
+	BUILTIN_FCODE( 0x01c, "b(of)" ) ,
+	BUILTIN_FCODE( 0x01d, "execute" ) ,
+	BUILTIN_FCODE( 0x01e, "+" ) ,
+	BUILTIN_FCODE( 0x01f, "-" ) ,
+	BUILTIN_FCODE( 0x020, "*" ) ,
+	BUILTIN_FCODE( 0x021, "/" ) ,
+	BUILTIN_FCODE( 0x022, "mod" ) ,
+	BUILTIN_FCODE( 0x023, "and" ) ,
+	BUILTIN_FCODE( 0x024, "or" ) ,
+	BUILTIN_FCODE( 0x025, "xor" ) ,
+	BUILTIN_FCODE( 0x026, "invert" ) ,
+	BUILTIN_FCODE( 0x026, "not" ) ,           /*  Synonym for "invert" */
+	BUILTIN_FCODE( 0x027, "lshift" ) ,
+	BUILTIN_FCODE( 0x027, "<<" ) ,            /*  Synonym for "lshift" */
+	BUILTIN_FCODE( 0x028, "rshift" ) ,
+	BUILTIN_FCODE( 0x028, ">>" ) ,            /*  Synonym for "rshift" */
+	BUILTIN_FCODE( 0x029, ">>a" ) ,
+	BUILTIN_FCODE( 0x02a, "/mod" ) ,
+	BUILTIN_FCODE( 0x02b, "u/mod" ) ,
+	BUILTIN_FCODE( 0x02c, "negate" ) ,
+	BUILTIN_FCODE( 0x02d, "abs" ) ,
+	BUILTIN_FCODE( 0x02e, "min" ) ,
+	BUILTIN_FCODE( 0x02f, "max" ) ,
+	BUILTIN_FCODE( 0x030, ">r" ) ,
+	BUILTIN_FCODE( 0x031, "r>" ) ,
+	BUILTIN_FCODE( 0x032, "r@" ) ,
+	BUILTIN_FCODE( 0x033, "exit" ) ,
+	BUILTIN_FCODE( 0x034, "0=" ) ,
+	BUILTIN_FCODE( 0x035, "0<>" ) ,
+	BUILTIN_FCODE( 0x036, "0<" ) ,
+	BUILTIN_FCODE( 0x037, "0<=" ) ,
+	BUILTIN_FCODE( 0x038, "0>" ) ,
+	BUILTIN_FCODE( 0x039, "0>=" ) ,
+	BUILTIN_FCODE( 0x03a, "<" ) ,
+	BUILTIN_FCODE( 0x03b, ">" ) ,
+	BUILTIN_FCODE( 0x03c, "=" ) ,
+	BUILTIN_FCODE( 0x03d, "<>" ) ,
+	BUILTIN_FCODE( 0x03e, "u>" ) ,
+	BUILTIN_FCODE( 0x03f, "u<=" ) ,
+	BUILTIN_FCODE( 0x040, "u<" ) ,
+	BUILTIN_FCODE( 0x041, "u>=" ) ,
+	BUILTIN_FCODE( 0x042, ">=" ) ,
+	BUILTIN_FCODE( 0x043, "<=" ) ,
+	BUILTIN_FCODE( 0x044, "between" ) ,
+	BUILTIN_FCODE( 0x045, "within" ) ,
+	BUILTIN_FCODE( 0x046, "drop" ) ,
+	BUILTIN_FCODE( 0x047, "dup" ) ,
+	BUILTIN_FCODE( 0x048, "over" ) ,
+	BUILTIN_FCODE( 0x049, "swap" ) ,
+	BUILTIN_FCODE( 0x04A, "rot" ) ,
+	BUILTIN_FCODE( 0x04b, "-rot" ) ,
+	BUILTIN_FCODE( 0x04c, "tuck" ) ,
+	BUILTIN_FCODE( 0x04d, "nip" ) ,
+	BUILTIN_FCODE( 0x04e, "pick" ) ,
+	BUILTIN_FCODE( 0x04f, "roll" ) ,
+	BUILTIN_FCODE( 0x050, "?dup" ) ,
+	BUILTIN_FCODE( 0x051, "depth" ) ,
+	BUILTIN_FCODE( 0x052, "2drop" ) ,
+	BUILTIN_FCODE( 0x053, "2dup" ) ,
+	BUILTIN_FCODE( 0x054, "2over" ) ,
+	BUILTIN_FCODE( 0x055, "2swap" ) ,
+	BUILTIN_FCODE( 0x056, "2rot" ) ,
+	BUILTIN_FCODE( 0x057, "2/" ) ,
+	BUILTIN_FCODE( 0x058, "u2/" ) ,
+	BUILTIN_FCODE( 0x059, "2*" ) ,
+	BUILTIN_FCODE( 0x05a, "/c" ) ,
+	BUILTIN_FCODE( 0x05b, "/w" ) ,
+	BUILTIN_FCODE( 0x05c, "/l" ) ,
+	BUILTIN_FCODE( 0x05d, "/n" ) ,
+	BUILTIN_FCODE( 0x05e, "ca+" ) ,
+	BUILTIN_FCODE( 0x05f, "wa+" ) ,
+	BUILTIN_FCODE( 0x060, "la+" ) ,
+	BUILTIN_FCODE( 0x061, "na+" ) ,
+	BUILTIN_FCODE( 0x062, "char+" ) ,
+	BUILTIN_FCODE( 0x062, "ca1+" ) ,          /*  Synonym for char+" */
+	BUILTIN_FCODE( 0x063, "wa1+" ) ,
+	BUILTIN_FCODE( 0x064, "la1+" ) ,
+	BUILTIN_FCODE( 0x065, "cell+" ) ,
+	BUILTIN_FCODE( 0x065, "na1+" ) ,          /*  Synonym for "cell+" */
+	BUILTIN_FCODE( 0x066, "chars" ) ,
+	BUILTIN_FCODE( 0x066, "/c*" ) ,           /*  Synonym for "chars" */
+	BUILTIN_FCODE( 0x067, "/w*" ) ,
+	BUILTIN_FCODE( 0x068, "/l*" ) ,
+	BUILTIN_FCODE( 0x069, "cells" ) ,
+	BUILTIN_FCODE( 0x069, "/n*" ) ,           /*  Synonym for "cells" */
+	BUILTIN_FCODE( 0x06a, "on" ) ,
+	BUILTIN_FCODE( 0x06b, "off" ) ,
+	BUILTIN_FCODE( 0x06c, "+!" ) ,
+	BUILTIN_FCODE( 0x06d, "@" ) ,
+	BUILTIN_FCODE( 0x06e, "l@" ) ,
+	BUILTIN_FCODE( 0x06f, "w@" ) ,
+	BUILTIN_FCODE( 0x070, "<w@" ) ,
+	BUILTIN_FCODE( 0x071, "c@" ) ,
+	BUILTIN_FCODE( 0x072, "!" ) ,
+	BUILTIN_FCODE( 0x073, "l!" ) ,
+	BUILTIN_FCODE( 0x074, "w!" ) ,
+	BUILTIN_FCODE( 0x075, "c!" ) ,
+	BUILTIN_FCODE( 0x076, "2@" ) ,
+	BUILTIN_FCODE( 0x077, "2!" ) ,
+	BUILTIN_FCODE( 0x078, "move" ) ,
+	BUILTIN_FCODE( 0x079, "fill" ) ,
+	BUILTIN_FCODE( 0x07a, "comp" ) ,
+	BUILTIN_FCODE( 0x07b, "noop" ) ,
+	BUILTIN_FCODE( 0x07c, "lwsplit" ) ,
+	BUILTIN_FCODE( 0x07d, "wljoin" ) ,
+	BUILTIN_FCODE( 0x07e, "lbsplit" ) ,
+	BUILTIN_FCODE( 0x07f, "bljoin" ) ,
+	BUILTIN_FCODE( 0x080, "wbflip" ) ,
+	BUILTIN_FCODE( 0x080, "flip" ) ,   /*  Synonym for "wbflip"  */
+	BUILTIN_FCODE( 0x081, "upc" ) ,
+	BUILTIN_FCODE( 0x082, "lcc" ) ,
+	BUILTIN_FCODE( 0x083, "pack" ) ,
+	BUILTIN_FCODE( 0x084, "count" ) ,
+	BUILTIN_FCODE( 0x085, "body>" ) ,
+	BUILTIN_FCODE( 0x086, ">body" ) ,
+	BUILTIN_FCODE( 0x087, "fcode-revision" ) ,
+	BUILTIN_FCODE( 0x087, "version" ) , /*  Synonym for "fcode-revision" */
+	BI_FCODE_VRBLE( 0x088, "span" ) ,
+	BUILTIN_FCODE( 0x089, "unloop" ) ,
+	BUILTIN_FCODE( 0x08a, "expect" ) ,
+	BUILTIN_FCODE( 0x08b, "alloc-mem" ) ,
+	BUILTIN_FCODE( 0x08c, "free-mem" ) ,
+	BUILTIN_FCODE( 0x08d, "key?" ) ,
+	BUILTIN_FCODE( 0x08e, "key" ) ,
+	BUILTIN_FCODE( 0x08f, "emit" ) ,
+	BUILTIN_FCODE( 0x090, "type" ) ,
+	BUILTIN_FCODE( 0x091, "(cr" ) ,
+	BUILTIN_FCODE( 0x092, "cr" ) ,
+	BI_FCODE_VRBLE( 0x093, "#out" ) ,
+	BI_FCODE_VRBLE( 0x094, "#line" ) ,
+	BUILTIN_FCODE( 0x095, "hold" ) ,
+	BUILTIN_FCODE( 0x096, "<#" ) ,
+	BUILTIN_FCODE( 0x097, "u#>" ) ,
+	BUILTIN_FCODE( 0x098, "sign" ) ,
+	BUILTIN_FCODE( 0x099, "u#" ) ,
+	BUILTIN_FCODE( 0x09a, "u#s" ) ,
+	BUILTIN_FCODE( 0x09b, "u." ) ,
+	BUILTIN_FCODE( 0x09c, "u.r" ) ,
+	BUILTIN_FCODE( 0x09d, "." ) ,
+	BUILTIN_FCODE( 0x09e, ".r" ) ,
+	BUILTIN_FCODE( 0x09f, ".s" ) ,
+	BI_FCODE_VRBLE( 0x0a0, "base" ) ,
+	OBSOLETE_FCODE( 0x0a1, "convert" ) ,
+	BUILTIN_FCODE( 0x0a2, "$number" ) ,
+	BUILTIN_FCODE( 0x0a3, "digit" ) ,
+	BI_FCODE_CONST( 0x0a4, "-1" ) ,
+	BI_FCODE_CONST( 0x0a4, "true" ) ,          /*  Synonym for "-1" */
+	BI_FCODE_CONST( 0x0a5, "0" ) ,
+	BI_FCODE_CONST( 0x0a5, "false" ) ,         /*  Synonym for "0" */
+	BI_FCODE_CONST( 0x0a5, "struct" ) ,        /*  Synonym for "0" */
+	BI_FCODE_CONST( 0x0a6, "1" ) ,
+	BI_FCODE_CONST( 0x0a7, "2" ) ,
+	BI_FCODE_CONST( 0x0a8, "3" ) ,
+	BI_FCODE_CONST( 0x0a9, "bl" ) ,
+	BI_FCODE_CONST( 0x0aa, "bs" ) ,
+	BI_FCODE_CONST( 0x0ab, "bell" ) ,
+	BUILTIN_FCODE( 0x0ac, "bounds" ) ,
+	BUILTIN_FCODE( 0x0ad, "here" ) ,
+	BUILTIN_FCODE( 0x0ae, "aligned" ) ,
+	BUILTIN_FCODE( 0x0af, "wbsplit" ) ,
+	BUILTIN_FCODE( 0x0b0, "bwjoin" ) ,
+	BUILTIN_FCODE( 0x0b1, "b(<mark)" ) ,
+	BUILTIN_FCODE( 0x0b2, "b(>resolve)" ) ,
+	OBSOLETE_FCODE( 0x0b3, "set-token-table" ) ,
+	OBSOLETE_FCODE( 0x0b4, "set-table" ) ,
+	BUILTIN_FCODE( 0x0b5, "new-token" ) ,
+	BUILTIN_FCODE( 0x0b6, "named-token" ) ,
+	BUILTIN_FCODE( 0x0b7, "b(:)" ) ,
+	BUILTIN_FCODE( 0x0b8, "b(value)" ) ,
+	BUILTIN_FCODE( 0x0b9, "b(variable)" ) ,
+	BUILTIN_FCODE( 0x0ba, "b(constant)" ) ,
+	BUILTIN_FCODE( 0x0bb, "b(create)" ) ,
+	BUILTIN_FCODE( 0x0bc, "b(defer)" ) ,
+	BUILTIN_FCODE( 0x0bd, "b(buffer:)" ) ,
+	BUILTIN_FCODE( 0x0be, "b(field)" ) ,
+	OBSOLETE_FCODE( 0x0bf, "b(code)" ) ,
+	BUILTIN_FCODE( 0x0c0, "instance" ) ,
+	BUILTIN_FCODE( 0x0c2, "b(;)" ) ,
+	BUILTIN_FCODE( 0x0c3, "b(to)" ) ,
+	BUILTIN_FCODE( 0x0c4, "b(case)" ) ,
+	BUILTIN_FCODE( 0x0c5, "b(endcase)" ) ,
+	BUILTIN_FCODE( 0x0c6, "b(endof)" ) ,
+	BUILTIN_FCODE( 0x0c7, "#" ) ,
+	BUILTIN_FCODE( 0x0c8, "#s" ) ,
+	BUILTIN_FCODE( 0x0c9, "#>" ) ,
+	BUILTIN_FCODE( 0x0ca, "external-token" ) ,
+	BUILTIN_FCODE( 0x0cb, "$find" ) ,
+	BUILTIN_FCODE( 0x0cc, "offset16" ) ,
+	BUILTIN_FCODE( 0x0cd, "evaluate" ) ,
+	BUILTIN_FCODE( 0x0cd, "eval" ) ,   /*  Synonym for "evaluate"  */
+	BUILTIN_FCODE( 0x0d0, "c," ) ,
+	BUILTIN_FCODE( 0x0d1, "w," ) ,
+	BUILTIN_FCODE( 0x0d2, "l," ) ,
+	BUILTIN_FCODE( 0x0d3, "," ) ,
+	BUILTIN_FCODE( 0x0d4, "um*" ) ,
+	BUILTIN_FCODE( 0x0d4, "u*x" ) ,        /*  Synonym for "um*" */
+	BUILTIN_FCODE( 0x0d5, "um/mod" ) ,
+	BUILTIN_FCODE( 0x0d5, "xu/mod" ) ,   /*  Synonym for "um/mod"  */
+	BUILTIN_FCODE( 0x0d8, "d+" ) ,
+	BUILTIN_FCODE( 0x0d8, "x+" ) ,   /*  Synonym for "d+"  */
+	BUILTIN_FCODE( 0x0d9, "d-" ) ,
+	BUILTIN_FCODE( 0x0d9, "x-" ) ,   /*  Synonym for "d-"  */
+	BUILTIN_FCODE( 0x0da, "get-token" ) ,
+	BUILTIN_FCODE( 0x0db, "set-token" ) ,
+	BI_FCODE_VRBLE( 0x0dc, "state" ) ,
+	BUILTIN_FCODE( 0x0dd, "compile" ) ,
+	BUILTIN_FCODE( 0x0de, "behavior" ) ,
+	BUILTIN_FCODE( 0x0f0, "start0" ) ,
+	BUILTIN_FCODE( 0x0f1, "start1" ) ,
+	BUILTIN_FCODE( 0x0f2, "start2" ) ,
+	BUILTIN_FCODE( 0x0f3, "start4" ) ,
+	BUILTIN_FCODE( 0x0fc, "ferror" ) ,
+	BUILTIN_FCODE( 0x0fd, "version1" ) ,
+	OBSOLETE_FCODE( 0x0fe, "4-byte-id" ) ,
+	BUILTIN_FCODE( 0x0ff, "end1" ) ,
+	OBSOLETE_FCODE( 0x101, "dma-alloc" ) ,
+	BUILTIN_FCODE( 0x102, "my-address" ) ,
+	BUILTIN_FCODE( 0x103, "my-space" ) ,
+	OBSOLETE_FCODE( 0x104, "memmap" ) ,
+	BUILTIN_FCODE( 0x105, "free-virtual" ) ,
+	OBSOLETE_FCODE( 0x106, ">physical" ) ,
+	OBSOLETE_FCODE( 0x10f, "my-params" ) ,
+	BUILTIN_FCODE( 0x110, "property" ) ,
+	BUILTIN_FCODE( 0x110, "attribute" ) ,    /*  Synonym for "property"  */
+	BUILTIN_FCODE( 0x111, "encode-int" ) ,
+	BUILTIN_FCODE( 0x111, "xdrint" ) ,     /*  Synonym for "encode-int"  */
+	BUILTIN_FCODE( 0x112, "encode+" ) ,
+	BUILTIN_FCODE( 0x112, "xdr+" ) ,          /*  Synonym for "encode+"  */
+	BUILTIN_FCODE( 0x113, "encode-phys" ) ,
+	BUILTIN_FCODE( 0x113, "xdrphys" ) ,   /*  Synonym for "encode-phys"  */
+	BUILTIN_FCODE( 0x114, "encode-string" ) ,
+	BUILTIN_FCODE( 0x114, "xdrstring" ) , /* Synonym for "encode-string" */
+	BUILTIN_FCODE( 0x115, "encode-bytes" ) ,
+	BUILTIN_FCODE( 0x115, "xdrbytes" ) ,  /*  Synonym for "encode-bytes" */
+	BUILTIN_FCODE( 0x116, "reg" ) ,
+	OBSOLETE_FCODE( 0x117, "intr" ) ,
+	OBSOLETE_FCODE( 0x118, "driver" ) ,
+	BUILTIN_FCODE( 0x119, "model" ) ,
+	BUILTIN_FCODE( 0x11a, "device-type" ) ,
+	BUILTIN_FCODE( 0x11b, "parse-2int" ) ,
+	BUILTIN_FCODE( 0x11b, "decode-2int" ) , /*  Synonym for "parse-2int" */
+	BUILTIN_FCODE( 0x11c, "is-install" ) ,
+	BUILTIN_FCODE( 0x11d, "is-remove" ) ,
+	BUILTIN_FCODE( 0x11e, "is-selftest" ) ,
+	BUILTIN_FCODE( 0x11f, "new-device" ) ,
+	BUILTIN_FCODE( 0x120, "diagnostic-mode?" ) ,
+	BUILTIN_FCODE( 0x121, "display-status" ) ,
+	BUILTIN_FCODE( 0x122, "memory-test-issue" ) ,
+	OBSOLETE_FCODE( 0x123, "group-code" ) ,
+	BI_FCODE_VRBLE( 0x124, "mask" ) ,
+	BUILTIN_FCODE( 0x125, "get-msecs" ) ,
+	BUILTIN_FCODE( 0x126, "ms" ) ,
+	BUILTIN_FCODE( 0x127, "finish-device" ) ,
+	BUILTIN_FCODE( 0x128, "decode-phys" ) ,
+	BUILTIN_FCODE( 0x12b, "interpose" ) ,
+	BUILTIN_FCODE( 0x130, "map-low" ) ,
+	BUILTIN_FCODE( 0x130, "map-sbus" ) ,   /*  Synonym for "map-low"  */
+	BUILTIN_FCODE( 0x131, "sbus-intr>cpu" ) ,
+	BI_FCODE_VALUE( 0x150, "#lines" ) ,
+	BI_FCODE_VALUE( 0x151, "#columns" ) ,
+	BI_FCODE_VALUE( 0x152, "line#" ) ,
+	BI_FCODE_VALUE( 0x153, "column#" ) ,
+	BI_FCODE_VALUE( 0x154, "inverse?" ) ,
+	BI_FCODE_VALUE( 0x155, "inverse-screen?" ) ,
+	OBSOLETE_VALUE( 0x156, "frame-buffer-busy?" ) ,
+	BI_FCODE_DEFER( 0x157, "draw-character" ) ,
+	BI_FCODE_DEFER( 0x158, "reset-screen" ) ,
+	BI_FCODE_DEFER( 0x159, "toggle-cursor" ) ,
+	BI_FCODE_DEFER( 0x15a, "erase-screen" ) ,
+	BI_FCODE_DEFER( 0x15b, "blink-screen" ) ,
+	BI_FCODE_DEFER( 0x15c, "invert-screen" ) ,
+	BI_FCODE_DEFER( 0x15d, "insert-characters" ) ,
+	BI_FCODE_DEFER( 0x15e, "delete-characters" ) ,
+	BI_FCODE_DEFER( 0x15f, "insert-lines" ) ,
+	BI_FCODE_DEFER( 0x160, "delete-lines" ) ,
+	BI_FCODE_DEFER( 0x161, "draw-logo" ) ,
+	BI_FCODE_VALUE( 0x162, "frame-buffer-adr" ) ,
+	BI_FCODE_VALUE( 0x163, "screen-height" ) ,
+	BI_FCODE_VALUE( 0x164, "screen-width" ) ,
+	BI_FCODE_VALUE( 0x165, "window-top" ) ,
+	BI_FCODE_VALUE( 0x166, "window-left" ) ,
+	BUILTIN_FCODE( 0x16a, "default-font" ) ,
+	BUILTIN_FCODE( 0x16b, "set-font" ) ,
+	BI_FCODE_VALUE( 0x16c, "char-height" ) ,
+	BI_FCODE_VALUE( 0x16d, "char-width" ) ,
+	BUILTIN_FCODE( 0x16e, ">font" ) ,
+	BI_FCODE_VALUE( 0x16f, "fontbytes" ) ,
+	OBSOLETE_FCODE( 0x170, "fb1-draw-character" ) ,
+	OBSOLETE_FCODE( 0x171, "fb1-reset-screen" ) ,
+	OBSOLETE_FCODE( 0x172, "fb1-toggle-cursor" ) ,
+	OBSOLETE_FCODE( 0x173, "fb1-erase-screen" ) ,
+	OBSOLETE_FCODE( 0x174, "fb1-blink-screen" ) ,
+	OBSOLETE_FCODE( 0x175, "fb1-invert-screen" ) ,
+	OBSOLETE_FCODE( 0x176, "fb1-insert-characters" ) ,
+	OBSOLETE_FCODE( 0x177, "fb1-delete-characters" ) ,
+	OBSOLETE_FCODE( 0x178, "fb1-insert-lines" ) ,
+	OBSOLETE_FCODE( 0x179, "fb1-delete-lines" ) ,
+	OBSOLETE_FCODE( 0x17a, "fb1-draw-logo" ) ,
+	OBSOLETE_FCODE( 0x17b, "fb1-install" ) ,
+	OBSOLETE_FCODE( 0x17c, "fb1-slide-up" ) ,
+	BUILTIN_FCODE( 0x180, "fb8-draw-character" ) ,
+	BUILTIN_FCODE( 0x181, "fb8-reset-screen" ) ,
+	BUILTIN_FCODE( 0x182, "fb8-toggle-cursor" ) ,
+	BUILTIN_FCODE( 0x183, "fb8-erase-screen" ) ,
+	BUILTIN_FCODE( 0x184, "fb8-blink-screen" ) ,
+	BUILTIN_FCODE( 0x185, "fb8-invert-screen" ) ,
+	BUILTIN_FCODE( 0x186, "fb8-insert-characters" ) ,
+	BUILTIN_FCODE( 0x187, "fb8-delete-characters" ) ,
+	BUILTIN_FCODE( 0x188, "fb8-insert-lines" ) ,
+	BUILTIN_FCODE( 0x189, "fb8-delete-lines" ) ,
+	BUILTIN_FCODE( 0x18a, "fb8-draw-logo" ) ,
+	BUILTIN_FCODE( 0x18b, "fb8-install" ) ,
+	OBSOLETE_FCODE( 0x1a0, "return-buffer" ) ,
+	OBSOLETE_FCODE( 0x1a1, "xmit-packet" ) ,
+	OBSOLETE_FCODE( 0x1a2, "poll-packet" ) ,
+	BUILTIN_FCODE( 0x1a4, "mac-address" ) ,
+	BUILTIN_FCODE( 0x201, "device-name" ) ,
+	BUILTIN_FCODE( 0x201, "name" ) ,   /*  Synonym for "device-name"  */
+	BUILTIN_FCODE( 0x202, "my-args" ) ,
+	BI_FCODE_VALUE( 0x203, "my-self" ) ,
+	BUILTIN_FCODE( 0x204, "find-package" ) ,
+	BUILTIN_FCODE( 0x205, "open-package" ) ,
+	BUILTIN_FCODE( 0x206, "close-package" ) ,
+	BUILTIN_FCODE( 0x207, "find-method" ) ,
+	BUILTIN_FCODE( 0x208, "call-package" ) ,
+	BUILTIN_FCODE( 0x209, "$call-parent" ) ,
+	BUILTIN_FCODE( 0x20a, "my-parent" ) ,
+	BUILTIN_FCODE( 0x20b, "ihandle>phandle" ) ,
+	BUILTIN_FCODE( 0x20d, "my-unit" ) ,
+	BUILTIN_FCODE( 0x20e, "$call-method" ) ,
+	BUILTIN_FCODE( 0x20f, "$open-package" ) ,
+	OBSOLETE_FCODE( 0x210, "processor-type" ) ,
+	OBSOLETE_FCODE( 0x211, "firmware-version" ) ,
+	OBSOLETE_FCODE( 0x212, "fcode-version" ) ,
+	BUILTIN_FCODE( 0x213, "alarm" ) ,
+	BUILTIN_FCODE( 0x214, "(is-user-word)" ) ,
+	BUILTIN_FCODE( 0x215, "suspend-fcode" ) ,
+	BUILTIN_FCODE( 0x216, "abort" ) ,
+	BUILTIN_FCODE( 0x217, "catch" ) ,
+	BUILTIN_FCODE( 0x218, "throw" ) ,
+	BUILTIN_FCODE( 0x219, "user-abort" ) ,
+	BUILTIN_FCODE( 0x21a, "get-my-property" ) ,
+	BUILTIN_FCODE( 0x21a, "get-my-attribute" ) ,   /*  Synonym for "get-my-property"  */
+	BUILTIN_FCODE( 0x21b, "decode-int" ) ,
+	BUILTIN_FCODE( 0x21b, "xdrtoint" ) ,   /*  Synonym for "decode-int"  */
+	BUILTIN_FCODE( 0x21c, "decode-string" ) ,
+	BUILTIN_FCODE( 0x21c, "xdrtostring" ), /* Synonym for "decode-string" */
+	BUILTIN_FCODE( 0x21d, "get-inherited-property" ) ,
+	BUILTIN_FCODE( 0x21d, "get-inherited-attribute" ) ,   /*  Synonym for "get-inherited-property"  */
+	BUILTIN_FCODE( 0x21e, "delete-property" ) ,
+	BUILTIN_FCODE( 0x21e, "delete-attribute" ) ,   /*  Synonym for "delete-property"  */
+	BUILTIN_FCODE( 0x21f, "get-package-property" ) ,
+	BUILTIN_FCODE( 0x21f, "get-package-attribute" ) ,   /*  Synonym for "get-package-property"  */
+	BUILTIN_FCODE( 0x220, "cpeek" ) ,
+	BUILTIN_FCODE( 0x221, "wpeek" ) ,
+	BUILTIN_FCODE( 0x222, "lpeek" ) ,
+	BUILTIN_FCODE( 0x223, "cpoke" ) ,
+	BUILTIN_FCODE( 0x224, "wpoke" ) ,
+	BUILTIN_FCODE( 0x225, "lpoke" ) ,
+	BUILTIN_FCODE( 0x226, "lwflip" ) ,
+	BUILTIN_FCODE( 0x227, "lbflip" ) ,
+	BUILTIN_FCODE( 0x228, "lbflips" ) ,
+	OBSOLETE_FCODE( 0x229, "adr-mask" ) ,
+	BUILTIN_FCODE( 0x230, "rb@" ) ,
+	BUILTIN_FCODE( 0x231, "rb!" ) ,
+	BUILTIN_FCODE( 0x232, "rw@" ) ,
+	BUILTIN_FCODE( 0x233, "rw!" ) ,
+	BUILTIN_FCODE( 0x234, "rl@" ) ,
+	BUILTIN_FCODE( 0x235, "rl!" ) ,
+	BUILTIN_FCODE( 0x236, "wbflips" ) ,
+	BUILTIN_FCODE( 0x236, "wflips" ) ,   /*  Synonym for "wbflips"  */
+	BUILTIN_FCODE( 0x237, "lwflips" ) ,
+	BUILTIN_FCODE( 0x237, "lflips" ) ,   /*  Synonym for "lwflips"  */
+	OBSOLETE_FCODE( 0x238, "probe" ) ,
+	OBSOLETE_FCODE( 0x239, "probe-virtual" ) ,
+	BUILTIN_FCODE( 0x23b, "child" ) ,
+	BUILTIN_FCODE( 0x23c, "peer" ) ,
+	BUILTIN_FCODE( 0x23d, "next-property" ) ,
+	BUILTIN_FCODE( 0x23e, "byte-load" ) ,
+	BUILTIN_FCODE( 0x23f, "set-args" ) ,
+	BUILTIN_FCODE( 0x240, "left-parse-string" ) ,
 
 	/* FCodes from 64bit extension addendum */
-	add_token( 0x22e, "rx@" );
-	add_token( 0x22f, "rx!" );
-	add_token( 0x241, "bxjoin" );
-	add_token( 0x242, "<l@" );
-	add_token( 0x243, "lxjoin" );
-	add_token( 0x244, "wxjoin" );
-	add_token( 0x245, "x," );
-	add_token( 0x246, "x@" );
-	add_token( 0x247, "x!" );
-	add_token( 0x248, "/x" );
-	add_token( 0x249, "/x*" );
-	add_token( 0x24a, "xa+" );
-	add_token( 0x24b, "xa1+" );
-	add_token( 0x24c, "xbflip" );
-	add_token( 0x24d, "xbflips" );
-	add_token( 0x24e, "xbsplit" );
-	add_token( 0x24f, "xlflip" );
-	add_token( 0x250, "xlflips" );
-	add_token( 0x251, "xlsplit" );
-	add_token( 0x252, "xwflip" );
-	add_token( 0x253, "xwflips" );
-	add_token( 0x254, "xwsplit" );
-
-	add_special(COLON, 	":");
-	add_special(SEMICOLON, 	";");
-	add_special(TOKENIZE, 	"'");
-	add_special(AGAIN, 	"again");
-	add_special(ALIAS, 	"alias");
-	add_special(GETTOKEN, 	"[']");
-	add_special(ASCII, 	"ascii");
-	add_special(BEGIN, 	"begin");
-	add_special(BUFFER, 	"buffer:");
-	add_special(CASE, 	"case");
-	add_special(CONST, 	"constant");
-	add_special(CONTROL, 	"control");
-	add_special(CREATE, 	"create");
-	add_special(DECIMAL, 	"decimal");
-	add_special(DEFER, 	"defer");
-	add_special(CDO, 	"?do");
-	add_special(DO, 	"do");
-	add_special(ELSE, 	"else");
-	add_special(ENDCASE, 	"endcase");
-	add_special(ENDOF, 	"endof");
-	add_special(EXTERNAL, 	"external");
-	add_special(FIELD, 	"field");
-	add_special(HEADERLESS, "headerless");
-	add_special(HEADERS, 	"headers");
-	add_special(HEX, 	"hex");
-	add_special(IF, 	"if");
-	add_special(CLEAVE, 	"?leave");
-	add_special(LEAVE, 	"leave");
-	add_special(CLOOP, 	"+loop");
-	add_special(LOOP, 	"loop");
-	add_special(OCTAL,	"octal");
-	add_special(OF,		"of");
-	add_special(REPEAT,	"repeat");
-	add_special(THEN,	"then");
-	add_special(TO,		"to");
-	add_special(UNTIL,	"until");
-	add_special(VALUE,	"value");
-	add_special(VARIABLE,	"variable");
-	add_special(WHILE,	"while");
-	add_special(OFFSET16,	"offset16");
-	add_special(BEGINTOK,	"tokenizer[");
-	add_special(EMITBYTE,	"emit-byte");
-	add_special(ENDTOK,	"]tokenizer");
-	add_special(FLOAD,	"fload");
-	add_special(STRING,	"\"");
-	add_special(PSTRING,	".\"");
-	add_special(PBSTRING,	".(");
-	add_special(SSTRING,	"s\"");
-	add_special(RECURSIVE,	"recursive");
-	add_special(NEXTFCODE,	"next-fcode");
+	BUILTIN_FCODE( 0x22e, "rx@" ) ,
+	BUILTIN_FCODE( 0x22f, "rx!" ) ,
+	BUILTIN_FCODE( 0x241, "bxjoin" ) ,
+	BUILTIN_FCODE( 0x242, "<l@" ) ,
+	BUILTIN_FCODE( 0x243, "lxjoin" ) ,
+	BUILTIN_FCODE( 0x244, "wxjoin" ) ,
+	BUILTIN_FCODE( 0x245, "x," ) ,
+	BUILTIN_FCODE( 0x246, "x@" ) ,
+	BUILTIN_FCODE( 0x247, "x!" ) ,
+	BUILTIN_FCODE( 0x248, "/x" ) ,
+	BUILTIN_FCODE( 0x249, "/x*" ) ,
+	BUILTIN_FCODE( 0x24a, "xa+" ) ,
+	BUILTIN_FCODE( 0x24b, "xa1+" ) ,
+	BUILTIN_FCODE( 0x24c, "xbflip" ) ,
+	BUILTIN_FCODE( 0x24d, "xbflips" ) ,
+	BUILTIN_FCODE( 0x24e, "xbsplit" ) ,
+	BUILTIN_FCODE( 0x24f, "xlflip" ) ,
+	BUILTIN_FCODE( 0x250, "xlflips" ) ,
+	BUILTIN_FCODE( 0x251, "xlsplit" ) ,
+	BUILTIN_FCODE( 0x252, "xwflip" ) ,
+	BUILTIN_FCODE( 0x253, "xwflips" ) ,
+	BUILTIN_FCODE( 0x254, "xwsplit" )
+};
+
+static const int number_of_builtin_tokens =
+	 sizeof(tokens_table)/sizeof(tic_hdr_t);
+
+/* **************************************************************************
+ *
+ *      Support functions specific to the FCode-Tokens list.
+ *
+ **************************************************************************** */
+
+
+/* **************************************************************************
+ *
+ *      Function name:  emit_token
+ *      Synopsis:       Emit the FCode token for the given FCode name.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             fc_name                     The name of the FCode
+ *         Local Static Variables:
+ *             fc_tokens_list_start        "Tail" of the "FC-Tokens" list
+ *
+ *      Outputs:
+ *         Returned Value:                 NONE
+ *
+ *      Error Detection:
+ *          This routine should only be called with hard-coded names from
+ *              within the program.  If the given name is not found in
+ *              the Built-in Tokens Table, that is a FATAL error.
+ *
+ *      Process Explanation:
+ *          Because the "FCode-Tokens" table was linked first, and the
+ *              pointer kept for this purpose, the "FC-Tokens" list can
+ *              be a subset of the "core" list, yet, when necessary, can
+ *              be searched with the same routines.
+ *
+ *      Extraneous Remarks:
+ *          I will bend the strict rules of well-structured code;
+ *              the exception case should never occur.
+ *
+ **************************************************************************** */
+
+void emit_token( const char *fc_name)
+{
+
+    if ( handle_tic_vocab( (char *)fc_name, fc_tokens_list_start) )
+    {
+        return;
+    }
+
+    tokenization_error( FATAL, "Did not recognize FCode name %s", fc_name);
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  lookup_token
+ *      Synopsis:       Return a pointer to the data-structure of the named
+ *                      word in the "FC-Tokens" list
+ *
+ *      Inputs:
+ *         Parameters:
+ *             tname                       The name to look up
+ *         Local Static Variables:
+ *             fc_tokens_list_start        "Tail" of the "FC-Tokens" list
+ *
+ *      Outputs:
+ *         Returned Value:                Pointer to the data-structure, or
+ *                                            NULL if not found.
+ *
+ **************************************************************************** */
+
+tic_hdr_t *lookup_token( char *tname)
+{
+    tic_hdr_t *found ;
+
+    found = lookup_tic_entry( tname, fc_tokens_list_start);
+    return ( found ) ;
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  entry_is_token
+ *      Synopsis:       Indicate whether the supplied pointer to a tic_hdr_t
+ *                      data-structure is one for which a single-token FCode
+ *                      number is assigned.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             test_entry                The entry to test; may be NULL
+ *         Local macros:
+ *             FC_TOKEN_FUNC             The function associated with
+ *                                           most single-token entries.
+ *             OBSO_FC_FUNC              The function associated with
+ *                                           "obsolete" FCode tokens.
+ *
+ *      Outputs:
+ *         Returned Value:               TRUE if the data-structure is
+ *                                           a single-token entry.
+ *
+ *      Process Explanation:
+ *          We cannot rely on the "definer" field to indicate whether
+ *              it is a single-token entry; instead, we will look at
+ *              the associated function.
+ *          Keep this routine here to avoid needing to export the names
+ *              of the permitted functions or their synonymous macros.
+ *              If we ever need to change it, we can do so at a single
+ *              point of maintenance.
+ *          Because the entry might have been found in the initial list
+ *              of entries to the "FCode-Tokens" list, we need to check
+ *              whether the associated function is either the general
+ *              single-token emitting function,  FC_TOKEN_FUNC , or the
+ *              function  OBSO_FC_FUNC , which presents a message before
+ *              emitting, but is still a valid single-token function.
+ *
+ **************************************************************************** */
+
+bool entry_is_token( tic_hdr_t *test_entry )
+{
+    bool retval = FALSE;
+    if ( test_entry != NULL )
+    {
+	if ( ( test_entry->funct == FC_TOKEN_FUNC )  ||
+	     ( test_entry->funct ==  OBSO_FC_FUNC )  )
+	{
+	    retval = TRUE;
+	}
+    }
+    return ( retval );
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  token_entry_warning
+ *      Synopsis:       Issue whatever warnings the given token_entry
+ *                      requires.  F['] needs this.
+ *      Inputs:
+ *         Parameters:
+ *             test_entry                The entry to test; may be NULL
+ *         Local macro:
+ *             OBSO_FC_FUNC              The function associated with
+ *                                           "obsolete" entries.
+ *      Outputs:
+ *         Returned Value:               NONE
+ *
+ *      Error Detection:
+ *          Warnings required by the given token_entry.
+ *
+ *      Extraneous Remarks:
+ *          At present, it's only the "Obsolete" warning.
+ *          But this is the place to add others, 
+ *              should they become necessary.
+ *
+ **************************************************************************** */
+
+void token_entry_warning( tic_hdr_t *t_entry)
+{
+    if ( t_entry->funct == OBSO_FC_FUNC )
+    {
+	obsolete_warning();
+    }
+}
+
+
+/* **************************************************************************
+ *
+ *      Create the initial "FWords" list.
+ *
+ **************************************************************************** */
+
+static tic_fwt_hdr_t fwords_list[] = {
+
+	BI_FWD_SKP_OW(COLON,	 	":") ,
+	BUILTIN_FWORD(SEMICOLON, 	";") ,
+	BI_FWD_SKP_OW(TICK, 		"'") ,
+	BUILTIN_FWORD(AGAIN, 		"again") ,
+	BI_FWD_SKP_OW(BRACK_TICK,  	 "[']") ,
+	BI_FWD_SKP_OW(ASCII,		"ascii") ,
+	BUILTIN_FWORD(BEGIN,		"begin") ,
+	BI_FWD_SKP_OW(BUFFER,		"buffer:") ,
+	BUILTIN_FWORD(CASE,		"case") ,
+	BI_FWD_SKP_OW(CONST,		"constant") ,
+	BI_FWD_SKP_OW(CONTROL,		"control") ,
+	BI_FWD_SKP_OW(CREATE,		"create") ,
+
+	BI_FWD_SKP_OW(DEFER,		"defer") ,
+	BUILTIN_FWORD(CDO,		"?do") ,
+	BUILTIN_FWORD(DO,		"do") ,
+	BUILTIN_FWORD(ELSE,		"else") ,
+	BUILTIN_FWORD(ENDCASE,		"endcase") ,
+	BUILTIN_FWORD(ENDOF,		"endof") ,
+	BUILTIN_FWORD(EXTERNAL, 	"external") ,
+	BI_FWD_SKP_OW(FIELD,		"field") ,
+	BUILTIN_FWORD(FINISH_DEVICE,	"finish-device" ) ,
+	BUILTIN_FWORD(HEADERLESS,	"headerless") ,
+	BUILTIN_FWORD(HEADERS,		"headers") ,
+
+	BUILTIN_FWORD(INSTANCE ,	"instance") ,
+
+	BUILTIN_FWORD(IF,		"if") ,
+	BUILTIN_FWORD(UNLOOP,		"unloop") ,
+	BUILTIN_FWORD(LEAVE,		"leave") ,
+	BUILTIN_FWORD(PLUS_LOOP, 	"+loop") ,
+	BUILTIN_FWORD(LOOP,		"loop") ,
+
+	BUILTIN_FWORD(OF,		"of") ,
+	BUILTIN_FWORD(REPEAT,		"repeat") ,
+	BUILTIN_FWORD(THEN,		"then") ,
+	BI_FWD_SKP_OW(TO,		"to") ,
+	BI_FWD_SKP_OW(IS,		"is") , /*  Deprecated synonym to TO  */
+	BUILTIN_FWORD(UNTIL,		"until") ,
+	BI_FWD_SKP_OW(VALUE,		"value") ,
+	BI_FWD_SKP_OW(VARIABLE,		"variable") ,
+	BUILTIN_FWORD(WHILE,		"while") ,
+	BUILTIN_FWORD(OFFSET16,		"offset16") ,
+
+	BI_FWD_STRING(STRING,		"\"") ,     /*  XXXXX  */
+	BI_FWD_STRING(PSTRING,		".\"") ,    /*  XXXXX  */
+	BI_FWD_STRING(PBSTRING,		".(") ,     /*  XXXXX  */
+	BI_FWD_STRING(SSTRING,		"s\"") ,    /*  XXXXX  */
+	BUILTIN_FWORD(IFILE_NAME,	"[input-file-name]"),
+	BUILTIN_FWORD(ILINE_NUM,	"[line-number]"),
+	BUILTIN_FWORD(RECURSE,		"recurse") ,
+	BUILTIN_FWORD(RECURSIVE,	"recursive") ,
+	BUILTIN_FWORD(RET_STK_FETCH,	"r@") ,
+	BUILTIN_FWORD(RET_STK_FROM,	"r>") ,
+	BUILTIN_FWORD(RET_STK_TO,	">r") ,
+	BUILTIN_FWORD(THEN,		"endif" ) ,  /*  Synonym for "then"  */
+	BUILTIN_FWORD(NEW_DEVICE,	"new-device" ) ,
+	BUILTIN_FWORD(LOOP_I,		"i") ,
+	BUILTIN_FWORD(LOOP_J,		"j") ,
 	/* version1 is also an fcode word, but it 
 	 * needs to trigger some tokenizer internals */
-	add_special(VERSION1,	"version1");
-	add_special(START0,	"start0");
-	add_special(START1,	"start1");
-	add_special(START2,	"start2");
-	add_special(START4,	"start4");
-	add_special(END0,	"end0");
-	add_special(END1,	"end1");
-	add_special(FCODE_V1,	"fcode-version1");
-	add_special(FCODE_V2,	"fcode-version2");
-	add_special(FCODE_V3,	"fcode-version3");
-	add_special(FCODE_END,	"fcode-end");
-	add_special(FCODE_DATE,	"fcode-date");
-	add_special(FCODE_TIME,	"fcode-time");
-	
-	add_special(HEXVAL,	"h#");
-	add_special(DECVAL,	"d#");
-	add_special(OCTVAL,	"o#");
-	add_special(CHAR,	"char");
-	add_special(CCHAR,	"[char]");
-	add_special(ABORTTXT,   "abort\"");
-
-	add_special(ENCODEFILE,	"encode-file");
+	BUILTIN_FWORD(VERSION1,		"version1") ,
+	BUILTIN_FWORD(START0,		"start0") ,
+	BUILTIN_FWORD(START1,		"start1") ,
+	BUILTIN_FWORD(START2,		"start2") ,
+	BUILTIN_FWORD(START4,		"start4") ,
+	BUILTIN_FWORD(END0,		"end0") ,
+	BUILTIN_FWORD(END1,		"end1") ,
+	BUILTIN_FWORD(FCODE_V1,		"fcode-version1") ,
+	BUILTIN_FWORD(FCODE_V2,		"fcode-version2") ,
+	BUILTIN_FWORD(FCODE_V3,		"fcode-version3") ,
+	BUILTIN_FWORD(FCODE_END,	"fcode-end") ,
+
+        /*  Support for IBM-style Locals  */
+	BI_FWD_STRING(CURLY_BRACE,	"{") ,
+	BI_FWD_STRING(DASH_ARROW,	"->") ,
+	BUILTIN_FWORD(EXIT,		"exit") ,
+
+
+	BUILTIN_FWORD(CHAR,		"char") ,
+	BUILTIN_FWORD(CCHAR,		"[char]") ,
+	BI_FWD_STRING(ABORTTXT,		"abort\"") ,
+
+	BUILTIN_FWORD(ENCODEFILE,	"encode-file") ,
+
+	BI_IG_FW_HDLR(ESCAPETOK,	"tokenizer[") ,
+	BI_IG_FW_HDLR(ESCAPETOK,	"f[") ,       /*  An IBM-ish synonym  */
+};
+
+static const int number_of_builtin_fwords =
+	 sizeof(fwords_list)/sizeof(tic_hdr_t);
+
+/* **************************************************************************
+ *
+ *      Create the initial list of "Shared_Words" (words that can
+ *          be executed similarly both during normal tokenization,
+ *          and also within "Tokenizer Escape Mode").
+ *
+ **************************************************************************** */
+
+static tic_fwt_hdr_t shared_words_list[] = {
+	SHARED_FWORD(FLOAD,		"fload") ,
+	/*  As does the "Allow Multi-Line" directive   */
+	SHR_SAMIG_FWRD(ALLOW_MULTI_LINE, "multi-line") ,
+
+	SHR_FWD_SKOW( F_BRACK_TICK,	 "f[']") ,
+
+	SH_FW_SK2WIL(ALIAS, 		"alias") ,
+	SHARED_FWORD(DECIMAL,		"decimal") ,
+	SHARED_FWORD(HEX,		"hex") ,
+	SHARED_FWORD(OCTAL,		"octal") ,
+	SH_FW_SK_WIL(HEXVAL,		"h#") ,
+	SH_FW_SK_WIL(DECVAL,		"d#") ,
+	SH_FW_SK_WIL(OCTVAL,		"o#") ,
+
+	SH_FW_SK_WIL(ASC_NUM,		"a#") ,
+	SH_FW_SK_WIL(ASC_LEFT_NUM,	"al#") ,
+
+	/* IBM-style extension.  Might be generalizable...  */
+	SHARED_FWORD(FLITERAL, 	"fliteral") ,
+
+	/*  Directives to extract the value of a Command-Line symbol */
+	SH_FW_SK_WIL(DEFINED,		"[defined]") ,
+	SH_FW_SK_WIL(DEFINED,		"#defined") ,
+	SH_FW_SK_WIL(DEFINED,		"[#defined]") ,
+
+	/*  Present the current date or time, either as an  */
+	/*  in-line string or as a user-generated message.  */
+	SHARED_FWORD(FCODE_DATE,	"[fcode-date]") ,
+	SHARED_FWORD(FCODE_TIME,	"[fcode-time]") ,
+
+	/*  Current definition under construction, similarly  */
+	SHARED_FWORD(FUNC_NAME,	"[function-name]"),
+
+	/*  Synonymous forms of the #ELSE and #THEN operators,
+	 *      associated with Conditional-Compilation,
+	 *      allowing for various syntax-styles, and for
+	 *      expansion by alias.
+	 */
+
+	/*  #ELSE  operators */
+	SHARED_FWORD(CONDL_ELSE,	"#else") ,
+	SHARED_FWORD(CONDL_ELSE,	"[else]") ,
+	SHARED_FWORD(CONDL_ELSE,	"[#else]") ,
+
+	/*  #THEN  operators */
+	SHARED_FWORD(CONDL_ENDER,	"#then") ,
+	SHARED_FWORD(CONDL_ENDER,	"[then]") ,
+	SHARED_FWORD(CONDL_ENDER,	"[#then]") ,
+	/*   #ENDIF variants for users who favor C-style notation   */
+	SHARED_FWORD(CONDL_ENDER,	"#endif") ,
+	SHARED_FWORD(CONDL_ENDER,	"[endif]") ,
+	SHARED_FWORD(CONDL_ENDER,	"[#endif]") ,
+
+
+	SHARED_FWORD(OVERLOAD,  "overload" ) ,
+
+	SHARED_FWORD(GLOB_SCOPE , "global-definitions" ) ,
+	SHARED_FWORD(DEV_SCOPE , "device-definitions" ) ,
+
+	/*  Directives to change a command-line flag value from source   */
+	SH_FW_SK_WIL(CL_FLAG,	"[FLAG]") ,
+	SH_FW_SK_WIL(CL_FLAG,	"#FLAG") ,
+	SH_FW_SK_WIL(CL_FLAG,	"[#FLAG]") ,
+
+	/*  Directives to force display of a command-line flags' values   */
+	SHARED_FWORD(SHOW_CL_FLAGS,	"[FLAGS]") ,
+	SHARED_FWORD(SHOW_CL_FLAGS,	"#FLAGS") ,
+	SHARED_FWORD(SHOW_CL_FLAGS,	"[#FLAGS]") ,
+	SHARED_FWORD(SHOW_CL_FLAGS,	"SHOW-FLAGS") ,
+
+	/*  Directives to save and retrieve the FCode Assignment number  */
+	SHARED_FWORD(PUSH_FCODE,	"FCODE-PUSH") ,
+	SHARED_FWORD(POP_FCODE, 	"FCODE-POP") ,
+
+	/*  Directive to reset the FCode Assignment number and
+	 *      re-initialize FCode Range overlap checking.
+	 */
+	SHARED_FWORD(RESET_FCODE,	"FCODE-RESET") ,
 
 	/* pci header generation is done differently 
 	 * across the available tokenizers. We try to
 	 * be compatible to all of them
 	 */
-	add_special(PCIHDR,	"pci-header");
-	add_special(PCIEND,	"pci-end");            /* SUN syntax */
-	add_special(PCIEND,	"pci-header-end");     /* Firmworks syntax */
-	add_special(PCIREV,	"pci-revision");       /* SUN syntax */
-	add_special(PCIREV,	"pci-code-revision");  /* SUN syntax */
-	add_special(PCIREV,	"set-rev-level");      /* Firmworks syntax */
-	add_special(NOTLAST,	"not-last-image");
+	SHARED_FWORD(PCIHDR,	  "pci-header") ,
+	SHARED_FWORD(PCIEND,	  "pci-end") ,           /* SUN syntax */
+	SHARED_FWORD(PCIEND,	  "pci-header-end") ,    /* Firmworks syntax */
+	SHARED_FWORD(PCIREV,	  "pci-revision") ,      /* SUN syntax */
+	SHARED_FWORD(PCIREV,	  "pci-code-revision") , /* SUN syntax */
+	SHARED_FWORD(PCIREV,	  "set-rev-level") ,     /* Firmworks syntax */
+	SHARED_FWORD(NOTLAST,	  "not-last-image") ,
+	SHARED_FWORD(NOTLAST,	  "not-last-img") ,      /* Shorthand form  */
+	SHARED_FWORD(ISLAST,	  "last-image") ,
+	SHARED_FWORD(ISLAST,	  "last-img") ,          /* Shorthand form  */
+	SHARED_FWORD(SETLAST,	  "set-last-image") ,
+	SHARED_FWORD(SETLAST,	  "set-last-img") ,      /* Shorthand form  */
+
+	SH_FW_SK_WIL(SAVEIMG,	  "save-image") ,
+	SH_FW_SK_WIL(SAVEIMG,	  "save-img") ,          /* Shorthand form  */
+
+	SHARED_FWORD(RESETSYMBS,  "reset-symbols") ,
+
+	/*  User-Macro definers    */
+	SHARED_IG_HDLR("[MACRO]", add_user_macro,  0 ,  skip_user_macro) ,
+
+	/*  Comments and Remarks   */
+	SHARED_IG_HDLR("\\",      process_remark, '\n', process_remark) ,
+	SHARED_IG_HDLR("(",       process_remark, ')',  process_remark) ,
+
+	/*  Directives to print or discard a user-generated message */
+	SHARED_IG_HDLR("[MESSAGE]",  user_message, '\n', skip_user_message) ,
+	SHARED_IG_HDLR("#MESSAGE",   user_message, '\n', skip_user_message) ,
+	SHARED_IG_HDLR("[#MESSAGE]", user_message, '\n', skip_user_message) ,
+	SHARED_IG_HDLR("#MESSAGE\"", user_message, '"' , skip_user_message) ,
+};
+
+static const int number_of_shared_words =
+	sizeof(shared_words_list)/sizeof(tic_hdr_t);
+
+/* **************************************************************************
+ *
+ *      Function name:  lookup_shared_word
+ *      Synopsis:       Return a pointer to the data-structure of the named
+ *                      word, only if it is a "Shared Word"
+ *
+ *      Inputs:
+ *         Parameters:
+ *             tname                     The name to look for
+ *         Local Static Variables:
+ *             global_voc_dict_ptr       "Tail" of Global Vocabulary
+ *
+ *      Outputs:
+ *         Returned Value:                Pointer to the data-structure, or
+ *                                            NULL if not found.
+ *
+ *      Process Explanation:
+ *          The "Shared Words" are scattered among the Global Vocabulary;
+ *              the user is allowed to create aliases, which may be in the
+ *              Current-Device.  We will search through the "current" scope
+ *              and decide whether the name we found is a "Shared Word" by
+ *              looking for  COMMON_FWORD  in the "definer" field.
+ *
+ *      Extraneous Remarks:
+ *          This is the only place where an additional check of the
+ *              "definer" field is required to identify a desired entry.
+ *              Should another "definer"-type be required, I recommend 
+ *              defining a general-purpose function in  ticvocab.c  and
+ *              applying it here and in the other place(s).
+ *
+ **************************************************************************** */
+ 
+tic_hdr_t *lookup_shared_word( char *tname)
+{
+    tic_hdr_t *found ;
+    tic_hdr_t *retval = NULL ;
+
+    found = lookup_current( tname );
+    if ( found != NULL )
+    {
+	if ( found->fword_defr == COMMON_FWORD )
+	{
+	    retval = found ;
+	}
+    }
+
+    return ( retval );
+
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  handle_shared_word
+ *      Synopsis:       Perform the function associated with the given name
+ *                      only if it is a "Shared Word".  Indicate if it was.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             tname                The "target" name for which to look
+ *
+ *      Outputs:
+ *         Returned Value:          TRUE if the name is a valid "Shared Word"
+ *
+ *      Extraneous Remarks:
+ *          This is very similar to a call to  handle_tic_vocab() except
+ *              for the additional filtering for a "Shared Word" definer.
+ *
+ **************************************************************************** */
+
+bool handle_shared_word( char *tname )
+{
+    tic_hdr_t *found ;
+    bool retval = FALSE;
+    
+    found = lookup_shared_word( tname );
+    if ( found != NULL )
+    {
+        found->funct(found->pfield);
+	retval = TRUE;
+    }
+
+    return ( retval ) ;
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  lookup_shared_f_exec_word
+ *      Synopsis:       Return a pointer to the data-structure of the named
+ *                      word, only if it is a "Shared F-Exec Word"
+ *
+ *      Inputs:
+ *         Parameters:
+ *             tname                     The name to look for
+ *         Local Static Variables:
+ *             global_voc_dict_ptr       "Tail" of Global Vocabulary
+ *         Macro Definitions:
+ *             FWORD_EXEC_FUNC           The "Active" function of the
+ *                                           sub-class of "Shared Word"s
+ *                                           that is the object of this
+ *                                           routine's search
+ *
+ *      Outputs:
+ *         Returned Value:                Pointer to the data-structure, or
+ *                                            NULL if not found.
+ *
+ *      Process Explanation:
+ *          The "Shared F-Exec Words" are the subset of "Shared Words" that
+ *              have the  FWORD_EXEC_FUNC  as their "Active" function.
+ *
+ *      Extraneous Remarks:
+ *          This is the only routine that requires a check of two fields;
+ *              it seems unlikely that there will be any need to generalize
+ *              the core of this routine...
+ *
+ **************************************************************************** */
+ 
+tic_hdr_t *lookup_shared_f_exec_word( char *tname)
+{
+    tic_hdr_t *found ;
+    tic_hdr_t *retval = NULL ;
+
+    found = lookup_shared_word( tname );
+    if ( found != NULL )
+    {
+	if ( found->funct == FWORD_EXEC_FUNC )
+	{
+	    retval = found ;
+	}
+    }
+
+    return ( retval );
+
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  init_dictionary
+ *      Synopsis:       Initialize all the vocabularies.  For the Global
+ *                      Vocabulary, fill in the link fields in each of the
+ *                      otherwise pre-initialized built-in lists, link the
+ *                      lists together, and set the relevant pointers.   For
+ *                      other lists, call their initialization routines.
+ *
+ *      Inputs:
+ *         Parameters:                         NONE
+ *         Global Variables:
+ *         Local Static Variables:
+ *             tokens_table                    Base of the "FC-Tokens" list
+ *             number_of_builtin_tokens        Number of "FC-Token" entries
+ *             fwords_list                     Base of the "FWords" list
+ *             number_of_builtin_fwords        Number of "FWord" entries
+ *             shared_words_list               Base of the "Shared Words" list
+ *             number_of_shared_words          Number of "Shared Words" entries
+ *
+ *      Outputs:
+ *         Returned Value:                      NONE
+ *         Local Static Variables:
+ *             global_voc_dict_ptr              "Tail" of Global Vocabulary
+ *             fc_tokens_list_start             "Tail" of "FC-Tokens" list
+ *             fc_tokens_list_ender             End of "FC-Tokens" search
+ *             shared_fwords_ender              End of Shared Words" search
+ *             global_voc_reset_ptr             Reset-point for Global Vocab
+ *
+ *      Process Explanation:
+ *          The first linked will be the last searched.
+ *              Link the "FC-Tokens" first, and mark their limits
+ *              Link the "FWords" next,
+ *              Mark the end-limit of the "Shared Words", and link them
+ *              The "Conditionals", defined in another file, are also "Shared";
+ *                  link them next.
+ *              Then link the Built-In Macros, also defined in another file.
+ *          These constitute the Global Vocabulary.
+ *              Mark the reset-point for the Global Vocabulary.
+ *          The "Tokenizer Escape" mode vocabulary is not linked to the Global
+ *              Vocabulary; call its initialization routine.
+ *
+ *      Extraneous Remarks:
+ *          I only wish I had done this sooner...
+ *
+ **************************************************************************** */
+
+void init_dictionary( void )
+{
+
+    global_voc_dict_ptr  = NULL;   /*  Belt-and-suspenders...  */
+
+    /*  The "FC-Tokens" list must be linked first.  */
+    fc_tokens_list_ender = global_voc_dict_ptr;
+    init_tic_vocab( tokens_table,
+                	number_of_builtin_tokens,
+                            &global_voc_dict_ptr ) ;
+    fc_tokens_list_start = global_voc_dict_ptr;
+
+    /*  Link the "FWords" next */
+   init_tic_vocab( (tic_hdr_t *)fwords_list,
+                        number_of_builtin_fwords,
+                            &global_voc_dict_ptr ) ;
+
+    /*  Mark the end-limit of the "Shared Words", and link them. */
+    shared_fwords_ender = global_voc_dict_ptr;
+    init_tic_vocab( (tic_hdr_t *)shared_words_list,
+                	number_of_shared_words,
+                            &global_voc_dict_ptr ) ;
+
+    /*  Link the "Conditionals" to the Global Vocabulary.  */
+    init_conditionals_vocab( &global_voc_dict_ptr ) ;
+
+    /*  Link the Built-In Macros */
+    init_macros( &global_voc_dict_ptr ) ;
+
+    /*  Mark the reset-point for the Global Vocabulary.  */
+    global_voc_reset_ptr = global_voc_dict_ptr;
+
+    /*   Initialize the "Tokenizer Escape" mode vocabulary  */
+    init_tokz_esc_vocab();
+
+    /*   Locals and Device-Node vocabularies are initially empty  */
+
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  reset_normal_vocabs
+ *      Synopsis:       Reset the vocabularies that were created in "Normal"
+ *                          (as distinguished from "Tokenizer Escape") mode
+ *                          to the proper state for a fresh tokenization.
+ *
+ *      Associated FORTH words:              END0  END1
+ *      Associated Tokenizer directives:     RESET-SYMBOLS  (in "Normal" mode)
+ *                                           FCODE-END
+ *
+ *      Inputs:
+ *         Parameters:                NONE
+ *         Global Variables:
+ *             global_voc_reset_ptr       Position to which to reset
+ *                                            the "Global" Vocabulary
+ *             current_device_node        Vocab struct of current dev-node
+ *
+ *      Outputs:
+ *         Returned Value:            NONE
+ *         Global Variables:    
+ *             global_voc_dict_ptr       Reset to "Built-In" position 
+ *             current_device_node       Reset to point at "root" dev-node
+ *         Memory Freed
+ *             All memory allocated by user-definitions in "normal" mode
+ *             -- Macros, Conditionals and Device-node Vocabularies -- are
+ *             reset via function call.
+ *
+ *      Error Detection:
+ *          Presence of extra device-node data structure(s) indicates that
+ *              there were more "new-device" calls than "finish-device";
+ *              report each as an ERROR 
+ *
+ *      Process Explanation:
+ *          Vocabularies created in other files, that have different
+ *              data-structures, will have "reset" routines of their
+ *              own associated with them in the files in which they
+ *              are created.  Those routines will be called from here.
+ *          Definitions in the "Tokenizer Escape Vocabulary", i.e.,
+ *              the one in effect in "Tokenizer Escape" mode, are
+ *              specifically not touched by this routine.
+ *
+ **************************************************************************** */
+
+void reset_normal_vocabs( void )
+{
+    reset_tic_vocab( &global_voc_dict_ptr, global_voc_reset_ptr );
+
+    /*  Delete the top-level device-node vocab.
+     *      If there are extra device-nodes,
+     *      delete their data structures and show errors
+     */
+    do
+    {
+        if ( current_device_node->parent_node != NULL )
+	{
+	    tokenization_error( TKERROR,
+		 "Missing FINISH-DEVICE for new device");
+	    started_at( current_device_node->ifile_name,
+		 current_device_node->line_no );
+	}
+	    delete_device_vocab();
+    }  while ( current_device_node->parent_node != NULL );
+
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  reset_vocabs
+ *      Synopsis:       Reset all the vocabularies to the proper state
+ *                      for beginning a fresh tokenization, particularly
+ *                      when multiple files are named on the command-line
+ *      
+ *      Inputs:
+ *         Parameters:                NONE
+ *
+ *      Outputs:
+ *         Returned Value:            NONE
+ *         Memory Freed
+ *             All memory allocated by user-definitions will be freed
+ *
+ *      Process Explanation:
+ *          Call the  reset_normal_vocabs()  routine to get the vocabularies
+ *              that apply to "Normal" mode, then call the "reset" routine
+ *              for the "Tokenizer Escape Vocabulary", which is supposed
+ *              to persist across device-nodes but not across input-files
+ *              named on the command-line.
+ *
+ **************************************************************************** */
+
+void reset_vocabs( void )
+{
+    reset_normal_vocabs();
+    reset_tokz_esc();
 }
diff --git a/toke/dictionary.h b/toke/dictionary.h
index 3a0c0e7..3d01873 100644
--- a/toke/dictionary.h
+++ b/toke/dictionary.h
@@ -1,3 +1,6 @@
+#ifndef _TOKE_DICTIONARY_H
+#define _TOKE_DICTIONARY_H
+
 /*
  *                     OpenBIOS - free your system! 
  *                         ( FCode tokenizer )
@@ -24,81 +27,152 @@
  *
  */
 
-#define COLON		0x01
-#define SEMICOLON	0x02
-#define TOKENIZE	0x03
-#define AGAIN		0x04
-#define ALIAS		0x05
-#define GETTOKEN 	0x06
-#define ASCII		0x07
-#define BEGIN		0x08
-#define BUFFER		0x09
-#define CASE		0x0a
-#define CONST		0x0b
-#define CONTROL		0x0c
-#define CREATE		0x0d
-#define DECIMAL		0x0e
-#define DEFER		0x0f
-#define CDO		0x10
-#define DO		0x11
-#define ELSE		0x12
-#define ENDCASE		0x13
-#define ENDOF		0x14
-#define EXTERNAL	0x15
-#define FIELD		0x16
-#define HEADERLESS	0x17
-#define HEADERS		0x18
-#define HEX		0x19
-#define IF		0x1a
-#define CLEAVE		0x1b
-#define LEAVE		0x1c
-#define CLOOP		0x1d
-#define LOOP		0x1e
-#define OCTAL		0x1f
-#define OF		0x20
-#define REPEAT		0x21
-#define THEN		0x22
-#define TO		0x23
-#define UNTIL		0x24
-#define VALUE		0x25
-#define VARIABLE	0x26	
-#define WHILE		0x27
-#define OFFSET16	0x28	
-#define BEGINTOK	0x29	
-#define EMITBYTE	0x2a	
-#define ENDTOK		0x2b
-#define FLOAD		0x2c
-#define STRING		0x2d
-#define PSTRING		0x2e
-#define PBSTRING	0x2f
-#define SSTRING		0x30
-#define RECURSIVE	0x31
-#define HEXVAL		0x32
-#define DECVAL		0x33
-#define OCTVAL		0x34
-
-#define END0		0xdb
-#define END1		0xdc
-#define CHAR		0xdd
-#define CCHAR		0xde
-#define ABORTTXT	0xdf
-
-#define NEXTFCODE	0xef
-
-#define ENCODEFILE	0xf0
-
-#define FCODE_V1	0xf1
-#define FCODE_V3	0xf2
-#define NOTLAST		0xf3
-#define PCIREV		0xf4
-#define PCIHDR		0xf5
-#define PCIEND		0xf6
-#define START0		0xf7
-#define START1		0xf8
-#define START2		0xf9
-#define START4		0xfa
-#define VERSION1	0xfb
-#define FCODE_TIME	0xfc
-#define FCODE_DATE	0xfd
-#define FCODE_V2	0xfe
-#define FCODE_END	0xff
+/* **************************************************************************
+ *         Modifications made in 2005 by IBM Corporation
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Modifications Author:  David L. Paktor    dlpaktor@us.ibm.com
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      Numeric values for FWord-type vocabulary entries.  Used by the
+ *          big "switch" statement in handle_internal(); a subset are 
+ *          also used as "definer-type" values associated with various
+ *          types of definitions.
+ *
+ **************************************************************************** */
+
+typedef enum fword_token {
+      UNSPECIFIED  = 0xBAADD00D ,  /*  Default (absence-of) "definer"        */
+      COMMON_FWORD = 0xC0EDC0DE ,  /*  Definer indicating a "shared" FWord   */
+      BI_FWRD_DEFN = 0xB1F4409D ,  /*  Definer indicating a "built-in FWord" */
+      COLON = 1 ,
+      SEMICOLON ,
+      TICK ,
+      AGAIN ,
+      ALIAS ,
+      BRACK_TICK ,
+      F_BRACK_TICK ,
+      ASCII ,
+      BEGIN ,
+      BUFFER ,
+      CASE ,
+      CONST ,
+      CONTROL ,
+      CREATE ,
+      DECIMAL ,
+      DEFER ,
+      DEFINED ,
+      CDO ,
+      DO ,
+      ELSE ,
+      ENDCASE ,
+      ENDOF ,
+      EXTERNAL ,
+      INSTANCE ,
+      FIELD ,
+      NEW_DEVICE ,
+      FINISH_DEVICE ,
+      FLITERAL ,
+      HEADERLESS ,
+      HEADERS ,
+      HEX ,
+      IF ,
+      UNLOOP ,
+      LEAVE ,
+      LOOP_I ,
+      LOOP_J ,
+      LOOP ,
+      PLUS_LOOP ,
+      OCTAL ,
+      OF ,
+      REPEAT ,
+      THEN ,
+      TO ,
+      IS ,
+      UNTIL ,
+      VALUE ,
+      VARIABLE ,
+      WHILE ,
+      OFFSET16 ,
+      ESCAPETOK ,
+      EMITBYTE ,
+      FLOAD ,
+      STRING ,
+      PSTRING ,
+      PBSTRING ,
+      SSTRING ,
+      RECURSIVE ,
+      RECURSE ,
+      RET_STK_FETCH ,
+      RET_STK_FROM ,
+      RET_STK_TO ,
+      HEXVAL ,
+      DECVAL ,
+      OCTVAL ,
+
+       ret_stk_from ,
+     ASC_NUM ,          /*  Convert char seq to number  */
+      ASC_LEFT_NUM ,     /*  same, only left-justified.  */
+
+      CONDL_ENDER ,      /*  Conditional "[THEN] / [ENDIF]" variants  */
+      CONDL_ELSE ,       /*  Conditional "[ELSE]" directive variants  */
+
+      PUSH_FCODE ,	/*  Save the FCode Assignment number  */
+      POP_FCODE ,	/*  Retrieve the FCode Assignment number  */
+      RESET_FCODE ,	/*  Reset FCode Ass't nr and overlap checking  */
+
+      CURLY_BRACE ,      /*  Support for IBM-style Locals  */
+      DASH_ARROW ,
+      LOCAL_VAL ,
+      EXIT ,
+
+      FUNC_NAME ,
+      IFILE_NAME ,
+      ILINE_NUM ,
+
+      CL_FLAG ,
+      SHOW_CL_FLAGS ,
+
+      OVERLOAD ,
+      ALLOW_MULTI_LINE ,
+      MACRO_DEF ,
+      GLOB_SCOPE ,
+      DEV_SCOPE ,
+
+      /*  This value has to be adjusted
+       *      so that  FCODE_END  comes
+       *      out to be  0xff
+       */
+      END0 = 0xd7 ,      /*   0xd7   */
+      END1 ,             /*   0xd8   */
+      CHAR ,             /*   0xd9   */
+      CCHAR ,            /*   0xda   */
+      ABORTTXT ,         /*   0xdb   */
+
+      NEXTFCODE ,        /*   0xdc   */
+
+      ENCODEFILE ,       /*   0xdd   */
+
+      FCODE_V1 ,         /*   0xde   */
+      FCODE_V3 ,         /*   0xdf   */
+      NOTLAST ,          /*   0xef   */
+      ISLAST ,           /*   0xf0   */
+      SETLAST ,          /*   0xf1   */
+      PCIREV ,           /*   0xf2   */
+      PCIHDR ,           /*   0xf3   */
+      PCIEND ,           /*   0xf4   */
+      RESETSYMBS ,       /*   0xf5   */
+      SAVEIMG ,          /*   0xf6   */
+      START0 ,           /*   0xf7   */
+      START1 ,           /*   0xf8   */
+      START2 ,           /*   0xf9   */
+      START4 ,           /*   0xfa   */
+      VERSION1 ,         /*   0xfb   */
+      FCODE_TIME ,       /*   0xfc   */
+      FCODE_DATE ,       /*   0xfd   */
+      FCODE_V2 ,         /*   0xfe   */
+      FCODE_END = 0xff   /*   0xff   */
+}  fwtoken ;
+
+#endif   /*  _TOKE_DICTIONARY_H    */
diff --git a/toke/emit.c b/toke/emit.c
index f51d49b..7ca55ef 100644
--- a/toke/emit.c
+++ b/toke/emit.c
@@ -24,283 +24,548 @@
  *
  */
 
+/* **************************************************************************
+ *         Modifications made in 2005 by IBM Corporation
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Modifications Author:  David L. Paktor    dlpaktor@us.ibm.com
+ **************************************************************************** */
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
+
+#include "pcihdr.h"
+
 #include "toke.h"
+#include "vocabfuncts.h"
 #include "stack.h"
+#include "scanner.h"
 #include "emit.h"
+#include "clflags.h"
+#include "errhandler.h"
+#include "stream.h"
+#include "nextfcode.h"
+
+/* **************************************************************************
+ *
+ *          Global Variables Imported
+ *              verbose         Enable optional messages, set by "-v" switch
+ *              noerrors        "Ignore Errors" flag, set by "-i" switch
+ *
+ **************************************************************************** */
 
-extern bool offs16;
-extern int verbose;
-extern u8 *ostart, *opc, *oend;
 
-/* PCI data */
-extern u16 pci_vpd, pci_revision;
-extern bool pci_is_last_image;
+/* **************************************************************************
+ *
+ *      Macro to zero-fill a field of the size of the given structure
+ *          into the Output Buffer using the  emit_byte()  routine.
+ *
+ **************************************************************************** */
 
-/* header pointers */
-extern u8  *fcode_hdr;
-extern u8  *pci_hdr;
+#define EMIT_STRUCT(x)  {int j; for (j=0; j < sizeof(x) ; j++ ) emit_byte(0); }
 
-extern bool haveend;
 
-u16 lookup_token(char *name);
+/* **************************************************************************
+ *
+ *      Local Static Variables, offsets into Output Buffer of ...:
+ *          fcode_start_ob_off      First FCode-Start byte
+ *          fcode_hdr_ob_off        FCode Header (Format byte)
+ *          fcode_body_ob_off       First functional FCode after FCode Header.
+ *          pci_hdr_ob_off          Start of PCI ROM Header Block structure
+ *          pci_data_blk_ob_off     Start of PCI Data Header Block structure
+ *
+ *     For all of these, -1 means "Not initialized"
+ *
+ *************************************************************************** */
+
+static  int fcode_start_ob_off = -1;
+static  int fcode_hdr_ob_off = -1;
+static  int fcode_body_ob_off = -1;
+static  int pci_hdr_ob_off = -1;
+static  int pci_data_blk_ob_off = -1;
+
+/* **************************************************************************
+ *
+ *          These are to detect a particular error:  If FCode has
+ *              been written, before an Fcode-start<n> or before
+ *               a PCI-header
+ *
+ **************************************************************************** */
 
-static bool little_endian(void)
+static bool fcode_written = FALSE;
+
+/* **************************************************************************
+ *
+ *          Variables and Functions Imported, with
+ *          Exposure as Limited as possible:
+ *              ostart
+ *              olen
+ *              increase_output_buffer
+ *
+ **************************************************************************** */
+
+extern u8 *ostart;
+extern int olen;
+extern void increase_output_buffer( void);
+
+
+/* **************************************************************************
+ *
+ *      Function name:  init_emit
+ *      Synopsis:       Initialize Local Static Variables before starting
+ *                          Output.
+ *                      Exposure as Limited as possible.
+ *
+ **************************************************************************** */
+void init_emit( void);       /*    Prototype.  Limit Exposure.   */
+void init_emit( void)
 {
-	static short one=1;
-	return *(char *)&one==1;
+    fcode_start_ob_off  = -1;
+    fcode_hdr_ob_off    = -1;
+    fcode_body_ob_off   = -1;
+    pci_hdr_ob_off      = -1;
+    pci_data_blk_ob_off = -1;
+    fcode_written       = FALSE;
+    haveend             = FALSE;   /*  Get this one too...  */
 }
 
-int emit_byte(u8 data)
+
+/* **************************************************************************
+ *
+ *      Function name:  emit_byte
+ *      Synopsis:       Fundamental routine for placing a byte
+ *                          into the Output Buffer.  Also, check
+ *                          whether the buffer needs to be expanded.
+ *                      For internal use only.
+ *
+ **************************************************************************** */
+
+static void emit_byte(u8 data)
 {
-	u8 *newout;
-	int newsize;
-
-	if(opc==oend) {
-		/* need more output space */
-		newsize = (oend - ostart) * 2;
-		printf("Increasing output buffer to %d bytes.\n", newsize);
-		if ((newout=realloc(ostart, newsize)) == NULL) {
-			printf("toke: could not allocate %d bytes for output buffer\n", newsize);
-			exit(-1);
-		}
-
-		/* move pointers */
-		opc=newout+(opc-ostart);
-		ostart=newout;
-		oend=ostart+newsize;
+	if ( opc == olen)
+	{
+	    increase_output_buffer();
 	}
 	
-	*opc=data;
-	opc++;
 
-	return 0;
+	*(ostart+opc) = data ;
+	opc++;
 }
 
-int emit_fcode(u16 tok)
+void emit_fcode(u16 tok)
 {
 	if ((tok>>8))
 		emit_byte(tok>>8);
 
 	emit_byte(tok&0xff);
-	
-	return 0;
+	fcode_written = TRUE;
 }
 
-int emit_token(const char *name)
-{
-	return emit_fcode(lookup_token((char *)name));
-}
-
-int emit_num32(u32 num)
+static void emit_num32(u32 num)
 {
 	emit_byte(num>>24);
 	emit_byte((num>>16)&0xff);
 	emit_byte((num>>8)&0xff);
 	emit_byte(num&0xff);
 
-	return 0;
 }
 
-int emit_num16(u16 num)
-{
-	emit_byte(num>>8);
-	emit_byte(num&0xff);
+/* **************************************************************************
+ *
+ *      Function name:  user_emit_byte
+ *      Synopsis:       Action of user-mandated call to emit-byte.
+ *                          Covers the corner-case where this is the
+ *                          first command issued in the source input.
+ *
+ **************************************************************************** */
 
-	return 0;
+void user_emit_byte(u8 data)
+{
+	emit_byte( data);
+	fcode_written = TRUE;
 }
 
-int emit_offset(s16 offs)
+void emit_offset(s16 offs)
 {
+    /*  Calling routine will test for out-of-range FCode-Offset  */
 	if (offs16)
-		emit_num16(offs);
-	else
-		emit_byte(offs);
-	
-	return 0;
+		emit_byte(offs>>8);
+	emit_byte(offs&0xff);
 }
 
-s16 receive_offset(void)
+void emit_literal(u32 num)
 {
-	s16 offs=0;
-	
-	if (offs16) {
-		offs=((*opc)<<8)|(*(opc+1));
-	} else
-		offs=(*opc);
-
-	return offs;
+    emit_token("b(lit)");
+    emit_num32(num);
 }
 
-int emit_string(u8 *string, unsigned int cnt)
+void emit_string(u8 *string, signed int cnt)
 {
-	unsigned int i=0;
+	signed int i=0;
+	signed int cnt_cpy = cnt;
 	
-	if (cnt>255) {
-		printf("string too long.");
-		exit(1);
+	if ( cnt_cpy > STRING_LEN_MAX )
+	{
+	    tokenization_error( TKERROR,
+		"String too long:  %d characters.  Truncating.\n",cnt);
+	    cnt_cpy = STRING_LEN_MAX ;
 	}
-	emit_byte(cnt);
-	for (i=0; i<cnt; i++)
+	emit_byte(cnt_cpy);
+	for (i=0; i<cnt_cpy; i++)
 		emit_byte(string[i]);
-
-	return 0;
 }
 
-int emit_fcodehdr(void)
+void emit_fcodehdr(const char *starter_name)
 {
-	/* We comply with IEEE 1275-1994 */
-	emit_byte(0x08);
 	
-	/*  checksum */
-	emit_num16(0);
+   /*  Check for error conditions   */
+    if ( fcode_written )
+    {
+        tokenization_error( TKERROR ,
+	    "Cannot create FCode header after FCode output has begun.\n");
+        if ( ! noerrors ) return ;
+    }
+
+	fcode_header_t *fcode_hdr;
+
+	fcode_start_ob_off = opc;
+	emit_token( starter_name );
+
+	fcode_hdr_ob_off = opc;
+	fcode_hdr = (fcode_header_t *)(ostart+fcode_hdr_ob_off);
 
-	/* len */
-	emit_num32(0);
+	EMIT_STRUCT(fcode_header_t);
+
+	fcode_body_ob_off = opc;
+
+	/* Format = 8 means we comply with IEEE 1275-1994 */
+	fcode_hdr->format = 0x08;
 
-	return 0;
 }
 
-int finish_fcodehdr(void)
+/* **************************************************************************
+ *
+ *      Function name:    finish_fcodehdr
+ *          Fill in the FCode header's checksum and length fields, and
+ *              reset the FCode-header pointer for the next image.
+ *
+ *          If  haveend  is true then the end0 has already been written
+ *              and  fcode_ender()  has been called.
+ *
+ *          Print a WARNING message if the end-of-file was encountered
+ *              without an end0 or an fcode-end
+ *
+ *          Print an informative message to standard-output giving the
+ *              checksum.  Call  list_fcode_ranges()  to print the
+ *              value of the last FCode-token that was assigned or
+ *              the Ranges of assigned FCode-token values if so be...
+ *              The final FCode-binary file-length will be printed
+ *              when the binary file is being closed.
+ *
+ **************************************************************************** */
+
+void finish_fcodehdr(void)
 {
-	u16 checksum=0;
-	u32 len,i;
 
-	if(!fcode_hdr)
+	if( fcode_hdr_ob_off == -1 )
 	{
-		printf("warning: trying to fix up unknown fcode header\n");
-		return -1;
+		tokenization_error( TKERROR,
+		    "Missing FCode header.\n");
+		return ;
 	}
 
-	/* If the program does not do this, we do */
+	/* If the program did not end cleanly, we'll handle it */
 	if (!haveend)
+	{
+	    tokenization_error ( WARNING,
+	    "End-of-file encountered without END0 or FCODE-END.  "
+		"Supplying END0\n");
 		emit_token("end0");
+	    fcode_ender();
+	}
 
-	len=(unsigned long)opc-(unsigned long)(fcode_hdr-1);
+	/*  Calculate and place checksum and length, if haven't already  */
+	if ( fcode_start_ob_off != -1 )
+	{
+	    u16 checksum;
+	    int length;
+
+	    u8 *fcode_body = ostart+fcode_body_ob_off;
+	    u8 *ob_end = ostart+opc;
+	    fcode_header_t *fcode_hdr =
+	         (fcode_header_t *)(ostart+fcode_hdr_ob_off);
 	
-	for (i=8;i<len;i++)
-		checksum+=fcode_hdr[i-1];
-
-	dpush((unsigned long)opc);
-	opc=fcode_hdr+1;
-	emit_num16(checksum);
-	emit_num32(len);
-	opc=(u8 *)dpop();
+	    length = opc - fcode_start_ob_off;
+
+	    for ( checksum = 0;
+	              fcode_body < ob_end ;
+		          checksum += *(fcode_body++) ) ;
+
+	    BIG_ENDIAN_WORD_STORE(fcode_hdr->checksum , checksum);
+	    BIG_ENDIAN_LONG_STORE(fcode_hdr->length , length);
+
 	if (verbose)
-		printf("toke: checksum is 0x%04x (%d bytes)\n", 
-							checksum, len);
+	    {
+		printf( "toke: checksum is 0x%04x (%d bytes).  ",
+		    checksum, length);
+		list_fcode_ranges( TRUE);
+	    }
+	}
 
-	fcode_hdr=NULL;
+	/*  Reset things for the next image...   */
+	fcode_start_ob_off = -1;
+	fcode_hdr_ob_off   = -1;
+	fcode_body_ob_off  = -1;
+	fcode_written      = FALSE;
 	haveend=FALSE;
-	return 0;
 }
 
-int emit_pcihdr(u16 vid, u16 did, u32 classid)
+/* **************************************************************************
+ *
+ *      Function name:  emit_pci_rom_hdr
+ *      Synopsis:       Write the PCI ROM Header Block into the Output Buffer
+ *
+ *      Inputs:
+ *         Parameters:                   NONE
+ *         Global Variables:        
+ *             opc                       Output Buffer Position Counter
+ *             ostart                    Start of Output Buffer
+ *
+ *      Outputs:
+ *         Returned Value:               NONE
+ *         Global Variables:    
+ *             pci_hdr_ob_off            PCI ROM Header Block Position
+ *                                           (Offset) in Output Buffer
+ *         FCode Output buffer:
+ *             Write the part of the PCI ROM Header Block we know:
+ *                 Fill in the signature and the field reserved for
+ *                 "processor architecture unique data".
+ *             Fill in the "Pointer to PCI Data Structure" with the
+ *                 size of the data structure, because the first PCI
+ *                 Data Structure will follow immediately.
+ *
+ *      Error Detection:   (Handled by calling routine)
+ *
+ **************************************************************************** */
+
+static void emit_pci_rom_hdr(void)
 {
-	int i;
+    rom_header_t *pci_hdr;
+    pci_hdr_ob_off = opc;
+    pci_hdr = (rom_header_t *)(ostart + pci_hdr_ob_off);
+
+    EMIT_STRUCT(rom_header_t);
 	
 	/* PCI start signature */
-	emit_byte(0x55); emit_byte(0xaa);
+    LITTLE_ENDIAN_WORD_STORE(pci_hdr->signature,0xaa55);
 	
 	/* Processor architecture */
-	emit_byte(0x34); emit_byte(0x00);
-
-	/* 20 bytes of padding */
-	for (i=0; i<20; i++) emit_byte(0x00);
+	/*  Note:
+	 *  The legacy code used to read:
+	 *
+	 *        pci_hdr->reserved[0] = 0x34;
+	 *
+	 *  I don't know what significance the literal  34  had, but
+	 *      by what might just be an odd coincidence, it is equal
+	 *      to the combined lengths of the  PCI-ROM-  and  PCI-Data-
+	 *      headers.
+	 *
+	 *  I suspect that it is more than merely an odd coincidence,
+	 *      and that the following would be preferable:
+	 */
+
+    LITTLE_ENDIAN_WORD_STORE( pci_hdr->reserved ,
+	(sizeof(rom_header_t) + sizeof(pci_data_t)) ) ;
+
+	/* already handled padding */
 
 	/* pointer to start of PCI data structure */
-	emit_byte(0x1c); emit_byte(0x00);
+    LITTLE_ENDIAN_WORD_STORE(pci_hdr->data_ptr, sizeof(rom_header_t) );
 
-	/* 2 bytes of zero padding */
-	emit_byte(0x00); emit_byte(0x00);
-	
-	/* PCI Data structure */
-	emit_byte('P'); emit_byte('C'); emit_byte('I'); emit_byte('R');
-	/* vendor id */
-	emit_byte(vid&0xff); emit_byte(vid>>8);
-	/* device id */
-	emit_byte(did&0xff); emit_byte(did>>8);
-	/* vital product data */
-	emit_byte(0x00); emit_byte(0x00);
-	/* length of pci data structure */
-	emit_byte(0x18); emit_byte(0x00);
-	/* PCI data structure revision */
-	emit_byte(0x00);
+}
 	
-	if (little_endian()) {
-		/* reg level programming */
-		emit_byte(classid & 0xff);
-		/* class code */
-		emit_byte((classid>>8)&0xff);
-		emit_byte((classid>>16)&0xff);
-	} else {
-		/* class code */
-		emit_byte((classid>>8)&0xff);
-		emit_byte((classid>>16)&0xff);
-		/* reg level programming */
-		emit_byte(classid & 0xff);
+/* **************************************************************************
+ *
+ *      Function name:  emit_pci_data_block
+ *      Synopsis:       Write the PCI Data Block into the Output Buffer
+ *
+ *      Inputs:
+ *         Parameters:                   NONE
+ *         Global Variables:        
+ *             opc                       Output Buffer Position Counter
+ *         Data-Stack Items:
+ *             Top:                      Class Code
+ *             Next:                     Device ID
+ *             3rd:                      Vendor ID
+ *
+ *      Outputs:
+ *         Returned Value:               NONE
+ *         Global Variables:    
+ *             pci_data_blk_ob_off       PCI Data Header Block Position
+ *                                           (Offset) in Output Buffer
+ *         Data-Stack, # of Items Popped:  3
+ *         FCode Output buffer:
+ *             Write the PCI Data Header Block:  Fill in the signature,
+ *                 Vendor ID, Device ID and Class Code, and everything
+ *                 else whose value we know.  (Size and Checksum will
+ *                 have to wait until we finish the image...)
+ *         Printout:
+ *             Advisory of Vendor, Device and Class 
+ *
+ *      Error Detection:   (Handled by calling routine)
+ *
+ **************************************************************************** */
+
+static void emit_pci_data_block(void)
+{
+    pci_data_t *pci_data_blk;
+    u32 class_id = dpop();
+    u16 dev_id   = dpop();
+    u16 vend_id  = dpop();
+
+    pci_data_blk_ob_off = opc;
+    pci_data_blk = (pci_data_t *)(ostart + pci_data_blk_ob_off);
+
+    EMIT_STRUCT(pci_data_t);
+
+    BIG_ENDIAN_LONG_STORE(pci_data_blk->signature , PCI_DATA_HDR );
+
+    LITTLE_ENDIAN_WORD_STORE(pci_data_blk->vendor , vend_id );
+    LITTLE_ENDIAN_WORD_STORE(pci_data_blk->device , dev_id );
+    LITTLE_ENDIAN_TRIPLET_STORE(pci_data_blk->class_code , class_id );
+
+    LITTLE_ENDIAN_WORD_STORE(pci_data_blk->dlen ,  sizeof(pci_data_t) );
+
+    pci_data_blk->drevision = PCI_DATA_STRUCT_REV ;
+
+	/* code type = open firmware = 1 */
+    pci_data_blk->code_type = 1;
+
+	/* last image flag */
+    pci_data_blk->last_image_flag = pci_is_last_image ? 0x80 : 0 ;
+
+    tokenization_error(INFO ,
+	"PCI header vendor id=0x%04x, "
+	    "device id=0x%04x, class=%06x\n",
+		vend_id, dev_id, class_id );
+
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  emit_pcihdr
+ *      Synopsis:       Supervise the writing of PCI Header information
+ *                          into the Output Buffer, when the  PCI-HEADER
+ *                          tokenizer directive has been encountered.
+ *
+ *      Inputs:
+ *         Parameters:                   NONE
+ *         Global Variables:        
+ *             fcode_start_ob_off        Initted if FCode output has begun
+ *             noerrors                  The "Ignore Errors" flag
+ *
+ *      Outputs:
+ *         Returned Value:               NONE
+ *         Global Variables:    
+ *         FCode Output buffer:
+ *
+ *      Error Detection:
+ *          An attempt to write a PCI Header after FCode output -- either an
+ *              Fcode-start<n> or ordinary FCode -- has begun is an ERROR.
+ *              Report it; do nothing further, unless "Ignore Errors" is set.
+ *
+ **************************************************************************** */
+
+void emit_pcihdr(void)
+{
+
+    /*  Check for error conditions   */
+    if (
+    /*  FCODE-START<n>  has already been issued  */
+              ( fcode_start_ob_off != -1 )
+    /*  Other FCode has been written             */
+	      ||  fcode_written
+	 )
+    {
+        tokenization_error( TKERROR ,
+	    "Cannot create PCI header after FCode output has begun.\n");
+        if ( ! noerrors ) return ;
 	}
 
-	/* size of image - to be filled later */
-	emit_byte(0x00); emit_byte(0x00);
-	/* revision level */
-	emit_byte(0x00); emit_byte(0x00);
-	/* code type = open firmware */
-	emit_byte(0x01);
-	emit_byte(0x80);
-	/* 2 bytes of padding */
-	emit_byte(0x00); emit_byte(0x00);
-
-	return 0;
+	emit_pci_rom_hdr();
+
+	emit_pci_data_block();
 }
 
+/* **************************************************************************
+ *
+ *      Function name:  finish_pcihdr
+ *      Synopsis:       Fill-in the fields of the PCI Header that could
+ *                      not be determined until the end of the PCI-block.
+ *
+ *************************************************************************** */
 
-int finish_pcihdr(void)
+void finish_pcihdr(void)
 {
-	u8 *tpc;
-	u32 imgsize=opc-ostart, imgblocks;
+
+	u32 imagesize ;
+	u32 imageblocks;
 	int padding;
 	
-	if(!pci_hdr)
+	rom_header_t *pci_hdr;
+	pci_data_t   *pci_data_blk;
+
+	if( pci_data_blk_ob_off == -1 )
 	{
-		printf("error: trying to fix up unknown pci header\n");
-		return -1;
+	    tokenization_error( TKERROR,
+		"%s without PCI-HEADER\n", strupr(statbuf) );
+	    return ;
 	}
 
+	pci_hdr = (rom_header_t *)(ostart + pci_hdr_ob_off);
+	pci_data_blk = (pci_data_t *)(ostart + pci_data_blk_ob_off);
+
 	/* fix up vpd */
-	tpc=opc;
-	opc=pci_hdr+36;
-	emit_byte(pci_vpd&0xff); emit_byte(pci_vpd>>8);
-
-	/* fix up image size */
-	opc=pci_hdr+44;
-	imgblocks=(imgsize+511)>>9; /* size is in 512byte blocks */
-	emit_byte(imgblocks&0xff); emit_byte(imgblocks>>8);
+	LITTLE_ENDIAN_WORD_STORE(pci_data_blk->vpd, pci_vpd);
+
+	/*   Calculate image size and padding */
+	imagesize = opc - pci_hdr_ob_off;     /*  Padding includes PCI hdr  */
+	imageblocks = (imagesize + 511) >> 9; /*  Size in 512-byte blocks   */
+	padding = (imageblocks << 9) - imagesize;
+
+	/* fix up image size. */
+	LITTLE_ENDIAN_WORD_STORE(pci_data_blk->ilen, imageblocks);
 	
 	/* fix up revision */
-	emit_byte(pci_revision&0xff); emit_byte(pci_revision>>8);
+	if ( big_end_pci_image_rev )
+	{
+	    BIG_ENDIAN_WORD_STORE(pci_data_blk->irevision, pci_image_rev);
+	}else{
+	    LITTLE_ENDIAN_WORD_STORE(pci_data_blk->irevision, pci_image_rev);
+	}
 	
 	/* fix up last image flag */
-	opc++;
-	emit_byte(pci_is_last_image?0x80:0x00);
-	opc=tpc;
+	pci_data_blk->last_image_flag = pci_is_last_image ? 0x80 : 0 ;
 	
 	/* align to 512bytes */
-	padding=((imgsize+511)&0xfffffe00)-imgsize;
+	
 	printf("Adding %d bytes of zero padding to PCI image.\n",padding);
 	while (padding--)
 		emit_byte(0);
+	if ( ! pci_is_last_image )
+	{
+	    printf("Note:  PCI header is not last image.\n");
+	}
+	printf("\n");
 	
-	pci_hdr=NULL;
-	return 0;
+	pci_hdr_ob_off      = -1;
+	pci_data_blk_ob_off = -1;
 }
 
 void finish_headers(void)
 {
-	if (fcode_hdr) finish_fcodehdr();
-	if (pci_hdr) finish_pcihdr();
+	if (fcode_hdr_ob_off != -1) finish_fcodehdr();
+	if (pci_hdr_ob_off != -1) finish_pcihdr();
 }
 
diff --git a/toke/emit.h b/toke/emit.h
index be2d3f8..987d210 100644
--- a/toke/emit.h
+++ b/toke/emit.h
@@ -1,3 +1,6 @@
+#ifndef _TOKE_EMIT_H
+#define _TOKE_EMIT_H
+
 /*
  *                     OpenBIOS - free your system! 
  *                         ( FCode tokenizer )
@@ -24,21 +27,90 @@
  *
  */
 
-#ifndef _H_EMIT
-#define _H_EMIT
-
-int emit_byte(u8 data);
-int emit_fcode(u16 tok);
-int emit_token(const char *name);
-int emit_num32(u32 num);
-int emit_num16(u16 num);
-int emit_offset(s16 offs);
-s16 receive_offset(void);
-int emit_string(u8 *string, unsigned int cnt);
-int emit_fcodehdr(void);
-int finish_fcodehdr(void);
-int emit_pcihdr(u16 vid, u16 did, u32 classid);
-int finish_pcihdr(void);
+/* **************************************************************************
+ *         Modifications made in 2005 by IBM Corporation
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Modifications Author:  David L. Paktor    dlpaktor@us.ibm.com
+ **************************************************************************** */
+ 
+#include "types.h"
+
+/* **************************************************************************
+ *          Structure Name:    fcode_header_t
+ *          Synopsis:          FCode Header within the Output Buffer
+ *                            
+ *   Fields:
+ *       format, checksum and length    All as prescribed in P1275, Sec 5.2.2.5
+ *       
+ *       Note that the Checksum and Length fields are stated as byte-arrays
+ *           rather than as integers.  This is intended to guarantee that
+ *           their endian-ness will remain independent of the endian-ness
+ *           of the host-platform on which this Tokenizer is running.
+ *       Note also that, as integers, both are BIG-Endian.      
+ *
+ **************************************************************************** */
+
+typedef struct {
+    u8  format;
+    u8  checksum[2];  /* [0] = Hi byte, [1] = Lo */
+    u8  length[4];    /* [0] = Hi, [1] = Hi-mid, [2] = Lo-mid, [3] = Lo  */
+} fcode_header_t;
+
+
+/* **************************************************************************
+ *          Macro Name:   STRING_LEN_MAX
+ *                        Max number of bytes allowable in an output string
+ *                            
+ *   Arguments:           NONE
+ *
+ *       This value must remail hard-coded and immutable.  It represents the
+ *           maximum number allowed in a FORTH counted-string's count-byte
+ *           (which is, of course, the maximum number that can be expressed
+ *           in an unsigned byte).
+ *       It should not be used for anything else (e.g., buffer sizes), and
+ *           most especially not for anything that might be changed!
+ *
+ **************************************************************************** */
+
+#define STRING_LEN_MAX    255
+
+
+/* **************************************************************************
+ *          Macro Name:   GET_BUF_MAX
+ *                        Size alloted to input-string buffer
+ *                            
+ *   Arguments:           NONE
+ *
+ *       This is a generous allotment for the buffer into which
+ *           input strings are gathered.  Overflow calculations are
+ *           also based on it.  It may be changed safely.
+ *       We like to keep it a nice power-of-two to make the memory-
+ *           allocation routine run efficiently and happily (Okay, so
+ *           that's anthropormism:  It's efficient and *we*'re happy.
+ *           Better?  I thought so...  ;-)
+ *
+ **************************************************************************** */
+
+#define GET_BUF_MAX    1024
+
+
+/* ************************************************************************** *
+ *
+ *      Function Prototypes / Functions Exported:
+ *
+ **************************************************************************** */
+
+void  emit_fcode(u16 tok);
+void  user_emit_byte(u8 data);
+
+void  emit_offset(s16 offs);
+void  emit_string(u8 *string, signed int cnt);
+void  emit_fcodehdr(const char *starter_name);
+void  finish_fcodehdr(void);
+void  emit_pcihdr(void);
+void  finish_pcihdr(void);
 void finish_headers(void);
+void  emit_end0(void);
+void  emit_literal(u32 num);
 
-#endif   /* _H_EMIT */
+#endif   /* _TOKE_EMIT_H */
diff --git a/toke/errhandler.c b/toke/errhandler.c
new file mode 100644
index 0000000..a07a6a9
--- /dev/null
+++ b/toke/errhandler.c
@@ -0,0 +1,956 @@
+/*
+ *                     OpenBIOS - free your system!
+ *                         ( FCode tokenizer )
+ *
+ *  This program is part of a free implementation of the IEEE 1275-1994
+ *  Standard for Boot (Initialization Configuration) Firmware.
+ *
+ *  Copyright (C) 2001-2005 Stefan Reinauer, <stepan@openbios.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ *
+ */
+
+/* **************************************************************************
+ *
+ *      Error-Handler for Tokenizer
+ *
+ *      Controls printing of various classes of errors
+ *
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Module Author:  David L. Paktor    dlpaktor@us.ibm.com
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      Functions Exported:
+ *          init_error_handler  Initialize the error-counts,
+ *                                  announce the file names.
+ *          tokenization_error  Handle an error of the given class,
+ *                                  print the given message in the 
+ *                                  standard format.
+ *          started_at          Supplemental message, giving a back-reference
+ *                                  to the "starting"  point of a compound
+ *                                  error, including last-colon identification.
+ *          just_started_at     Supplemental back-reference to "starting"  point
+ *                                  of compound error, but without last-colon
+ *                                  identification.
+ *          where_started       Supplemental message, giving a more terse back-
+ *                                  -reference to "start" of compound-error.
+ *          just_where_started Supplemental message, more terse back-reference,
+ *                                  without last-colon identification.
+ *          in_last_colon      Supplemental back-reference message,
+ *                                  identifying last Colon-definition.
+ *          safe_malloc         malloc with built-in failure test.
+ *          error_summary       Summarize final error-message status
+ *                                  before completing tokenization.
+ *
+ **************************************************************************** */
+
+
+/* **************************************************************************
+ *
+ *          We will define a set of bit-valued error-types and a
+ *          global bit-mask.  Each error-message will be associated
+ *          with one of the bit-valued error-types.  The bit-mask,
+ *          which will be set by a combination of defaults and user
+ *          inputs (mainly command-line arguments), will control
+ *          whether an error-message of any given type is printed.
+ *          
+ *          Another bit-mask variable will accumulate the error-
+ *          types that occur within any given run; at the end of
+ *          the run, it will be examined to determine if the run
+ *          failed, i.e., if the output should be suppressed.
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *          Error-types fall into the following broad categories:
+ *              FATAL           Cause to immediately stop activity
+ *              TKERROR         Sufficient to make the run a failure,
+ *                                  but not to stop activity.
+ *              WARNING         Not necessarily an error, but something
+ *                                  to avoid.  E.g., it might rely on
+ *                                  assumptions that are not necessarily
+ *                                  what the user/programmer wants.  Or:
+ *                                  It's a deprecated feature, or one
+ *                                  that might be incompatible with
+ *                                  other standard tokenizers.
+ *              INFO            Nothing is changed in processing, but
+ *                                  an advisory is still in order.
+ *              MESSAGE         Message generated by the user.  (Complete;
+ *                                  new-line will be added by display routine.)
+ *              P_MESSAGE       Partial Message -- Instigated by user, but
+ *                                  pre-formatted and not complete.  New-line
+ *                                  will be added by follow-up routine.
+ *
+ **************************************************************************** */
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#include "types.h"
+#include "toke.h"
+#include "stream.h"
+#include "errhandler.h"
+#include "scanner.h"
+
+/* **************************************************************************
+ *
+ *          Global Variables Imported
+ *              iname           Name of file currently being processed
+ *              lineno          Current line-number being processed
+ *              noerrors        "Ignore Errors" flag, set by "-i" switch
+ *              opc             FCode Output Buffer Position Counter
+ *              verbose         If true, enable Advisory Messages
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *              Internal Static Variables
+ *          print_msg               Whether beginning of a message was printed;
+ *                                      therefore, whether to print the rest.
+ *          errs_to_print           Error Verbosity Mask.  Bits set correspond
+ *                                      to message-types that will be printed
+ *                                      May be altered by Command-Line switches.
+ *          err_types_found         Accumulated Error-types.  Bits
+ *                                      set correspond to error-types
+ *                                      that have occurred.
+ *          message_dest            Message Dest'n.  Usually ERRMSG_DESTINATION
+ *                                      (stdout) except when we need to switch.
+ *          err_count               Count of Error Messages
+ *          warn_count              Count of Warning Messages
+ *          info_count              Count of "Advisory" Messages
+ *          user_msg_count          Count of User-generated Messages
+ *          fatal_err_exit          Exit code to be used for "Fatal" error.
+ *                                       This is a special accommodation
+ *                                       for the  safe_malloc  routine.
+ *
+ **************************************************************************** */
+
+static bool  print_msg ;
+static int errs_to_print = ( FATAL | TKERROR | WARNING | 
+                             MESSAGE | P_MESSAGE | FORCE_MSG ) ;
+static int err_types_found =  0 ;
+static int err_count       =  0 ;
+static int warn_count      =  0 ;
+static int info_count      =  0 ;
+static int user_msg_count  =  0 ;
+static int fatal_err_exit  = -1 ;
+static FILE *message_dest;     /*  Would like to init to  ERRMSG_DESTINATION
+				*      here, but the compiler complains...
+				*/
+
+/* **************************************************************************
+ *
+ *              Internal Static Constant Structure
+ *          err_category            Correlate each error-type code with its
+ *                                      Counter-variable and the printable
+ *                                      form of its name.
+ *          num_categories          Number of entries in the err_category table
+ *
+ **************************************************************************** */
+
+typedef struct {
+    int  type_bit ;		/*  Error-type single-bit code        */
+    char *category_name ;	/*  Printable-name base               */
+    char *single ;		/*  Suffix to print singular of name  */
+    char *plural ;		/*  Suffix to print plural of name    */
+    int  *counter ;		/*  Associated Counter-variable       */
+    bool new_line ;		/*  Whether to print new-line at end  */
+} err_category ;
+
+static const err_category  error_categories[] = {
+    /*  FATAL  must be the first entry in the table.   */
+    /*  No plural is needed; only one is allowed....   */
+    { FATAL,    "Fatal Error", "", "",     &err_count      , TRUE  },
+
+    { TKERROR,    "Error"     , "", "s",    &err_count      , FALSE },
+    { WARNING,    "Warning"   , "", "s",    &warn_count     , FALSE },
+    { INFO,       "Advisor"   , "y", "ies", &info_count     , FALSE },
+    { MESSAGE ,   "Message"   , "", "s",    &user_msg_count , TRUE  },
+    { P_MESSAGE , "Message"   , "", "s",    &user_msg_count , FALSE }
+};
+
+static const int num_categories =
+    ( sizeof(error_categories) / sizeof(err_category) );
+
+
+#ifdef NEEDS_STRUPR
+
+/* **************************************************************************
+ *
+ *      Function name:  toup
+ *      Synopsis:       Support function for  strupper
+ *                      Converts one character
+ *
+ *      Inputs:
+ *         Parameters:
+ *             chr_ptr                 Pointer to the character
+ *
+ *      Outputs:
+ *         Returned Value:             None
+ *         Supplied Pointers:
+ *             The character pointed to is changed
+ *
+ *      Process Explanation:
+ *          Because this fills in a lack in the host system, we cannot
+ *              rely on the functions  islower  or  toupper , which are
+ *              usually built-in but might be similarly missing.
+ *
+ **************************************************************************** */
+
+static void toup( char *chr_ptr)
+{
+    const unsigned char upcas_diff = ( 'a' - 'A' );
+    if ( ( *chr_ptr >= 'a' ) && ( *chr_ptr <= 'z' ) )
+    {
+	*chr_ptr -= upcas_diff ;
+    }
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  strupper
+ *      Synopsis:       Replacement for  strupr  on systems that don't 
+ *                      seem to have it.  A necessary hack.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             strung              Pointer to the string to be changed
+ *
+ *      Outputs:
+ *         Returned Value:         Same pointer that was passed in
+ *         Supplied Pointers:
+ *             The string pointed to will be converted to upper case
+ *
+ *      Process Explanation:
+ *          Because it fills in a lack in the host system, this routine
+ *              does not rely on the functions  islower  or  toupper
+ *              which are usually built-in but might be missing.
+ *
+ **************************************************************************** */
+
+char *strupper( char *strung)
+{
+    char *strindx;
+    for (strindx = strung; *strindx != 0; strindx++)
+    {
+        toup( strindx);
+    }
+    return strung;
+}
+
+/* **************************************************************************
+ *
+ *     If  strupr  is missing, it's a good bet that so is  strlwr 
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      Function name:  tolow
+ *      Synopsis:       Support function for  strlower
+ *                      Converts one character
+ *
+ *      Inputs:
+ *         Parameters:
+ *             chr_ptr                 Pointer to the character
+ *
+ *      Outputs:
+ *         Returned Value:             None
+ *         Supplied Pointers:
+ *             The character pointed to is changed
+ *
+ *      Process Explanation:
+ *          Because this fills in a lack in the host system, we cannot
+ *              rely on the functions  isupper  or  tolower , which are
+ *              usually built-in but might be similarly missing.
+ *
+ **************************************************************************** */
+
+static void tolow( char *chr_ptr)
+{
+    const unsigned char lowcas_diff = ( 'A' - 'a' );
+    if ( ( *chr_ptr >= 'A' ) && ( *chr_ptr <= 'Z' ) )
+    {
+	*chr_ptr -= lowcas_diff ;
+    }
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  strlower
+ *      Synopsis:       Replacement for  strlwr  on systems that don't 
+ *                      seem to have it.  A necessary hack.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             strung              Pointer to the string to be changed
+ *
+ *      Outputs:
+ *         Returned Value:         Same pointer that was passed in
+ *         Supplied Pointers:
+ *             The string pointed to will be converted to lower case
+ *
+ *      Process Explanation:
+ *          Because it fills in a lack in the host system, this routine
+ *              does not rely on the functions  isupper  or  tolower
+ *              which are usually built-in but might be missing.
+ *
+ **************************************************************************** */
+
+char *strlower( char *strung)
+{
+    char *strindx;
+    for (strindx = strung; *strindx != 0; strindx++)
+    {
+        tolow( strindx);
+    }
+    return strung;
+}
+
+
+#endif  /*   NEEDS_STRUPR   */
+ 
+/* **************************************************************************
+ *
+ *      Function name:  init_error_handler
+ *      Synopsis:       Initialize the error-handler before starting a
+ *                          new tokenization; both the aspects that will
+ *                          persist across the entire run and those that
+ *                          need to be reset, such as error-counts.
+ *
+ *      Inputs:
+ *         Parameters:                 NONE
+ *         Global Variables: 
+ *              verbose                Set by "-v" switch
+ *         Macro:
+ *             ERRMSG_DESTINATION      Error message destination;
+ *                                         (Set by development-time switch)
+ *             FFLUSH_STDOUT           Flush STDOUT if err-msg-dest is STDERR
+ *
+ *      Outputs:
+ *         Returned Value:             NONE
+ *         Global Variables:
+ *             errs_to_print           Add the INFO bit if verbose is set
+ *         Local Static Variables:
+ *             message_dest            Point it at ERRMSG_DESTINATION (stderr)
+ *           Reset the following to zero:
+ *             err_types_found         Accumulated Error-types.
+ *             err_count               Count of Error Messages
+ *             warn_count              Count of Warning Messages
+ *             info_count              Count of "Advisory" Messages
+ *             user_msg_count          Count of User-generated Messages
+ *         Other Exotic Effects:
+ *             Flush stdout if Error message destination is not stdout, to
+ *                 avoid collisions with stderr once Error Messaging begins.
+ *
+ *      Extraneous Remarks:
+ *          This needs to be done before attempting to read the input file,
+ *              so that any Messages that occur there can be properly counted.
+ *
+ **************************************************************************** */
+
+void init_error_handler( void)
+{
+    message_dest  =  ERRMSG_DESTINATION;
+    if ( verbose )  errs_to_print |= INFO ;
+    err_types_found = 0 ;
+    err_count = 0 ;
+    warn_count = 0 ;
+    info_count = 0 ;
+    user_msg_count = 0 ;
+    FFLUSH_STDOUT
+}
+
+/* **************************************************************************
+ *
+ *      Function name:    tokenization_error
+ *      Synopsis:         Handle an error of the given class,
+ *                            print the given message in the standard format.
+ *      
+ *      Inputs:
+ *         Parameters:
+ *             err_type       int        One of the bit-valued error-types
+ *             The remaining parameters are a format string and corresponding
+ *                 data objects such as would be sent to  printf() 
+ *         Global Variables:
+ *             errs_to_print        Error Verbosity Mask.
+ *             iname                Name of file currently being processed
+ *             lineno               Current line-number being processed
+ *             fatal_err_exit       Exit code for "Fatal" error, if applicable.
+ *         Macro:
+ *             ERRMSG_DESTINATION        Error message destination;
+ *                                           (Development-time switch)
+ *         Note:  Whether this routine will or will not supply a new-line
+ *             at the end of the printout depends on the category of the
+ *             message.  The new-line is included for a FATAL or a User-
+ *             Generated Message, and excluded for the rest.  For those,
+ *             the calling routine must be responsible for including a
+ *             new-line at the end of the format string or for otherwise
+ *             finishing the line, as by calling started_at()
+ *
+ *      Outputs:
+ *         Returned Value:                 NONE
+ *         Local Static Variables:
+ *             err_types_found             Accumulated Error-types.
+ *             print_msg                   Whether this message was printed;
+ *                                             may be used by started_at()
+ *                    One of the following Category Counters
+ *                         will be incremented, as applicable:
+ *             err_count
+ *             warn_count
+ *             info_count 
+ *             user_msg_count
+ *         Printout:    Directed to  stdout or stderr 
+ *                          (see definition of ERRMSG_DESTINATION)
+ *
+ *      Error Detection:
+ *              Err_type not in list
+ *                      Print special message; treat cause as an Error.
+ *                      Force printout.
+ *
+ *      Process Explanation:
+ *          Accumulated the Error-type into  err_types_found 
+ *          Identify the Error-Category:
+ *              Check the Error-Type against the bit-code.
+ *                  The Error-type may have more than one bit set,
+ *                  but if it matches the Category bit-code, it's it.
+ *              If it doesn't match any Error-Category bit-code, print
+ *                  a special message and treat it as an ERROR code.
+ *          Check the Error-Type against the Error Verbosity Mask;
+ *          If it has a bit set, print the Error-Category, together
+ *                  with the source-file name and line number, and
+ *                  the rest of the message as supplied.
+ *              The table that translates the Error-type into a printable
+ *                  Error-Category string also identifies the applicable
+ *                  Category Counter; increment it.
+ *          Of course, there's no return from a FATAL error; it exits.
+ *
+ **************************************************************************** */
+
+void tokenization_error( int err_type, char* msg, ... )
+{
+    int indx ;
+
+    /*  Initial settings:  treat as an Error.  */
+    char *catgy_name = "Error";
+    char *catgy_suffx = "";
+    int *catgy_counter = &err_count;
+    bool print_new_line = FALSE;
+
+    /*  Accumulated the Error-type into  err_types_found  */
+    err_types_found |= err_type;
+
+    /*  Identify the Error-Category.  */
+    for ( indx = 0 ; indx < num_categories ; indx ++ )
+    {
+        if ( ( error_categories[indx].type_bit & err_type ) != 0 )
+        {
+            catgy_name = error_categories[indx].category_name;
+            catgy_suffx = error_categories[indx].single;
+            catgy_counter = error_categories[indx].counter;
+	    print_new_line = error_categories[indx].new_line;
+            break;
+        }
+    }
+
+    /*  Special message if  err_type  not in list; treat as an Error.  */
+    if ( catgy_name == NULL )
+    {
+         fprintf(ERRMSG_DESTINATION,
+	      "Program error: Unknown Error-Type, 0x%08x.  "
+              "  Will treat as Error.\n", err_type) ;
+         err_types_found |= TKERROR;
+         print_msg = TRUE ;
+    } else {
+         /*  Check the Error-Type against the Error Verbosity Mask  */
+         print_msg = BOOLVAL( ( errs_to_print & err_type ) != 0 );
+    }
+
+    if ( print_msg )
+    {
+        va_list argp;
+
+        if ( iname != NULL )
+	{
+	    fprintf(ERRMSG_DESTINATION, "%s%s:  File %s, Line %d.  ",
+        	 catgy_name, catgy_suffx, iname, lineno);
+	}else{
+	    /*  Don't print iname or lineno if no file opened.  */
+	    fprintf(ERRMSG_DESTINATION, "%s%s:  ",
+        	 catgy_name, catgy_suffx);
+	}
+
+        va_start(argp, msg);
+        vfprintf(ERRMSG_DESTINATION, msg, argp);
+        va_end(argp);
+	if ( print_new_line ) fprintf(ERRMSG_DESTINATION, "\n");
+
+	/*   Increment the category-counter.  */
+	*catgy_counter += 1;
+    }
+    if ( err_type == FATAL )
+    {
+        fprintf(ERRMSG_DESTINATION, "Tokenization terminating.\n");
+        error_summary();
+        exit ( fatal_err_exit );
+    }
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  print_where_started
+ *      Synopsis:       Supplemental message, following a tokenization_error,
+ *                          giving a back-reference to the "start" point of
+ *                          the compound-error being reported.
+ *                      This is a retro-fit; it does the heavy lifting for
+ *                          the routines  started_at() ,  just_started_at() , 
+ *                           where_started() ,  just_where_started() and
+ *                           in_last_colon() .
+ *
+ *      Inputs:
+ *         Parameters:
+ *             show_started         Whether to print a phrase about "started"
+ *             show_that_st         Whether to print "that started" as opposed
+ *                                      to " , which started"
+ *             saved_ifile          File-name saved for "back-reference"
+ *             saved_lineno         Line-number saved for "back-reference"
+ *             may_show_incolon     Whether to allow a call to  in_last_colon()
+ *                                      Needed to prevent infinite recursion...
+ *         Global Variables:        
+ *             iname                Name of file currently being processed
+ *             lineno               Current line-number being processed
+ *         Local Static Variables:
+ *             print_msg            Whether the beginning part of the message
+ *                                      was printed by tokenization_error()
+ *             message_dest         Message Destination. Is ERRMSG_DESTINATION
+ *                                      (stdout) usually, except sometimes...
+ *
+ *      Outputs:
+ *         Returned Value:          None
+ *         Printout:
+ *             The remainder of a message:  the location of a back-reference.
+ *                 The phrase "that started" is switchable.  This routine
+ *                 will supply the leading space and a new-line; the routines
+ *                 that call this can be used to finish the line.
+ *
+ *      Process Explanation:
+ *          This routine is called immediately after tokenization_error()
+ *              If tokenization_error() didn't print, neither will we.
+ *              The residual state of  print_msg  will tell us that.
+ *          If the preceding message ended with something general about a
+ *              "Colon Definition" or "Device-Node" or the like, we want
+ *              the message to read:  "that started on line ... [in file ...]"
+ *          If the end of the preceding message was something more specific,
+ *              we just want the message to read:  "on line ... [in file ...]"
+ *          If the saved input file name doesn't match our current input
+ *              file name, we will print it and the saved line-number.
+ *          If the file name hasn't changed, we will print only the saved
+ *              line-number.
+ *          If neither is changed, there's no point in printing any of the
+ *              above-mentioned text.    
+ *          If a Colon-definition is in progress, show its name and the
+ *              line on which it started.  Protect against infinite loop!
+ *          End the line.
+ *
+ *      Extraneous Remarks:
+ *          This is a retrofit.  Earlier, it was just  started_at() .  Later,
+ *              I generated more specific messages, and needed a way to leave
+ *              out the "that started".  I could, theoretically, have added
+ *              the extra parameter to  started_at() , but by now there are
+ *              so many of calls to it that I'd rather leave them as is, and
+ *              just change the name of the routine in the few places that
+ *              need the terser form of the message.
+ *
+ **************************************************************************** */
+
+static void print_where_started( bool show_started,
+                                   bool show_that_st,
+				   char * saved_ifile,
+				       unsigned int saved_lineno,
+                                           bool may_show_incolon)
+{
+    if ( print_msg )
+    {
+	bool fil_is_diff;
+	bool lin_is_diff;
+
+	/*  File names are case-sensitive  */
+	fil_is_diff = BOOLVAL(strcmp(saved_ifile, iname) != 0 );
+	lin_is_diff = BOOLVAL(saved_lineno != lineno );
+	if ( fil_is_diff || lin_is_diff )
+	{
+	    if ( show_started )
+	    {
+		if ( show_that_st )
+		{
+		    fprintf(message_dest, " that");
+		}else{
+		    fprintf(message_dest, " , which");
+		}
+		fprintf(message_dest, " started");
+	    }
+	    fprintf(message_dest, " on line %d", saved_lineno);
+	    if ( fil_is_diff )
+	    {
+	        fprintf(message_dest, " of file %s", saved_ifile);
+	    }
+	}
+
+	if ( may_show_incolon )
+	{
+	    in_last_colon();
+	}else{
+	    fprintf(message_dest, "\n");
+	}
+    }
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  started_at
+ *      Synopsis:       Supplemental back-reference message,
+ *                          with the "that started"  phrase,
+ *                          and with last-colon identification.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             saved_ifile          File-name saved for "back-reference"
+ *             saved_lineno         Line-number saved for "back-reference"
+ *
+ *      Outputs:
+ *         Returned Value:          None
+ *         Global Variables:
+ *         Printout:
+ *             The "...started at..." remainder of a message, giving a back-
+ *                 -reference to the  "start" point supplied in the params,
+ *                 and the start of the current Colon-definition if one is
+ *                 in effect.
+ *             Will supply a new-line and can be used to finish the line.
+ *
+ **************************************************************************** */
+
+void started_at( char * saved_ifile, unsigned int saved_lineno)
+{
+    print_where_started( TRUE, TRUE, saved_ifile, saved_lineno, TRUE);
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  print_started_at
+ *      Synopsis:       Same as started_at() except output will be directed
+ *                          to  stdout  instead of to ERRMSG_DESTINATION
+ *
+ *      Extraneous Remarks:
+ *          A retrofit.  Can you tell?
+ *
+ **************************************************************************** */
+ 
+void print_started_at( char * saved_ifile, unsigned int saved_lineno)
+{
+    message_dest = stdout;
+	started_at( saved_ifile, saved_lineno);
+    message_dest = ERRMSG_DESTINATION;
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  just_started_at
+ *      Synopsis:       Supplemental back-reference message,
+ *                          with the "that started"  phrase,
+ *                          but without last-colon identification.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             saved_ifile          File-name saved for "back-reference"
+ *             saved_lineno         Line-number saved for "back-reference"
+ *
+ *      Outputs:
+ *         Returned Value:          None
+ *         Global Variables:
+ *         Printout:
+ *             The "...started at..." remainder of a message, giving a back-
+ *                 -reference to the  "start" point supplied in the params,
+ *                 and no more.
+ *             Will supply a new-line and can be used to finish the line.
+ *
+ **************************************************************************** */
+
+void just_started_at( char * saved_ifile, unsigned int saved_lineno)
+{
+    print_where_started( TRUE, TRUE, saved_ifile, saved_lineno, FALSE);
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  where_started
+ *      Synopsis:       Supplemental back-reference message,
+ *                          without the "that started"  phrase,
+ *                          but with last-colon identification.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             saved_ifile          File-name saved for "back-reference"
+ *             saved_lineno         Line-number saved for "back-reference"
+ *
+ *      Outputs:
+ *         Returned Value:          None
+ *         Global Variables:
+ *         Printout:
+ *             The remainder of a message, giving a back-reference to the
+ *                 "start" point supplied in the parameters, and the start
+ *                 of the current Colon-definition if one is in effect.
+ *             Will supply a new-line and can be used to finish the line.
+ *
+ **************************************************************************** */
+
+void where_started( char * saved_ifile, unsigned int saved_lineno)
+{
+    print_where_started( FALSE, FALSE, saved_ifile, saved_lineno, TRUE);
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  just_where_started
+ *      Synopsis:       Supplemental back-reference message,
+ *                          without the "that started"  phrase,
+ *                          and without last-colon identification.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             saved_ifile          File-name saved for "back-reference"
+ *             saved_lineno         Line-number saved for "back-reference"
+ *
+ *      Outputs:
+ *         Returned Value:          None
+ *         Global Variables:
+ *         Printout:
+ *             The remainder of a message, giving a back-reference to the
+ *                 "start" point supplied in the parameters, and no more.
+ *             Will supply a new-line and can be used to finish the line.
+ *
+ **************************************************************************** */
+
+void just_where_started( char * saved_ifile, unsigned int saved_lineno)
+{
+    print_where_started( FALSE, FALSE, saved_ifile, saved_lineno, FALSE);
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  in_last_colon
+ *      Synopsis:       Supplemental back-reference message, identifying
+ *                          last Colon-definition if one is in effect.
+ *                      Can be used to finish the line in either case.
+ *
+ *      Inputs:
+ *         Parameters:                   NONE
+ *         Global Variables:
+ *             incolon                   TRUE if Colon-definition is in progress
+ *             last_colon_defname        Name of last colon-definition
+ *             last_colon_filename       File where last colon-def'n made
+ *             last_colon_lineno         Line number of last colon-def'n
+ *         Local Static Variables:
+ *             print_msg            Whether the beginning part of the message
+ *                                      was printed by tokenization_error()
+ *             message_dest         Message Destination. Is ERRMSG_DESTINATION
+ *                                      (stdout) usually, except sometimes...
+ *
+ *      Outputs:
+ *         Returned Value:                  NONE
+ *         Printout:
+ *             Remainder of a message:
+ *                "in definition of  ... , which started ..."
+ *
+ *      Process Explanation:
+ *          Because this routine does some of its own printing, it needs
+ *              to check the residual state of  print_msg  first.
+ *          The calling routine does not need to test   incolon ; it can
+ *              call this to end the line in either case.
+ *
+ **************************************************************************** */
+
+void in_last_colon( void )
+{
+    if ( print_msg )
+    {
+	if ( incolon )
+	{
+	    fprintf( message_dest, " in definition of  %s ",
+		strupr( last_colon_defname) );
+	    print_where_started( TRUE, FALSE,
+		last_colon_filename, last_colon_lineno, FALSE);
+	}else{
+	    fprintf(message_dest, "\n");
+	}
+    }
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  safe_malloc
+ *      Synopsis:       malloc with built-in failure test.
+ *      
+ *      Inputs:
+ *         Parameters:
+ *             size       size_t     Size of memory-chunk to allocate
+ *             phrase     char *     Phrase to print after "... while "
+ *                                       in case of failure.
+ *
+ *      Outputs:
+ *         Returned Value:           Pointer to allocated memory
+ *         Global Variables:
+ *             fatal_err_exit       On memory allocation failure, change
+ *                                       to a special system-defined value
+ *
+ *      Error Detection:
+ *          On memory allocation failure, declare a FATAL error.  Set up
+ *              for a special system-defined EXIT value that indicates
+ *              insufficient memory.
+ *
+ *      Process Explanation:
+ *          It is the responsibility of the calling routine to be sure
+ *              the "phrase" is unique within the program.  It is intended
+ *              as a debugging aid, to help localize the point of failure.
+ *
+ **************************************************************************** */
+
+_PTR safe_malloc( size_t size, char *phrase)
+{
+    _PTR retval ;
+    retval = malloc (size);
+    if ( !retval )
+    {
+        fatal_err_exit = -ENOMEM ;
+        tokenization_error( FATAL, "Out of memory while %s.", phrase);
+    }
+    return ( retval );
+}
+
+/* **************************************************************************
+ *
+ *      Function name:         error_summary
+ *      Synopsis:              Summarize final error-message status
+ *                                 before completing tokenization.
+ *                             Indicate if OK to produce output.
+ *      
+ *      Inputs:
+ *         Parameters:                   NONE
+ *         Global Variables:        
+ *             noerrors             "Ignore Errors" flag, set by "-i" switch
+ *             err_types_found      Accumulated Error-types.
+ *             error_categories     Table of Error-types, Message-Counters
+ *                                      and their printable names.
+ *             opc                  FCode Output Buffer Position Counter
+ *                                      (zero means there was no output).
+ *
+ *      Outputs:
+ *         Returned Value:          True = OK to produce output (But caller
+ *                                      must still verify non-zero opc)
+ *         Printout:
+ *             Various messages.
+ *
+ *      Process Explanation:
+ *          The first entry in the error_categories table is FATAL    
+ *              We won't need to print a tally of that...
+ *      
+ **************************************************************************** */
+
+bool error_summary( void )
+{
+    /*  Bit-mask of error-types that require suppressing output   */
+    static const int suppress_mask = ( FATAL | TKERROR );
+    bool retval = TRUE;
+    bool suppressing = FALSE;
+
+    /*  There's no escaping a FATAL error   */
+    if ( ( err_types_found & FATAL ) != 0 )
+    {
+	/*   FATAL error.  Don't even bother with the tally.   */
+	suppressing = TRUE;
+    } else {
+
+	if ( opc == 0 )
+	{
+	    printf ( "Nothing Tokenized");
+	}else{
+	    printf ( "Tokenization Completed");
+	}
+
+	if ( err_types_found != 0 )
+	{
+	    int indx;
+	    bool tally_started = FALSE ;
+	    printf (". ");
+	    /*
+	     *  Print a tally of the error-types;
+	     *  handle plurals and punctuation appropriately.
+	     */
+	    /*  Start at indx = 1 to skip examining FATALs   */
+	    for ( indx = 1; indx < num_categories ; indx ++ )
+	    {
+		if ( *(error_categories[indx].counter) > 0 )
+		{
+		    printf ("%s %d %s%s",
+	        	tally_started ? "," : "" ,
+			    *(error_categories[indx].counter),
+				error_categories[indx].category_name,
+				    *(error_categories[indx].counter) > 1 ?
+					 error_categories[indx].plural :
+					     error_categories[indx].single );
+		    /*  Zero out the counter, to prevent displaying the
+		     *      number of Messages twice, since it's shared
+		     *      by the "Messages" and "P_Messages" categories.
+		     */
+		    *(error_categories[indx].counter) = 0;
+		    tally_started = TRUE;
+		}
+	    }
+	}
+        printf (".\n");
+
+	if ( ( err_types_found & suppress_mask ) != 0 )
+	{    /*  Errors found.  Not  OK to produce output    */
+             /*  Unless "Ignore Errors" flag set...          */
+	    if ( INVERSE(noerrors) )
+            {
+		suppressing = TRUE;
+            }else{
+		if ( opc > 0 )
+		{
+		    printf ("Error-detection over-ridden; "
+				"producing binary output.\n");
+		}
+            }
+	}
+    }
+    if ( suppressing )
+    {
+	retval = FALSE ;
+	printf ("Suppressing binary output.\n");
+    }
+    return ( retval );
+}
+
diff --git a/toke/errhandler.h b/toke/errhandler.h
new file mode 100644
index 0000000..e714d69
--- /dev/null
+++ b/toke/errhandler.h
@@ -0,0 +1,119 @@
+#ifndef _TOKE_ERRHANDLER_H
+#define _TOKE_ERRHANDLER_H
+
+/*
+ *                     OpenBIOS - free your system!
+ *                         ( FCode tokenizer )
+ *
+ *  This program is part of a free implementation of the IEEE 1275-1994
+ *  Standard for Boot (Initialization Configuration) Firmware.
+ *
+ *  Copyright (C) 2001-2005 Stefan Reinauer, <stepan@openbios.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ *
+ */
+
+/* **************************************************************************
+ *
+ *      Function Prototypes for Tokenizer Error-Handler
+ *
+ *      Defines symbols for the various classes of errors
+ *          for the Error-Handler and for all its users
+ *
+ *
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Module Author:  David L. Paktor    dlpaktor@us.ibm.com
+ *
+ **************************************************************************** */
+
+#include "types.h"
+
+#define  FATAL       0x80000000
+#define  TKERROR     0x04000000
+#define  WARNING     0x00200000
+#define  INFO        0x00010000
+#define  MESSAGE     0x00000800
+#define  P_MESSAGE   0x00000040
+#define  FORCE_MSG   0x00000001
+
+void init_error_handler( void);
+void tokenization_error( int err_type, char* msg, ... );
+void started_at( char * saved_ifile, unsigned int saved_lineno);
+void print_started_at( char * saved_ifile, unsigned int saved_lineno);
+void just_started_at( char * saved_ifile, unsigned int saved_lineno);
+void where_started( char * saved_ifile, unsigned int saved_lineno);
+void just_where_started( char * saved_ifile, unsigned int saved_lineno);
+void in_last_colon( void );
+_PTR safe_malloc( size_t size, char *phrase);
+bool error_summary( void );   /*  Return TRUE if OK to produce output. */
+
+
+/* **************************************************************************
+ *
+ *      Macros:
+ *          ERRMSG_DESTINATION      During development, I used this to switch
+ *               error message destination between STDOUT and STDERR, until I
+ *               settled on which is preferable.  Recently, I have proven to
+ *               my satisfaction that STDERR is preferable:  error-messages
+ *               produced by a sub-shell will be correctly synchronized with
+ *               the error-messages we produce.  When I tested using STDOUT
+ *               for error-messages, that error-case looked garbled.
+ *          FFLUSH_STDOUT           fflush( stdout) if error message destination
+ *              is STDERR, No-op if it's STDOUT.  A few of these, judiciously
+ *              placed, kept our own regular and error messages nicely in sync.
+ *
+ **************************************************************************** */
+
+#define ERRMSG_DESTINATION stderr
+#define FFLUSH_STDOUT  fflush( stdout);
+
+/*  We're no longer switching the above.
+ *  The below is left here to show what had been done formerly.
+ */
+#if -1     /*  Switchable error-message destination  */ 
+#else      /*  Switchable error-message destination  */
+#define ERRMSG_DESTINATION stdout
+#define FFLUSH_STDOUT  /*  Don't need to do anything here  */
+#endif     /*  Switchable error-message destination  */
+
+/*  Some systems don't seem to have  strupr   */
+#ifdef SYS_IS_GNU_Linux
+#define NEEDS_STRUPR
+#endif  /*   SYS_IS_GNU_Linux   */
+#ifdef SYS_IS_AIX
+#define NEEDS_STRUPR
+#endif  /*   SYS_IS_AIX   */
+/*  ???  Should this instead be tuned to Proc'r is PPC ???  Why? */
+
+#ifdef NEEDS_STRUPR
+
+/* **************************************************************************
+ *
+ *     A necessary hack for systems that don't seem
+ *         to have  strupr  and  strlwr
+ *     Let's avoid a naming conflict, just in case... 
+ *
+ **************************************************************************** */
+
+extern char *strupper( char *strung);
+#define strupr strupper
+
+extern char *strlower( char *strung);
+#define strlwr strlower
+
+
+#endif  /*   NEEDS_STRUPR   */
+
+#endif  /*   _TOKE_ERRHANDLER_H   */
diff --git a/toke/flowcontrol.c b/toke/flowcontrol.c
new file mode 100644
index 0000000..b936fd2
--- /dev/null
+++ b/toke/flowcontrol.c
@@ -0,0 +1,2080 @@
+/*
+ *                     OpenBIOS - free your system!
+ *                         ( FCode tokenizer )
+ *
+ *  This program is part of a free implementation of the IEEE 1275-1994
+ *  Standard for Boot (Initialization Configuration) Firmware.
+ *
+ *  Copyright (C) 2001-2005 Stefan Reinauer, <stepan@openbios.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ *
+ */
+
+/* **************************************************************************
+ *
+ *      Support Functions for tokenizing FORTH Flow-Control structures.
+ *
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Module Author:  David L. Paktor    dlpaktor@us.ibm.com
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      Functions Exported:
+ *               These first two do their work after the calling routine
+ *                        has written the token for the required variant:
+ *
+ *          mark_do                        Mark branches for "do" variants
+ *          resolve_loop                   Resolve "loop" variants' branches
+ *
+ *               The remaining routines' descriptions are all similar:
+ *                        Write the token(s), handle the outputs, mark
+ *                        or resolve the branches, and verify correct
+ *                        control-structure matching, for tokenizing
+ *                        the ........................ statement in FORTH
+ *          emit_if                          IF
+ *          emit_else                        ELSE
+ *          emit_then                        THEN
+ *          emit_begin                       BEGIN
+ *          emit_again                       AGAIN
+ *          emit_until                       UNTIL
+ *          emit_while                       WHILE
+ *          emit_repeat                      REPEAT
+ *          emit_case                        CASE
+ *          emit_of                          OF
+ *          emit_endof                       ENDOF
+ *          emit_endcase                     ENDCASE
+ *
+ *      Three additional routines deal with matters of overall balance
+ *      of the Control-Structures, and identify the start of any that
+ *      were not balanced.  The first just displays Messages:
+ *
+ *          announce_control_structs
+ *
+ *      The other two clear and re-balance them:
+ *
+ *          clear_control_structs_to_limit
+ *          clear_control_structs
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      Still to be done:
+ *          Correct analysis of Return-Stack usage around Flow-Control
+ *              constructs, including within Do-Loops or before Loop
+ *              Elements like I and J or UNLOOP or LEAVE.
+ *          Similarly, Return-Stack usage around IF ... ELSE ... THEN
+ *              statements needs analysis.  For instance, the following:
+ * 
+ *          blablabla >R  yadayada IF  R> gubble ELSE flubble R>  THEN
+ * 
+ *              is, in fact, correct, while something like:
+ * 
+ *          blablabla >R  yadayada IF  R> gubble THEN
+ * 
+ *              is an error.
+ * 
+ *          Implementing an analysis that would be sufficiently accurate
+ *              to justify reporting an ERROR with certainty (rather than
+ *              a mere WARNING speculatively) would probably require full
+ *              coordination with management of Flow-Control constructs,
+ *              and so is noted here.
+ *
+ **************************************************************************** */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "types.h"
+#include "toke.h"
+#include "emit.h"
+#include "vocabfuncts.h"
+#include "scanner.h"
+#include "stack.h"
+#include "errhandler.h"
+#include "flowcontrol.h"
+#include "stream.h"
+
+/* **************************************************************************
+ *
+ *          Global Variables Imported
+ *              opc              FCode Output Buffer Position Counter
+ *              noerrors         "Ignore Errors" flag, set by "-i" switch     
+ *              do_loop_depth    How deep we are inside DO ... LOOP variants   
+ *              incolon          State of tokenization; TRUE if inside COLON
+ *              statbuf          The word just read from the input stream
+ *              iname            Name of input file currently being processed
+ *              lineno           Current line-number being processed
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *          Global Variables Exported
+ *              control_stack_depth        Number of items on "Control-Stack"
+ *
+ **************************************************************************** */
+
+int control_stack_depth = 0;
+
+
+/* **************************************************************************
+ *
+ *              Internal Static Functions:
+ *          push_cstag                     Push an item onto the Control-Stack
+ *          pop_cstag                      Pop one item from the Control-Stack
+ *          control_stack_size_test        Test C-S depth; report if error
+ *          control_structure_mismatch     Print error-message
+ *          offset_too_large               Print error-message
+ *          matchup_control_structure      Error-check Control-Stack
+ *          matchup_two_control_structures Error-check two Control-Stack entries
+ *          emit_fc_offset                 Error-check and output FCode-Offset
+ *          control_structure_swap         Swap control-struct branch-markers
+ *          mark_backward_target           Mark target of backward-branch
+ *          resolve_backward               Resolve backward-target for branch
+ *          mark_forward_branch            Mark forward-branch
+ *          resolve_forward                Resolve forward-branch at target
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *              Internal Named Constants
+ *   Note:  These control-structure identifier tags -- a.k.a. cstags --
+ *       are used to identify the matching components of particular
+ *       control-structures.  They are passed as parameters, and either
+ *       "Pushed" onto the "Control-Stack", or compared with what is on
+ *       "Top" of the "Control-Stack", as an error-check.
+ *
+ *            name                    used by forth words:
+ *         BEGIN_CSTAG             BEGIN AGAIN UNTIL REPEAT
+ *         IF_CSTAG                IF ELSE THEN
+ *         WHILE_CSTAG             WHILE REPEAT THEN
+ *         DO_CSTAG                DO ?DO LOOP +LOOP
+ *         CASE_CSTAG              CASE OF ENDCASE
+ *         OF_CSTAG                OF ENDOF
+ *         ENDOF_CSTAG             ENDOF ENDCASE
+ *
+ *   The numbers assigned are arbitrary; they were selected for a
+ *       high unlikelihood of being encountered in normal usage,
+ *       and constructed with a hint of mnemonic value in mind.
+ *
+ **************************************************************************** */
+                                 /*     Mnemonic:   */
+#define BEGIN_CSTAG  0xC57be916  /*  CST BEGIN      */
+#define IF_CSTAG     0xC57A901f  /*  CSTAG (0) IF   */
+#define WHILE_CSTAG  0xC573412e  /*  CST WHILE      */
+#define DO_CSTAG     0xC57A90d0  /*  CSTAG (0) DO   */
+#define CASE_CSTAG   0xC57Aca5e  /*  CSTA CASE      */
+#define OF_CSTAG     0xC57A90f0  /*  CSTAG OF (0)   */
+#define ENDOF_CSTAG  0xC57e6d0f  /*  CST ENDOF   */
+
+
+/* **************************************************************************
+ *
+ *     Control-Structure identification, matching, completion and error
+ *         messaging will be supported by a data structure, which we
+ *         will call a CSTAG-Group
+ *
+ *     It consists of one "Data-item" and several "Marker" items, thus:
+ *
+ *         The Data-item in most cases will be a value of OPC (the Output
+ *             Buffer Position Counter) which will be used in calculating 
+ *             an offset or placing an offset or both, as the case may be,
+ *             for the control structure in question.  The one exception
+ *             is for a CSTAG-Group generated by a CASE statement; its
+ *             Data-item will be an integer count of the number of "OF"s
+ *             to be resolved when the ENDCASE statement is reached.
+ *
+ *         The CSTAG for the FORTH word, as described above
+ *         The name of the input file in which the word was encountered
+ *             (actually, a pointer to a mem-alloc'ed copy of the filename)
+ *         The line number, within the input file, of the word's invocation
+ *         The Absolute Token Number in all Source Input of the word
+ *         The FORTH word that started the structure, (used in error messages)
+ *         A flag to indicate when two CSTAG-Groups are created together,
+ *             which will be used to prevent duplicate error messages when,
+ *             for instance, a  DO  is mismatched with a  REPEAT .
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *               "Control-Stack" Diagram Notation
+ *
+ *     The CSTAG-Groups will be kept in an order resembling a data-stack,
+ *         (even though it won't be the data-stack itself).  We will refer
+ *         to this list of structures as the "Control Stack", and in our
+ *         comments we will show their arrangement in a format resembling
+ *         stack-diagram remarks.
+ *
+ *     In these "Control-Stack Diagrams", we will use the notation:
+ *		   <Stmt>_{FOR|BACK}w_<TAGNAM>
+ *         to represent a CSTAG-Group generated by a <Stmt> -type of
+ *         statement, with a "FORw"ard or "BACKw"ard branch-marker and
+ *         a CSTAG of the <TAGNAM> type.
+ *
+ *     A CASE-CSTAG-Group will have a different notation:
+ *		   N_OFs...CASE_CSTAG
+ *
+ *     In all cases, a CSTAG-Group will be manipulated as a unit.
+ *
+ *     The notation for Control-Stack Diagram remarks will largely resemble
+ *         the classic form used in FORTH, i.e., enclosed in parentheses,
+ *         lowest item to the left, top item on the right, with a double-
+ *         hyphen to indicate "before" or "after".
+ *
+ *     Enclosure in {curly-braces} followed by a subscript-range indicates
+ *         that the Stack-item or Group is repeated.
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      We are not keeping the "Control Stack" structures on the regular
+ *          data stack because a sneaky combination of user-inputs could
+ *          throw things into chaos were we to use that scheme.  Consider
+ *          what would happen if a number were put on the stack, say, in
+ *          tokenizer-escape mode, in between elements of a flow-control
+ *          structure...  Theoretically, there is no reason to prohibit
+ *          that, but it would be unexpectedly problematical for most
+ *          FORTH-based tokenizers.
+ *
+ *      Maintaining the "Control Stack" structures in a linked-list would
+ *          be a more nearly bullet-proof approach.  The theory of operation
+ *          would be the same, broadly speaking, and there would be no need
+ *          to check for  NOT_CSTAG  and no risk of getting the elements of
+ *          the control-structures out of sync.
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *          Structure Name:    cstag_group_t
+ *          Synopsis:          Control-Structure Tag Group
+ *                            
+ *   Fields:
+ *       cs_tag             Control-structure identifier tag
+ *       cs_inp_fil         Name of input file where C-S was started
+ *       cs_line_num        Line-number in Current Source when C-S was started
+ *       cs_abs_token_num  "Absolute" Token Number when C-S was started
+ *       cs_word            The FORTH word that started the C-S
+ *       cs_not_dup         FALSE if second "Control Stack" entry for same word
+ *       cs_datum           Data-Item of the Group
+ *       prev               Pointer to previous CSTAG-Group in linked-list
+ *
+ *       All data using this structure will remain private to this file,
+ *           so we declare it here rather than in the  .h  file
+ *
+ **************************************************************************** */
+
+typedef struct cstag_group {
+    unsigned long cs_tag;
+    char *cs_inp_fil;
+    unsigned int cs_line_num;
+    unsigned int cs_abs_token_num;
+    char *cs_word;
+    bool cs_not_dup;
+    unsigned long cs_datum;
+    struct cstag_group *prev;
+} cstag_group_t;
+
+/* **************************************************************************
+ *
+ *          Internal Static Variables
+ *     control_stack          "Thread" Pointer to the linked-list of 
+ *                                 "Control Stack" structure entries
+ *     not_cs_underflow       Flag used to prevent duplicate messages
+ *     not_consuming_two      Flag used to prevent loss of messages
+ *     didnt_print_otl        Flag used to prevent duplicate messages
+ *
+ **************************************************************************** */
+
+static cstag_group_t *control_stack = NULL;   /*  "Top" of the "Stack"  */
+
+/* **************************************************************************
+ *
+ *     not_cs_underflow is used only by routines that make two calls to
+ *         resolve a marker.  It is set TRUE before the first call; if
+ *         that call had a control-stack underflow, the error-message
+ *         routine resets it to FALSE.  The calling routine can then
+ *         test it as the condition for the second call.
+ *     Routines that make only one call to resolve a marker can ignore it.
+ *
+ **************************************************************************** */
+
+static bool not_cs_underflow;  /*  No need to initialize.  */
+
+/* **************************************************************************
+ *
+ *     not_consuming_two is also used only by routines that make two calls
+ *         to resolve a marker, but for this case, those routines only need  
+ *         to reset it to FALSE and not to test it; that will be done by
+ *         the  control_structure_mismatch()  routine when it looks at
+ *         the  cs_not_dup  field.  If the mismatch occurred because of
+ *         a combination of control-structures that consume one each,
+ *         the message will be printed even for the second "Control Stack"
+ *         entry.  The routine that changed it will have to set it back to
+ *         TRUE when it's done with it.
+ *
+ *     didnt_print_otl is used similarly, but only for the offset-too-large
+ *        error in the   DO ... LOOP  type of control-structures.
+ *
+ **************************************************************************** */
+
+static bool not_consuming_two = TRUE;
+static bool didnt_print_otl = TRUE;
+
+
+/* **************************************************************************
+ *
+ *      Function name:  push_cstag
+ *      Synopsis:       Push a new CSTAG-Group onto the front ("Top")
+ *                      of the (notional) Control-Stack.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             cstag           ID Tag for Control-Structure to "Push"
+ *             datum           The Data-Item for the new CSTAG-Group
+ *         Global Variables:
+ *             iname           Name of input file currently being processed
+ *             lineno          Current-Source line-number being processed
+ *             abs_tokenno     "Absolute"Token Number of word being processed
+ *             statbuf         The word just read, which started the C-S
+ *         Local Static Variables:
+ *             control_stack   Will become the new entry's "prev"
+ *
+ *      Outputs:
+ *         Returned Value:     None
+ *         Global Variables:
+ *             control_stack_depth            Incremented
+ *         Local Static Variables:
+ *             control_stack   Will become the "previous" entry in the list
+ *         Items Pushed onto Control-Stack:
+ *             Top:            A new CSTAG-Group, params as given
+ *         Memory Allocated
+ *             New CSTAG-Group structure
+ *             Duplicate of name of current input file
+ *             Duplicate of word just read
+ *         When Freed?
+ *             When Removing a CSTAG-Group, in pop_cstag()
+ *
+ **************************************************************************** */
+
+static void push_cstag( unsigned long cstag, unsigned long datum)
+{
+    cstag_group_t *cs_temp;
+
+    cs_temp = control_stack;
+    control_stack = safe_malloc( sizeof(cstag_group_t), "pushing CSTag");
+
+    control_stack->cs_tag = cstag;
+    control_stack->cs_inp_fil = strdup(iname);
+    control_stack->cs_line_num = lineno;
+    control_stack->cs_abs_token_num = abs_token_no;
+    control_stack->cs_word = strdup(statbuf);
+    control_stack->cs_not_dup = TRUE;
+    control_stack->cs_datum = datum;
+    control_stack->prev = cs_temp;
+
+    control_stack_depth++;
+    
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  pop_cstag
+ *      Synopsis:       Remove a CSTAG-Group from the front ("Top") of the
+ *                      (notional) Control-Stack.
+ *
+ *      Inputs:
+ *         Parameters:                    NONE
+ *         Global Variables:
+ *         Local Static Variables:
+ *             control_stack              CSTAG-Group on "Top"
+ *
+ *      Outputs:
+ *         Returned Value:                NONE
+ *         Global Variables:
+ *             control_stack_depth        Decremented
+ *         Local Static Variables:
+ *             control_stack              "Previous" entry will become current
+ *         Memory Freed
+ *             mem-alloc'ed copy of input filename
+ *             mem-alloc'ed copy of Control-structure FORTH word
+ *             CSTAG-Group structure
+ *         Control-Stack, # of Items Popped:  1
+ *
+ *      Process Explanation:
+ *          The calling routine might not check for empty Control-Stack,
+ *              so we have to be sure and check it here.
+ *
+ **************************************************************************** */
+
+static void pop_cstag( void)
+{
+
+    if ( control_stack != NULL )
+    {
+	cstag_group_t *cs_temp;
+
+	cs_temp = control_stack->prev;
+	free( control_stack->cs_word );
+	free( control_stack->cs_inp_fil );
+	free( control_stack );
+	control_stack = cs_temp;
+
+	control_stack_depth--;
+    }
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  control_stack_size_test
+ *      Synopsis:       Detect Control Stack underflow; report if an ERROR.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             min_depth                 Minimum depth needed
+ *         Global Variables:
+ *             control_stack_depth       Current depth of Control Stack
+ *             statbuf                   Word to name in error message
+ *
+ *      Outputs:
+ *         Returned Value:                TRUE if adequate depth
+ *         Local Static Variables:
+ *             not_cs_underflow           Reset to FALSE if underflow detected.
+ *         Printout:
+ *             Error message is printed.
+ *                 Identify the colon definition if inside one.
+ *
+ *      Process Explanation:
+ *          Some statements need more than one item on the Control Stack;
+ *             they will do their own  control_stack_depth  testing and
+ *             make a separate call to this routine.
+ *
+ **************************************************************************** */
+
+static bool control_stack_size_test( int min_depth )
+{
+    bool retval = TRUE;
+
+    if ( control_stack_depth < min_depth )
+    {
+	retval = FALSE;
+	tokenization_error ( TKERROR,
+		"Control-Stack underflow at %s", strupr(statbuf) );
+	in_last_colon();
+
+	not_cs_underflow = FALSE;   /*  See expl'n early on in this file  */
+    }
+
+    return( retval );
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  control_structure_mismatch
+ *      Synopsis:       Report an ERROR after a Control Structure mismatch
+ *                      was detected.
+ *
+ *      Inputs:
+ *         Parameters:                    NONE
+ *         Global Variables:
+ *             statbuf              Word encountered, to name in error message
+ *         Local Static Variables:
+ *             control_stack        "Pushed" Control-Structure Tag Group
+ *             not_consuming_two    See explanation early on in this file
+ *         Control-Stack Items:
+ *             Top:                 "Current" Control-Structure Tag Group
+ *                                      Some of its "Marker" information
+ *                                      will be used in the error message
+ *
+ *      Outputs:
+ *         Returned Value:                NONE
+ *         Printout:
+ *             Error message is printed
+ *
+ *      Process Explanation:
+ *          This routine is called after a mismatch is detected, and
+ *              before the CSTAG-Group is "Popped" from the notional
+ *              Control-Stack.
+ *          If the  control_stack  pointer is NULL, print a different
+ *              Error message
+ *          Don't print if the "Control Stack" entry is a duplicate and
+ *              we're processing a statement that consumes two entries.
+ *
+ **************************************************************************** */
+
+static void control_structure_mismatch( void )
+{
+    if ( control_stack->cs_not_dup || not_consuming_two )
+    {
+	tokenization_error ( TKERROR,
+	    "The %s is mismatched with the %s" ,
+		strupr(statbuf), strupr(control_stack->cs_word));
+	where_started( control_stack->cs_inp_fil, control_stack->cs_line_num );
+    }
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  offset_too_large
+ *      Synopsis:       Report an ERROR after a too-large fcode-offset
+ *                      was detected.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             too_large_for_16     TRUE if the offset is too large to be
+ *                                      expressed as a 16-bit signed number.
+ *         Global Variables:
+ *             statbuf              Word encountered, to name in error message
+ *             offs16               Whether we are using 16-bit offsets
+ *         Local Static Variables:
+ *             control_stack        "Pushed" Control-Structure Tag Group
+ *             didnt_print_otl      Switch to prevent duplicate message
+ *         Control-Stack Items:
+ *             Top:                 "Current" Control-Structure Tag Group
+ *                                      Some of its "Marker" information
+ *                                      will be used in the error message
+ *
+ *      Outputs:
+ *         Returned Value:          NONE
+ *         Local Static Variables:
+ *             didnt_print_otl      Will be reset to FALSE
+ *             
+ *         Printout:
+ *             Error message:
+ *                 Branch offset too large between <here> and <there>
+ *             Advisory message, if we are using 8-bit offsets, will
+ *                 indicate whether switching to 16-bit offsets would help
+ *
+ *      Process Explanation:
+ *          Two branches are involved in a DO ... LOOP  structure:  an "outer"
+ *              forward-branch and a slightly smaller "inner" backward-branch.
+ *              In the majority of cases, if one offset exceeds the limit,
+ *              both will.  There is, however, a very small but distinct
+ *              possibility that the offset for the smaller branch will not
+ *              exceed the limit while the larger one does.  To prevent two
+ *              messages from being printed in the routine instance, but still
+ *              assure that one will be printed in the rare eventuality, we
+ *              utilize the flag called  didnt_print_otl  in conjunction
+ *              with the  cs_not_dup  field.
+ *
+ **************************************************************************** */
+
+static void offset_too_large( bool too_large_for_16 )
+{
+    if ( control_stack->cs_not_dup || didnt_print_otl )
+    {
+	tokenization_error( TKERROR,
+	    "Branch offset is too large between %s and the %s" ,
+		strupr(statbuf), strupr(control_stack->cs_word));
+	where_started( control_stack->cs_inp_fil, control_stack->cs_line_num );
+	if ( INVERSE( offs16 ) )
+	{
+	    if ( too_large_for_16 )
+	    {
+		tokenization_error ( INFO,
+		    "Offset would be too large even if 16-bit offsets "
+			"were in effect.\n");
+	    }else{
+		tokenization_error ( INFO,
+		    "Offset might fit if 16-bit offsets "
+			"(e.g., fcode-version2) were used.\n" );
+	    }
+	}
+    }
+    didnt_print_otl = FALSE;
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  emit_fc_offset
+ *      Synopsis:       Test whether the given FCode-Offset is out-of-range;
+ *                      before placing it into the FCode Output Buffer.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             fc_offset               The given FCode-Offset
+ *         Global Variables:
+ *             offs16                  Whether we are using 16-bit offsets
+ *             noerrors                "Ignore Errors" flag
+ *
+ *      Outputs:
+ *         Returned Value:             NONE
+ *
+ *      Error Detection:
+ *          Error if the given FCode-Offset exceeds the range that can
+ *              be expressed by the size (i.e., 8- or 16- -bits) of the
+ *              offsets we are using.  Call  offset_too_large()  to print
+ *              the Error message; also, if  noerrors  is in effect, issue
+ *              a Warning showing the actual offset and how it will be coded.
+ *
+ *      Process Explanation:
+ *          For forward-branches, the OPC will have to be adjusted to
+ *              indicate the location that was reserved for the offset
+ *              to be written, rather than the current location.  That
+ *              will all be handled by the calling routine.
+ *          We will rely on "C"'s type-conversion (type-casting) facilities.
+ *          Look at the offset value both as an 8-bit and as a 16-bit offset,
+ *              then determine the relevant course of action.
+ *
+ **************************************************************************** */
+
+static void emit_fc_offset( int fc_offset)
+{
+    int fc_offs_s16 = (s16)fc_offset;
+    int fc_offs_s8  =  (s8)fc_offset;
+    bool too_large_for_8  = BOOLVAL( fc_offset != fc_offs_s8 );
+    bool too_large_for_16 = BOOLVAL( fc_offset != fc_offs_s16);
+
+    if ( too_large_for_16 || ( INVERSE(offs16) && too_large_for_8 ) )
+    {
+	offset_too_large( too_large_for_16 );
+	if ( noerrors )
+	{
+	    int coded_as = offs16 ? (int)fc_offs_s16 : (int)fc_offs_s8 ;
+	    tokenization_error( WARNING,
+		"Actual offset is 0x%x (=dec %d), "
+		    "but it will be coded as 0x%x (=dec %d).\n",
+			fc_offset, fc_offset, coded_as, coded_as );
+	}
+    }
+
+    emit_offset( fc_offs_s16 );
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  matchup_control_structure
+ *      Synopsis:       Error-check. Compare the given control-structure
+ *                          identifier tag with the one in the CSTAG-Group
+ *                          on "Top" of the "Control Stack".
+ *                      If they don't match, report an error, and, if not
+ *                          "Ignoring Errors", return Error indication.
+ *                      If no error, pass the Data-item back to the caller.
+ *                      Do not consume the CSTAG-Group; that will be the
+ *                          responsibility of the calling routine.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             cstag          Control-struc ID Tag expected by calling function
+ *         Global Variables:
+ *             noerrors       "Ignore Errors" flag
+ *         Local Static Variables:
+ *             control_stack   "Pushed" (current) Control-Structure Tag Group
+ *         Control-Stack Items:
+ *             Top:            Current CSTAG-Group
+ *
+ *      Outputs:
+ *         Returned Value:     TRUE = Successful match, no error.
+ *
+ *      Error Detection:
+ *           Control Stack underflow or cstag mismatch.  See below for details.
+ *
+ *      Process Explanation:
+ *           If the expected cstag does not match the cs_tag from the CSTAG
+ *               Group on "Top" of the "Control Stack", print an ERROR message,
+ *               and, unless the "Ignore Errors" flag is in effect, prepare
+ *               to return FALSE.
+ *          However, if we've "underflowed" the "Control Stack", we dare not
+ *              ignore errors; that could lead to things like attempting to
+ *              write a forward-branch FCode-offset to offset ZERO, over the
+ *              FCODE- or PCI- -header block.  We don't want that...
+ *          So, if the  control_stack  pointer is NULL, we will print an
+ *              ERROR message and immediately return FALSE.
+ *          Since we will not consume the CSTAG-Group, the calling routine
+ *              can access the Data-Item and any "Marker" information it may
+ *              still require via the local  control_stack  pointer. The caller
+ *              will be responsible for removing the CSTAG-Group.
+ *
+ *      Special Exception to "Ignore Errors":
+ *          At the last usage of the  CASE_CSTAG , for the ENDCASE statement,
+ *              this routine will be called to control freeing-up memory, etc.
+ *          For the OF statement, it will be called to control incrementing
+ *              the OF-count datum.
+ *          Processing an ENDCASE statement with the datum from any other
+ *              CSTAG-Group can lead to a huge loop.
+ *          Processing any other "resolver" with the datum from an ENDCASE
+ *              CSTAG-Group can lead to mistaking a very low number for an
+ *              offset into the Output Buffer and attempting to write to it.
+ *          Incrementing the datum from any other CSTAG-Group can lead to
+ *              a variety of unacceptable errors, too many to guess.
+ *          So, if either the given cstag or the cs_tag field of the "Top"
+ *              CSTAG-Group is a CASE_CSTAG , we will not ignore errors.
+ *
+ **************************************************************************** */
+
+static bool matchup_control_structure( unsigned long cstag )
+{
+    bool retval = FALSE;
+
+    if ( control_stack_size_test( 1) )
+    {
+	retval = TRUE;
+
+	if ( control_stack->cs_tag != cstag )
+	{
+	    control_structure_mismatch();
+
+	    if (    ( INVERSE(noerrors) )
+		 || ( cstag == CASE_CSTAG )
+		 || ( control_stack->cs_tag == CASE_CSTAG )
+	            )
+	    {
+		retval = FALSE;
+	    }
+	}
+
+    }
+    return ( retval );
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  control_structure_swap
+ *      Synopsis:       Swap control-structure branch-marker Groups
+ *
+ *      Inputs:
+ *         Parameters:                NONE
+ *         Local Static Variables:
+ *             control_stack          Pointer to "Control Stack" linked-list
+ *         Control-Stack Items:
+ *             Top:                   CSTAG-Group_0
+ *             Next:                  CSTAG-Group_1
+ *
+ *      Outputs:
+ *         Returned Value:            NONE
+ *         Local Static Variables:
+ *             control_stack          Points to former "previous" and vice-versa
+ *         Items on Control-Stack:
+ *             Top:                   CSTAG-Group_1
+ *             Next:                  CSTAG-Group_0
+ *
+ *      Error Detection:
+ *          If control-stack depth is not at least 2, CS underflow ERROR.
+ *              This might trigger other routines' error detections also...
+ *
+ *      Extraneous Remarks:
+ *          Before control-structure identification was implemented, offsets
+ *              were kept on the data-stack, and this was a single SWAP.
+ *          When CSTAGs were added, the "Group" was only a pair kept on the
+ *               data-stack -- the CSTAG and the Data-item -- and this
+ *               became a TWO_SWAP()
+ *          For a while, when I tried keeping the CSTAG-Group on the stack,
+ *               this became a FOUR_SWAP()
+ *          That turned out to be unacceptably brittle; this way is much
+ *               more robust. 
+ *          I am so glad I called this functionality out into a separate
+ *              routine, early on in the development process.
+ *
+ *          This is the function called  1 CSROLL  in section A.3.2.3.2
+ *              of the ANSI Forth spec, which likewise corresponds to the
+ *              modifier that Wil Baden, in his characteristically elegant
+ *              nomenclature, dubbed:  BUT 
+ *
+ **************************************************************************** */
+
+static void control_structure_swap( void )
+{
+    if ( control_stack_size_test( 2) )
+    {
+	cstag_group_t *cs_temp;
+
+	cs_temp = control_stack->prev;
+
+	control_stack->prev = cs_temp->prev;
+	cs_temp->prev = control_stack;
+	control_stack = cs_temp;
+    }
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  matchup_two_control_structures
+ *      Synopsis:       For functions that resolve two CSTAG-Groups, both
+ *                          matchup both "Top of Control Stack"  entries
+ *                          before processing them...
+ *
+ *      Inputs:
+ *         Parameters:
+ *             top_cstag      Control-struc ID Tag expected on "Top" CS entry
+ *             next_cstag     Control-struc ID Tag expected on "Next" CS entry
+ *         Local Static Variables:
+ *             not_cs_underflow   Used for underflow detection.
+ *         Control-Stack Items:
+ *             Top:            Current CSTAG-Group
+ *             Next:           Next CSTAG-Group
+ *
+ *      Outputs:
+ *         Returned Value:     TRUE = Successful matches, no error.
+ *         Global Variables:
+ *             noerrors       "Ignore Errors" flag; cleared, then restored
+ *         Local Static Variables:
+ *             not_consuming_two               Cleared, then restored
+ *         Control-Stack, # of Items Popped:   2 (if matches unsuccessful)
+ *
+ *      Error Detection:
+ *          Control Stack underflow detected by control_structure_swap()
+ *          Control Structure mismatch detected by  control_structure_mismatch()
+ *
+ *      Process Explanation:
+ *          We will use  matchup_control_structure()  to do the "heavy lifting".
+ *          We will not be ignoring errors in these cases.
+ *          Save the results of a match of  top_cstag
+ *          Swap the top two CS entries.
+ *          If an underflow was detected, there's no more matching to be done.
+ *          Otherwise:
+ *              Save the results of a match of  next_cstag
+ *              Swap the top two CS entries again, to their original order.
+ *          The result is TRUE if both matches were successful.
+ *          If the matches were not successful, consume the top two entries
+ *              (unless there's only one, in which case consume it).
+ *
+ **************************************************************************** */
+
+static bool matchup_two_control_structures( unsigned long top_cstag,
+                                                unsigned long next_cstag)
+{
+    bool retval;
+    bool topmatch;
+    bool nextmatch = FALSE;
+    bool sav_noerrors = noerrors;
+    noerrors = FALSE;
+    not_consuming_two = FALSE;
+
+    not_cs_underflow = TRUE;
+    topmatch = matchup_control_structure( top_cstag);
+    if ( not_cs_underflow )
+    {
+	control_structure_swap();
+	if ( not_cs_underflow )
+	{
+	   nextmatch = matchup_control_structure( next_cstag);
+	   control_structure_swap();
+	}
+    }
+
+    retval = BOOLVAL( topmatch && nextmatch);
+
+    if ( INVERSE( retval) )
+    {
+        pop_cstag();
+        pop_cstag();
+    }
+
+    not_consuming_two = TRUE;
+    noerrors = sav_noerrors;
+    return ( retval );
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  mark_backward_target
+ *      Synopsis:       Mark the target of an expected backward-branch
+ *
+ *      Associated FORTH words:                 BEGIN  DO  ?DO
+ *
+ *      Inputs:
+ *         Parameters:
+ *             cstag              Control-structure ID tag for calling function
+ *         Global Variables:
+ *             opc                Output Buffer Position Counter
+ *
+ *      Outputs:
+ *         Returned Value:            NONE
+ *         Items Pushed onto Control-Stack:
+ *             Top:                 <Stmt>_BACKw_<TAGNAM>
+ *
+ *      Process Explanation:
+ *          Just before this function is called, the token that begins the
+ *              control-structure was written to the FCode Output buffer.
+ *          OPC, the FCode Output Buffer Position Counter, is at the
+ *              destination to which the backward-branch will be targeted.
+ *          Create a CSTAG-Group with the given C-S Tag, and OPC as its datum;
+ *              push it onto the Control-Stack.
+ *          Later, when the backward-branch is installed, the FCode-offset
+ *              will be calculated as the difference between the OPC at
+ *              that time and the target-OPC we saved here.
+ *      
+ **************************************************************************** */
+
+static void mark_backward_target(unsigned long cstag )
+{
+    push_cstag( cstag, (unsigned long)opc);
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  mark_forward_branch
+ *      Synopsis:       Mark the location of, and reserve space for, the
+ *                          FCode-offset associated with a forward branch.
+ *
+ *      Associated FORTH words:                 IF  WHILE  ELSE
+ *
+ *      Inputs:
+ *         Parameters:
+ *             cstag              Control-structure ID tag for calling function
+ *
+ *      Outputs:
+ *         Returned Value:            NONE
+ *         Items Pushed onto Control-Stack:
+ *             Top:                 <Stmt>_FORw_<TAGNAM>
+ *         FCode Output buffer:
+ *             Place-holder FCode-offset of zero.
+ *
+ *      Process Explanation:
+ *          Just before this function is called, the forward-branch token
+ *              that begins the control-structure was written to the FCode
+ *              Output buffer.
+ *          It will need an FCode-offset to the destination to which it will
+ *              be targeted, once that destination is known.
+ *          Create a CSTAG-Group with the given C-S Tag, and OPC as its datum;
+ *              push it onto the Control-Stack.  (This is the same action as
+ *              for marking a backward-target.)
+ *          Then write a place-holder FCode-offset of zero to the FCode
+ *              Output buffer.
+ *          Later, when the destination is known, the FCode-offset will be
+ *              calculated as the difference between the OPC at that time
+ *              and the FCode-offset location we're saving now.  That offset
+ *              will be over-written onto the place-holder offset of zero at
+ *              the location in the Output buffer that we saved on the
+ *              Control-Stack in this routine.
+ *
+ **************************************************************************** */
+
+static void mark_forward_branch(unsigned long cstag )
+{
+    mark_backward_target(cstag );
+    emit_offset(0);
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  resolve_backward
+ *      Synopsis:       Resolve backward-target when a backward branch
+ *                      is reached.  Write FCode-offset to reach saved
+ *                      target from current location.
+ *      
+ *      Associated FORTH words:                 AGAIN  UNTIL  REPEAT
+ *                                                LOOP  +LOOP
+ *
+ *      Inputs:
+ *         Parameters:
+ *             cstag              Control-structure ID tag for calling function
+ *         Global Variables:
+ *             opc                Output Buffer Position Counter
+ *         Control-Stack Items:
+ *             Top:              <Stmt>_BACKw_<TAGNAM>
+ *
+ *      Outputs:
+ *         Returned Value:             NONE
+ *         Global Variables:
+ *             opc               Incremented by size of an FCode-offset
+ *         Control-Stack, # of Items Popped:   1
+ *         FCode Output buffer:
+ *             FCode-offset to reach backward-target
+ *
+ *      Error Detection:
+ *          Test for Control-structure ID tag match.
+ *
+ *      Process Explanation:
+ *          Just before this function is called, the backward-branch token
+ *              that ends the control-structure was written to the FCode
+ *              Output buffer.
+ *          The current OPC is at the point from which the FCode-offset
+ *              is to be calculated, and at which it is to be written.
+ *          The top of the Control-Stack should have the CSTAG-Group from
+ *              the statement that prepared the backward-branch target that
+ *              we expect to resolve.  Its datum is the OPC of the target
+ *              of the backward branch.
+ *          If the supplied Control-structure ID tag does not match the one
+ *              on top of the Control-Stack, announce an error.  We will
+ *              still write an FCode-offset, but it will be a place-holder
+ *              of zero.
+ *          Otherwise, the FCode-offset we will write will be the difference
+ *              between the target-OPC and our current OPC.
+ *
+ **************************************************************************** */
+
+static void resolve_backward( unsigned long cstag)
+{
+    unsigned long targ_opc;
+    int fc_offset = 0;
+
+    if ( matchup_control_structure( cstag) )
+    {
+	targ_opc = control_stack->cs_datum;
+	fc_offset = targ_opc - opc;
+    }
+
+    emit_fc_offset( fc_offset );
+    pop_cstag();
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  resolve_forward
+ *      Synopsis:       Resolve a forward-branch when its target has been
+ *                      reached.  Write the FCode-offset into the space
+ *                      that was reserved.
+ *
+ *      Associated FORTH words:                 ELSE  THEN  REPEAT
+ *                                                LOOP  +LOOP
+ *
+ *      Inputs:
+ *         Parameters:
+ *             cstag              Control-structure ID tag for calling function
+ *         Global Variables:
+ *             opc                Output Buffer Position Counter
+ *         Control-Stack Items:
+ *             Top:               <Stmt>_FORw_<TAGNAM>
+ *
+ *      Outputs:
+ *         Returned Value:             NONE
+ *         Global Variables:
+ *             opc               Changed, then restored.
+ *         Control-Stack, # of Items Popped:   1
+ *         FCode Output buffer:
+ *             FCode-offset is written to location where space was reserved
+ *                 when the forward-branch was marked.
+ *
+ *      Error Detection:
+ *          Test for Control-structure ID tag match.
+ *
+ *      Process Explanation:
+ *          Just before this function is called, the last token -- and 
+ *              possibly, FCode-offset -- that is within the scope of
+ *              what the branch might skip was written to the FCode
+ *              Output buffer.
+ *          The current OPC is at the point from which the FCode-offset
+ *              is to be calculated, but not at which it is to be written.
+ *          The top of the Control-Stack should have the CSTAG-Group from
+ *              the statement that prepared the forward-branch we expect
+ *              to resolve, and for which our current OPC is the target.
+ *              Its datum is the OPC of the space that was reserved for
+ *              the forward-branch whose target we have just reached.
+ *          If the supplied Control-structure ID tag does not match the one
+ *              on top of the Control-Stack, announce an error and we're done.
+ *          Otherwise, the datum is used both as part of the calculation of
+ *              the FCode-offset we are about to write, and as the location
+ *              to which we will write it.
+ *          The FCode-offset is calculated as the difference between our
+ *              current OPC and the reserved OPC location.
+ *          We will not be ignoring errors in these cases, because we would
+ *              be over-writing something that might not be a place-holder
+ *              for a forward-branch at an earlier location in the FCode
+ *              Output buffer.
+ *
+ **************************************************************************** */
+
+static void resolve_forward( unsigned long cstag)
+{
+    unsigned long resvd_opc;
+    bool sav_noerrors = noerrors;
+    bool cs_match_result;
+    noerrors = FALSE;
+    /*  Restore the "ignore-errors" flag before we act on our match result
+     *      because we want it to remain in effect for  emit_fc_offset()
+     */
+    cs_match_result = matchup_control_structure( cstag);
+    noerrors = sav_noerrors;
+
+    if ( cs_match_result )
+    {
+	int saved_opc;
+	int fc_offset;
+
+	resvd_opc = control_stack->cs_datum;
+	fc_offset = opc - resvd_opc;
+
+	saved_opc = opc;
+	opc = resvd_opc;
+
+
+	emit_fc_offset( fc_offset );
+	opc = saved_opc;
+    }
+    pop_cstag();
+}
+	
+
+/* **************************************************************************
+ *
+ *      The functions that follow are the exported routines that
+ *          utilize the preceding support-routines to effect their
+ *          associated FORTH words.
+ *
+ *      The routines they call will take care of most of the Error
+ *          Detection via stack-depth checking and Control-structure
+ *          ID tag matching, so those will not be called-out in the
+ *          prologues.
+ *
+ **************************************************************************** */
+
+
+/* **************************************************************************
+ *
+ *      Function name:  emit_if
+ *      Synopsis:       All the actions when IF is encountered
+ *
+ *      Associated FORTH word:                 IF
+ *
+ *      Inputs:
+ *         Parameters:             NONE
+ *
+ *      Outputs:
+ *         Returned Value:         NONE
+ *         Items Pushed onto Control-Stack:
+ *             Top:                If_FORw_IF
+ *         FCode Output buffer:
+ *             Token for conditional branch -- b?branch -- followed by
+ *                 place-holder of zero for FCode-offset
+ *              
+ *
+ **************************************************************************** */
+
+void emit_if( void )
+{
+    emit_token("b?branch");
+    mark_forward_branch( IF_CSTAG );
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  emit_then
+ *      Synopsis:       All the actions when THEN is encountered; also
+ *                      part of another forward-branch resolver's action.
+ *
+ *      Associated FORTH words:                 THEN  ELSE
+ *
+ *      Inputs:
+ *         Parameters:                  NONE
+ *         Local Static Variables:
+ *             control_stack       Points to "Top" Control-Structure Tag Group
+ *         Control-Stack Items:
+ *             Top:                If_FORw_IF | While_FORw_WHILE
+ *
+ *      Outputs:
+ *         Returned Value:              NONE
+ *         Control-Stack, # of Items Popped:   1
+ *         FCode Output buffer:
+ *             Token for forward-resolve -- b(>resolve) -- then the space
+ *                 reserved for the forward-branch FCode-offset is filled
+ *                 in so that it reaches the token after the  b(>resolve) . 
+ *
+ *      Process Explanation:
+ *          The THEN statement or the ELSE statement must be able to resolve
+ *              a WHILE statement, in order to implement the extended flow-
+ *              -control structures as described in sec. A.3.2.3.2 of the
+ *              ANSI Forth Spec.
+ *          But we must prevent the sequence  IF ... BEGIN ...  REPEAT  from
+ *              compiling as though it were:  IF ... BEGIN ...  AGAIN THEN
+ *          We do this by having a separate CSTAG for WHILE and allowing
+ *              it here but not allowing the IF_CSTAG when processing REPEAT.
+ *
+ **************************************************************************** */
+
+void emit_then( void )
+{
+    emit_token("b(>resolve)");
+    if ( control_stack != NULL )
+    {
+	if ( control_stack->cs_tag == WHILE_CSTAG )
+	{
+	    control_stack->cs_tag = IF_CSTAG;
+	}
+    }
+    resolve_forward( IF_CSTAG );
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  emit_else
+ *      Synopsis:       All the actions when ELSE is encountered
+ *
+ *      Associated FORTH word:                 ELSE
+ *
+ *      Inputs:
+ *         Parameters:             NONE
+ *         Global Variables:
+ *             control_stack_depth   Current depth of Control Stack
+ *         Local Static Variables:
+ *             not_cs_underflow      If this is FALSE after the c-s swap, it
+ *                                       means an underflow resulted; skip
+ *                                       the call to resolve the first marker.
+ *         Control-Stack Items:
+ *             Top:                {If_FORw_IF}1
+ *                 (Datum is OPC of earlier forward-branch; must be resolved.)
+ *
+ *      Outputs:
+ *         Returned Value:             NONE
+ *         Control-Stack, # of Items Popped:   1
+ *         Items Pushed onto Control-Stack:
+ *             Top:                {If_FORw_IF}2
+ *                 (Datum is current OPC, after forward-branch is placed.)
+ *         FCode Output buffer:
+ *             Token for unconditional branch -- bbranch-- followed by
+ *                 place-holder of zero for FCode-offset.  Then, token
+ *                  for forward-resolve -- b(>resolve) -- and the space
+ *                  reserved earlier for the conditional forward-branch
+ *                  FCode-offset is filled in to reach the token after
+ *                  the  b(>resolve) .
+ *
+ *      Error Detection:
+ *          If the "Control-Stack" is empty, bypass the forward branch
+ *              and let the call to  control_structure_swap()  report
+ *              the underflow error.  Then use  not_cs_underflow  to
+ *              control whether to resolve the forward-branch. 
+ *
+ *      Process Explanation:
+ *          The final item needed within the scope of what the earlier
+ *              conditional branch might skip is an unconditional branch
+ *              over the "else"-clause to follow.  After that, the earlier
+ *              conditional branch needs to be resolved.  This last step
+ *              is identical to the action of  THEN .
+ *
+ **************************************************************************** */
+
+void emit_else( void )
+{
+    if ( control_stack_depth > 0 )
+    {
+	emit_token("bbranch");
+	mark_forward_branch( IF_CSTAG );
+    }
+    not_cs_underflow = TRUE;
+    control_structure_swap();
+    if ( not_cs_underflow )
+    {
+        emit_then();
+    }
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  emit_begin
+ *      Synopsis:       All the actions when BEGIN is encountered
+ *
+ *      Associated FORTH word:                 BEGIN
+ *
+ *      Inputs:
+ *         Parameters:             NONE
+ *
+ *      Outputs:
+ *         Returned Value:         NONE
+ *         Items Pushed onto Control-Stack:
+ *             Top:                Begin_BACKw_BEGIN
+ *                 (Datum is current OPC, target of future backward-branch)
+ *         FCode Output buffer:
+ *             Token for target of backward branch -- b(<mark)
+ *
+ **************************************************************************** */
+
+void emit_begin( void )
+{
+    emit_token("b(<mark)");
+    mark_backward_target( BEGIN_CSTAG );
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  emit_again
+ *      Synopsis:       All the actions when AGAIN is encountered
+ *
+ *      Associated FORTH words:               AGAIN  REPEAT
+ *
+ *      Inputs:
+ *         Parameters:             NONE
+ *         Control-Stack Items:
+ *             Top:                Begin_BACKw_BEGIN
+ *                        (Datum is OPC of backward-branch target at BEGIN)
+ *
+ *      Outputs:
+ *         Returned Value:         NONE
+ *         Control-Stack, # of Items Popped:   1
+ *         FCode Output buffer:
+ *             Token for unconditional branch -- bbranch -- followed by
+ *                 FCode-offset that reaches just after the  b(<mark) 
+ *                 token at the corresponding  BEGIN  statement. 
+ *
+ *      Process Explanation:
+ *          The FCode-offset is calculated as the difference between our
+ *              current OPC and the target-OPC saved on the Control-Stack.
+ *              
+ **************************************************************************** */
+
+void emit_again( void )
+{
+    emit_token("bbranch");
+    resolve_backward( BEGIN_CSTAG );
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  emit_until
+ *      Synopsis:       All the actions when UNTIL is encountered
+ *
+ *      Associated FORTH word:                 UNTIL
+ *
+ *      Process Explanation:
+ *          Same as AGAIN except token is conditional branch -- b?branch --
+ *              instead of unconditional.
+ *
+ **************************************************************************** */
+
+void emit_until( void )
+{
+    emit_token("b?branch");
+    resolve_backward( BEGIN_CSTAG );
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  emit_while
+ *      Synopsis:       All the actions when WHILE is encountered
+ *
+ *      Associated FORTH word:                 WHILE
+ *
+ *      Inputs:
+ *         Parameters:                  NONE
+ *         Global Variables:
+ *             control_stack_depth       Number of items on "Control-Stack"
+ *         Control-Stack Items:
+ *             Top:                      Begin_BACKw_BEGIN
+ *                                 (Datum is OPC of backward-branch target)
+ *
+ *      Outputs:
+ *         Returned Value:              NONE
+ *         Control-Stack:        1 item added below top item.
+ *         Items on Control-Stack:
+ *             Top:                Begin_BACKw_BEGIN
+ *             Next:               While_FORw_WHILE
+ *         FCode Output buffer:
+ *             Token for conditional branch -- b?branch -- followed by
+ *                 place-holder of zero for FCode-offset
+ *
+ *      Error Detection:
+ *          If the "Control-Stack" is empty, bypass creating the branch
+ *              and let the call to  control_structure_swap()  report
+ *              the underflow error.
+ *
+ *      Process Explanation:
+ *          Output a conditional forward-branch sequence, similar to  IF 
+ *              (except with a WHILE CSTAG), but be sure to leave the
+ *              control-structure branch-marker that was created by the
+ *              preceding  BEGIN   on top of the one just generated:
+ *              the  BEGIN  needs to be resolved first in any case, and
+ *              doing this here is the key to implementing the extended
+ *              control-flow structures as described in sec. A.3.2.3.2
+ *              of the ANSI Forth Spec.
+ *
+ *      Extraneous Remarks:
+ *          It was for the use of this function that Wil Baden coined the
+ *              name BUT for the control-structure swap routine.  The idea
+ *              was that the implementation of WHILE could be boiled down
+ *              to:  IF BUT   (couldn't quite fit an AND in there...;-} )
+ *          Naturally, this implementation is a smidgeon more complicated...
+ *
+ **************************************************************************** */
+
+void emit_while( void )
+{
+    if ( control_stack_depth > 0 )
+    {
+	emit_token("b?branch");
+	mark_forward_branch( WHILE_CSTAG );
+    }
+    control_structure_swap();
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  emit_repeat
+ *      Synopsis:       All the actions when REPEAT is encountered
+ *
+ *      Associated FORTH word:                 REPEAT
+ *
+ *      Inputs:
+ *         Parameters:                  NONE
+ *         Local Static Variables:
+ *             not_cs_underflow    If FALSE after first call to resolve marker,
+ *                                     an underflow resulted; skip second call.
+ *         Control-Stack Items:
+ *             Top:                Begin_BACKw_BEGIN
+ *                        (Datum is OPC of backward-branch target at BEGIN)
+ *             Next:               If_FORw_IF
+ *                        (Datum is OPC of FCode-offset place-holder)
+ *
+ *      Outputs:
+ *         Returned Value:                    NONE
+ *         Local Static Variables:
+ *             not_consuming_two              Cleared, then restored
+ *         Control-Stack, # of Items Popped:   2
+ *         FCode Output buffer:
+ *             Token for unconditional branch -- bbranch -- followed by
+ *                 FCode-offset that reaches just after the  b(<mark) 
+ *                 token at the corresponding  BEGIN  statement.  Then
+ *                 the token for forward-resolve -- b(>resolve) -- and
+ *                 the space reserved for the conditional forward-branch
+ *                 FCode-offset is filled in so that it reaches the token
+ *                 after the  b(>resolve) .
+ *
+ *      Process Explanation:
+ *          The action is identical to that taken for AGAIN followed
+ *               by the action for THEN.
+ *          The Local Static Variable  not_consuming_two  gets cleared
+ *               and restored by this routine.
+ *
+ **************************************************************************** */
+
+void emit_repeat( void )
+{
+    if ( matchup_two_control_structures( BEGIN_CSTAG, WHILE_CSTAG ) )
+    {
+	not_cs_underflow = TRUE;
+	not_consuming_two = FALSE;
+	emit_again();
+	if ( not_cs_underflow )
+	{
+            emit_token("b(>resolve)");
+	    resolve_forward( WHILE_CSTAG );
+	}
+	not_consuming_two = TRUE;
+    }
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  mark_do
+ *      Synopsis:       Common routine for marking the branches for
+ *                      the "do" variants
+ *
+ *      Associated FORTH words:              DO  ?DO
+ *
+ *      Inputs:
+ *         Parameters:                  NONE
+ *
+ *      Outputs:
+ *         Returned Value:              NONE
+ *         Global Variables:
+ *             do_loop_depth         Incremented
+ *         Items Pushed onto Control-Stack:
+ *             Top:              Do_FORw_DO
+ *             Next:             Do_BACKw_DO
+ *         FCode Output buffer:
+ *             Place-holder of zero for FCode-offset
+ *
+ *      Error Detection:
+ *          The  do_loop_depth  counter will be used by other routines
+ *              to detect misplaced "LEAVE", "UNLOOP", "I" and suchlike.
+ *              (Imbalanced "LOOP"  statements are detected by the CSTag
+ *              matching mechanism.)
+ *
+ *      Process Explanation:
+ *          Just before this function is called, the forward-branching token
+ *              for the "DO" variant that begins the control-structure was
+ *              written to the FCode Output buffer.
+ *          It needs an FCode-offset for a forward-branch to just after
+ *              its corresponding "LOOP" variant and the FCode-offset
+ *              associated therewith.
+ *          That "LOOP" variant's associated FCode-offset is targeted
+ *              to the token that follows the one for this "DO" variant
+ *              and its FCode-offset.
+ *          Mark the forward-branch with the C-S Tag for DO and write a
+ *              place-holder FCode-offset of zero to FCode Output.
+ *          Indicate that the mark that will be processed second (but which
+ *              was made first) is a duplicate of the one that will be
+ *              processed first.
+ *          Then mark the backward-branch target, also with the DO C-S Tag.
+ *          Finally, increment the  do_loop_depth  counter.
+ *
+ *      Extraneous Remarks:
+ *          This is more complicated to describe than to code...  ;-)
+ *
+ **************************************************************************** */
+
+void mark_do( void )
+{
+    mark_forward_branch( DO_CSTAG);
+    control_stack->cs_not_dup = FALSE;
+    mark_backward_target( DO_CSTAG);
+    do_loop_depth++;
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  resolve_loop
+ *      Synopsis:       Common routine for resolving the branches for
+ *                      the "loop" variants.
+ *
+ *      Associated FORTH words:              LOOP  +LOOP
+ *
+ *      Inputs:
+ *         Parameters:                  NONE
+ *         Global Variables:
+ *             statbuf             Word read from input stream (either "loop"
+ *                                     or "+loop"), used for Error Message.
+ *         Local Static Variables:
+ *             not_cs_underflow    If FALSE after first call to resolve marker,
+ *                                     an underflow resulted; skip second call.
+ *         Control-Stack Items:
+ *             Top:                Do_FORw_DO
+ *             Next:               Do_BACKw_DO
+ *
+ *      Outputs:
+ *         Returned Value:                    NONE
+ *         Global Variables:
+ *             do_loop_depth                  Decremented
+ *         Local Static Variables:
+ *             not_consuming_two              Cleared, then restored
+ *             didnt_print_otl                Set, then set again at end.
+ *         Control-Stack, # of Items Popped:   2
+ *         FCode Output buffer:
+ *             FCode-offset that reaches just after the token of the
+ *                 corresponding "DO" variant.  Then the space reserved
+ *                 for the FCode-offset of the forward-branch associated
+ *                 with the "DO" variant is filled in so that it reaches
+ *                 the token just after the "DO" variant's FCode-offset.
+ *                 
+ *      Error Detection:
+ *          A value of zero in  do_loop_depth  before it's decremented
+ *              indicates a  DO ... LOOP  imbalance, which is an ERROR,
+ *              but our other error-reporting mechanisms will catch it,
+ *              so we don't check or report it here.
+ *
+ *      Process Explanation:
+ *          Just before this function is called, the backward-branching
+ *              token for the "LOOP" variant that ends the control-structure
+ *              was written to the FCode Output buffer.
+ *          It needs an FCode-offset for a backward-branch targeted just
+ *              after its corresponding "DO" variant and the FCode-offset
+ *              associated therewith.
+ *          That "DO" variant's associated FCode-offset is targeted to
+ *              the token that follows the one for this "LOOP" variant
+ *              and its FCode-offset.
+ *          Make sure there are two DO C-S Tag entries on the Control Stack.
+ *          Resolve the backward-branch, matching your target to the first
+ *              C-S Tag for DO
+ *          Then resolve the forward-branch, targeting to your new OPC
+ *              position, and also making sure you match the DO C-S Tag.
+ *          We keep track of  do_loop_depth  for other error-detection
+ *              by decrementing it; make sure it doesn't go below zero.
+ *          Don't bother resolving the forward-branch if we underflowed
+ *              the "Control Stack" trying to resolve the backward-branch.
+ *          If the two top C-S Tag entries are not for a DO statement, the
+ *              matchup_two_control_structures() routine will consume both
+ *              or up to two of them, and we will place a dummy offset of
+ *              zero to follow-up the backward-branching token that has
+ *              already been written.
+ *      
+ *      Extraneous Remarks:
+ *          This is only a little more complicated to describe
+ *              than to code...  ;-)
+ *
+ **************************************************************************** */
+
+void resolve_loop( void )
+{
+    if ( INVERSE( matchup_two_control_structures( DO_CSTAG, DO_CSTAG) ) )
+    {
+	emit_offset( 0 );
+    }else{
+	not_cs_underflow = TRUE;
+	didnt_print_otl = TRUE;
+	not_consuming_two = FALSE;
+	resolve_backward( DO_CSTAG);
+	if ( not_cs_underflow )
+	{
+	    resolve_forward( DO_CSTAG);
+	}
+	if ( do_loop_depth > 0 ) do_loop_depth--;
+	not_consuming_two = TRUE;
+	didnt_print_otl = TRUE;   /*  Might have gotten cleared   */
+    }
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  emit_case
+ *      Synopsis:       All the actions when CASE is encountered
+ *
+ *      Associated FORTH word:                 CASE
+ *
+ *      Inputs:
+ *         Parameters:             NONE
+ *
+ *      Outputs:
+ *         Returned Value:         NONE
+ *         Items Pushed onto Control-Stack:
+ *             Top:              N_OFs=0...CASE_CSTAG
+ *                    (Datum is 0 , Initial count of  OF .. ENDOF  pairs)
+ *         FCode Output buffer:
+ *             Token for start of a CASE structure -- b(case)
+ *                 Does not require an FCode-offset.
+ *
+ **************************************************************************** */
+
+void emit_case( void )
+{
+    push_cstag( CASE_CSTAG, 0);
+    emit_token("b(case)");
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  emit_of
+ *      Synopsis:       All the actions when OF is encountered
+ *
+ *      Associated FORTH word:                 OF
+ *
+ *      Inputs:
+ *         Parameters:             NONE
+ *         Control-Stack Items:
+ *             Top:                N_OFs...CASE_CSTAG
+ *                    (Datum is OF-count, number of  OF .. ENDOF  pairs)
+ *            {Next and beyond}:   {Endof_FORw_ENDOF}1..n_ofs
+ *            { Repeat for OF-count number of times }
+ *
+ *      Outputs:
+ *         Returned Value:         NONE
+ *         Control-Stack, 1 Item Pushed, 1 modified:
+ *             Top:                Of_FORw_OF
+ *             Next:               N_OFs+1...CASE_CSTAG
+ *                    (Datum has been incremented)
+ *            {3rd and beyond}:    {Endof_FORw_ENDOF}1..n_ofs
+ *            { Repeat for 1 through the un-incremented OF-count }
+ *            (Same as Next etcetera at input-time.)
+ *         FCode Output buffer:
+ *             Token for OF statement -- b(of) -- followed by
+ *                 place-holder FCode-offset of zero
+ *
+ *      Error Detection:
+ *          Matchup CASE-cstag before incrementing OF-count
+ *
+ *      Process Explanation:
+ *          Main difference between this implementation and that outlined
+ *              in "the book" (see below) is that we do not directly use
+ *              the routine for the IF statement's flow-control; we will
+ *              use a different CSTAG for better mismatch detection.
+ *
+ *      Extraneous Remarks:
+ *          This is a "by the book" (ANSI Forth spec, section A.3.2.3.2)
+ *              implementation (mostly).  Incrementing the OF-count here,
+ *              after we've matched up the CSTAG, gives us (and the user)
+ *              just a little bit more protection...
+ *
+ **************************************************************************** */
+
+void emit_of( void )
+{
+
+    if ( matchup_control_structure( CASE_CSTAG ) )
+    {
+	emit_token("b(of)");
+
+	/*
+	 *  See comment-block about "Control-Stack" Diagram Notation
+	 *       early on in this file.
+	 *
+	 */
+
+	/* (    {Endof_FORw_ENDOF}1..n_ofs  N_OFs...CASE_CSTAG -- )          */
+
+	/*  Increment the OF-count .  */
+	(control_stack->cs_datum)++;
+
+	/* (    {Endof_FORw_ENDOF}1..n_ofs  N_OFs+1...CASE_CSTAG -- )        */
+
+	mark_forward_branch( OF_CSTAG );
+	/* ( -- {Endof_FORw_ENDOF}1..n_ofs  N_OFs+1...CASE_CSTAG Of_FORw_OF )
+	 */
+    }
+    /*  Leave the CSTAG-Group on the "Control-Stack" .  */
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  emit_endof
+ *      Synopsis:       All the actions when ENDOF is encountered
+ *
+ *      Associated FORTH word:                 ENDOF
+ *
+ *      Inputs:
+ *         Parameters:             NONE
+ *         Control-Stack Items:
+ *             Top:                Of_FORw_OF
+ *             Next:               N_OFs+1...CASE_CSTAG
+ *                    (Datum has been incremented)
+ *            {3rd and beyond}:    {Endof_FORw_ENDOF}1..n_ofs
+ *            { Repeat for 1 through the un-incremented OF-count )
+ *
+ *      Outputs:
+ *         Returned Value:         NONE
+ *         Control-Stack, 1 Item Popped, 1 new Item Pushed.
+ *             Top:                N_OFs...CASE_CSTAG
+ *                    (The count itself is unchanged from input-time, but
+ *                         the number of {Endof_FORw_ENDOF} CSTAG-Groups
+ *                         has caught up with this number, so it is
+ *                         no longer notated as " + 1 ").
+ *            {Next and beyond}:   {Endof_FORw_ENDOF}1..n_ofs
+ *            { Repeat for 1 through the updated OF-count )
+ *         FCode Output buffer:
+ *             Token for ENDOF statement -- b(endof) -- followed by
+ *                 place-holder FCode-offset of zero.  Then the space reserved
+ *                 for the FCode-offset of the forward-branch associated
+ *                 with the "OF" statement is filled in so that it reaches
+ *                 the token just after the "ENDOF" statement's FCode-offset.
+ *
+ *      Error Detection:
+ *          If control-stack depth  is not at least 2, CS underflow ERROR
+ *              and no further action.
+ *          Routine that resolves the forward-branch checks for matchup error.
+ *
+ **************************************************************************** */
+
+void emit_endof( void )
+{
+    if ( control_stack_size_test( 2) )
+    {
+	emit_token("b(endof)");
+
+	/*  See "Control-Stack" Diagram Notation comment-block  */
+
+	/*  Stack-diagrams might need to be split across lines.  */
+
+	/* (    {Endof_FORw_ENDOF}1..n_ofs  N_OFs+1...CASE_CSTAG  ...  
+	 *                       ...                          Of_FORw_OF -- )
+	 */
+	mark_forward_branch(ENDOF_CSTAG);
+	/* ( -- {Endof_FORw_ENDOF}1..n_ofs  N_OFs+1...CASE_CSTAG  ...  
+	 *                       ...  Of_FORw_OF  {Endof_FORw_ENDOF}n_ofs+1 )
+	 */
+
+	control_structure_swap();
+	/* ( -- {Endof_FORw_ENDOF}1..n_ofs  N_OFs+1...CASE_CSTAG  ...
+	 *                       ...  {Endof_FORw_ENDOF}n_ofs+1  Of_FORw_OF )
+	 */
+
+	resolve_forward( OF_CSTAG );
+	/* ( -- {Endof_FORw_ENDOF}1..n_ofs  N_OFs+1...CASE_CSTAG        ...
+	 *                       ...  {Endof_FORw_ENDOF}n_ofs+1  )
+	 */
+
+	control_structure_swap();
+	/* ( -- {Endof_FORw_ENDOF}1..n_ofs         ...
+	 *                       ...  {Endof_FORw_ENDOF}n_ofs+1   ...
+	 *                                        ...  N_OFs+1...CASE_CSTAG )
+	 */
+
+	/*  The number of ENDOF-tagged Forward-Marker pairs has now
+	 *     caught up with the incremented OF-count; therefore,
+	 *     we can notate the above as:
+	 *
+	 *  ( {Endof_FORw_ENDOF}1..n_ofs  N_OFs CASE_CSTAG )
+	 *
+	 *     and we are ready for another  OF ... ENDOF  pair,
+	 *     or for the ENDCASE statement.
+	 */
+    }
+
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  emit_endcase
+ *      Synopsis:       All the actions when ENDCASE is encountered
+ *
+ *      Associated FORTH word:                 ENDCASE
+ *
+ *      Inputs:
+ *         Parameters:             NONE
+ *         Control-Stack Items:
+ *             Top:                N_OFs...CASE_CSTAG
+ *                    (Datum is OF-count, number of  OF .. ENDOF  pairs)
+ *            {Next and beyond}:   {Endof_FORw_ENDOF}1..n_ofs
+ *            { Repeat for OF-count number of times }
+ *
+ *      Outputs:
+ *         Returned Value:         NONE
+ *         Control-Stack, # of Items Popped:  OF-count + 1
+ *         FCode Output buffer:
+ *             Token for ENDCASE statement -- b(endcase)
+ *             Then the spaces reserved for the FCode-offsets of all the
+ *                 forward-branches associated with the OF-count number
+ *                 of ENDOF statements are filled in so that they reach
+ *                 the token just after this "ENDCASE" statement.
+ *
+ *      Error Detection:
+ *          Routine that resolves the forward-branch checks for matchup error
+ *              for each forward-branch filled in, plus the matchup routine
+ *              checks before the OF-count is retrieved.
+ *
+ *      Process Explanation:
+ *          Retrieve the OF-count and resolve that number of ENDOF statements
+ *      
+ *      Extraneous Remarks:
+ *          The setup makes coding this routine appear fairly simple...  ;-}
+ *
+ **************************************************************************** */
+
+void emit_endcase( void )
+{
+    unsigned long n_endofs ;
+    if ( matchup_control_structure( CASE_CSTAG) )
+    {
+	int indx;
+
+	emit_token("b(endcase)");
+	n_endofs = control_stack->cs_datum;
+	for ( indx = 0 ; indx < n_endofs ; indx++ )
+	{
+	    /*  Because  matchup_control_structure  doesn't pop the
+	     *      control-stack, we have the  N_OFs...CASE_CSTAG
+	     *      item on top of the  Endof_FORw_ENDOF  item we
+	     *      want to resolve.  We need to keep it there so
+	     *      the  POP  is valid for the other path as well
+	     *      as at the end of this one.
+	     *  So we  SWAP  to get at the  Endof_FORw_ENDOF  item.
+	     */
+	    control_structure_swap();
+	    resolve_forward( ENDOF_CSTAG);
+	}
+    }
+    pop_cstag();
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  control_struct_incomplete
+ *      Synopsis:       Print a Message of given severity with origin info for
+ *                          a control-structure that has not been completed.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             c_s_entry             Control-structure about which to display
+ *             severity              Severity of the messages to display.
+ *             call_cond             String identifying Calling Condition;
+ *                                       used in the message.
+ *
+ *      Outputs:
+ *         Returned Value:           NONE
+ *             
+ *         Printout:
+ *             Message of given severity...
+ *
+ *      Process Explanation:
+ *          The calling routine will be responsible for all filtering of
+ *               duplicate structures and the like.  This routine will
+ *               simply display a message.
+ *
+ **************************************************************************** */
+
+static void control_struct_incomplete(
+			    int severity,
+				char *call_cond,
+				    cstag_group_t *c_s_entry)
+{
+    tokenization_error ( severity,
+	"%s before completion of %s" ,
+	    call_cond, strupr(c_s_entry->cs_word));
+    where_started( c_s_entry->cs_inp_fil, c_s_entry->cs_line_num );
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  announce_control_structs
+ *      Synopsis:       Print a series of Messages (of severity as specified)
+ *                          announcing that the calling event is occurring
+ *                          in the context of Control-Flow structure(s),
+ *                          back to the given limit.  Leave the control
+ *                          structures in effect.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             severity              Severity of the messages to display.
+ *             call_cond             String identifying Calling Condition;
+ *                                       used in the message.
+ *             abs_token_limit       Limit, in terms of abs_token_no
+ *         Local Static Variables:
+ *             control_stack         Pointer to "Top" of "Control-Stack"
+ *
+ *      Outputs:
+ *         Returned Value:           NONE
+ *         Printout:
+ *             A Message for each unresolved Control-Flow structure.
+ *
+ **************************************************************************** */
+
+void announce_control_structs( int severity, char *call_cond,
+				          unsigned int abs_token_limit)
+{
+    cstag_group_t *cs_temp = control_stack;
+    while ( cs_temp != NULL )
+    {
+	if ( cs_temp->cs_abs_token_num < abs_token_limit )
+	{
+	    break;
+	}
+	if ( cs_temp->cs_not_dup )
+	{
+	    control_struct_incomplete( severity, call_cond, cs_temp );
+	}
+	cs_temp = cs_temp->prev;
+    }
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  clear_control_structs_to_limit
+ *      Synopsis:       Clear items from the "Control-Stack" back to the given
+ *                          limit.  Print error-messages with origin info for
+ *                          control-structures that have not been completed.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             call_cond                 String identifying Calling Condition;
+ *                                           used in the Error message.
+ *             abs_token_limit           Limit, in terms of abs_token_no
+ *         Global Variables:
+ *             control_stack_depth       Number of items on "Control-Stack"
+ *             control_stack             Pointer to "Top" of "Control-Stack"
+ *         Control-Stack Items:
+ *             The  cs_inp_fil  and  cs_line_num  tags of any item cleared
+ *                 from the "Control-Stack" are used in error-messages.
+ *
+ *      Outputs:
+ *         Returned Value: 
+ *         Global Variables:
+ *             do_loop_depth             Decremented when "DO" item cleared.
+ *             control_stack_depth       Decremented by called routine.
+ *         Control-Stack, # of Items Popped:  As many as go back to given limit
+ *         Memory Freed
+ *             By called routine.
+ *
+ *      Error Detection:
+ *          Any item on the "Control-Stack" represents a Control-Structure
+ *              that was not completed when the Calling Condition was
+ *              encountered.  Error; identify the origin of the structure.
+ *          No special actions if  noerrors  is set.
+ *
+ *      Process Explanation:
+ *          The given limit corresponds to the value of  abs_token_no  at
+ *              the time the colon-definition (or whatever...) was created.
+ *              Any kind of Control-Structure imbalance at the end of the
+ *              colon-definition is an error and the entries must be cleared,
+ *              but the colon-definition may have been created inside nested
+ *              interpretation-time Control-Structures, and those must be
+ *              preserved. 
+ *             
+ *          Of course, if this routine is called with a given limit of zero,
+ *              that would mean all the entries are to be cleared.  That will
+ *              be the way  clear_control_structs()  is implemented.
+ *          We control the loop by the  cs_abs_token_num  field, but also
+ *              make sure we haven't underflowed  control_stack_depth
+ *          We skip messages and other processing for items that are duplicates
+ *                    of others, based on the  cs_not_dup  field.
+ *               If the cs_tag field is  DO_CSTAG  we decrement  do_loop_depth
+ *          The  pop_cstag()  routine takes care of the rest.
+ *               
+ *      Extraneous Remarks:
+ *          This is a retrofit; necessary because we now  permit definitions
+ *              to occur inside interpretation-time Control-Structures.  Calls
+ *              to  clear_control_structs()  are already scattered around...
+ *
+ **************************************************************************** */
+
+void clear_control_structs_to_limit( char *call_cond,
+				          unsigned int abs_token_limit)
+{
+    while ( control_stack_depth > 0 )
+    {
+	if ( control_stack->cs_abs_token_num < abs_token_limit )
+	{
+	    break;
+	}
+	if ( control_stack->cs_not_dup )
+	{
+	    control_struct_incomplete( TKERROR, call_cond, control_stack );
+	    if ( control_stack->cs_tag == DO_CSTAG) do_loop_depth--;
+	}
+	pop_cstag();
+    }
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  clear_control_structs
+ *      Synopsis:       Make sure the "Control-Stack" is cleared, and print
+ *                          error-messages (giving origin information) for
+ *                          control-structures that have not been completed.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             call_cond                 String identifying Calling Condition;
+ *                                           used in the Error message.
+ *         Global Variables:
+ *             control_stack_depth       Number of items on "Control-Stack"
+ *             control_stack             Pointer to "Top" of "Control-Stack"
+ *         Control-Stack Items:
+ *             The  cs_inp_fil  and  cs_line_num  tags of any item found on
+ *                 the "Control-Stack" are used in error-messages.
+ *
+ *      Outputs:
+ *         Returned Value:               NONE
+ *         Global Variables:
+ *             control_stack_depth       Reset to zero.
+ *             do_loop_depth             Reset to zero.
+ *         Control-Stack, # of Items Popped:    All of them
+ *             
+ *      Error Detection:
+ *          Any item on the "Control-Stack" represents a Control-Structure
+ *              that was not completed when the Calling Condition was
+ *              encountered.  Error; identify the origin of the structure.
+ *          No special actions if  noerrors  is set.
+ *
+ *      Process Explanation:
+ *          Filter the duplicate messages caused by structures (e.g., DO)
+ *              that place two entries on the "Control-Stack" by testing
+ *              the  cs_not_dup  field of the "Top" "Control-Stack" item,
+ *              which would indicate double-entry...
+ *
+ *      Extraneous Remarks:
+ *          This is called before a definition of any kind, and after a 
+ *              colon-definition.  Flow-control constructs should *never*
+ *              be allowed to cross over between immediate-execution mode
+ *              and compilation mode.  Likewise, not between device-nodes.
+ *          Also, at the end of tokenization, there should not be any
+ *              unresolved flow-control constructs.
+ *
+ **************************************************************************** */
+
+void clear_control_structs( char *call_cond)
+{
+    clear_control_structs_to_limit( call_cond, 0);
+}
diff --git a/toke/flowcontrol.h b/toke/flowcontrol.h
new file mode 100644
index 0000000..e2aabf8
--- /dev/null
+++ b/toke/flowcontrol.h
@@ -0,0 +1,74 @@
+#ifndef _TOKE_FLOWCONTROL_H
+#define _TOKE_FLOWCONTROL_H
+
+/*
+ *                     OpenBIOS - free your system!
+ *                         ( FCode tokenizer )
+ *
+ *  This program is part of a free implementation of the IEEE 1275-1994
+ *  Standard for Boot (Initialization Configuration) Firmware.
+ *
+ *  Copyright (C) 2001-2005 Stefan Reinauer, <stepan@openbios.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ *
+ */
+
+/* **************************************************************************
+ *
+ *      External Variables and Function Prototypes for Support Functions
+ *          used in tokenizing FORTH Flow-Control structures.
+ *
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Module Author:  David L. Paktor    dlpaktor@us.ibm.com
+ *
+ **************************************************************************** */
+
+
+/* ************************************************************************** *
+ *
+ *      Global Variables Exported
+ *
+ **************************************************************************** */
+
+extern int control_stack_depth;
+ 
+/* ************************************************************************** *
+ *
+ *      Function Prototypes / Functions Exported:
+ *
+ **************************************************************************** */
+
+void emit_if( void );
+void emit_then( void );
+void emit_else( void );
+void emit_begin( void );
+void emit_again( void );
+void emit_until( void );
+void emit_while( void );
+void emit_repeat( void );
+void mark_do( void );
+void resolve_loop( void );
+void emit_case( void );
+void emit_of( void );
+void emit_endof( void );
+void emit_endcase( void );
+
+void announce_control_structs( int severity, char *call_cond,
+				          unsigned int abs_token_limit);
+void clear_control_structs_to_limit( char *call_cond,
+				          unsigned int abs_token_limit);
+void clear_control_structs( char *call_cond);
+
+#endif   /*  _TOKE_FLOWCONTROL_H    */
diff --git a/toke/macros.c b/toke/macros.c
index 92d2933..17c01cb 100644
--- a/toke/macros.c
+++ b/toke/macros.c
@@ -24,6 +24,31 @@
  *
  */
 
+/* **************************************************************************
+ *         Modifications made in 2005 by IBM Corporation
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Modifications Author:  David L. Paktor    dlpaktor@us.ibm.com
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      Support functions for the  MACROS  vocabulary, implemented
+ *          as a TIC-Headerlist type of data structure, and linked in
+ *          to the Global Vocabulary.
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      Functions Exported:
+ *          init_macros             Initialize the link-pointers in the
+ *                                      initial "Built-In" portion of
+ *                                      the  macros  vocabulary
+ *          add_user_macro          Add an entry to the  macros  vocabulary
+ *          skip_user_macro         Consume a Macro definition if Ignoring
+ *
+ **************************************************************************** */
+
 #include <stdio.h>
 #include <stdlib.h>
 #if defined(__linux__) && ! defined(__USE_BSD)
@@ -32,107 +57,489 @@
 #include <string.h>
 #include <errno.h>
 
-#include "toke.h"
+#include "errhandler.h"
+#include "ticvocab.h"
+#include "stream.h"
+#include "scanner.h"
+#include "dictionary.h"
+#include "devnode.h"
+#include "macros.h"
 
-typedef struct macro {
-	u8  *name;
-	u8  *alias;
-	struct macro *next;
-} macro_t;
+/* **************************************************************************
+ *
+ *              Internal Static Variables
+ *          macros_tbl                    Initial array of "Built-In" Macros
+ *          number_of_builtin_macros      Number of "Built-In" Macro entries.
+ *
+ **************************************************************************** */
 
-static macro_t *macros=NULL;
+/* **************************************************************************
+ *
+ *      Revision History:
+ *          Thu, 27 Oct 2005 by David L. Paktor
+ *              Identify the macros that resolve to a single word.
+ *              Remove them from here and enter them as synonymous entries
+ *                  in the Tokens, Specials or Shared-words vocabularies.
+ *          Wed, 30 Nov 2005 by David L. Paktor
+ *              Allow user-definition of macros.
+ *          Fri, 06 Jan 2006 by David L. Paktor
+ *              Re-define the Macros as a TIC-Headerlist, and make them
+ *                  part of the Global Vocabulary
+ *
+ **************************************************************************** */
 
-char *lookup_macro(char *name)
+
+
+/* **************************************************************************
+ *
+ *      Function name:  macro_recursion_error
+ *      Synopsis:       Function that will go temporarily into the FUNCT
+ *                      field of a Macro's TIC-entry, to protect against
+ *                      recursive macro invocations.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             pfield              Param field of the TIC-entry; unused.
+ *         Global Variables:
+ *             statbuf             The name being invoked erroneously.
+ *
+ *      Outputs:
+ *         Returned Value:         NONE
+ *         Printout:
+ *             Error Message.
+ *
+ *      Error Detection:
+ *          If this function is called, it is an ERROR
+ *
+ *      Extraneous Remarks:
+ *          This Tokenizer does not have the early-binding characterisitics
+ *              of FORTH; its Macros are strings, evaluated when invoked
+ *              rather than when they are defined.  A reference to a name
+ *              that matches the macro would cause recursion, possibly
+ *              infinite.  We will not allow that.
+ *
+ **************************************************************************** */
+
+static void macro_recursion_error( tic_param_t pfield)
 {
-	macro_t *curr;
-	
-	for (curr=macros; curr!=NULL; curr=curr->next)
-		if (!strcasecmp(name,(char *)curr->name))
-			break;
+    tokenization_error( TKERROR,
+	"Recursive invocation of macro named %s\n", statbuf);
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  eval_mac_string
+ *      Synopsis:       Function that goes into FUNCT field of a TIC-entry
+ *                      in the Macros list.  Protect against recursion.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             pfield              Param field of the TIC-entry
+ *         Global Variables:
+ *             tic_found           The TIC-entry that has just been found;
+ *                                     it's the entry for this Macro.
+ *
+ *      Outputs:
+ *         Returned Value:         NONE
+ *         Global Variables:
+ *             report_multiline    Cleared to FALSE
+ *         Global Behavior:
+ *            The Macro will be evaluated as string input.
+ *
+ *      Error Detection:
+ *          An attempt at recursion will be detected because the FUNCT field
+ *              of the Macro entry will have been temporarily be replaced by
+ *              macro_recursion_error()
+ *
+ *      Process Explanation:
+ *          Save the address of the routine that is in the FUNCT field
+ *               of the entry for this Macro.  (Hey!  It's this routine...)
+ *          Replace the FUNCT field of the Macro entry with the Macro
+ *              Recursion Error Detection routine
+ *          Pass the address of the "resumption" routine and its argument
+ *              (the entry for this Macro), to  push_source()
+ *          Recast the type of the parameter field to a string
+ *          Make it the new Input Source Buffer.
+ *          Suspend multi-line warning; see comment in body of add_user_macro()
+ *              The multi-line warning flag is kept by  push_source()
+ *
+ *      Still to be done:
+ *          If an error is encountered during Macro evaluation, display
+ *              supplemental information giving the name of the Macro 
+ *              being run, and the file and line number in which it was
+ *              defined.
+ *          This will require changes to the way user Macros are added
+ *              and retained, and to the way error messages are displayed.
+ *
+ *      Revision History:
+ *          Updated Thu, 23 Feb 2006 by David L. Paktor
+ *              Do not process Macros (or, for that matter, User-defined
+ *                  Symbols or FLOADed files) with a routine that calls
+ *                  its own instance of  tokenize(), because the Macro
+ *                  (etc.) might contain a phrase (such as the start of
+ *                  a conditional) that must be terminated within the
+ *                  body of a file, thus causing an undeserved Error.
+ *                  Instead, they need to be handled in a more sophis-
+ *                  ticated way, tied in with the operation of get_word()
+ *                  perhaps, that will make a smooth transition between
+ *                  the body of the Macro and the resumption of processing
+ *                  the source file.  The end-of-file will only be seen
+ *                  at the end of an actual input file or when getting
+ *                  a delimited string.
+ *          Updated Fri, 24 Feb 2006 by David L. Paktor
+ *              Re-integrate Recursion Error Detection with the above.
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *     In order to integrate Recursion Error Detection with the smooth
+ *         transition to resumption of processing the source file, we
+ *         need to create a "resumption" routine that will restore the
+ *         normal behavior of the macro after it's completed, by re-
+ *         instating the address of the normal Macro-invocation routine;
+ *         that routine, of course, is the one that passes the address
+ *         of the "resumption" routine to push_source().  In order to
+ *         get around this chicken-and-egg dilemma, we will create a
+ *         local static variable into which the address of the normal
+ *         Macro-invocation routine will be stored.  We actually only
+ *         need it once, but we'd rather avoid the overhead of checking,
+ *         every time, whether it has already been set; since it's always
+ *         the same, there's no harm in storing it every time.
+ *
+ **************************************************************************** */
+
+typedef void (*vfunct)();  /*  Pointer to function returning void  */
+static vfunct sav_mac_funct ;
 
-	return curr?(char *)curr->alias:NULL;
+
+/* **************************************************************************
+ *
+ *     This "resumption" routine will be called by  pop_source()
+ *     The parameter is the Macro dictionary-entry whose behavior
+ *         is to be restored.
+ *
+ **************************************************************************** */
+
+static void mac_string_recovery( tic_hdr_t *macro_entry)
+{
+    (*macro_entry).funct = sav_mac_funct;
+    (*macro_entry).ign_func = sav_mac_funct;
 }
 
-int add_macro(char *name, char *alias)
+/* **************************************************************************
+ *
+ *     The normal Macro-invocation routine, at last...
+ *
+ **************************************************************************** */
+static void eval_mac_string( tic_param_t pfield)
 {
-	macro_t *curr;
+    int mac_str_len = strlen(pfield.chr_ptr);
+    /*  We can't use  (*tic_found).pfld_size  for the string length
+     *      because, if this is an alias for a macro, it will be zero...
+     */
+    /*  We can change that by de-coupling the decision to free the
+     *      param-field from whether pfld_size is non-zero (by intro-
+     *      ducing yet another field into the  tic_param_t  struct),
+     *      but we're not doing that today...
+     */
 
-	curr=malloc(sizeof(macro_t));
-	if(!curr) {
-		printf("Out of memory while adding macro.\n");
-		exit(-ENOMEM);
-	}
+    sav_mac_funct = *tic_found->funct;
+    (*tic_found).funct = macro_recursion_error;
+    (*tic_found).ign_func = macro_recursion_error;
+    push_source( mac_string_recovery, tic_found, FALSE);
+    report_multiline = FALSE;  /*  Must be done AFTER call to push_source()
+                                *      because  report_multiline  is part of
+                                *      the state that  push_source()  saves.
+				*/
+    init_inbuf( pfield.chr_ptr, mac_str_len);
+}
 
-	curr->next=macros;
-	curr->name=(u8 *)name;
-	curr->alias=(u8 *)alias;
+/* **************************************************************************
+ *
+ *     Builtin Macros do not need Recursion Error Detection.
+ *     Intermediate routine to convert parameter type.
+ *
+ **************************************************************************** */
+static void eval_builtin_mac( tic_param_t pfield)
+{
+    eval_string( pfield.chr_ptr);
+}
+/* **************************************************************************
+ *
+ *      Make a macro, because we might eliminate this layer later on.
+ *
+ **************************************************************************** */
+#define EVAL_MAC_FUNC  eval_mac_string
+#define BUILTIN_MAC_FUNC  eval_builtin_mac
+
+/* **************************************************************************
+ *
+ *      Initialization macro definition
+ *
+ **************************************************************************** */
 
-	macros=curr;
-	return 0;
+#define BUILTIN_MACRO(nam, alias) BUILTIN_MAC_TIC(nam, BUILTIN_MAC_FUNC, alias )
+
+static tic_mac_hdr_t macros_tbl[] = {
+	BUILTIN_MACRO( "(.)",		"dup abs <# u#s swap sign u#>") ,
+
+
+	BUILTIN_MACRO( "?",		"@ .") ,
+	BUILTIN_MACRO( "1+",		"1 +") ,
+	BUILTIN_MACRO( "1-",		"1 -") ,
+	BUILTIN_MACRO( "2+",		"2 +") ,
+	BUILTIN_MACRO( "2-",		"2 -") ,
+
+	BUILTIN_MACRO( "accept",      "span @ -rot expect span @ swap span !") ,
+	BUILTIN_MACRO( "allot", 	"0 max 0 ?do 0 c, loop") ,
+	BUILTIN_MACRO( "blank", 	"bl fill") ,
+	BUILTIN_MACRO( "carret",	"h# d") ,
+	BUILTIN_MACRO( ".d",		"base @ swap h# a base ! . base !") ,
+	BUILTIN_MACRO( "decode-bytes",  ">r over r@ + swap r@ - rot r>") ,
+	BUILTIN_MACRO( "3drop", 	"drop 2drop") ,
+	BUILTIN_MACRO( "3dup",		"2 pick 2 pick 2 pick") ,
+	BUILTIN_MACRO( "erase", 	"0 fill") ,
+	BUILTIN_MACRO( ".h",		"base @ swap h# 10 base ! . base !") ,
+	BUILTIN_MACRO( "linefeed",	"h# a") ,
+
+	BUILTIN_MACRO( "s.",		"(.) type space") ,
+	BUILTIN_MACRO( "space", 	"bl emit") ,
+	BUILTIN_MACRO( "spaces",	"0 max 0 ?do space loop") ,
+	BUILTIN_MACRO( "(u.)",		"<# u#s u#>") ,
+	BUILTIN_MACRO( "?leave",	"if leave then"),
+};
+
+static const int number_of_builtin_macros =
+	 sizeof(macros_tbl)/sizeof(tic_mac_hdr_t);
+
+/* **************************************************************************
+ *
+ *      Function name:  init_macros
+ *      Synopsis:       Initialize the link-pointers in the "Built-In"
+ *                          portion of the  macros  vocabulary, dynamically.
+ *      
+ *      Inputs:
+ *         Parameters:
+ *             tic_vocab_ptr                 Pointer to Global Vocab Pointer
+ *         Global Variables:
+ *             macros_tbl                    Initial "Built-In" Macros array
+ *             number_of_builtin_macros      Number of "Built-In" Macro entries
+ *
+ *      Outputs:
+ *         Returned Value:          NONE
+ *         Global Variables:    
+ *             The link-fields of the initial "Built-In" Macros array entries
+ *                  will be filled in.
+ *         Supplied Pointers:
+ *             *tic_vocab_ptr                Updated to "tail" of Macros array
+ *
+ **************************************************************************** */
+
+void init_macros( tic_hdr_t **tic_vocab_ptr )
+{
+    init_tic_vocab( (tic_hdr_t *)macros_tbl,
+        number_of_builtin_macros,
+	    tic_vocab_ptr );
 }
 
-void init_macros(void) 
+
+/* **************************************************************************
+ *
+ *      Function name:  print_if_mac_err
+ *      Synopsis:       Report a user-macro definition error, if so be.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             failure             TRUE if error was detected
+ *             func_cpy            STRDUP() of function name, for error message
+ *
+ *      Outputs:
+ *         Returned Value:         NONE
+ *         Memory Freed
+ *             Contents of func_cpy, error or not.
+ *         Printout:
+ *             Error message, if  failure  is TRUE.
+ *
+ **************************************************************************** */
+static void print_if_mac_err( bool failure, char *func_cpy)
 {
-	add_macro( "eval",	"evaluate");
-	add_macro( "(.)", 	"dup abs <# u#s swap sign u#>");
-	add_macro( "<<", 	"lshift");
-	add_macro( ">>",	"rshift");
-	add_macro( "?",		"@ .");
-	add_macro( "1+",	"1 +");
-	add_macro( "1-",	"1 -");
-	add_macro( "2+",	"2 +");
-	add_macro( "2-",	"2 -");
-	/* add_macro( "abort\"",	"-2 throw"); */
-	add_macro( "accept",	"span @ -rot expect span @ swap span !");
-	add_macro( "allot",	"0 max 0 ?do 0 c, loop");
-	add_macro( "blank",	"bl fill");
-	add_macro( "/c*",	"chars");
-	add_macro( "ca1+",	"char+");
-	add_macro( "carret",	"h# d");
-	add_macro( ".d",	"base @ swap h# a base ! . base !");
-	add_macro( "decode-bytes", ">r over r@ + swap r@ - rot r>");
-	add_macro( "3drop",	"drop 2drop");
-	add_macro( "3dup",	"2 pick 2 pick 2 pick");
-	add_macro( "erase",	"0 fill");
-	add_macro( "false",	"0");
-	add_macro( ".h",	"base @ swap h# 10 base ! . base !");
-	add_macro( "linefeed",	"h# a");
-	add_macro( "/n*",	"cells");
-	add_macro( "na1+",	"cell+");
-	add_macro( "not",	"invert");
-	add_macro( "s.",	"(.) type space");
-	add_macro( "space",	"bl emit");
-	add_macro( "spaces",	"0 max 0 ?do space loop");
-	add_macro( "struct",	"0");
-	add_macro( "true",	"-1");
-	add_macro( "(u.)",	"<# u#s u#>");
-
-	/* H.7 FCode name changes */
-	add_macro( "decode-2int",		"parse-2int");
-	add_macro( "delete-attribute",		"delete-property");
-	add_macro( "get-inherited-attribute",	"get-inherited-property");
-	add_macro( "get-my-attribute",		"get-my-property");
-	add_macro( "get-package-attribute",	"get-package-property");
-	add_macro( "attribute",	  "property");
-	add_macro( "flip",	  "wbflip");
-	add_macro( "is",	  "to");
-	add_macro( "lflips",	  "lwflips");
-	add_macro( "map-sbus",	  "map-low");
-	add_macro( "u*x",	  "um*");
-	add_macro( "version",	  "fcode-revision");
-	add_macro( "wflips",	  "wbflips");
-	add_macro( "x+",	  "d+");
-	add_macro( "x-",	  "d-");
-	add_macro( "xdr+",	  "encode+");
-	add_macro( "xdrbytes",	  "encode-bytes");
-	add_macro( "xdrint",	  "encode-int");
-	add_macro( "xdrphys",	  "encode-phys");
-	add_macro( "xdrstring",	  "encode-string");
-	add_macro( "xdrtoint",	  "decode-int");
-	add_macro( "xdrtostring", "decode-string");
-	add_macro( "xu/mod",	  "um/mod");
+    if ( failure )
+    {
+	tokenization_error( TKERROR,
+	   "%s directive expects name and definition on the same line\n",
+	       strupr(func_cpy));
+    }
+    free( func_cpy);
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  add_user_macro
+ *      Synopsis:       Parse input and add a user-defined Macro.
+ *
+ *      Associated Tokenizer directive:        [MACRO]
+ *
+ *      Inputs:
+ *         Parameters:                 NONE
+ *         Global Variables:
+ *             pc                      Input-source Scanning pointer
+ *             statbuf                 Symbol retrieved from input stream.
+ *             in_tokz_esc             TRUE if in "Tokenizer-Escape" mode
+ *             current_definitions     Pointer to Current Vocabulary pointer,
+ *                                         either Global or Current Device-Node
+ *             tokz_esc_vocab         "Tokenizer Escape" Vocab pointer
+ *
+ *      Outputs:
+ *         Returned Value:            NONE
+ *         Global Variables:
+ *             *current_definitions   { One of these will point  }
+ *             tokz_esc_vocab         {     to the new entry     }
+ *         Memory Allocated:
+ *             Copy of directive, for error message
+ *             Copy of Macro name
+ *             Copy of Macro body
+ *             Memory for the new entry will be allocated by support routine.
+ *         When Freed?
+ *             Copy of directive:  When error might be reported.
+ *             Macro name, body and entry:  Upon end of tokenization, or when
+ *                 RESET-SYMBOLS is issued in the same mode and Scope as when
+ *                 the Macro was defined. 
+ *
+ *      Error Detection:
+ *          At least two words in the input stream are expected to be on
+ *              the same line as the directive.  The  get_word_in_line()
+ *              and  get_rest_of_line()  routines will check for that;
+ *              we will issue the Error Message for either condition.
+ *          Check if the Macro name is a duplicate; warn_if_duplicate()
+ *              routine will issue message.
+ *
+ *      Process Explanation:
+ *          We start just after the directive has been recognized.
+ *          Get one word in line -- this is the macro name
+ *          Get input to end of line.  This is the "body" of the macro.
+ *          Add the Macro to the Current vocab, using support routine.
+ *          Set the definer field to MACRO_DEF and the Function to the
+ *              same one that's used for the built-in macros.
+ *          User-defined Macros may need to be processed while ignoring
+ *              (because they might include conditional-operators, etc.)
+ *              We will set the ign_func the same as the active function.
+ *
+ *      To be considered:
+ *          Do we want to do further filtration? 
+ *              Remove comments?
+ *              Compress whitespace?
+ *              Allow backslash at end of line to continue to next line?
+ *
+ *      Extraneous Remarks:
+ *          The scope of User-Macro definitions will follow the same rules
+ *              as all other definition types:  if Device-Definitions are
+ *              in effect, the scope of the new Macro definition will be
+ *              confined to the current Device-Node; if Global-Definitions
+ *              are in effect when it is defined, its scope will be Global;
+ *              if it was declared when we were in "Tokenizer Escape" mode,
+ *              then its scope will be limited to "Tokenizer Escape" mode.
+ *
+ **************************************************************************** */
+
+/*  This pointer is exported to this file only  */
+extern tic_hdr_t *tokz_esc_vocab ;
+
+void add_user_macro( void)
+{
+    char *macroname;
+    char *macrobody;
+    bool failure = TRUE;
+
+    /*  Copy of function name, for error message  */
+    char *func_cpy = strdup( statbuf);
+
+    if ( get_word_in_line( NULL ) )
+    {
+        /*  This is the Macro name  */
+	macroname = strdup( statbuf);
+
+	if ( INVERSE(get_rest_of_line() ) )
+	{
+	    /*  No body on line  */
+	    free( macroname);
 	
-	/* non standard but often used macros */
-	add_macro( "name",	"device-name");
-	add_macro( "endif",	"then");
+	}else{
+	    /*  We have valid Macro body on line  */
+	    int mac_body_len = 0;
+
+	    tic_hdr_t **target_vocab = current_definitions;
+	    if ( in_tokz_esc ) target_vocab = &tokz_esc_vocab ;
+
+            warn_if_duplicate( macroname);
+	    trace_creation( MACRO_DEF, macroname);
+
+	    /*  Tack on a new-line, so that a remark will appear
+	     *      to be properly terminated.   This might trigger
+	     *      an undeserved multi-line warning if the Macro
+	     *      is an improperly terminated quote; we will work
+	     *      around that problem by temporarily suspending
+	     *      multi-line warnings during macro processing.
+	     */
+	    strcat( statbuf, "\n");
+	    macrobody = strdup( statbuf);
+	    mac_body_len = strlen(macrobody);
+
+	    add_tic_entry( macroname, EVAL_MAC_FUNC,
+	                       (TIC_P_DEFLT_TYPE)macrobody,
+			           MACRO_DEF, mac_body_len,
+				       EVAL_MAC_FUNC, target_vocab );
+	    failure = FALSE;
+	}
+    }
+
+    print_if_mac_err( failure, func_cpy);
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  skip_user_macro
+ *      Synopsis:       Consume the text of a user-defined Macro from the
+ *                          Input Stream, with no processing.  (Called when
+ *                          a user-Macro definer occurs in a segment that
+ *                          is being Ignored.)
+ *
+ *      Inputs:
+ *         Parameters:
+ *             pfield             "Parameter field" pointer, to satisfy
+ *                                    the calling convention, but not used
+ *         Global Variables:
+ *             statbuf            Word currently being processed.
+ *
+ *      Outputs:
+ *         Returned Value:        NONE
+ *
+ *      Error Detection:
+ *          At least two words in the input stream are expected to be on
+ *              the same line as the user-Macro definer, same as when the
+ *              directives occurs in a segment that is not being Ignored.
+ *              The  get_word_in_line()  and  get_rest_of_line()  routines
+ *              will check for condition., we will issue the Error Message.
+ *
+ *      Process Explanation:
+ *          We need to protect against the case of a macro-definition that
+ *              invokes a directive that alters Conditional processing...
+ *
+ **************************************************************************** */
+void skip_user_macro( tic_bool_param_t pfield )
+{
+    bool failure = TRUE;
+    char *func_cpy = strdup( statbuf);
+    if ( get_word_in_line( NULL ) )
+    {
+	if ( get_rest_of_line() )
+	{
+	    failure = FALSE;
+	}
+    }
+
+    print_if_mac_err( failure, func_cpy);
+
 }
diff --git a/toke/macros.h b/toke/macros.h
new file mode 100644
index 0000000..5afd170
--- /dev/null
+++ b/toke/macros.h
@@ -0,0 +1,58 @@
+#ifndef _TOKE_MACROS_H
+#define _TOKE_MACROS_H
+
+/*
+ *                     OpenBIOS - free your system!
+ *                         ( FCode tokenizer )
+ *
+ *  This program is part of a free implementation of the IEEE 1275-1994
+ *  Standard for Boot (Initialization Configuration) Firmware.
+ *
+ *  Copyright (C) 2001-2005 Stefan Reinauer, <stepan@openbios.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ *
+ */
+
+/* **************************************************************************
+ *
+ *      Prototypes for functions that operate on the  MACROS vocabulary,
+ *          which is implemented as a String-Substitution-type vocab.
+ *
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Module Author:  David L. Paktor    dlpaktor@us.ibm.com
+ *
+ **************************************************************************** */
+
+
+#include "types.h"
+#include "ticvocab.h"
+
+/* ************************************************************************** *
+ *
+ *      Function Prototypes / Functions Exported:
+ *
+ **************************************************************************** */
+
+void init_macros( tic_hdr_t **tic_vocab_ptr );
+void add_user_macro( void);
+void skip_user_macro( tic_bool_param_t pfield );
+#if  0  /*  What's this doing here?  */
+char *lookup_macro(char *name);
+bool exists_as_macro(char *name);
+bool create_macro_alias( char *new_name, char *old_name );
+void reset_macros_vocab( void );
+#endif  /*  What's this doing here?  */
+
+#endif   /*  _TOKE_MACROS_H    */
diff --git a/toke/nextfcode.c b/toke/nextfcode.c
new file mode 100644
index 0000000..c76015a
--- /dev/null
+++ b/toke/nextfcode.c
@@ -0,0 +1,708 @@
+/*
+ *                     OpenBIOS - free your system!
+ *                         ( FCode tokenizer )
+ *
+ *  This program is part of a free implementation of the IEEE 1275-1994
+ *  Standard for Boot (Initialization Configuration) Firmware.
+ *
+ *  Copyright (C) 2001-2005 Stefan Reinauer, <stepan@openbios.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ *
+ */
+
+/* **************************************************************************
+ *
+ *      Functions for Managing FCode Assignment Pointer and for
+ *          Detection of Overlapping-FCode Error in Tokenizer
+ *
+ *      (C) Copyright 2006 IBM Corporation.  All Rights Reserved.
+ *      Module Author:  David L. Paktor    dlpaktor@us.ibm.com
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      The fact that the user is able to specify, at any time, the
+ *          next FCode number to be assigned introduces the risk that
+ *          a symbol might inadvertently be assigned an FCode that is
+ *          still in use by another symbol, which could lead to bizarre
+ *          and hard-to-trace failures at run-time.
+ *
+ *      This module will support a means whereby to detect and report,
+ *          as an Error, overlapping FCode assignments.
+ *
+ *      The task is further complicated by the fact that, under some
+ *          circumstances, "recycling" a range of FCodes can be done
+ *          safely, and the programmer may do so intentionally.
+ *
+ *      We will define a way for the programmer to specify that FCode
+ *          assignments are being intentionally "recycled", and that
+ *          overlaps with previously-assigned FCodes are not to be
+ *          treated as Errors.  We will not attempt to analyze whether
+ *          it is, indeed, safe to do so; the programmer who does this
+ *          is presumed to be sufficiently responsible.
+ *
+ **************************************************************************** */
+
+
+/* **************************************************************************
+ *
+ *      Functions Exported:
+ *          reset_fcode_ranges   (Re-)Initialize the range of assignable
+ *                                   FCode numbers and clear the records
+ *                                   of prevously-assigned ranges of FCodes
+ *          list_fcode_ranges    Display a final report of assigned FCode
+ *                                   ranges at end of tokenization or when
+ *                                   the  reset_fcodes()  routine is called.
+ *          set_next_fcode       Set the start of a new Range of FCode
+ *                                   numbers to be assigned.
+ *          assigning_fcode      The next FCode number is about to be assigned;
+ *                                   test for out-of-bounds, overlap, etc.
+ *                                   errors.
+ *          bump_fcode           Increment the next FCode number prior to the
+ *                                    next assignment.
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      Revision History:
+ *          06 Jun 06  -- Need became apparent after verification test
+ *                            against existing device-drivers.
+ *              
+ *
+ **************************************************************************** */
+
+
+/* **************************************************************************
+ *
+ *      Still to be done:
+ *          Detect and report when the Current Range stops overlapping
+ *              one particular Range and starts overlapping another.
+ *
+ *          Detect and report when the Current Range overlaps more than
+ *              one Range at a time (e.g., if other Ranges themselves
+ *              overlap, and the Current Range is stepping through them)
+ *              but, again, only display one message per overlapped Range.
+ *
+ **************************************************************************** */
+
+
+
+/* **************************************************************************
+ *
+ *          Global Variables Imported
+ *              iname              Name of current input file
+ *              lineno             Line Number within current input file
+ *
+ **************************************************************************** */
+
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "toke.h"
+#include "nextfcode.h"
+#include "errhandler.h"
+#include "stream.h"
+#include "scanner.h"
+
+
+/* **************************************************************************
+ *
+ *          Global Variables Exported
+ *              nextfcode          The next FCode-number to be assigned
+ *
+ **************************************************************************** */
+
+u16  nextfcode;         /*  The next FCode-number to be assigned              */
+
+/* **************************************************************************
+ *
+ *      Internal (Static) Structure:
+ *          fcode_range_t         The record of a Range of assigned FCodes
+ *
+ *   Fields:
+ *       fcr_start            FCode number at the start of a this Range
+ *       fcr_end              Last FCode number in this Range that has
+ *                                actually been assigned.  0 if none made yet.
+ *       fcr_infile           File name of where this Range was started
+ *       fcr_linenum          Line number where this Range was started
+ *       fcr_not_lapped       TRUE if an overlap error has not been reported
+ *                                against this Range.  Use this to prevent
+ *                                issuing an Error message every time an
+ *                                overlapping FCode is assigned; once per
+ *                                Range is sufficient.
+ *       fcr_next             Pointer to following entry in linked-list.
+ *
+ *   We will keep the list of assigned FCode Ranges as a forward-linked,
+ *       rather than the more usual backward-linked, list for convenience
+ *       at listing-time.  Otherwise, it doesn't make much difference.
+ *
+ **************************************************************************** */
+
+typedef struct fcode_range
+    {
+        u16                 fcr_start;
+	u16                 fcr_end ;
+	char               *fcr_infile;
+	int                 fcr_linenum;
+	bool                fcr_not_lapped;
+	struct fcode_range *fcr_next;
+    }  fcode_range_t ;
+
+
+/* **************************************************************************
+ *
+ *          Internal Static Variables
+ *     ranges_exist              TRUE if FCode Ranges have been created;
+ *                                   Prevents unnecessary overlap checking.
+ *     changes_listed            TRUE if no changes to any of the Ranges
+ *                                   have taken place since the last time
+ *                                   a Listing was displayed.  Prevents
+ *                                   unnecessary repetions (e.g., if a
+ *                                    reset_fcode_ranges()  was called
+ *                                   right after an operation that causes
+ *                                   a Listing
+ *
+ *          These four apply if no FCode Ranges have been created:
+ *
+ *     range_start               First FCode in the current first (only) range.
+ *     range_end                 Last FCode in current first (only) range that
+ *                                   has actually been assigned.  0 if none yet.
+ *     first_fcr_infile          File name of where first (only) range started.
+ *     first_fcr_linenum         Line number where first (only) range started.
+ *
+ *          These two apply after FCode Ranges have been created:
+ *
+ *     first_fc_range            Pointer to the first entry in the linked
+ *                                   list of FCode Ranges.
+ *     current_fc_range          Pointer to the entry in the linked list of
+ *                                   Ranges that contains the Current Range.
+ *
+ **************************************************************************** */
+
+static bool           ranges_exist      = FALSE;
+static bool           changes_listed    = FALSE;
+
+static u16            range_start       = FCODE_START;
+static u16            range_end         = 0;
+static char          *first_fcr_infile  = NULL;
+static int            first_fcr_linenum = 0;
+
+static fcode_range_t *first_fc_range    = NULL;
+static fcode_range_t *current_fc_range  = NULL;
+
+/* **************************************************************************
+ *
+ *      Function name:  reset_fcode_ranges
+ *      Synopsis:       (Re-)Initialize the range of assignable FCode numbers
+ *                          and clear the records of prevously-assigned Ranges
+ *
+ *      Inputs:
+ *         Parameters:                  NONE
+ *         Global Variables:
+ *             iname                    Name of current input file
+ *             lineno                   Line Number within current input file
+ *         Local Static Variables:
+ *             ranges_exist             TRUE if FCode Ranges have been created
+ *             first_fc_range           Pointer to First FCode Range
+ *             current_fc_range         Pointer to the current Range
+ *
+ *      Outputs:
+ *         Returned Value:              NONE
+ *         Global Variables:
+ *             nextfcode                Initialized to Standard start value
+ *                                          for user-assigned FCodes
+ *         Local Static Variables:
+ *             ranges_exist             Cleared to FALSE
+ *             changes_listed           Reset to FALSE
+ *             range_start              Reset to Standard start value
+ *             range_end                Reset to 0
+ *             first_fcr_infile         Copy of iname
+ *             first_fcr_linenum        Copy of lineno
+ *             first_fc_range           Reset to NULL
+ *             current_fc_range         Reset to NULL
+ *         Memory Allocated
+ *             For  first_fcr_infile , which will have a copy of  iname
+ *         When Freed?
+ *             The next time this routine is called.
+ *         Memory Freed
+ *             Any FCode Ranges that were in effect will be freed, and the
+ *                 memory for their  fcr_infile  fields will be freed.
+ *             If  iname  has changed, memory for  first_fcr_infile  will
+ *                 be freed before the new copy is made.
+ *
+ *      Process Explanation:
+ *          This will be called either as part of normal initialization
+ *              or in response to a User-issued directive.
+ *          In the former case, it may be called twice:  once before any
+ *              Source is examined, and once again in response to the first
+ *              (and only to the first) invocation of an FCode-Starter, at
+ *              which time the input file name and line number will be updated.
+ *          In the latter case, the calling routine will be responsible for
+ *              displaying any Advisory Messages and listings of previously
+ *              assigned FCode Ranges.
+ *
+ **************************************************************************** */
+
+void reset_fcode_ranges( void)
+{
+    if ( ranges_exist )
+    {
+	while ( current_fc_range != NULL )
+	{
+	    current_fc_range = first_fc_range->fcr_next;
+	    free( first_fc_range->fcr_infile);
+	    free( first_fc_range);
+	    first_fc_range = current_fc_range;
+	}
+	ranges_exist = FALSE;
+    }else{
+	if ( first_fcr_infile != NULL )
+	{
+	    if ( strcmp( first_fcr_infile, iname) != 0 )
+	    {
+		free( first_fcr_infile);
+		first_fcr_infile = NULL;
+	    }
+	}
+    }
+
+    changes_listed    = FALSE;
+    range_start       = FCODE_START;
+    range_end         = 0;
+
+    if ( first_fcr_infile == NULL )
+    {
+	first_fcr_infile = strdup( iname);
+    }
+    first_fcr_linenum = lineno;
+    nextfcode         = FCODE_START;
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  list_fcode_ranges
+ *      Synopsis:       Display an Advisory of assigned FCode ranges at
+ *                          end of tokenization or upon reset_fcodes() 
+ *
+ *      Inputs:
+ *         Parameters:
+ *             final_tally               TRUE if printing a final tally at
+ *                                           end of tokenization.  
+ *         Global Variables:
+ *             verbose                   Do not print anything if not set.
+ *             nextfcode                 FCode next after last-assigned
+ *         Local Static Variables:
+ *             changes_listed            If TRUE, only print new-line.
+ *             ranges_exist              TRUE if more than one Range exists.
+ *             range_start               FCode at start of only range
+ *             range_end                 Last FCode in only range; 0 if none.
+ *             first_fc_range            Ptr to start of FCode Ranges list
+ *
+ *      Outputs:
+ *         Returned Value:               NONE
+ *         Local Static Variables:
+ *             changes_listed           Set to TRUE. 
+ *         Printout:
+ *            Printed to Standard Out on final tally, or to STDERR otherwise.
+ *            One of three formats:
+ *            1   No FCodes assigned.
+ *            2   Last assigned FCode = 0xXXX
+ *            3   FCodes assigned:
+ *                    [ No FCodes assigned in the range that started ... ]
+ *                    [ From 0xXXX to 0xYYY ** in the range that started ... ]
+ *                        (** = Indicator if the Range has an Overlap Error.)
+ *
+ *      Process Explanation:
+ *          This is called to complete an Advisory or Standard-Out Message
+ *              that doesn't end in a new-line.
+ *
+ *      Extraneous Remarks:
+ *          If we ever decide not to keep entries for Ranges in which no
+ *              assignments were made, let's not remove the code that lists
+ *              them.  It's harmless to keep it around, and we remain ready...
+ *
+ **************************************************************************** */
+
+void list_fcode_ranges( bool final_tally)
+{
+    if ( verbose )
+    {
+	FILE *message_dest = ( final_tally ? stdout : ERRMSG_DESTINATION );
+	if ( changes_listed )
+	{
+	    fprintf(message_dest, "\n");
+	}else{
+	    changes_listed = TRUE;
+
+	    if ( INVERSE(ranges_exist) )
+	    {   /*  List the first and only range  */
+		if ( range_end == 0 )
+		{
+		    fprintf(message_dest, "No FCodes assigned.\n");
+		}else{
+		    if ( range_start == FCODE_START )
+		    {
+			fprintf(message_dest,
+			    "Last assigned FCode = 0x%x\n", range_end);
+		    }else{
+			fprintf(message_dest,
+			    "FCodes assigned:  0x%x to 0x%x\n",
+				range_start, range_end);
+		    }
+		}
+		/*  We are done listing the first and only range  */
+	    }else{   /*  List the collection of Ranges  */
+
+		/*  Pionter to function returning void  */
+		typedef void (*vfunct)();
+
+		/*  Function for the  started_at()  part of the message  */
+		vfunct start_at_funct =
+	            ( final_tally ? print_started_at : started_at );
+
+
+		fcode_range_t *next_range = first_fc_range;
+
+		fprintf(message_dest, "FCodes assigned:\n");
+
+		while ( next_range != NULL )
+		{
+		    if ( next_range->fcr_end == 0 )
+		    {
+			fprintf(message_dest, "    None assigned");
+		    }else{
+			fprintf(message_dest, "    From 0x%x to 0x%x",
+			    next_range->fcr_start, next_range->fcr_end );
+			if ( INVERSE( next_range->fcr_not_lapped) )
+			{
+			    fprintf(message_dest, " ***Overlap***" );
+			}
+		    }
+		    fprintf(message_dest, " in the range");
+		    (*start_at_funct)(
+			next_range->fcr_infile, next_range->fcr_linenum );
+
+		    next_range = next_range->fcr_next;
+		}
+	    }
+	}
+    }
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  set_next_fcode
+ *      Synopsis:       Set the start of a new Range of FCode numbers
+ *
+ *      Inputs:
+ *         Parameters:
+ *             new_fcode                 Start of the new range of FCodes
+ *         Global Variables:
+ *             nextfcode                 The next FCode-number to be assigned
+ *             iname                     Name of current input file
+ *             lineno                    Line Number within current input file
+ *         Local Static Variables:
+ *             ranges_exist              TRUE if FCode Ranges have been created
+ *             range_start               First FCode in the current (first
+ *                                           and only) range
+ *             range_end                 Last FCode in only range; 0 if none.
+ *             current_fc_range          Pointer to the current Range if there
+ *                                           are more than one.
+ *
+ *      Outputs:
+ *         Returned Value:               NONE
+ *         Global Variables:
+ *             nextfcode                 Set to the start of the new range
+ *         Local Static Variables:
+ *             ranges_exist              May be set to TRUE
+ *             first_fc_range            May be initialized
+ *             current_fc_range          May be initialized or moved
+ *             first_fcr_infile          May be updated, may be made NULL
+ *             first_fcr_linenum         May be updated, may be made irrelevant
+ *             range_start               May be set to start of the new range
+ *                                           or rendered irrelevant
+ *             range_end                 Reset to 0 (by  reset_fcode_ranges() )
+ *             changes_listed            Reset to FALSE
+ *         Memory Allocated
+ *             For new Range data structure; for copy of  iname
+ *         When Freed?
+ *             By reset_fcode_ranges()
+ *
+ *      Error Detection:
+ *          Not here.
+ *          The calling routine will detect and report attempts to set an
+ *             illegal new range. 
+ *          Overlap with earlier Ranges will be detected and reported when
+ *              the FCode is actually Assigned.
+ *
+ *      Process Explanation:
+ *          The calling routine will not call this routine with a new starting
+ *              FCode that is not legal per the Standard.
+ *          It may call with a new starting FCode that is equal to  nextfcode
+ *          If no Ranges exist yet, and the new starting FCode is equal to
+ *              the current value of  nextfcode , this is a continuation of
+ *              the first and only range; do not change the file name or line
+ *              number; just go away.
+ *          If no Ranges exist yet, and no FCode assignments have been made
+ *              in the current range, then this is a new start for the first
+ *              and only range; detect the latter condition by range_end == 0
+ *              Call the  reset_fcode_ranges()  routine to update the file name
+ *              and line number, then update the remaining variables for the
+ *              current (first and only) range, and you are done here.
+ *          If no Ranges exist yet, and if FCode assignments _have_ been made
+ *              in the current (first and only) range, create a data structure
+ *              for the first (and now no longer only) Range and point both
+ *              the  first_fc_range  and  current_fc_range  pointers at it.
+ *              Set the  ranges_exist  flag to TRUE.
+ *          If Ranges exist, whether from being newly-created, above, or from
+ *              earlier, create a data structure for the new Current Range
+ *              and move the  current_fc_range  pointer to point at it.  If
+ *              the new starting FCode is equal to  nextfcode  we still want
+ *              to create a new Range that will be listed separately.
+ *          If no assignments were made within the Current Range, we will not
+ *              overwrite or delete it; it will be listed at the appropriate
+ *              time, and will be harmless in the overlap test.
+ *
+ *      Extraneous Remarks:
+ *          We will trade off the strict rules of structured code here,
+ *              in exchange for ease of coding.
+ *
+ **************************************************************************** */
+
+void set_next_fcode( u16  new_fcode)
+{
+    if ( INVERSE( ranges_exist) )
+    {    /*  The current range is the first and only.  */
+
+	if ( new_fcode == nextfcode )
+	{
+	    /*  Do nothing here  */
+	    return;
+	}
+
+	if ( range_end == 0 )
+	{   /*  No FCode assignments have been made in the current range  */
+	    /*  This is still the first and only range.                   */
+
+	    reset_fcode_ranges();   /*  Update file name and line number  */
+	    range_start = new_fcode;
+	    nextfcode = new_fcode;
+
+	    /*  We are done here  */
+	    return;
+
+	}else{  /*  Create the data structure for the first Range  */
+	    first_fc_range = safe_malloc( sizeof( fcode_range_t),
+				 "creating first FCode Range" );
+	    first_fc_range->fcr_start        = range_start;
+	    first_fc_range->fcr_end          = range_end;
+	    first_fc_range->fcr_infile       = first_fcr_infile;
+	    first_fc_range->fcr_linenum      = first_fcr_linenum;
+	    first_fc_range->fcr_not_lapped   = TRUE;
+	    first_fc_range->fcr_next         = NULL;
+
+	    first_fcr_infile  = NULL;
+	    first_fcr_linenum = 0;
+	    range_start       = FCODE_START;
+	    range_end         = 0;
+
+	    current_fc_range  = first_fc_range;
+
+	    ranges_exist      = TRUE;
+	}
+    }
+
+    /*  Previous Ranges exist now for sure!  */
+    current_fc_range->fcr_next  = safe_malloc( sizeof( fcode_range_t),
+				      "creating new FCode Range" );
+    current_fc_range = current_fc_range->fcr_next;
+
+    nextfcode                         = new_fcode;
+    current_fc_range->fcr_start       = nextfcode;
+    current_fc_range->fcr_end         = 0;
+                                  /*  Will be filled in by first assignment  */
+    current_fc_range->fcr_infile      = strdup( iname);
+    current_fc_range->fcr_linenum     = lineno;
+    current_fc_range->fcr_not_lapped  = TRUE;
+    current_fc_range->fcr_next        = NULL;
+
+    changes_listed                    = FALSE;
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  find_overlap
+ *      Synopsis:       Compare the FCode under test against existing
+ *                          FCode Ranges and return a pointer to the
+ *                          Range against which it overlaps, if any.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             test_fcode                 FCode to be tested
+ *         Global Variables:
+ *             
+ *         Local Static Variables:
+ *             ranges_exist               If not TRUE, no need to test
+ *             first_fc_range             Start of Ranges to test
+ *             current_fc_range           Do not test Current Range
+ *
+ *      Outputs:
+ *         Returned Value:                Pointer to FCode Range in which an
+ *                                            overlap exists, or NULL if none.
+ *
+ *      Error Detection:
+ *          The calling routine will treat any findings as it deems appropriate.
+ *
+ *      Process Explanation:
+ *          A Range within which no assignments were made will never "hit"
+ *              the overlap test because its  fcr_end  field will be zero
+ *              and its  fcr_start  field will be non-zero; there's no
+ *              number that will be "between" them!
+ *
+ **************************************************************************** */
+
+static fcode_range_t *find_overlap( u16 test_fcode)
+{
+    fcode_range_t *retval = NULL;
+    if ( ranges_exist )
+    {
+	fcode_range_t *test_range = first_fc_range;
+	while ( test_range != current_fc_range )
+	{
+	    if ( ( test_fcode <= test_range->fcr_end ) &&
+	         ( test_fcode >= test_range->fcr_start )  )
+	    {
+		retval = test_range;
+		break;
+	    }
+	    test_range = test_range->fcr_next;
+	}
+    }
+
+    return( retval);
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  assigning_fcode
+ *      Synopsis:       Commit the next FCode number to be assigned;
+ *                          test for out-of-bounds, overlap, etc. errors.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             
+ *         Global Variables:
+ *             nextfcode
+ *         Local Static Variables:
+ *             ranges_exist         TRUE if FCode Ranges have been created
+ *             first_fc_range       First entry in linked list of Ranges.
+ *             current_fc_range     List entry for Current Range.
+ *
+ *      Outputs:
+ *         Returned Value:                  NONE
+ *         Global Variables:
+ *         Local Static Variables:
+ *             changes_listed               Reset to FALSE
+ *                    One of these two will be set to  nextfcode 
+ *             range_end                       ... if  ranges_exist  is FALSE
+ *             current_fc_range->fcr_end       ... if  ranges_exist  is TRUE
+ *
+ *      Error Detection:
+ *          FATAL if the value of  nextfcode  is larger than the legal
+ *              maximum for an FCode
+ *          ERROR if the value of  nextfcode   falls within one of the
+ *              existing Ranges (other than the current one, of course)
+ *
+ **************************************************************************** */
+
+void assigning_fcode( void)
+{
+    if ( nextfcode > FCODE_LIMIT )
+    {
+	/*  Let's give a last summarization before we crap out */
+	tokenization_error( INFO, "");
+	list_fcode_ranges( FALSE);
+
+	tokenization_error( FATAL,
+	    "Too many definitions.  "
+	    "Assigned FCode exceeds limit "
+	    "specified by IEEE-1275.");
+	/*
+	 *  No need to  return()  from here.
+	 *  FATAL error exits program.
+	 */
+    }
+
+    changes_listed = FALSE;
+
+    if ( INVERSE(ranges_exist) )
+    {    /*  No Overlap Error checking needed here.  */
+	range_end = nextfcode;
+    }else{
+	current_fc_range->fcr_end = nextfcode;
+
+	/*   Detect and report Overlap Error only once per Range  */
+	if ( current_fc_range->fcr_not_lapped )
+	{
+	    fcode_range_t *found_lap = find_overlap( nextfcode);
+	    if ( found_lap != NULL )
+	    {
+		tokenization_error( TKERROR,
+		    "Assigning FCode of 0x%x, "
+			"which overlaps the range", nextfcode);
+		started_at( found_lap->fcr_infile, found_lap->fcr_linenum);
+
+		current_fc_range->fcr_not_lapped = FALSE;
+	    }
+	}
+    }
+
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  bump_fcode
+ *      Synopsis:       Increment the next assignable FCode number
+ *                          prior to the next assignment.
+ *
+ *      Inputs:
+ *         Parameters:                   NONE
+ *         Global Variables:
+ *             nextfcode                 The next FCode-number to be assigned
+ *
+ *      Outputs:
+ *         Returned Value:               NONE
+ *         Global Variables:
+ *             nextfcode                 Incremented
+ *
+ *      Extraneous Remarks:
+ *          This looks like a no-brainer now, but if we ever need this
+ *              function to perform any more sophisticated background
+ *              activity, we can limit the scope of our modifications
+ *              to this routine.
+ *
+ **************************************************************************** */
+
+void bump_fcode( void)
+{
+    nextfcode++;
+}
diff --git a/toke/nextfcode.h b/toke/nextfcode.h
new file mode 100644
index 0000000..062bd1a
--- /dev/null
+++ b/toke/nextfcode.h
@@ -0,0 +1,80 @@
+#ifndef _TOKE_NEXTFCODE_H
+#define _TOKE_NEXTFCODE_H
+
+/*
+ *                     OpenBIOS - free your system!
+ *                         ( FCode tokenizer )
+ *
+ *  This program is part of a free implementation of the IEEE 1275-1994
+ *  Standard for Boot (Initialization Configuration) Firmware.
+ *
+ *  Copyright (C) 2001-2005 Stefan Reinauer, <stepan@openbios.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ *
+ */
+
+/* **************************************************************************
+ *
+ *      Function Prototypes for Managing FCode Assignment Pointer 
+ *         and for Detection of Overlapping-FCode Error in Tokenizer
+ *
+ *      (C) Copyright 2006 IBM Corporation.  All Rights Reserved.
+ *      Module Author:  David L. Paktor    dlpaktor@us.ibm.com
+ *
+ **************************************************************************** */
+
+#include "types.h"
+
+
+/* ************************************************************************** *
+ *
+ *      Global Variables Exported
+ *
+ **************************************************************************** */
+
+extern u16  nextfcode;         /*  The next FCode-number to be assigned      */
+
+
+/* ************************************************************************** *
+ *
+ *      Function Prototypes / Functions Exported:
+ *
+ **************************************************************************** */
+
+void reset_fcode_ranges( void);
+void list_fcode_ranges( bool final_tally);
+void set_next_fcode( u16  new_fcode);
+void assigning_fcode( void);
+void bump_fcode( void);
+
+/* **************************************************************************
+ *
+ *          Macros:
+ *
+ *          FCODE_START             Standard-specified starting number for
+ *                                      user-generated FCodes.
+ *
+ *          FCODE_LIMIT             Standard-specified maximum number for
+ *                                      FCodes of any origin.
+ *
+ *      I know these are not likely to change, but I still feel better
+ *          making them named symbols, just on General Principles...
+ *
+ **************************************************************************** */
+
+#define FCODE_START  0x0800
+#define FCODE_LIMIT  0x0fff
+
+#endif   /*  _TOKE_NEXTFCODE_H    */
diff --git a/toke/parselocals.c b/toke/parselocals.c
new file mode 100644
index 0000000..84f460a
--- /dev/null
+++ b/toke/parselocals.c
@@ -0,0 +1,944 @@
+/*
+ *                     OpenBIOS - free your system!
+ *                         ( FCode tokenizer )
+ *
+ *  This program is part of a free implementation of the IEEE 1275-1994
+ *  Standard for Boot (Initialization Configuration) Firmware.
+ *
+ *  Copyright (C) 2001-2005 Stefan Reinauer, <stepan@openbios.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ *
+ */
+
+/* **************************************************************************
+ *
+ *      Parsing functions for IBM-style Local Values
+ *
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Module Author:  David L. Paktor    dlpaktor@us.ibm.com
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      Functions Exported:
+ *          declare_locals      Pick up the Locals' names after the {
+ *          handle_local        Insert the code to access a Local
+ *          exists_as_local     Confirm whether a name is in the Locals vocab
+ *          assign_local        Process the "Assign to a Local" operator ( -> )
+ *          finish_locals       Insert the code for exiting a routine
+ *                                  that uses locals
+ *          forget_locals       Remove the locals' names from the search   
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *          These are the names of the three routines that will be invoked
+ *          when Locals are used.  Their definitions exist in a separate
+ *          Local Values Support FCode source-file that must be FLOADed
+ *          into the user's tokenization source.
+ *
+ **************************************************************************** */
+
+/*  Note that the enclosing curly-braces are part of the name  */
+static const char* push_locals = "{push-locals}"; /* ( #ilocals #ulocals -- ) */
+static const char* pop_locals = "{pop-locals}";   /* ( #locals -- )           */
+static const char* local_addr = "_{local}";       /* ( local# -- addr )       */
+
+/*  Switchable Fetch or Store operator to apply to  local_addr.   */
+static const char* local_op = "@";   /*  Initially Fetch  */
+
+
+/* **************************************************************************
+ *
+ *      Revision History:
+ *          Updated Wed, 13 Jul 2005 by David L. Paktor
+ *              Command-line control for:
+ *                  Support for Locals in general
+ *                  Whether to accept the "legacy" separator (semicolon)
+ *                  Whether to issue a message for the "legacy" separator
+ *          Updated Tue, 10 Jan 2006 by David L. Paktor
+ *              Convert to  tic_hdr_t  type vocabulary.
+ *
+ **************************************************************************** */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "ticvocab.h"
+#include "dictionary.h"
+#include "scanner.h"
+#include "parselocals.h"
+#include "errhandler.h"
+#include "clflags.h"
+#include "stream.h"
+#include "devnode.h"
+#include "flowcontrol.h"
+
+/* **************************************************************************
+ *
+ *      Global Variables Imported
+ *          statbuf
+ *          pc    
+ *          opc
+ *          incolon
+ *          lastcolon
+ *          ibm_locals_legacy_separator      Accept ; as the "legacy" separator
+ *          ibm_legacy_separator_message     Issue a message for "legacy" sep'r
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *          Internal Static Variables
+ *              local_names        Vocabulary for new local-names
+ *              num_ilocals        Number of initialized local variables
+ *              num_ulocals        Number of uninitialized local variables
+ *              localno            Running Local-Number to be assigned
+ *              eval_buf           Internally-generated string to be parsed
+ *              l_d_lineno         Locals Declaration Line Number
+ *
+ **************************************************************************** */
+
+static tic_hdr_t *local_names = NULL;
+static int num_ilocals = 0;
+static int num_ulocals = 0;
+static int localno = 0;
+static char eval_buf[64];
+static unsigned int l_d_lineno;  	/*  For Error Messages   */
+
+/* **************************************************************************
+ *
+ *     The  local_names  vocabulary follows the same  tic_hdr_t   structure
+ *         as the dictionaries of tokens, special-functions, etcetera.   Its
+ *         "parameter field" is an integer, used to store the Local's number,
+ *         an its "function" is invoke_local(), defined further below.
+ *
+ *     The vocabulary is initially empty, so there's no need for an "init"
+ *         or a "reset" routine.
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      Function name:  int_to_str
+ *      Synopsis:       Convert an integer into a compilable string.
+ *                      Suport routine for invoke_local().
+ *
+ *      Inputs:
+ *         Parameters:
+ *             num             The number to convert
+ *             bufr            The buffer into which to place it.
+ *                                 Needn't be very long:
+ *                                 five at least, ten is enough
+ *
+ *      Outputs:
+ *         Returned Value:     Pointer to  bufr
+ *             bufr            Contents are changed.
+ *
+ *      Process Explanation:
+ *          Convert into decimal.  If the number is greater than 8,
+ *              prepend a  d#  in front of it.  If less, don't.
+ *              We specifically want to avoid a  d#  in front of
+ *              the numbers 0 1 2 and 3, which are also named constants;
+ *              there's no need to treat 'em as literals.
+ *          The calling routine will be responsible for allocating
+ *              and freeing the buffer.
+ *
+ *      Extraneous Remarks:
+ *          Too bad  atoi()  isn't a Standard C function; I could convert
+ *             using the current base, and be guaranteed that it would be
+ *             interpreted in the same base.
+ *          Instead, I have to fiddle-faddle around with  d#  ...
+ *
+ **************************************************************************** */
+
+static char *int_to_str( int num, char *bufr)
+{
+     char* prefix = "d# ";
+     if ( num < 8 ) prefix = "";
+     sprintf(bufr,"%s%d",prefix, num);
+     return (bufr);
+}
+
+
+
+/* **************************************************************************
+ *
+ *      Function name:  invoke_local
+ *      Synopsis:       Compile-in the code to access the Local whose
+ *                      assigned Number is given.  This function is
+ *                      entered into the Local-Names Vocabulary entry.
+ *      
+ *      Inputs:
+ *         Parameters:
+ *             pfield              The Vocabulary entry's Param field, taken
+ *                                     from the Assigned Number of the Local.
+ *         Local Static Variables:
+ *             local_addr          Name of  _{local}  routine, invoked
+ *                                     when a Local is used 
+ *             local_op            Fetch or Store operator to apply.
+ *
+ *      Outputs:
+ *         Returned Value:         None
+ *         Local Static Variables:
+ *             eval_buf            Phrase constructed here; will become new
+ *                                     Source Input Buffer, temporarily
+ *
+ *      Error Detection:
+ *          If the Local Values Support FCode source-file was not
+ *              FLOADed into the user's tokenization source, then
+ *              the function  _{local}  will be an "unknown name".
+ *
+ *      Process Explanation:
+ *          We are going to generate a string of the form:
+ *                  " #local _{local} OP"
+ *              and pass it to the Parser for evaluation.
+ *          The call to  _{local}  is preceded by its parameter, which is
+ *               its Assigned Local-Number, and followed by the appropriate
+ *               OPerator, which will be "Fetch" if the Local's name was
+ *               invoked by itself, or "Store" if its invocation was made
+ *               in conjuction with the  ->  operator.
+ *          The string-buffer may be local, but it must be stable.
+ *
+ *      Revision History:
+ *      Updated Thu, 24 Mar 2005 by David L. Paktor
+ *          Factored-out to permit  lookup_local()  to be a "pure"
+ *          function that can be used for duplicate-name detection.
+ *      Updated Tue, 10 Jan 2006 by David L. Paktor
+ *          Accommodate conversion to  tic_hdr_t  type vocabulary.
+ *
+ **************************************************************************** */
+
+static void invoke_local( tic_param_t pfield )
+{
+    char local_num_buf[10];
+    int loc_num = (int)pfield.deflt_elem;
+
+    int_to_str(loc_num, local_num_buf);
+    sprintf( eval_buf, "%s %s %s", local_num_buf, local_addr, local_op );
+    eval_string( eval_buf);
+
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  locals_separator
+ *      Synopsis:       Test whether the given character is the separator
+ *                          between initted and uninitted Local Names.
+ *                      Optionally, allow Semi-Colon as a separator and issue
+ *                          an optional Advisory.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             subj     One-character "subject" of the test
+ *         Global Variables:    
+ *             ibm_locals_legacy_separator     Allow Semi-Colon as a separator?
+ *             ibm_legacy_separator_message    Issue an Advisory message?
+ *
+ *      Outputs:
+ *         Returned Value:   TRUE if the character is the separator
+ *
+ *      Error Detection:
+ *          If the separator is Semi-Colon, and  ibm_locals_legacy_separator 
+ *              is TRUE, then if  ibm_legacy_separator_message  is TRUE,
+ *              issue an Advisory message.
+ *          If the flag to allow Semi-Colon is FALSE, then simply do not
+ *              acknowledge a valid separator.  Other routines will report
+ *              an erroneous attempt to use an already-defined symbol.
+ *
+ *      Revision History:
+ *          Updated Wed, 13 Jul 2005 by David L. Paktor
+ *          Bring the questions of whether to accept semicolon as a separator
+ *              -- and whether to issue a message for it -- under the control 
+ *              of external flags (eventually set by command-line switches),
+ *              rather than being hard-compiled.
+ *
+ *      Extraneous Remarks:
+ *          In the interest of avoiding too deeply nested "IF"s, I will
+ *              not be adhering strictly to the rules of structure.
+ *
+ **************************************************************************** */
+
+static bool locals_separator( char subj )
+{
+    bool retval = FALSE;
+    /*  Is it the preferred (i.e., non-legacy) separator?   */
+    if ( subj == '|' )
+    {  
+	retval = TRUE;
+	return ( retval );
+    }
+	
+    if ( ibm_locals_legacy_separator )
+    {
+	if ( subj == ';' )
+	{
+	    retval = TRUE;
+	    if ( ibm_legacy_separator_message )
+	    {
+		tokenization_error ( WARNING , "Semicolon as separator in "
+		    "Locals declaration is deprecated in favor of '|'\n");
+	    }
+	}
+    }
+    return ( retval );
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  add_local
+ *      Synopsis:       Given a pointer to a name and a number, enter
+ *                      them into the vocabulary for new Local names.
+ *      
+ *      Inputs:
+ *         Parameters:
+ *             lnum              The assigned number
+ *             lname             Pointer to the name
+ *         Local Static Variables:
+ *             local_names       The vocabulary for new Local names
+ *
+ *      Outputs:
+ *         Returned Value:       NONE
+ *         Local Static Variables:
+ *             local_names       Enter the new Local's name and number.
+ *         Memory Allocated:
+ *             A place into which the name will be copied
+ *         When Freed?
+ *             When  forget_locals()  routine frees up all memory
+ *                 allocations in the "Local Names" Vocabulary.
+ *
+ *      Process Explanation:
+ *          Allocate a stable place in memory for the name, via  strdup().
+ *          The entry's "action" will be the  invoke_local()  function,
+ *              defined above.  The "parameter field" size is zero.
+ *
+ **************************************************************************** */
+
+static void add_local( TIC_P_DEFLT_TYPE lnum, char *lname)
+{
+    char *lnamecopy ;
+
+    lnamecopy = strdup( lname);
+    add_tic_entry( lnamecopy, invoke_local, lnum,
+		       LOCAL_VAL, 0, NULL, &local_names );
+    trace_creation( LOCAL_VAL, lname);
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  gather_locals
+ *      Synopsis:       Collect Local names, for both initted and uninitted
+ *                      Return an indication as to whether to continue
+ *                      gathering Locals' names
+ *      
+ *      Inputs:
+ *         Parameters:
+ *             initted        TRUE if we are gathering initted Local names.
+ *             counter        Pointer to variable that's counting names.
+ *         Global Variables:
+ *             statbuf        The symbol just retrieved from the input stream.
+ *         Local Static Variables:
+ *             localno        Running Local-Number to be assigned
+ *             l_d_lineno     Line # of Locals Declar'n start (for err mssg)
+ *
+ *      Outputs:
+ *         Returned Value:    TRUE = Ended with initted/uninitted separator
+ *         Local Static Variables:
+ *             localno        Incremented for each Local name declared
+ *             local_names    Enter the new locals' names into the Vocabulary.
+ *                            Numeric field is assigned local number.
+ *
+ *      Error Detection:
+ *          A Local-name that duplicates an existing name is an ERROR.
+ *              Especially if that name is <Semicolon> and the flag
+ *              called  ibm_locals_legacy_separator  was not set.
+ *          Issue an Error if close-curly-brace terminator is not found,
+ *              or if imbedded comment is not terminated, before end of file.
+ *          If the Separator is found a second-or-more time, issue an Error
+ *              and continue collecting uninitted Local names.
+ *
+ *      Revision History:
+ *      Updated Thu, 24 Mar 2005 by David L. Paktor
+ *          Allow comments to be interspersed among the declarations.
+ *          Error-check duplicate Local-name.
+ *      Updated Wed, 30 Mar 2005 by David L. Paktor
+ *          Warning when name length exceeds ANSI-specified max (31 chars). 
+ *      Updated Thu, 07 Jul 2005 by David L. Paktor
+ *          Protect against PC pointer-overrun due to unterminated
+ *              comment or declaration.
+ *          Error-check for numbers.
+ *          No name-length check; doesn't go into FCode anyway.
+ *
+ **************************************************************************** */
+
+static bool gather_locals( bool initted, int *counter )
+{
+    signed long wlen;
+    bool retval = FALSE;
+
+    while ( TRUE )
+    {
+        wlen = get_word();
+
+	if ( wlen <= 0 )
+	{
+	    warn_unterm( TKERROR, "Local-Values Declaration", l_d_lineno);
+	    break;
+	}
+
+	/*  Allow comments to be interspersed among the declarations.  */
+	if ( filter_comments( statbuf) )
+	{
+	    /*  Unterminated and Multi-line checking already handled   */
+	    continue;
+	}
+	/*  Is this the terminator or the separator? */
+	if ( wlen == 1 )    /*  Maybe   */
+	{
+	    /*  Check for separator   */
+	    if (locals_separator( statbuf[0] ) )
+	    {
+	        /*  If gathering initted Local names, separator is legit  */
+	        if ( initted )
+		{
+		    retval = TRUE;
+		    break;
+		}else{
+		    tokenization_error ( TKERROR,
+		        "Excess separator -- %s -- found "
+			    "in Local-Values declaration", statbuf);
+		    in_last_colon();
+		    continue;
+		}
+	    }
+	    /*  Haven't found the separator.  Check for the terminator  */
+	    if ( statbuf[0] == '}' )
+	    {
+		break;
+	    }
+	}
+	/*  It was not the terminator or the separator  */
+	{
+	    long tmp;
+	    char *where_pt1;  char *where_pt2;
+	    /*  Error-check for duplicated names  */
+	    if ( word_exists ( statbuf, &where_pt1, &where_pt2 ) )
+	    {
+		tokenization_error ( TKERROR, "Cannot declare %s "
+		    "as a Local-Name; it's already defined %s%s",
+			statbuf, where_pt1, where_pt2 );
+		show_node_start();
+		continue;
+	    }
+	    /*  Error-check for numbers.  */
+	    if ( get_number(&tmp) )
+	    {
+		tokenization_error ( TKERROR, "Cannot declare %s "
+		    "as a Local-Name; it's a number.\n", statbuf );
+		continue;
+	    }
+
+	    /*  We've got a valid new local-name    */
+	    /*  Don't need to check name length; it won't go into the FCode  */
+
+	    /*  Increment our counting-v'ble  */
+	    *counter += 1;
+
+	    /*  Define our new local-name in the Locals' vocabulary  */
+	    add_local( localno, statbuf );
+
+	    /*  Bump the running Local-Number  */
+	    localno++;
+
+	}
+    }
+    return ( retval );
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  activate_locals
+ *      Synopsis:       Compile-in the call to  {push-locals}  that
+ *                      the new definition under construction will need,
+ *                      now that the Locals have been declared.
+ *      
+ *      Inputs:
+ *         Parameters:                NONE
+ *         Global Variables:
+ *             num_ilocals              First argument to  {push-locals}
+ *             num_ulocals              Second argument to  {push-locals}
+ *             push_locals              Name of  {push-locals}  routine.
+ *
+ *      Outputs:
+ *         Returned Value:            NONE
+ *         Local Static Variables:
+ *             eval_buf               Phrase constructed here; will become
+ *                                        new Source Input Buffer, temporarily
+ *
+ *      Error Detection:
+ *          If the Local Values Support FCode source-file was not
+ *              FLOADed into the user's tokenization source, then
+ *              the function  {push-locals}  will be an "unknown name".
+ *
+ *      Process Explanation:
+ *          We are going to generate a string of the form:
+ *                  " #ilocals #ulocals {push-locals}"
+ *              and pass it to the Parser for evaluation.
+ *          The string-buffer may be local, but it must be stable.
+ *
+ *      Question under consideration.:
+ *          Do we want to check if  {push-locals}  is an unknown name,
+ *              and give the user a hint of what's needed?  And, if so,
+ *              do we do it only once, or every time?
+ *
+ **************************************************************************** */
+
+static void activate_locals( void )
+{
+    char ilocals_buf[10];
+    char ulocals_buf[10];
+     
+    int_to_str(num_ilocals, ilocals_buf ); 
+    int_to_str(num_ulocals, ulocals_buf );
+    sprintf( eval_buf,"%s %s %s",ilocals_buf, ulocals_buf, push_locals);
+    eval_string( eval_buf);
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  error_check_locals
+ *      Synopsis:       Indicate whether Locals declaration is erronious
+ *      
+ *      Inputs:
+ *         Parameters:     NONE
+ *         Global Variables:
+ *             incolon             TRUE if colon def'n is in effect.
+ *             opc                 FCode Output buffer Position Counter
+ *             lastcolon           Value of opc when Colon def'n was started
+ *
+ *      Outputs:
+ *         Returned Value:         TRUE if found errors severe enough to
+ *                                     preclude further processing of Decl'n
+ *
+ *      Errors Detected:
+ *           Colon definition not in effect.  ERROR and return TRUE.
+ *           Locals declaration inside body of colon-definition (i.e., after
+ *                something has been compiled-in to it) is potentially risky,
+ *                but may be valid, and is a part of legacy practice.  It
+ *                will not be treated as an outright ERROR, but it will
+ *                generate a WARNING...
+ *           Multiple locals declarations inside a single colon-definition
+ *                are completely disallowed.  ERROR and return TRUE.
+ *           Locals declaration inside a control-structure is prohibited.
+ *                Generate an ERROR, but return FALSE to allow processing
+ *                of the declaration to continue.
+ *
+ **************************************************************************** */
+
+/*  The value of  lastcolon  when Locals Declaration is made.
+ *      If it's the same, that detects multiple locals declaration attempt.
+ */
+static int last_local_colon = 0;
+
+static bool error_check_locals ( void )
+{
+    bool retval = FALSE;
+    
+    if ( ! incolon )
+    {
+	tokenization_error ( TKERROR,
+	    "Can only declare Locals inside of a Colon-definition.\n");
+        retval = TRUE;
+    } else {
+	if ( last_local_colon == lastcolon )
+	{
+	    tokenization_error ( TKERROR, "Excess Locals Declaration");
+	    in_last_colon();
+	    retval = TRUE;
+	}else{
+            last_local_colon = lastcolon;
+	    if ( opc > lastcolon )
+	    {
+		tokenization_error ( WARNING,
+		    "Declaring Locals after the body of a Colon-definition "
+		    "has begun is not recommended.\n");
+	    }
+	    announce_control_structs( TKERROR,
+		"Local-Values Declaration encountered",
+		    last_colon_abs_token_no);
+	}
+    }
+    return ( retval );
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  declare_locals
+ *      Synopsis:       Process (or Ignore) the Declaration of Locals,
+ *                          upon encountering Curly-brace ( {  )
+ *      
+ *      Inputs:
+ *         Parameters:
+ *             ignoring            TRUE if "Ignoring"
+ *         Global Variables:
+ *             statbuf             Next symbol to process.
+ *             lineno              Current Line Number in Input File
+ *             report_multiline    FALSE to suspend multiline warning
+ *
+ *      Outputs:
+ *         Returned Value:         NONE
+ *         Global Variables:
+ *             statbuf             Advanced to end of Locals Declaration.
+ *             pc                  Bumped past the close-curly-brace
+ *         Local Static Variables:
+ *             localno             Init'd, then updated by gather_locals()
+ *             l_d_lineno          Line Number of start of Locals Declaration
+ *
+ *      Error Detection:
+ *          See  error_check_locals()
+ *              After Error messages, will bypass further processing until the
+ *                  terminating close-curly-brace of a Locals Declaration.
+ *                  If the terminating close-curly-brace missing under those
+ *                  circumstances, issue an Error
+ *              If terminating close-curly-brace is missing when the Locals
+ *                  Declaration is otherwise valid, gather_locals() will
+ *                  detect and report the Error.
+ *              Warning if multiline declaration.  Because embedded comments
+ *                  may also supppress the multiline warning, we need to save
+ *                  and restore the state of the report_multiline switch...
+ *
+ **************************************************************************** */
+
+void declare_locals ( bool ignoring)
+{
+    num_ilocals = 0;
+    num_ulocals = 0;
+    localno = 0;
+    
+    l_d_lineno = lineno;
+    bool sav_rep_mul_lin = report_multiline;
+    report_multiline = TRUE;
+
+    if ( ignoring || error_check_locals() )
+    {
+       if ( skip_until ( '}' ) )
+       {
+	   warn_unterm(TKERROR,
+	       "misplaced Local-Values Declaration", l_d_lineno);
+       }else{
+	   pc++ ;  /*  Get past the close-curly-brace  */
+       }
+    }else{
+       if (gather_locals( TRUE,  &num_ilocals ) )
+       {
+	   gather_locals( FALSE, &num_ulocals );
+       }
+    }
+
+    /*  If PC has reached the END,  gather_locals()  will
+     *      have already issued an "unterminated" Error;
+     *      a "multiline" warning would be redundant
+     *      repetitive, unnecessary, excessive, unaesthetic
+     *      and -- did I already mention? -- redundant.
+     */
+    if ( pc < end )
+    {
+	report_multiline = sav_rep_mul_lin;
+	warn_if_multiline( "Local-Values declaration", l_d_lineno);
+    }
+
+    /*  Don't do anything if no Locals were declared    */
+    /*  This could happen if the  {  }  field is empty  */
+    if ( localno != 0 )
+    {
+	activate_locals();
+    }
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  handle_local
+ *      Synopsis:       Process the given name as a Local Name;
+ *                      indicate if it was a valid Local Name.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             lname                The "Local" name for which to look
+ *         Local Static Variables:  
+ *             local_names          The vocabulary for Local names
+ *
+ *      Outputs:
+ *         Returned Value:          TRUE if the name is a valid "Local Name"
+ *
+ **************************************************************************** */
+
+static bool handle_local( char *lname)
+{
+    bool retval = handle_tic_vocab( lname, local_names );
+    return ( retval ) ;
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  lookup_local
+ *      Synopsis:       Return a pointer to the data-structure of the named
+ *                      word, only if it was a valid Local Name.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             lname                The "Local" name for which to look
+ *         Local Static Variables:  
+ *             local_names          The vocabulary for Local names
+ *
+ *      Outputs:
+ *         Returned Value:          Pointer to the data-structure, or
+ *                                      NULL if not found.
+ *
+ **************************************************************************** */
+
+tic_hdr_t *lookup_local( char *lname)
+{
+    tic_hdr_t *retval = lookup_tic_entry( lname, local_names );
+    return ( retval ) ;
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  create_local_alias
+ *      Synopsis:       Create an alias in the "Local Names" Vocabulary
+ *
+ *      Associated FORTH word:              ALIAS
+ *
+ *      Inputs:
+ *         Parameters:
+ *             old_name             Name of existing entry
+ *             new_name             New name for which to create an entry
+ *
+ *      Outputs:
+ *         Returned Value:          TRUE if  old_name  found in "Locals" vocab
+ *         Global Variables:    
+ *             local_names          Will point to the new entry
+ *         Memory Allocated:
+ *             Memory for the new entry, by the support routine
+ *         When Freed?
+ *             When  forget_locals()  routine frees up all memory
+ *                 allocations in the "Local Names" Vocabulary.
+ *
+ **************************************************************************** */
+
+bool create_local_alias(char *new_name, char *old_name)
+{
+    bool retval = create_tic_alias( new_name, old_name, &local_names );
+    return ( retval );
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  exists_as_local
+ *      Synopsis:       Simply confirm whether a given name exists
+ *                      within the Locals vocabulary.
+ *      
+ *      Inputs:
+ *         Parameters:
+ *             stat_name          Name to look up
+ *
+ *      Outputs:
+ *         Returned Value:        TRUE if stat_name was a Local
+ *
+ **************************************************************************** */
+
+bool exists_as_local( char *stat_name )
+{
+    bool retval = exists_in_tic_vocab(stat_name, local_names );
+    return ( retval );
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  assign_local
+ *      Synopsis:       Process the "Assign to a Local" operator ( -> )
+ *      
+ *      Inputs:
+ *         Parameters:             NONE
+ *         Global Variables:
+ *             statbuf          Next symbol to process
+ *             pc               Input-source Scanning pointer
+ *             lineno           Input-source Line Number. Used for Err Mssg.
+ *
+ *      Outputs:
+ *         Returned Value:         NONE
+ *         Global Variables:
+ *             statbuf          Advanced to next symbol
+ *             pc               Advanced; may be unchanged if error.
+ *             lineno           Advanced; may be unchanged if error
+ *             local_op         Will be set to Store and then reset to Fetch.
+ *         Global Behavior:
+ *             Construct a phrase and pass it to the Tokenizer.
+ *
+ *      Error Detection:
+ *          If next symbol is not a Local name, print ERROR message    
+ *              and restore  pc  so that the next symbol will be    
+ *              processed by ordinary means.
+ *          In the extremely unlikely case that -> is last symbol in  
+ *              the source-file, report an ERROR.
+ *
+ *      Process Explanation:
+ *          Save the PC.
+ *          Get the next symbol; check for end-of-file.
+ *          Set Local Operator ( local_op ) to "Store", to prepare to apply it.
+ *          Pass the next symbol to  handle_local() .
+ *          If  handle_local()  failed to find the name, you have
+ *              detected an error; restore  pc .
+ *          Otherwise, you have invoked the local and applied "Store" to it.
+ *          At the end, reset  local_op  to "Fetch".
+ *
+ **************************************************************************** */
+
+void assign_local ( void )
+{
+    signed long wlen;
+    bool is_okay;
+    u8 *savd_pc = pc;
+    unsigned int savd_lineno = lineno;
+
+    wlen = get_word();
+
+	if ( wlen <= 0 )
+	{
+	    warn_unterm(TKERROR, "Locals Assignment", lineno);
+	    return;
+	}
+
+    local_op = "!";   /*  Set to Store  */
+
+    is_okay = handle_local( statbuf);
+    if( INVERSE(is_okay)  )
+    {
+        tokenization_error ( TKERROR,
+	    "Cannot apply -> to %s, only to a declared Local.\n", statbuf );
+        pc = savd_pc;
+	lineno = savd_lineno;
+    }
+    local_op = "@";   /*  Reset to Fetch  */
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  finish_locals
+ *      Synopsis:       Compile-in the call to  {pop-locals}  that the
+ *                      new definition under construction will need
+ *                      when it's about to complete execution, i.e.,
+ *                      before an EXIT or a SemiColon.  But only if the
+ *                      current definition under construction is using Locals.
+ *      
+ *      Inputs:
+ *         Parameters:       NONE
+ *             
+ *         Local Static Variables:
+ *             localno            Total # of Locals.
+ *                                    Both a param to  {pop-locals} 
+ *                                    and an indicator that Locals are in use.
+ *             pop_locals         Name of  {pop-locals}  routine.
+ *
+ *      Outputs:
+ *         Returned Value:        NONE
+ *         Local Static Variables:
+ *             eval_buf            Phrase constructed here; will become new
+ *                                     Source Input Buffer, temporarily
+ *
+ *      Error Detection:
+ *          If the Local Values Support FCode source-file was not
+ *              FLOADed into the user's tokenization source, then
+ *              the function  {pop-locals}  will be an "unknown name".
+ *
+ *      Revision History:
+ *          Updated Fri, 24 Feb 2006 by David L. Paktor
+ *              The eval_string() routine no longer calls its own
+ *                  instance of  tokenize() .  In order to make a
+ *                  smooth transition between the processing the
+ *                  internally-generated string and the resumption
+ *                  of processing the source file, it simply sets
+ *                  up the string to be processed next.
+ *              In this case, however, we need to have the string
+ *                  processed right away, as the calling routine
+ *                  emits a token that must follow those generated
+ *                  by this.
+ *              Fortunately, we know the exact contents of the string.
+ *                  Two calls to tokenize_one_word() will satisfy the
+ *                  requirement.
+ *
+ **************************************************************************** */
+
+void finish_locals ( void )
+{
+     /*    Don't do anything if Locals are not in use    */
+    if ( localno > 0 )
+    {
+        char nlocals_buf[10];
+     
+        int_to_str(localno, nlocals_buf ); 
+        sprintf( eval_buf,"%s %s",nlocals_buf, pop_locals);
+        eval_string( eval_buf);
+	tokenize_one_word( get_word() );
+	tokenize_one_word( get_word() );
+    }
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  forget_locals
+ *      Synopsis:       Remove the Locals' names from the special Vocabulary
+ *                      free-up their allocated memory, and reset the Locals'
+ *                      counters (which are also the indication that Locals
+ *                      are in use).  This is done at the time a SemiColon
+ *                      is processed.  But only if the current definition
+ *                      under construction is using Locals.
+ *      
+ *      Inputs:
+ *         Parameters:              NONE
+ *         Local Static Variables:
+ *             local_names          The vocabulary for new Local names
+ *
+ *      Outputs:
+ *         Returned Value:          NONE
+ *         Local Static Variables:
+ *             local_names          Emptied and pointing at NULL.
+ *             num_ilocals          Reset to zero
+ *             num_ulocals              ditto
+ *             localno                  ditto
+ *         Memory Freed
+ *             All memory allocations in the "Local Names" Vocabulary.
+ *
+ **************************************************************************** */
+
+void forget_locals ( void )
+{
+     /*    Don't do anything if Locals are not in use    */
+    if ( localno != 0 )
+    {
+        reset_tic_vocab( &local_names, NULL ) ;
+
+        num_ilocals = 0;
+        num_ulocals = 0;
+        localno = 0;
+    }
+}
diff --git a/toke/parselocals.h b/toke/parselocals.h
new file mode 100644
index 0000000..90e3d7a
--- /dev/null
+++ b/toke/parselocals.h
@@ -0,0 +1,48 @@
+#ifndef _TOKE_LOCALX_H
+#define _TOKE_LOCALX_H
+
+/*
+ *                     OpenBIOS - free your system!
+ *                         ( FCode tokenizer )
+ *
+ *  This program is part of a free implementation of the IEEE 1275-1994
+ *  Standard for Boot (Initialization Configuration) Firmware.
+ *
+ *  Copyright (C) 2001-2005 Stefan Reinauer, <stepan@openbios.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ *
+ */
+
+/* **************************************************************************
+ *
+ *     Function Prototypes / External definitions for Parsing
+ *          functions for IBM-style Local Values in Tokenizer
+ *
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Module Author:  David L. Paktor    dlpaktor@us.ibm.com
+ *
+ **************************************************************************** */
+
+#include "ticvocab.h"
+
+void declare_locals ( bool ignoring);
+tic_hdr_t *lookup_local( char *lname);
+bool exists_as_local( char *stat_name );
+bool create_local_alias(char *new_name, char *old_name);
+void assign_local ( void );
+void finish_locals ( void );
+void forget_locals ( void );
+
+#endif   /*  _TOKE_LOCALX_H    */
diff --git a/toke/scanner.c b/toke/scanner.c
index 0acd6ca..030f667 100644
--- a/toke/scanner.c
+++ b/toke/scanner.c
@@ -24,6 +24,12 @@
  *
  */
 
+/* **************************************************************************
+ *         Modifications made in 2005 by IBM Corporation
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Modifications Author:  David L. Paktor    dlpaktor@us.ibm.com
+ **************************************************************************** */
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
@@ -34,74 +40,596 @@
 #include <time.h>
 #include <ctype.h>
 
-#include "toke.h"
+#include "macros.h"
 #include "stack.h"
 #include "stream.h"
 #include "emit.h"
+#include "toke.h"
 #include "dictionary.h"
+#include "vocabfuncts.h"
+#include "scanner.h"
+#include "errhandler.h"
+#include "tokzesc.h"
+#include "conditl.h"
+#include "flowcontrol.h"
+#include "usersymbols.h"
+#include "clflags.h"
+#include "devnode.h"
+#include "tracesyms.h"
+#include "nextfcode.h"
 
-#define ERROR    do { if (!noerrors) exit(-1);  } while (0)
-
-extern u8 *start, *pc, *end, *opc, *ostart;
-extern int verbose, noerrors;
+#include "parselocals.h"
 
-u8   *statbuf=NULL;
-u16  nextfcode;
-u8   base=0x0a;
+/* **************************************************************************
+ *
+ *  Some VERY IMPORTANT global variables follow
+ *
+ **************************************************************************** */
 
-/* header pointers */
-u8  *fcode_hdr=NULL;
-u8  *pci_hdr=NULL;
+u8  *statbuf=NULL;      /*  The word just read from the input stream  */
+u8   base=0x0a;         /*  The numeric-interpretation base           */
 
 /* pci data */
 bool pci_is_last_image=TRUE;
-bool pci_want_header=FALSE;
-u16  pci_revision=0x0001;
+u16  pci_image_rev=0x0001;  /*  Vendor's Image, NOT PCI Data Structure Rev */
 u16  pci_vpd=0x0000;
 
-bool offs16=TRUE;
-static bool intok=FALSE, incolon=FALSE;
-bool haveend=FALSE;
 
-static u8 *skipws(u8 *str)
+/*  Having to do with the state of the tokenization  */
+bool offs16       = TRUE;    /*  We are using 16-bit branch- (etc) -offsets */
+bool in_tokz_esc  = FALSE;   /*  TRUE if in "Tokenizer Escape" mode   */
+bool incolon      = FALSE;   /*  TRUE if inside a colon definition    */
+bool haveend      = FALSE;   /*  TRUE if the "end" code was read.     */
+int do_loop_depth = 0;       /*  How deep we are inside DO ... LOOP variants  */
+
+/*  Used for error-checking of IBM-style Locals  */
+int lastcolon;   /*  Location in output stream of latest colon-definition. */
+
+/*  Used for error reporting   */
+char *last_colon_defname = NULL;   /*  Name of last colon-definition        */
+char *last_colon_filename = NULL;  /*  File where last colon-def'n made     */
+unsigned int last_colon_lineno;    /*  Line number of last colon-def'n      */
+bool report_multiline = TRUE;      /*  False to suspend multiline warning   */
+unsigned int last_colon_abs_token_no;
+
+/* **************************************************************************
+ *  Local variables
+ **************************************************************************** */
+static u16  last_colon_fcode;  /*  FCode-number assigned to last colon-def'n  */
+                               /*      Used for RECURSE  */
+
+static bool do_not_overload = TRUE ;  /*  False to suspend dup-name-test     */
+static bool got_until_eof = FALSE ;   /*  TRUE to signal "unterminated"      */
+
+static unsigned int last_colon_do_depth = 0;
+
+/*  State of headered-ness for name-creation  */
+typedef enum headeredness_t {
+       FLAG_HEADERLESS ,
+       FLAG_EXTERNAL ,
+       FLAG_HEADERS }  headeredness ;
+static headeredness hdr_flag = FLAG_HEADERLESS ;  /*  Init'l default state  */
+
+/*  Local variables having to do with:                                      */
+/*       ...  the state of the tokenization                                 */
+static bool is_instance = FALSE;        /*  Is "instance" is in effect?     */
+static char *instance_filename = NULL;  /*  File where "instance" invoked   */
+static unsigned int instance_lineno;    /*  Line number of "instance"       */
+static bool fcode_started = FALSE ;     /*  Only 1 fcode_starter per block. */
+static bool first_fc_starter = TRUE;    /*  Only once per tokenization...   */
+
+/*       ... with the state of the input stream,                            */
+static bool need_to_pop_source;
+
+/*       ... with the use of the return stack,                              */
+static int ret_stk_depth = 0;          /*  Return-Stack-Usage-Depth counter */
+
+/*       ... and with control of error-messaging.                           */
+           /*  Should a warning about a dangling "instance" 
+	    *      be issued at the next device-node change?
+	    */
+static bool dev_change_instance_warning = TRUE;
+
+           /*  Has a gap developed between "instance" and its application?  */
+static bool instance_definer_gap = FALSE;
+
+           /*  Shared phrases                                               */
+static char *in_tkz_esc_mode = "in Tokenizer-Escape mode.\n";
+
+
+/* **************************************************************************
+ *
+ *      Function name:  skip_ws
+ *      Synopsis:       Advance the PC past all whitespace.
+ *                      Protect against pointer over-runs 
+ *
+ *      Inputs:
+ *         Parameters:                  NONE
+ *         Global Variables:        
+ *             pc                       Input-source Scanning pointer
+ *             end                      End of input-source buffer
+ *
+ *      Outputs:
+ *         Returned Value:      TRUE if PC reached END before non-blank char
+ *         Global Variables:    
+ *             pc            Advanced to first non-blank char, or to END  
+ *             lineno        Incremented if encountered new-line along the way
+ *
+ *      Error Detection:
+ *          Return a TRUE if End of input-source buffer reached before
+ *              non-blank character.  Not necessarily an error; allow
+ *              calling routine to decide...
+ *
+ **************************************************************************** */
+
+static bool skip_ws(void)
 {
-	while (str && (*str=='\t' || *str==' ' || *str=='\n' )) {
-		if (*str=='\n') 
-			lineno++;
-		str++;
+    bool retval = TRUE;
+    char ch_tmp;
+
+    for (  ; pc < end; pc++ )
+{
+        ch_tmp = *pc;
+	if ( (ch_tmp != '\t') && (ch_tmp != ' ') && (ch_tmp != '\n' ) )
+	{
+	    retval = FALSE;
+	    break;
+	}
+        if ( ch_tmp == '\n')  lineno++;
+    }
+    return ( retval );
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  skip_until
+ *      Synopsis:       Advance the PC to the given character.
+ *                      Do not copy anything into statbuf.
+ *                      Protect against pointer over-runs 
+ *
+ *      Inputs:
+ *         Parameters:
+ *             lim_ch                   Limiting Character
+ *         Global Variables:        
+ *             pc                       Input-source Scanning pointer
+ *             end                      End of input-source buffer
+ *
+ *      Outputs:
+ *         Returned Value:      TRUE if PC reached END before finding LIM_CH
+ *         Global Variables:    
+ *             pc            Advanced to first occurrence of LIM_CH, or to END  
+ *             lineno        Incremented if encountered new-line along the way
+ *
+ *      Error Detection:
+ *          Return a TRUE if End of input-source buffer reached before
+ *              desired character.  Not necessarily an error; allow calling
+ *              routine to decide...
+ *
+ **************************************************************************** */
+
+bool skip_until( char lim_ch)
+{
+    bool retval = TRUE;
+    char ch_tmp;
+
+    for (  ; pc < end; pc++ )
+    {
+        ch_tmp = *pc;
+        if ( ch_tmp == lim_ch )
+	{
+	    retval = FALSE;
+	    break;
+	}
+        if ( ch_tmp == '\n')  lineno++;
 	}
+    return ( retval );
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  get_until
+ *      Synopsis:       Return, in  statbuf, the string from  PC  to the first
+ *                      occurrence of the given delimiter-character..
+ *
+ *      Inputs:
+ *         Parameters:
+ *             needle          The given delimiter-character
+ *         Global Variables:
+ *             pc              Input-source Scanning Pointer
+ *
+ *      Outputs:
+ *         Returned Value:     Length of the string obtained
+ *         Global Variables:
+ *             statbuf         The string obtained from the input stream;
+ *                                 does not include the delimiter-character.
+ *             pc              Bumped past the delimiter-character, unless
+ *                                 it's a new-line, in which case leave it
+ *                                 to be handled by  get_word()
+ *         Local Static Variables:
+ *             got_until_eof   Pass this as a signal that the end of the
+ *                                 buffer was reached before the delimiter;
+ *                                 Testing whether PC has reached END is
+ *                                 not a sufficient indication.
+ *
+ *      Error Detection:
+ *          If string overflows  statbuf  allocation, ERROR, and 
+ *              return "no string" (i.e., length = 0).
+ *          Otherwise, if delimiter not found before eof, keep string.
+ *              Protection against PC pointer-over-run past END is
+ *              provided by  skip_until() .  Reaching END will be
+ *              handled by calling routine; pass indication along
+ *              via Local Static Variable.
+ *
+ *      Process Explanation:
+ *          Skip the delimiter-character from further input, unless it's a
+ *              new-line which will be skipped anyway.  Let  skip_until() 
+ *              and  get_word()  handle incrementing line-number counters.
+ *          If skip_until()  indicated reaching end-of-file, don't bump PC
+ *
+ *      Revision History:
+ *          Updated Thu, 14 Jul 2005 by David L. Paktor
+ *              More robust testing for when PC exceeds END 
+ *                  Involved replacing  firstchar()
+ *
+ **************************************************************************** */
 	
-	return str;
+static signed long get_until(char needle)
+{                                                                               
+	u8 *safe;                                                         
+	unsigned long len = 0;
+
+	safe=pc;
+
+	got_until_eof = skip_until(needle);
+
+	len = pc - safe;
+	if (len >= GET_BUF_MAX )
+	{
+	    tokenization_error( TKERROR,
+		"get_until buffer overflow.  Max is %d.\n", GET_BUF_MAX-1 );
+	    len = GET_BUF_MAX-1;
 }
 
-static u8 *firstchar(u8 needle, u8 *str)
+	memcpy(statbuf, safe, len);
+	statbuf[len]=0;
+
+	if ( INVERSE(got_until_eof) )
 {
-	while (str && *str!=needle) {
-		if (*str=='\n') 
-			lineno++;
-		str++;
+	    if ( needle != '\n' )  pc++;
+	}
+	return len;
+}
+
+
+/* **************************************************************************
+ *
+ *          We are going to use a fairly sophisticated mechanism to
+ *              make a smooth transition between processing the body
+ *              of a Macro, a User-defined Symbol or an FLOADed file 
+ *              and the resumption of processing the source file, so
+ *              that the end-of-file will only be seen at the end of
+ *              the primary input file (the one from the command-line).
+ *         This mechanism will be tied in with the get_word() routine
+ *
+ *         We are going to define a private data-structure in which
+ *              we will save the state of the current source file,
+ *              and from which, of course, we will recover it.  Its
+ *              fields will be:
+ *                   A pointer to the next structure in the list.
+ *                   The saved values of  START  END  and  PC
+ *                   The saved values of  INAME  and  LINENO
+ *                   A flag indicating that get-word should "pause"
+ *                        before popping the source-stream because
+ *                        the input file will be changing.
+ *                   A place from which to save and recover the state of
+ *                        whether we're testing for "Multi-line" strings;
+ *                        to prevent undeserved "Multi-line" warnings
+ *                        during Macro processing.
+ *                   A pointer to a "resumption" routine, to call
+ *                        when resuming processing the source file;
+ *                        the routine takes a pointer parameter
+ *                        and has no return value.  The pointer
+ *                        may be NULL if no routine is needed.
+ *                   The pointer to pass as the parameter to the
+ *                        resumption routine.
+ *
+ **************************************************************************** */
+
+typedef struct source_state
+    {
+	struct source_state   *next;
+	u8                    *old_start;
+	u8                    *old_pc;
+	u8                    *old_end;
+	char                  *old_iname;
+	unsigned int           old_lineno;
+	bool                   pause_before_pop;
+	bool                   sav_rep_multlin;
+	void                 (*resump_func)();
+	_PTR                   resump_param;
+    } source_state_t ;
+
+static source_state_t  *saved_source = NULL;
+
+
+/* **************************************************************************
+ *
+ *      Function name:  push_source
+ *      Synopsis:       Save the state of the current source file, in the
+ *                          source_state data-structure LIFO linked-list.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             res_func              Pointer to routine to call when resuming
+ *                                       processing the saved source file.
+ *             res_param             Parameter to pass to res_func.
+ *                                   Either or both pointers may be NULL.
+ *             file_chg              TRUE if input file is going to change.
+ *         Global Variables:
+ *             start                 Points to current input buffer
+ *             end                   Points to end of current input buffer
+ *             pc                    Input point in current buffer
+ *             iname                 Name of current source file
+ *             lineno                Line number in current source file
+ *             report_multiline      Whether we're testing for "Multi-line"
+ *         Local Static Variables:
+ *             saved_source          Pointer to the source_state data-structure
+ *
+ *      Outputs:
+ *         Returned Value:           NONE
+ *         Local Static Variables:
+ *             saved_source          Points to new source_state entry
+ *         Memory Allocated
+ *             for the new source_state entry
+ *         When Freed?
+ *             When resuming processing the source file, by drop_source().
+ *
+ *      Process Explanation:
+ *          The calling routine will establish the new input buffer via
+ *              a call to init_inbuf() or the like.
+ *
+ **************************************************************************** */
+
+void push_source( void (*res_func)(), _PTR res_parm, bool file_chg )
+{
+    source_state_t  *new_sav_src;
+
+    new_sav_src = safe_malloc( sizeof(source_state_t), "pushing Source state");
+
+    new_sav_src->next = saved_source;
+    new_sav_src->old_start = start;
+    new_sav_src->old_pc = pc;
+    new_sav_src->old_end = end;
+    new_sav_src->old_iname = iname;
+    new_sav_src->old_lineno = lineno;
+    new_sav_src->pause_before_pop = file_chg;
+    new_sav_src->sav_rep_multlin = report_multiline;
+    new_sav_src->resump_func = res_func;
+    new_sav_src->resump_param = res_parm;
+
+    saved_source = new_sav_src;
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  drop_source
+ *      Synopsis:       Remove last saved state of source processing
+ *                          from the source_state LIFO linked-list,
+ *                          without (or after) restoring.
+ *
+ *      Inputs:
+ *         Parameters:               NONE
+ *         Local Static Variables:
+ *             saved_source          Pointer to the source_state data-structure
+ *
+ *      Outputs:
+ *         Returned Value:           NONE
+ *         Local Static Variables:
+ *             saved_source          Points to previous source_state entry
+ *         Memory Freed
+ *             Saved source_state entry that was just "dropped"
+ *
+ *      Error Detection:
+ *          None.  Called only when linked-list is known not to be at end.  
+ *
+ **************************************************************************** */
+
+static void drop_source( void)
+{
+    source_state_t  *former_sav_src = saved_source;
+
+    saved_source = saved_source->next ;
+    free( former_sav_src);
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  pop_source
+ *      Synopsis:       Restore the state of source processing as it was
+ *                          last saved in the source_state linked-list.
+ *
+ *      Inputs:
+ *         Parameters:               NONE
+ *         Local Static Variables:
+ *             saved_source          Pointer to the source_state data-structure
+ *             need_to_pop_source    If TRUE, don't check before popping.
+ *
+ *      Outputs:
+ *         Returned Value:           TRUE if reached end of linked-list
+ *         Global Variables:
+ *             start                 Points to restored input buffer
+ *             end                   Points to end of restored input buffer
+ *             pc                    Input point in restored buffer
+ *             iname                 Name of restored source file
+ *             lineno                Line number in restored source file
+ *             report_multiline      Restored to saved value.
+ *         Local Static Variables:
+ *             saved_source          Points to previous source_state entry
+ *             need_to_pop_source    TRUE if postponed popping till next time
+ *         Memory Freed
+ *             Saved source-state entry that was just "popped"
+ *
+ *      Process Explanation:
+ *          First check the need_to_pop_source flag.
+ *          If it is set, we will clear it and go ahead and pop.
+ *          If it is not set, we will check the  pause_before_pop  field
+ *                  of the top entry in the source_state linked-list.
+ *              If the  pause_before_pop  field is set, we will set the
+ *                  need_to_pop_source flag and return.
+ *              If it is not, we will go ahead and pop.
+ *          If we are going to go ahead and pop, we will call the
+ *              "Resume-Processing" routine (if it's not NULL) before
+ *              we restore the saved source state.
+ *
+ **************************************************************************** */
+
+static bool pop_source( void )
+{
+    bool retval = TRUE;
+
+    if ( saved_source != NULL )
+    {
+	retval = FALSE;
+	if ( need_to_pop_source )
+	{
+	    need_to_pop_source = FALSE;
+	}else{
+	    if ( saved_source->pause_before_pop )
+	    {
+	        need_to_pop_source = TRUE;
+		return( retval);
+	    }
+	}
+
+	if ( saved_source->resump_func != NULL )
+	{
+	    saved_source->resump_func( saved_source->resump_param);
 	}
+	report_multiline = saved_source->sav_rep_multlin;
+	lineno = saved_source->old_lineno ;
+	iname = saved_source->old_iname ;
+	end = saved_source->old_end ;
+	pc = saved_source->old_pc ;
+	start = saved_source->old_start ;
 
-	return str;
+	drop_source();
+    }
+    return( retval);
 }
 
-static unsigned long get_word(void)
+
+/* **************************************************************************
+ *
+ *      Function name:  get_word
+ *      Synopsis:       Gather the next "word" (aka Forth Token) from the
+ *                          input stream.
+ *                      A Forth Token is, of course, a string of characters
+ *                          delimited by white-space (blank, tab or new-line).
+ *                      Do not increment line-number counters here; leave
+ *                          the delimiter after the word unconsumed.
+ *
+ *      Inputs:
+ *         Parameters:                 NONE
+ *         Global Variables:
+ *             pc                      Input-stream Scanning Pointer
+ *         Local Static Variables:
+ *             need_to_pop_source      If TRUE, pop_source() as first step
+ *
+ *      Outputs:
+ *         Returned Value:             Length of "word" gotten;
+ *                                     0 if  reached end of file.
+ *                                     -1 if reached end of primary input
+ *                                         (I.e., end of all source)
+ *         Global Variables:
+ *             statbuf                 Copy of "gotten" word
+ *             pc                      Advanced to end of "gotten" word,
+ *                                         (i.e., the next word is "consumed")
+ *                                         unless returning zero.
+ *             abs_token_no            Incremented, if valid "word" (token)
+ *                                         was gotten.
+ *
+ *      Process Explanation:
+ *          Skip whitespace to the start of the token, 
+ *             then skip printable characters to the end of the token.
+ *          That part's easy, but what about when skipping whitespace
+ *              brings you to the end of the input stream?
+ *          First, look at the  need_to_pop_source  flag.  If it's set,
+ *              we came to the end of the input stream the last time
+ *              through.  Now we need to  pop_source()  first.
+ *          Next, we start skipping whitespace; this detects when we've
+ *                  reached the end of the input stream.  If we have,
+ *                  then we need to  pop_source()  again.
+ *              If  pop_source()  returned a TRUE, we've reached the end
+ *                  of the primary input file.  Return -1.
+ *              If  pop_source()  turned the  need_to_pop_source  flag
+ *                  to TRUE again, then we need to "pause" until the
+ *                  next time through; return zero.
+ *          Otherwise, we proceed with collecting the token as described.
+ *
+ *      Revision History:
+ *          Updated Thu, 23 Feb 2006 by David L. Paktor
+ *              Tied this routine in with a more sophisticated mechanism that
+ *                  makes a smooth transition between processing the body of
+ *                  a Macro, a User-defined Symbol or an FLOADed file, and 
+ *                  the resumption of processing the source file, so that the
+ *                  end-of-file will only be seen at the end of the primary
+ *                  input file (the one that came from the command-line)
+ *          Updated Fri, 24 Feb 2006 by David L. Paktor
+ *              This is trickier than I thought.  Added a global indicator
+ *                  of whether a file-boundary was crossed while getting
+ *                  the word; previously, that was indicated by a return
+ *                  value of zero, which now means something else...
+ *              The flag,  closed_stream , will be cleared every time this
+ *                  routine is entered, and set whenever close_stream() is
+ *                  entered.
+ *         Updated Tue, 28 Feb 2006 at 10:13 PST by David L. Paktor
+ *              Trickier still.  On crossing a file-boundary, must not
+ *                  consume the first word in the resumed file, for one
+ *                  call; instead, return zero.  Consume it on the next
+ *                  call.  The  closed_stream  flag is now irrelevant and
+ *                  has gone away.
+ *
+ **************************************************************************** */
+
+signed long get_word( void)
 {
 	size_t len;
 	u8 *str;
+	bool keep_skipping;
+	bool pop_result;
+
+	if ( need_to_pop_source )
+	{
+	    pop_result = pop_source();
+	}
 
-	pc=skipws(pc);
-	if (pc>=end)
+	do {
+	    keep_skipping = skip_ws();
+	    if ( keep_skipping )
+	    {
+		pop_result = pop_source();
+		if ( pop_result || need_to_pop_source )
+		{
+		    statbuf[0] = 0;
+		    if ( pop_result )
+		    {
+			return -1;
+		    }
 		return 0;
+		}
+	    }
+	} while ( keep_skipping );
 
 	str=pc;
-	while (str && *str && *str!='\n' && *str!='\t' && *str!=' ')
+	while ( (str < end) && *str && *str!='\n' && *str!='\t' && *str!=' ')
 		str++;
 
 	len=(size_t)(str-pc);
-	if (len>1023) {
-		printf("%s:%d: error: buffer overflow.\n", iname, lineno);
-		ERROR;
+	if (len >= GET_BUF_MAX )
+	{
+	    tokenization_error ( FATAL,
+		"get_word buffer overflow.  Max is %d.", GET_BUF_MAX-1 );
 	}
 
 	memcpy(statbuf, pc, len); 
@@ -112,39 +640,297 @@ static unsigned long get_word(void)
 			iname, lineno, statbuf, len);
 #endif
 	pc+=len;
+	abs_token_no++;
 	return len;
 }
 
-static unsigned long get_until(char needle)
+
+/* **************************************************************************
+ *
+ *      Function name:  get_word_in_line
+ *      Synopsis:       Get the next word on the same line as the current
+ *                      line of input.  If the end of line was reached
+ *                      before a word was found, print an error message
+ *                      and return an indication.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             func_nam        Name of the function expecting the same-line
+ *                                 input; for use in the Error Message.
+ *                                 If NULL, do not issue Error Message
+ *         Global Variables:
+ *             pc              Input character pointer.  Saved for comparison
+ *             lineno          Current input line number.  Saved for comparison
+ *
+ *      Outputs:
+ *         Returned Value:     TRUE = success.  Word was acquired on same line.
+ *         Global Variables:
+ *             statbuf         Advanced to the next word in the input stream.
+ *             pc              Advanced if no error; restored otherwise.
+ *
+ *      Error Detection:
+ *          If no next word is gotten (i.e., we're at end-of-file), or if
+ *              one is gotten but not on the same line, the routine will
+ *              return FALSE; if  func_nam  is not NULL, an ERROR Message
+ *              will be issued.
+ *          Also, the values of  PC  LINENO  and  ABS_TOKEN_NO  will be reset
+ *              to the positions they had when this routine was entered.
+ *
+ **************************************************************************** */
+
+bool get_word_in_line( char *func_nam)
 {                                                                               
-	u8 *safe;                                                         
-	unsigned long len;                                                      
+    signed long wlen;
+    bool retval = TRUE;
+    u8 *save_pc = pc;
+    unsigned int save_lineno = lineno;
+    unsigned int save_abs_token_no = abs_token_no;
 
-	safe=pc;
-	pc=firstchar(needle,safe);
-	if (pc>=end)
-		return 0;
+    /*  Copy of function name, for error message  */
+    char func_cpy[FUNC_CPY_BUF_SIZE+1];
+
+    /*  Do this first, in the likely event that  func_nam  was  statbuf   */
+    if ( func_nam != NULL )
+    {
+	strncpy( func_cpy, func_nam, FUNC_CPY_BUF_SIZE);
+	func_cpy[FUNC_CPY_BUF_SIZE] = 0;  /*  Guarantee a null terminator  */
+    }
+
+    wlen = get_word();
+    if ( ( lineno != save_lineno ) || ( wlen <= 0 ) )
+    {
+	abs_token_no = save_abs_token_no;
+	lineno = save_lineno;
+	pc = save_pc;
+	retval = FALSE;
+	if ( func_nam != NULL )
+	{
+	    tokenization_error ( TKERROR,
+	       "Operator %s expects its target on the same line\n",
+		   strupr(func_cpy));
+	}
+    }
+    return ( retval );
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  get_rest_of_line
+ *      Synopsis:       Get all the remaining text on the same line as
+ *                      the current line of input.  If there is no text
+ *                      (not counting whitespace) before the end of line,
+ *                      return an indication.
+ *
+ *      Inputs:
+ *         Parameters:         NONE
+ *         Global Variables:
+ *             pc              Input character pointer.  Saved for restoration
+ *             lineno          Current input line number.  Saved for comparison
+ *
+ *      Outputs:
+ *         Returned Value:     TRUE = success.  Text was acquired on same line.
+ *         Global Variables:
+ *             statbuf         Contains the text found in the input stream.
+ *             pc              Advanced to end of line or of whitespace, if
+ *                                 no error; restored otherwise.
+ *             lineno          Preserved if no error; otherwise, restored.
+ *             abs_token_no    Restored if error; otherwise, advanced as normal.
+ *
+ *      Error Detection:
+ *          Routine will return FALSE if no text is gotten on the same line.
+ *
+ **************************************************************************** */
+
+bool get_rest_of_line( void)
+{
+    bool retval = FALSE;
+    u8 *save_pc = pc;
+    unsigned int save_lineno = lineno;
+    unsigned int save_abs_token_no = abs_token_no;
+
+    if ( INVERSE( skip_ws() ) )
+    {
+        if ( lineno == save_lineno )
+	{
+	    signed long wlen = get_until('\n');
+	    if ( wlen > 0 ) retval = TRUE;
+	}else{
+	    abs_token_no = save_abs_token_no;
+	    lineno = save_lineno;
+	    pc = save_pc;
+	}
+    }
+    return( retval);
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  warn_unterm
+ *      Synopsis:       Message for "Unterminated ..." something
+ *                      Show saved line-number, where the "something" started,
+ *                      and the definition, if any, in which it occurred.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             severity              Type of error/warning message to display
+ *                                       usually either WARNING or TKERROR
+ *             something             String to print after "Unterminated"
+ *             saved_lineno          Line-Number where the "something" started
+ *         Global Variables:
+ *             lineno                Saved, then restored.
+ *             last_colon_defname    Used only if unterm_is_colon is TRUE;
+ *         Local Static Variables:
+ *             unterm_is_colon       See 07 Mar 2006 entry under Rev'n History
+ *
+ *      Outputs:
+ *         Returned Value:           NONE
+ *         Global Variables:
+ *             lineno                Saved, then restored.
+ *         Local Static Variables:
+ *             unterm_is_colon       Reset to FALSE
+ *         Printout:
+ *             Warning or Error message
+ *
+ *      Revision History:
+ *          Updated Mon, 06 Mar 2006 by David L. Paktor
+ *              Added call to in_last_colon()
+ *          Updated Tue, 07 Mar 2006 by David L. Paktor
+ *              Call to in_last_colon() works okay in most cases except for
+ *                  when the "something" is a Colon Definition; there, it
+ *                  results in the phrase: ... Definition in definition of ...
+ *                  which is awkward.  To eliminate that, I am introducing 
+ *                  a Local Static Variable flag called  unterm_is_colon
+ *                  which will be set only in the appropriate place and
+ *                  re-cleared here.  It's a retro-fit, of course; it could
+ *                  have been a parameter had the need for it occurred when
+ *                  this routine was first constructed... 
+ *
+ **************************************************************************** */
+
+static bool unterm_is_colon = FALSE;
+void warn_unterm( int severity, char *something, unsigned int saved_lineno)
+{
+    unsigned int tmp = lineno;
+    lineno = saved_lineno;
+    if ( unterm_is_colon )
+    {
+	tokenization_error( severity, "Unterminated %s of %s\n",
+	    something, strupr( last_colon_defname) );
+	unterm_is_colon = FALSE;
+    }else{
+	tokenization_error( severity, "Unterminated %s", something);
+	in_last_colon();
+    }
+    lineno = tmp;
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  warn_if_multiline
+ *      Synopsis:       Test for "Multi-line ..." something and issue WARNING
+ *                      Show saved line-number, where the "something" started
+ *
+ *      Inputs:
+ *         Parameters:
+ *             something          String to print after "Unterminated"
+ *             start_lineno       Line-Number where the "something" started
+ *         Global Variables:
+ *             lineno             Line-Number where we are now
+ *             iname              Input file name, to satisfy ...where_started()
+ *                                    (Not crossing any actual file boundary.)
+ *             report_multiline   TRUE = go ahead with the message
+ *
+ *      Outputs:
+ *         Returned Value:        NONE
+ *         Global Variables:
+ *             report_multiline   Restored to TRUE.
+ *
+ *      Error Detection:
+ *          Only issue message if the current  lineno  doesn't equal
+ *              the start_lineno  
+ *
+ *      Process Explanation:
+ *          The directive "multi-line" allows the user to specify that
+ *              the next "Multi-line ..." something is intentional, and
+ *              will cause its warning to be suppressed.  It remains in
+ *              effect until it's "used"; afterwards, it's reset.
+ *
+ **************************************************************************** */
+
+void warn_if_multiline( char *something, unsigned int start_lineno )
+{
+    if ( report_multiline && ( start_lineno != lineno ) )
+    {
+	tokenization_error( WARNING, "Multi-line %s, started", something);
+	where_started( iname, start_lineno);
+    }
+    report_multiline = TRUE;
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  string_remark
+ *      Synopsis:       Suspend string parsing past end of line and
+ *                      whitespace at start of the new line.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             errmsg_txt            Text to be used for error-message.
+ *         Global Variables:
+ *             pc                    Input-source Scanning pointer
+ *
+ *      Outputs:
+ *         Returned Value:           NONE
+ *         Global Variables:
+ *             pc                    Will point to first non-blank in new line
+ *
+ *      Error Detection:
+ *          The return value of the skip_until() or skip_ws() routine
+ *             will indicate if PC goes past END.  Issue a WARNING.
+ *             The calling routine will handle things from there.
+ *
+ **************************************************************************** */
 
-	len=(unsigned long)pc-(unsigned long)safe;
-	if (len>1023) {
-		printf("%s:%d: error: buffer overflow\n", iname, lineno);
-		ERROR;
+static void string_remark(char *errmsg_txt)
+{
+    unsigned int sav_lineno = lineno;
+    bool eof = skip_until('\n');
+    if ( ! eof )
+    {
+	eof = skip_ws();
+    }
+    if ( eof )
+    {
+	warn_unterm(WARNING, errmsg_txt, sav_lineno);
 	}
 	
-	memcpy(statbuf, safe, len);
-	statbuf[len]=0;
-	return len;
 }
 
+
+/*  Convert the given string to a number in the supplied base   */
+/*  Allow -- and ignore -- embedded periods.    */
+/*  The  endptr  param represents a pointer that will be updated
+ *      with the address of the first non-numeric character encountered,
+ *      (unless it is a NULL, in which case it is ignored).
+ */
+/*  There is no test for a completely invalid string;
+ *  the calling routine is responsible for ascertaining
+ *  the validity of the string being passed.
+ */
 static long parse_number(u8 *start, u8 **endptr, int lbase) 
 {
 	long val = 0;
-	int negative = 0, curr;
+	bool negative = FALSE ;
+	int  curr;
 	u8 *nptr=start;
 
 	curr = *nptr;
-	if (curr == '-') {
-		negative=1;
+	if (curr == '-')
+	{
+		negative = TRUE ;
 		nptr++;
 	}
 	
@@ -177,993 +963,4574 @@ static long parse_number(u8 *start, u8 **endptr, int lbase)
 		*endptr=nptr;
 
 	if (negative)
-		return -val;
+	{
+		val = -val;
+	}
 	return val;
 }
 
-static u8 *get_sequence(u8 *walk)
+/* **************************************************************************
+ *
+ *      Function name:  add_byte_to_string
+ *      Synopsis:       Add the given byte (or character) to the string
+ *                          being accumulated in statbuf, but protect
+ *                          against a buffer overflow.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             nu_byte           The given character to be added
+ *             walk              Pointer to pointer to the position
+ *                                   in  statbuf  where the character
+ *                                   is to be placed
+ *         Global Variables:
+ *             statbuf           Buffer where the string is accumulated
+ *         Macros:
+ *             GET_BUF_MAX       Size of the buffer
+ *
+ *      Outputs:
+ *         Returned Value:       NONE
+ *         Supplied Pointers:
+ *             **walk            Given character is placed here
+ *             *walk             Incremented in any case
+ *
+ *      Error Detection:
+ *          If  walk  has reached end of string buffer, do not place
+ *              the character, but continue to increment  walk .
+ *              Calling routine will detect overflow.
+ *
+ **************************************************************************** */
+				
+static void add_byte_to_string( u8 nu_byte, u8 **walk )
+{
+    if ( *walk - statbuf < GET_BUF_MAX )
+    {
+	**walk = nu_byte;
+	}
+    (*walk)++;
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  c_string_escape
+ *      Synopsis:       Process C-style escape syntax in strings
+ *
+ *      Inputs:
+ *         Parameters:
+ *             walk                    Pointer to pointer to area into
+ *                                         which to put acquired values
+ *         Global Variables:
+ *             pc                      Input-source Scanning pointer
+ *
+ *      Outputs:
+ *         Returned Value:             NONE
+ *         Global Variables:
+ *             pc                      Point to last character processed.
+ *         Supplied Pointers:
+ *             *walk                   Advanced by number of bytes acquired
+ *
+ *      Error Detection:
+ *          WARNING conditions.  See under "Process Explanation" below.
+ *
+ *      Process Explanation:
+ *          Start with  PC  pointing to the first character to process
+ *              i.e., after the backslash.
+ *          We recognize newline, tab and numbers
+ *          A digit-string in the current base can be converted to a number.
+ *          The first non-numeric character ends the numeric sequence
+ *              and gets swallowed up.
+ *          If the number exceeds the size of a byte, use the truncated
+ *          	value and issue a WARNING.
+ *          If the first character in the "digit"-string was non-numeric,
+ *              use the character literally and issue a WARNING.
+ *          If the character that ended the numeric sequence is a quote,
+ *              it might be the end of the string, or the start of a
+ *              special-character or even of an "( ... ) hex-sequence,
+ *              so don't swallow it up.
+ *
+ *      Still to be done:
+ *          Better protection against PC pointer-over-run past END.
+ *              Currently, this works, but it's held together by threads:
+ *              Because  init_stream  forces a null-byte at the end of
+ *              the input buffer, parse_number() exits immediately upon
+ *              encountering it.  This situation could be covered more
+ *              robustly...
+ *
+ **************************************************************************** */
+
+static void c_string_escape( u8 **walk)
 {
-	u8 val, pval[3];
+    char c = *pc;
+    u8 val;
+    /*  We will come out of this "switch" statement
+     *      with a value for  val  and a decision
+     *      as to whether to write it.
+     */
+    bool write_val = TRUE;
 	
-	pc++; /* skip the ( */
+    switch (c)
+    {
+			case 'n':
+				/* newline */
+	    val = '\n';
+				break;
+			case 't':
+				/* tab */
+	    val = '\t';
+				break;
+			default:
+
+	    /*  Digit-string?  Convert it to a number, using the current base.
+	     *  The first non-numeric character ends the numeric sequence
+	     *      and gets swallowed up.
+	     *  If the number exceeds the size of a byte, use the truncated
+	     *      value and issue a WARNING.
+	     *  If the first character in the "digit"-string was non-numeric,
+	     *      use the character literally and issue a WARNING.
+	     */
+
+	     /*
+	     *  If the sequence ender is a quote, it might be the end of
+	     *      the string, or the start of a special-character or even
+	     *      of an "( ... ) hex-sequence, so don't swallow it up.
+	     */
+	    {
+		long lval;
+		u8 *sav_pc = pc;
+		lval=parse_number(pc, &pc, base);
+		val = (u8)lval;
 #ifdef DEBUG_SCANNER
-	printf("%s:%d: debug: hex field:", iname, lineno);
+				if (verbose)
+					printf( "%s:%d: debug: escape code "
+						"0x%x\n",iname, lineno, val);
 #endif
-	pval[1]=0; pval[2]=0;
+		if ( lval > 0x0ff )
+		{
+		    tokenization_error ( WARNING,
+			"Numeric String after \\ overflows byte.  "
+			    "Using 0x%02x.\n", val);
+			}
+
+		if ( pc == sav_pc )
+		{
+		    /*  NOTE:  Here, PC hasn't been advanced past its
+		     *      saved value, so we can count on  C  remaining
+		     *      unchanged since the start of the routine.
+		     */ 
+		    /*  Don't use the null-byte at the end of the buffer  */
+		    if ( ( pc >= end ) 
+		    /*        or a sequence-ending quote.                 */
+			 || ( c == '"' ) )
+		    {
+			write_val = FALSE;
+		    }else{
+			/*  In the WARNING message, print the character
+			 *      if it's printable or show it in hex
+			 *      if it's not.
+			 */
+			if ( (c > 0x20 ) && ( c <= 0x7e) )
+			{
+			    tokenization_error ( WARNING,
+				"Unrecognized character, %c, "
+				    "after \\ in string.  "
+					"Using it literally.\n", c);
+			}else{
+			    tokenization_error ( WARNING,
+				"Unrecognized character, 0x%02x, "
+				    "after \\ in string.  "
+					"Using it literally.\n", c);
+			}
+			val = c;
+		    }
+		}
+		/*  NOTE:  Here, however, PC may have been advanced...  */
+		/*  Don't swallow the sequence-ender if it's a quote.   */
+		if ( *pc == '"' )
+		{
+		    pc--;
+		}
 
-	for(;;) {
-		while (!isxdigit(*pc) && (*pc) != ')')
-			pc++;
+	    }   /*  End of the  "default"  clause  */
+    }    /*  End of the  "switch"  statement  */
 
-		pval[0]=*pc;
-		if (pval[0]==')')
-			break;
+    if ( write_val ) add_byte_to_string( val, walk );
 
-		pc++; /* this cannot be a \n */
+}
 
-		pval[1]=*pc;
-		if ( *pc!=')' && *pc++=='\n' )
-			lineno++;
-				
-		val=parse_number(pval, NULL, 16);
-		*(walk++)=val;
+/* **************************************************************************
+ *
+ *      Function name:  get_sequence
+ *      Synopsis:       Process the Hex-Number option in strings
+ *                      Protect against PC pointer-over-run past END.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             **walk           Pointer to pointer to area into which
+ *                                  to put acquired values
+ *         Global Variables:
+ *             pc               Input-source Scanning pointer
+ *             end              End of input-source buffer
+ *
+ *      Outputs:
+ *         Returned Value:      TRUE = "Normal Completion" (I.e., not EOF)
+ *         Global Variables:
+ *             pc               Points at terminating close-paren, or END
+ *             lineno           Input File Line-Number Counter, may be incr'd
+ *         Supplied Pointers:
+ *             *walk            Advanced by number of values acquired
+ *
+ *      Error Detection:
+ *          End-of-file encountered before end of hex-sequence:
+ *              Issue a Warning, conclude processing, return FALSE.
+ *
+ *      Process Explanation:
+ *          SETUP and RULES:
+ *              Start with  PC  pointing to the first character
+ *                  after the '('  (Open-Paren)     
+ *              Bytes are gathered from digits in pairs, except
+ *                  when separated they are treated singly.
+ *              Allow a backslash in the middle of the sequence
+ *                  to skip to the end of the line and past the
+ *                  whitespace at the start of the next line,
+ *                  i.e., it acts as a comment-escape.
+ *
+ *          INITIALIZE:
+ *              PV_indx = 0
+ *              Set return-indicator to "Abnormal Completion"
+ *              Ready_to_Parse = FALSE
+ *              Stuff NULL into PVAL[2]
+ *          WHILE PC is less than END
+ *              Pick up character at PC into Next_Ch
+ *              IF  Next_Ch  is close-paren :
+ *                  Set return-indicator to "Normal Completion".
+ *                  Done!  Break out of loop.
+ *              ENDIF
+ *              IF comment-escape behavior (controlled by means of a
+ *                      command-line switch) is allowed
+ *                  IF  Next_Ch  is backslash :
+ *                      Skip to end-of line, skip whitespace.
+ *                      If that makes PC reach END :  WARNING message.
+ *                          (Don't need to break out of loop;
+ *                               normal test will terminate.)
+ *                      CONTINUE Loop.
+ *                          (Don't increment PC; PC is already at right place).
+ *                  ENDIF
+ *              ENDIF
+ *              IF  Next_Ch  is a valid Hex-Digit character :
+ *                  Stuff it into  PVAL[PV_indx]
+ *                  IF (PV_indx is 0) :
+ *                      Increment PV_indx
+ *                  ELSE
+ *                      Set Ready_to_Parse to TRUE
+ *          	    ENDIF
+ *              ELSE
+ *                  IF  Next_Ch  is a New-Line, increment Line Number counter
+ *                  IF (PV_indx is 1) :
+ *                      Stuff NULL into PVAL[1]
+ *                      Set Ready_to_Parse to TRUE
+ *          	    ENDIF
+ *              ENDIF
+ *              IF Ready_to_Parse
+ *                  Parse PVAL
+ *                  Stuff into WALK
+ *                  Reset PV_indx to zero
+ *                  Reset Ready_to_Parse to FALSE
+ *              ENDIF
+ *              Increment PC
+ *          REPEAT
+ *          Return with Normal/Abnormal completion indicator
+ *
+ **************************************************************************** */
+
+static bool get_sequence(u8 **walk)
+{
+    int pv_indx = 0;
+    bool retval = FALSE;   /*  "Abnormal Completion" indicator  */
+    bool ready_to_parse = FALSE;
+    char next_ch;
+    char pval[3];
+
+#ifdef DEBUG_SCANNER
+	printf("%s:%d: debug: hex field:", iname, lineno);
+#endif
+    pval[2]=0;
+
+    while ( pc < end )
+    {
+	next_ch = *pc;
+	if ( next_ch == ')' )
+	{
+	    retval = TRUE;
+				break;
+	}
+	if ( hex_remark_escape )
+	{
+	    if ( next_ch == '\\' )
+	    {
+		string_remark("string hex-sequence remark");
+		continue;
+	    }
+	}
+	if ( isxdigit(next_ch) )
+	{
+	    pval[pv_indx] = next_ch;
+	    if ( pv_indx == 0 )
+	    {
+		pv_indx++;
+	    }else{
+		ready_to_parse = TRUE;
+	    }
+	}else{
+	    if ( next_ch == '\n' )  lineno++ ;
+	    if ( pv_indx != 0 )
+	    {
+		pval[1] = 0;
+		ready_to_parse = TRUE;
+	    }
+	}
+	if ( ready_to_parse )
+	{
+	    u8 val = parse_number(pval, NULL, 16);
+	    *((*walk)++)=val;
 #ifdef DEBUG_SCANNER
 		printf(" %02x",val);
 #endif
+	    pv_indx = 0;
+	    ready_to_parse = FALSE;
 	}
+	pc++;
+    }
 #ifdef DEBUG_SCANNER
 	printf("\n");
 #endif
-
-	return walk;
+    return ( retval );
 }
 
-static unsigned long get_string(void)
+/* **************************************************************************
+ *
+ *    Return the length of the string.
+ *    Pack the string, without the terminating '"' (Quote), into statbuf
+ *    Protect against PC pointer-over-run past END.
+ *    Enable Quote-Backslash as a String-Remark Escape.
+ *    Allowability of Quote-Backslash as a String-Remark is under control
+ *        of a command-line switch (string_remark_escape ).
+ *    Allowability of C-style escape characters is under control
+ *        of a command-line switch ( c_style_string_escape ).
+ *
+ *    Truncate string to size of Forth Packed-String (i.e., uses leading
+ *        count-byte, so limited to 255, number that one byte can express)
+ *        unless the string is being gathered for a Message or is being
+ *        consumed for purposes of ignoring it, in either of which case
+ *        that limit need not be enforced.  Parameter "pack_str" controls
+ *        this:  TRUE  if limit needs to be enforced.
+ *
+ *    Issue WARNING if string length gets truncated.
+ *    Issue WARNING if string crosses line.
+ *        The issuance of the Multi-line WARNING is under control of a
+ *           one-shot directive similar to OVERLOAD , called  MULTI-LINE
+ *
+ *    Still to be decided:
+ *        Do we want to bring the allowability of strings crossing
+ *            lines under control of a command-line switch?
+ *
+ ************************************************************************** */
+
+static signed long get_string( bool pack_str)
 {
 	u8 *walk;
 	unsigned long len;
-	bool run=1;
-	u8 c, val;
+	char c;
+	bool run = TRUE;
+	unsigned long start_lineno = lineno;    /*  For warning message  */
 	
+	/*
+	 *  Bump past the single whitespace character that delimits
+	 *      the command -- e.g.,  ."  or  "  or suchlike -- that
+	 *      starts the string.  Allow new-line to be a command-
+	 *      -delimiting whitespace character.  Regard any sub-
+	 *      sequent whitespace characters as part of the string
+	 */
+	if (*pc++=='\n') lineno++;
+
+	got_until_eof = TRUE ;
+
 	walk=statbuf;
 	while (run) {
-		switch ((c=*pc)) {
-		case '\\':
-			switch ((c=*(++pc))) {
-			case 'n':
-				/* newline */
-				*(walk++)='\n';
+		switch ((c=*pc))
+		{
+		    /*  Standard use of '"' (Quote)  for special-char escape  */
+		    case '\"':
+			/*  Skip the '"' (Quote) */
+				pc++;
+			/*  End of the buffer also ends the string cleanly  */
+			if ( pc >= end )
+			{
+			    run = FALSE;
+			    got_until_eof = FALSE ;
 				break;
-			case 't':
-				/* tab */
-				*(walk++)='\t';
-				break;
-			default:
-				val=parse_number(pc, &pc, base);
-#ifdef DEBUG_SCANNER
-				if (verbose)
-					printf( "%s:%d: debug: escape code "
-						"0x%x\n",iname, lineno, val);
-#endif
-				*(walk++)=val;
 			}
-			break;
-		case '\"':
-			pc++; /* skip the " */
-
-			/* printf("switching: %c\n",*pc); */
-			switch(*pc) {
-			case '(':
-				walk=get_sequence(walk);
-				break;
-			case '"':
-				*(walk++)='"';
-				pc++;
+			/*  Pick up the next char after the '"' (Quote) */
+			c=*pc;
+			switch (c)
+			{
+			    case '(':
+				pc++; /* skip the '(' */
+				run = get_sequence(&walk);
 				break;
+
 			case 'n':
-				*(walk++)='\n';
-				pc++;
+				add_byte_to_string( '\n', &walk);
 				break;
 			case 'r':
-				*(walk++)='\r';
-				pc++;
+				add_byte_to_string( '\r', &walk);
 				break;
 			case 't':
-				*(walk++)='\t';
-				pc++;
+				add_byte_to_string( '\t', &walk);
 				break;
 			case 'f':
-				*(walk++)='\f';
-				pc++;
+				add_byte_to_string( '\f', &walk);
 				break;
 			case 'l':
-				*(walk++)='\n';
-				pc++;
+				add_byte_to_string( '\n', &walk);
 				break;
 			case 'b':
-				*(walk++)=0x08;
-				pc++;
+				add_byte_to_string( 0x08, &walk);
 				break;
 			case '!':
-				*(walk++)=0x07;
-				pc++;
+				add_byte_to_string( 0x07, &walk);
 				break;
 			case '^':
-				pc++;
-				c=toupper(*(pc++));
-				*(walk++)=c-'A';
+				pc++;    /*   Skip the up-arrow (Caret) */
+				add_byte_to_string( *pc & 0x1f , &walk);
 				break;
-			case '\n':
-				lineno++;
+			    /*  We're done after any of the whitespace
+			     *     characters follows a quote.
+			     */
 			case ' ':
 			case '\t':
-				run=0;
+				/*  Advance past the terminating whitespace
+				 *       character, except newline.
+				 *  Let  get_word()  handle that.
+				 */
+				pc++;
+			    case '\n':
+				run=FALSE;
+				got_until_eof = FALSE ;
 				break;
 			default:
-				*(walk++)=*(pc++);
+				/*  Control allowability of Quote-Backslash
+				 *      as a String-Remark by means of a
+				 *      command-line switch.
+				 */
+				if ( string_remark_escape )
+				{
+				    if ( c == '\\' )
+				    {
+					string_remark("string-escape remark");
+					/* The first non-blank in the new line
+					 *     has not been processed yet.
+					 *     Back up to allow it to be.
+					 */
+					pc--;
 				break;
 			}
+				}
+				add_byte_to_string( c, &walk);
+			}
 			break;
+		    case '\n':
+			/*  Allow strings to cross lines.  Include the
+			 *      newline in the string.  Account for it.
+			 */
+			lineno++;
 		default:
-			*(walk++)=c;
+			/*  Control allowability of C-style escape-character
+			 *      syntax by means of a command-line switch.
+			 */
+			if ( c_style_string_escape )
+			{
+			    if ( c == '\\' )
+			    {
+				pc++;
+				c_string_escape(&walk );
+				break;
+			    }
+			}
+			add_byte_to_string( c, &walk);
+		}
+		/*  Advance past the char processed, unless we're done.     */
+		if ( run ) pc++;
+		/*  Done if we hit end of file before string was concluded  */
+		if ( pc >= end )
+		{
+		    run = FALSE;
+		    if ( got_until_eof )
+		    {
+			warn_unterm( WARNING, "string", start_lineno);
+			/*  Prevent multiple messages for one error  */
+			got_until_eof = FALSE;
+		    }
 		}
-		if (*pc++=='\n') lineno++;
 	}
 	
-	*(walk++)=0;
-	
-	if (pc>=end)
-		return 0;
-	
-	len=(unsigned long)walk-(unsigned long)statbuf;
-	if (len>1023) {
-		printf("%s:%d: error: buffer overflow\n", iname, lineno);
-		ERROR;
+	warn_if_multiline( "string", start_lineno);
+
+	len = walk - statbuf;
+	if (len >= GET_BUF_MAX )
+	{
+	    tokenization_error ( TKERROR,
+		"get_string buffer overflow.  Max is %d\n.", GET_BUF_MAX-1 );
+	    len = GET_BUF_MAX-1;
 	}
 #ifdef DEBUG_SCANNER
 	if (verbose)
 		printf("%s:%d: debug: scanned string: '%s'\n", 
 					iname, lineno, statbuf);
 #endif
+	if ( pack_str && (len > STRING_LEN_MAX) )
+	{
+	    tokenization_error ( WARNING,
+		"String length being truncated to %d.\n", STRING_LEN_MAX );
+	    len = STRING_LEN_MAX;
+	}
+	statbuf[len] = 0;
+
+	return len ;
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  handle_user_message
+ *      Synopsis:       Collect a user-generated tokenization-time message;
+ *                          either print it or discard it.  Shared code
+ *                          for  user_message()  and  skip_user_message()
+ *
+ *      Inputs:
+ *         Parameters:
+ *             delim                End-of-string delimiter character.
+ *                                  If it's a double-quote ("), we will use
+ *                                      the get-string() routine, with all
+ *                                      its options, to collect the message.
+ *                                  Otherwise, we'll capture plain text from
+ *                                      the input stream.
+ *             print_it             TRUE if we should print the message 
+ *         Local Static Variables:
+ *             got_until_eof        TRUE if reached end of buffer before delim.
+ *         Global Variables:
+ *             lineno               Save, then restore.
+ *
+ *      Outputs:
+ *         Returned Value:          NONE
+ *         Global Variables:
+ *             statbuf              The string will be collected in here
+ *             
+ *         Printout (if  print_it  is TRUE):
+ *            The string, with new-line tacked on, will be printed from
+ *                the  tokenization_error()  routine as a MESSAGE.
+ *            The line-number will be shown as of the origin of the message
+ *
+ *      Error Detection:
+ *          Error-reports will be printed regardless of  print_it  param.
+ *          If delimiter was not found, show "Unterminated" warning message.
+ *          If delimiter was " (double-quote), the get_string() routine
+ *              already checked for a multi-line construct; if delimiter is
+ *              a new-line, then a multi-line construct is impossible.
+ *              otherwise, we will do the multi-line check here.
+ *
+ **************************************************************************** */
+
+static void handle_user_message( char delim, bool print_it )
+{
+    signed long wlen;
+    unsigned int start_lineno = lineno;
+    unsigned int multiline_start = lineno;    /*  For warning message  */
+    bool check_multiline = FALSE;
+    const char *ug_msg = "user-generated message";
+
+    if ( delim == '"' )
+    {
+	wlen = get_string( FALSE);
+    }else{
+	/*
+	 *  When the message-delimiter is a new-line, and the
+	 *      command-delimiter was a new-line, it means the
+	 *      string length is zero; we won't bump the PC.
+	 *  Otherwise, we will honor the convention we extend
+	 *      to  .(  whereby, if the command is delimited
+	 *      by a new-line, we allow the string to begin
+	 *      on the next line.
+	 */
+	if ( delim == '\n' )
+	{
+	    if ( *pc != '\n') pc++;
+	}else{
+		if (*pc++=='\n') lineno++;
+	    multiline_start = lineno;
+	    check_multiline = TRUE;
+	}
+	wlen = get_until( delim );
+    }
+
+    if ( print_it )
+    {
+	unsigned int tmp_lineno = lineno;
+	lineno = start_lineno;
+	/*  Don't add a new-line to body of the message.
+	 *  Routine already takes care of that.
+	 *  Besides, buffer might be full...
+	 */
+	tokenization_error( MESSAGE, statbuf);
+	lineno = tmp_lineno;
+    }
+
+    if ( got_until_eof )   /*  Crude but effective retrofit... */
+    {
+	warn_unterm(WARNING, (char *)ug_msg, start_lineno);
+    }else{
+	if ( check_multiline )
+	{
+	    warn_if_multiline( (char *)ug_msg, multiline_start);
+	}
+    }
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  user_message
+ *      Synopsis:       Collect a user-generated message and
+ *                          print it at tokenization-time.
+ *
+ *      Tokenizer directive (either mode):
+ *          Synonyms                              String Delimiter
+ *             [MESSAGE]  #MESSAGE  [#MESSAGE]        end-of-line
+ *             #MESSAGE"                                  "  
+ *      "Tokenizer-Escape" mode directive         String Delimiter
+ *          .(                                            )
+ *          ."                                            "
+ *
+ *      Inputs:
+ *         Parameter is the "parameter field" of the TIC entry, which
+ *             was initialized to the end-of-string delimiter character.
+ *
+ *      Outputs:
+ *         Returned Value:          NONE
+ *         Printout:                User-message, parsed from input.
+ *
+ *      Extraneous Remarks:
+ *          We would have preferred to simply use the "character value"
+ *              aspect of the union, but we found portability issues
+ *              between big- and little- -endian processors, so we still
+ *              have to recast its type here.
+ *
+ **************************************************************************** */
+
+void user_message( tic_param_t pfield )
+{
+    char delim = (char)pfield.deflt_elem ;
+    handle_user_message( delim, TRUE);
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  skip_user_message
+ *      Synopsis:       Collect a user-generated message and discard it.
+ *                          Used when ignoring a Conditional section.
+ *
+ *      Tokenizer directive (either mode):
+ *          Synonyms                              String Delimiter
+ *             [MESSAGE]  #MESSAGE  [#MESSAGE]        end-of-line
+ *             #MESSAGE"                                  "  
+ *      "Tokenizer-Escape" mode directive         String Delimiter
+ *          .(                                            )
+ *          ."                                            "
+ *
+ *      Inputs:
+ *         Parameters:
+ *             pfield               "Parameter field" of the TIC entry, which
+ *                                      was initialized to the delimiter.
+ *
+ *      Outputs:
+ *         Returned Value:          NONE
+ *         Printout:                NONE
+ *
+ **************************************************************************** */
 
-	return len>255?255:len;
+void skip_user_message( tic_param_t pfield )
+{
+    char delim = (char)pfield.deflt_elem ;
+    handle_user_message( delim, FALSE);
 }
 
-static int get_number(long *result)
+
+
+/* **************************************************************************
+ *
+ *      Function name:  get_number
+ *      Synopsis:       If the word retrieved from the input stream is a
+ *                      valid number (under the current base) convert it.
+ *                      Return an indication if it was not.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             *result             Pointer to place to return the number
+ *         Global Variables:
+ *             statbuf             The word just read that is to be converted.
+ *             base                The current numeric-interpretation base.
+ *
+ *      Outputs:
+ *         Returned Value:         TRUE = Input was a valid number
+ *         Supplied Pointers:
+ *             *result             The converted number, if valid
+ *                                     otherwise undefined
+ *
+ *      Revision History:
+ *          Updated Mon, 28 Mar 2005 by David L. Paktor
+ *              Always use the current base.
+ *              Reversed sense of return-flag.
+ *
+ **************************************************************************** */
+
+bool get_number( long *result)
 {
-	u8 lbase, *until;
-	long val;
+    u8 *until;
+    long val;
+    bool retval = FALSE ;
 
-	lbase=intok?0x10:base;
-	val=parse_number(statbuf,&until, lbase);
+    val = parse_number(statbuf, &until, base);
 	
 #ifdef DEBUG_SCANNER
-	printf("%s:%d: debug: parsing number: base 0x%x, val 0x%lx, "
-			"processed %ld of %ld bytes\n", iname, lineno, 
-			lbase, val,(size_t)(until-statbuf), strlen((char *)statbuf));
+    printf("%s:%d: debug: parsing number: base 0x%x, val 0x%lx, "
+		"processed %ld of %ld bytes\n", iname, lineno, 
+		 base, val,(size_t)(until-statbuf), strlen((char *)statbuf));
 #endif
 
-	if (until==(statbuf+strlen((char *)statbuf))) {
-		*result=val;
-		return 0;
-	}
-		
-	return -1;
+    /*  If number-parsing ended before the end of the input word,
+     *      then the input word was not a valid number.
+     */
+    if (until==(statbuf+strlen((char *)statbuf)))
+    {
+	*result=val;
+	retval = TRUE;
+    }
+
+    return ( retval );
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  deliver_number
+ *      Synopsis:       Deliver the supplied number according to the
+ *                              state of the tokenizer:
+ *                          In normal tokenization mode, emit it as an
+ *                              FCode literal.
+ *                          In  "Tokenizer-Escape" mode, push it onto
+ *                              the Data Stack.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             numval                  The number, verified to be valid.
+ *         Global Variables:
+ *             in_tokz_esc   TRUE if tokenizer is in "Tokenizer Escape" mode.
+ *
+ *      Outputs:
+ *         Returned Value:             NONE 
+ *         Items Pushed onto Data-Stack:
+ *             Top:                    The number, if  in_tokz_esc  was TRUE
+ *         FCode Output buffer:
+ *             If  in_tokz_esc  was FALSE, a  b(lit)  token will be written,
+ *                 followed by the number.
+ *
+ **************************************************************************** */
+
+static void deliver_number( long numval)
+{
+    if ( in_tokz_esc )
+    {
+        dpush( numval );
+    } else {
+        emit_literal(numval);
+    }
+}
+/* **************************************************************************
+ *
+ *      Function name:  handle_number
+ *      Synopsis:       Convert the word just retrieved from the input stream
+ *                              to a number.
+ *                      Indicate whether the string was a valid number and
+ *                              deliver it, as appropriate.
+ *
+ *      Inputs:
+ *         Parameters:                 NONE
+ *         Global Variables:
+ *             statbuf       The word that was just read, and to be converted.
+ *
+ *      Outputs:
+ *         Returned Value:    TRUE = Input string was a valid number
+ *         If input string was a valid number, the converted number will
+ *             be delivered, as appropriate, by  deliver_number(). 
+ *
+ **************************************************************************** */
+
+static bool handle_number( void )
+{
+    bool retval ;
+    long numval;
+
+    retval = get_number( &numval );
+    if ( retval )
+    {
+        deliver_number( numval );
+    }
+
+    return ( retval );
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  ascii_right_number
+ *      Synopsis:       Convert a character sequence to a number, justified
+ *                          toward the right (i.e., the low-order bytes) and
+ *                          deliver it, as appropriate.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             in_str                  The input string
+ *
+ *      Outputs:
+ *         Returned Value:             NONE
+ *         The converted number will be delivered by  deliver_number(). 
+ *
+ *      Process Explanation:
+ *          The last four characters in the sequence will become the number.
+ *          If there are fewer than four, they will fill the low-order part
+ *              of the number.
+ *          Example:  PCIR            is converted to  h# 50434952
+ *                    CPU             is converted to  h# 00435055
+ *             and
+ *          	      LotsOfStuff     is equivalent to  a# tuff 
+ *                                    and is converted to  h# 74756666
+ *
+ **************************************************************************** */
+
+static void ascii_right_number( char *in_str)
+{
+    u8 nxt_ch;
+    char *str_ptr = in_str;
+    long numval = 0;
+
+    for ( nxt_ch = (u8)*str_ptr ;
+	    ( nxt_ch = (u8)*str_ptr ) != 0 ;
+        	str_ptr++ )
+    {
+        numval = ( numval << 8 ) + nxt_ch ;
+    }
+    deliver_number( numval );
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  ascii_left_number
+ *      Synopsis:       Similar to  ascii_right_number()  except justified
+ *                          toward the left (i.e., the high-order bytes).
+ *                      
+ *
+ *      Inputs:
+ *         Parameters:
+ *             in_str                  The input string
+ *
+ *      Outputs:
+ *         Returned Value:            NONE
+ *         The converted number will be delivered by  deliver_number().
+ *
+ *      Process Explanation:
+ *          If there are fewer than four characters in the sequence, they
+ *              will fill the high-order part of the number.
+ *                    CPU             is converted to  h# 43505500
+ *          In all other respects, similar to  ascii_right_number()
+ *
+ **************************************************************************** */
+
+static void ascii_left_number( char *in_str)
+{
+    u8 nxt_ch;
+    char *str_ptr = in_str;
+    long numval = 0;
+    int shift_amt = 24;
+    bool shift_over = FALSE ;
+
+    for ( nxt_ch = (u8)*str_ptr ;
+	    ( nxt_ch = (u8)*str_ptr ) != 0 ;
+        	str_ptr++ )
+    {
+        if ( shift_over )  numval <<= 8;
+	if ( shift_amt == 0 )  shift_over = TRUE ;
+	numval += ( nxt_ch << shift_amt );
+	if ( shift_amt > 0 ) shift_amt -= 8;
+    }
+    deliver_number( numval );
+
 }
 
+/* **************************************************************************
+ *
+ *      Function name:  init_scanner
+ *      Synopsis:       Allocate memory the Scanner will need.
+ *                          Only need to call once per program run.
+ *
+ **************************************************************************** */
+
 void init_scanner(void)
 {
-	statbuf=malloc(1024);
-	if (!statbuf) {
-		printf ("no memory.\n");
-		exit(-1);
-	}
+	statbuf=safe_malloc(GET_BUF_MAX, "initting scanner");
 }
 
+/* **************************************************************************
+ *
+ *      Function name:  exit_scanner
+ *      Synopsis:       Free up memory the Scanner used
+ *
+ **************************************************************************** */
+
 void exit_scanner(void)
 {
 	free(statbuf);
 }
 
-#define FLAG_EXTERNAL 0x01
-#define FLAG_HEADERS  0x02
-char *name, *alias;
-int flags=0;
+/* **************************************************************************
+ *
+ *      Function name:  set_hdr_flag
+ *      Synopsis:       Set the state of the "headered-ness" flag to the
+ *                          value given, unless over-ridden by one or both
+ *                          of the "always-..." Command-Line Flags
+ *
+ *      Inputs:
+ *         Parameters:
+ *             new_flag                  New setting
+ *         Global Variables:
+ *             always_headers            Override HEADERLESS and make HEADERS
+ *             always_external           Override HEADERLESS and HEADERS;
+ *                                           make EXTERNAL
+ *
+ *      Outputs:
+ *         Returned Value:               None
+ *         Local Static Variables:
+ *             hdr_flag                  Adjusted to new setting
+ *
+ *      Process Explanation:
+ *          If  always_headers  is TRUE, and  new_flag  is not FLAG_EXTERNAL
+ *              then set to FLAG_HEADERS
+ *          If  always_external  is TRUE, set to FLAG_EXTERNAL, regardless.
+ *              (Note:  always_external  over-rides  always_headers).
+ *          Otherwise, set to  new_flag
+ *
+ **************************************************************************** */
+
+static void set_hdr_flag( headeredness new_flag)
+{
+    headeredness new_state = new_flag;
+    switch ( new_flag)
+    {
+	case FLAG_HEADERLESS:
+	    {
+		if ( always_headers )
+		{   new_state = FLAG_HEADERS;
+		}
+	    /*  No  break.  Intentional...   */
+	    }
+	case FLAG_HEADERS:
+	    {
+		if ( always_external )
+		{   new_state = FLAG_EXTERNAL;
+		}
+	    /*  No  break.  Intentional...   */
+	    }
+	case FLAG_EXTERNAL:
+	    break;  /*  Satisfy compiler's error-checking...   */
+	/*  No default needed here...   */
+    }
+
+    hdr_flag = new_state;
+
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  init_scan_state
+ *      Synopsis:       Initialize various state variables for each time
+ *                          a new tokenization scan is started.
+ *
+ *      Inputs:
+ *         Parameters:             NONE
+ *
+ *      Outputs:
+ *         Returned Value:         NONE
+ *         Global Variables:   Initialized to:
+ *             base                            0x0a (I.e., base = "decimal")
+ *             nextfcode                       By  reset_fcode_ranges()
+ *             pci_is_last_image               TRUE
+ *             incolon                         FALSE
+ *         Local Static Variables:
+ *             hdr_flag                  FLAG_HEADERLESS (unless over-ridden)
+ *             is_instance                     FALSE
+ *             last_colon_filename             NULL
+ *             instance_filename               NULL
+ *             dev_change_instance_warning     TRUE
+ *             instance_definer_gap            FALSE
+ *             need_to_pop_source              FALSE
+ *             first_fc_starter                TRUE
+ *             ret_stk_depth                   0
+ *         Memory Freed
+ *             Copies of input-file name in  last_colon_filename  and
+ *                 instance_filename , if allocated.
+ *
+ **************************************************************************** */
 
-static int create_word(void)
+void init_scan_state( void)
 {
-	unsigned long wlen;
+    base = 0x0a;
+    pci_is_last_image = TRUE;
+    incolon = FALSE;
+    is_instance = FALSE;
+    set_hdr_flag( FLAG_HEADERLESS);
+    reset_fcode_ranges();
+    first_fc_starter = TRUE;
+    if ( last_colon_filename != NULL ) free( last_colon_filename);
+    if ( instance_filename != NULL ) free( instance_filename);
+    last_colon_filename = NULL;
+    instance_filename = NULL;
+    dev_change_instance_warning = TRUE;
+    instance_definer_gap = FALSE;
+    need_to_pop_source = FALSE;
+    ret_stk_depth = 0;
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  collect_input_filename
+ *      Synopsis:       Save a copy of the current input file name in the
+ *                          given variable, for error-reporting purposes
+ *
+ *      Inputs:
+ *         Parameters:
+ *             saved_nam                    Pointer to pointer for copy of name
+ *         Global Variables:
+ *             iname                        Current input file name
+ *         Local Static Variables:
+ *
+ *      Outputs:
+ *         Returned Value:                  NONE
+ *         Supplied Pointers:
+ *             *saved_nam                   Copy of name
+ *         Memory Allocated
+ *             For copy of input file name
+ *         When Freed?
+ *             Subsequent call to this routine with same pointer
+ *             (Last copy made will be freed if starting a new tokenization,
+ *                 otherwise, will persist until end of program.) 
+ *         Memory Freed
+ *             Previous copy in same pointer.
+ *
+ *      Process Explanation:
+ *          If there is a previous copy, and it still matches the current
+ *              input-file name, we don't need to free or re-allocate.
+ *
+ **************************************************************************** */
 
-	if (incolon) {
-		printf("%s:%d: error: creating words not allowed "
-			"in colon definition.\n", iname, lineno);
-		ERROR;
+static void collect_input_filename( char **saved_nam)
+{
+    bool update_lcfn = TRUE;    /*  Need to re-allocate?  */
+    if ( *saved_nam != NULL )
+    {
+	if ( strcmp( *saved_nam, iname) == 0 )
+	{
+	    /*  Last collected filename unchanged from iname  */
+	    update_lcfn = FALSE;
+	}else{
+	    free( *saved_nam);
 	}
-	
-	if(nextfcode > 0xfff) {
-		printf("%s:%d: error: maximum number of fcode words "
-			"reached.\n", iname, lineno);
-		ERROR;
+    }
+    if ( update_lcfn )
+    {
+	*saved_nam = strdup(iname);
+    }
+} 
+
+/* **************************************************************************
+ *
+ *      Function name:  test_in_colon
+ *      Synopsis:       Error-check whether a word is being used in the
+ *                      correct state, relative to being inside a colon
+ *                      definition; issue a message if it's not.
+ *      
+ *      Inputs:
+ *         Parameters:
+ *             wname            The name of the word in question
+ *             sb_in_colon      TRUE if the name should be used inside
+ *                                  a colon-definition only; FALSE if
+ *                                  it may only be used outside of a
+ *                                  colon-definition.
+ *             severity         Type of error/warning message to call.
+ *                                  usually either WARNING or TKERROR
+ *             use_instead      Word the error-message should suggest be
+ *                                  used "instead".  This may be a NULL,
+ *                                  in which case the "suggestion" part
+ *                                  of the message will simply be omitted.
+ *         Global Variables:
+ *             incolon          State of the tokenization; TRUE if inside
+ *                                  a colon definition
+ *
+ *      Outputs:
+ *         Returned Value:     TRUE if no error.
+ *         Printout:           Error messages as indicated.
+ *
+ *      Error Detection:
+ *          If the state, relative to being inside a colon-definition,
+ *              is not what the parameter says it should be, issue a
+ *              message of the indicated severity, and return FALSE.
+ *
+ **************************************************************************** */
+
+static bool test_in_colon ( char *wname,
+                           bool sb_in_colon,    /*  "Should Be IN colon"  */
+			        int severity,
+				     char *use_instead)
+{
+    bool is_wrong;
+    bool retval = TRUE ;
+
+    is_wrong = BOOLVAL(( sb_in_colon != FALSE ) != ( incolon != FALSE )) ;
+    if ( is_wrong )
+    {  
+        char *ui_pt1 = "";
+        char *ui_pt2 = "";
+        char *ui_pt3 = "";
+	retval = FALSE;
+	if ( use_instead != NULL )
+	{
+	    ui_pt1 = "  Use  ";
+	    ui_pt2 = use_instead;
+	    ui_pt3 = "  instead.";
 	}
-	
-	wlen=get_word();
-	name=strdup((char *)statbuf);
+	tokenization_error ( severity, "The word  %s  should not be used "
+	    "%sside of a colon definition.%s%s%s\n", strupr(wname),
+	        sb_in_colon ? "out" : "in", ui_pt1, ui_pt2, ui_pt3 );
+    }
+    return ( retval );
+}
 
-#ifdef DEBUG_SCANNER
-	printf("%s:%d: debug: defined new word %s, fcode no 0x%x\n",
-			iname, lineno, name, nextfcode);
-#endif
-	add_token(nextfcode, name);
-	if (flags) {
-		if (flags&FLAG_EXTERNAL)
-			emit_token("external-token");
-		else
-			emit_token("named-token");
-		emit_string((u8 *)name, wlen);
-	} else
-		emit_token("new-token");
-	
-	emit_fcode(nextfcode);
-	nextfcode++;
+/* **************************************************************************
+ *
+ *      Function name:  must_be_deep_in_do
+ *      Synopsis:       Check that the statement in question is called 
+ *                          from inside the given depth of structures
+ *                          of the  DO ... LOOP -type (i.e., any combination
+ *                          of DO  or ?DO  and  LOOP  or  +LOOP ).
+ *                      Show an error if it is not.
+ *
+ **************************************************************************** */
+
+static void must_be_deep_in_do( int how_deep )
+{
+    int functional_depth = do_loop_depth;
+    if ( incolon )
+    {
+        functional_depth -= last_colon_do_depth;
+    }
+    if ( functional_depth < how_deep )
+    {
+	char deep_do[64] = "";
+	int indx;
+	bool prefix = FALSE;
+
+	for ( indx = 0; indx < how_deep ; indx ++ )
+	{
+	    strcat( deep_do, "DO ... ");
+	}
+	for ( indx = 0; indx < how_deep ; indx ++ )
+	{
+	    if ( prefix )
+	    {
+		strcat( deep_do, " ... ");
+	    }
+	    strcat( deep_do, "LOOP");
+	    prefix = TRUE;
+	}
+
+	tokenization_error( TKERROR,
+	    "%s outside of  %s  structure", strupr(statbuf), deep_do);
+	in_last_colon();
+    }
+
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  bump_ret_stk_depth
+ *      Synopsis:       Increment or decrement the Return-Stack-Usage-Depth
+ *                          counter.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             bump              Amount by which to increment;
+ *                                   negative number to decrement.
+ *         Local Static Variables:
+ *             ret_stk_depth     The Return-Stack-Usage-Depth counter
+ *
+ *      Outputs:
+ *         Returned Value:        NONE
+ *         Local Static Variables:
+ *             ret_stk_depth     Incremented or decremented
+ *
+ *      Process Explanation:
+ *          This simple-seeming function is actually a place-holder
+ *             for future expansion.  Proper error-detection of
+ *             Return-Stack usage is considerably more complex than
+ *             what we are implementing here, and is deferred for a
+ *             later revision.
+ *
+ *      Still to be done:
+ *          Full detection of whether the Return-Stack has been cleared
+ *              when required, including analysis of Return-Stack usage
+ *              within Flow-Control constructs, and before Loop elements...
+ *
+ *      Extraneous Remarks:
+ *          Some FORTHs use a Loop-Control stack separate from the Return-
+ *              -Stack, but others use the Return-Stack to keep LOOP-control
+ *              elements.  An FCode program must be portable between different
+ *              environments, and so must adhere to the restrictions listed
+ *              in the ANSI Spec:
+ *
+ *       3.2.3.3   Return stack  
+ *        . . . . . .
+ *       A program may use the return stack for temporary storage during the
+ *          execution of a definition subject to the following restrictions:
+ *       	A program shall not access values on the return stack (using R@,
+ *       	    R>, 2R@ or 2R>) that it did not place there using >R or 2>R;
+ *       	A program shall not access from within a do-loop values placed
+ *       	    on the return stack before the loop was entered;
+ *       	All values placed on the return stack within a do-loop shall
+ *       	    be removed before I, J, LOOP, +LOOP, UNLOOP, or LEAVE is
+ *       	    executed;
+ *       	All values placed on the return stack within a definition
+ *       	    shall be removed before the definition is terminated
+ *       	    or before EXIT is executed.
+ *
+ **************************************************************************** */
+
+static void bump_ret_stk_depth( int bump)
+{
+    ret_stk_depth += bump;
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  ret_stk_balance_rpt
+ *      Synopsis:       Display a Message if usage of the Return-Stack
+ *                          appears to be out of balance.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             before_what         Phrase to use in Message;
+ *                                     if NULL, use statbuf...
+ *             clear_it            TRUE if this call should also clear the
+ *                                     Return-Stack-Usage-Depth counter
+ *         Global Variables:
+ *             statbuf             Word currently being processed
+ *         Local Static Variables:
+ *             ret_stk_depth       The Return-Stack-Usage-Depth counter
+ *
+ *      Outputs:
+ *         Returned Value:         NONE
+ *         Local Static Variables:
+ *             ret_stk_depth       May be cleared
+ *
+ *      Error Detection:
+ *          Based simply on whether the Return-Stack-Usage-Depth counter
+ *              is zero.  This is a weak and uncertain implementation;
+ *              therefore, the Message will be a WARNING phrased with
+ *              some equivocation.
+ *
+ *      Process Explanation:
+ *          Proper detection of Return-Stack usage errors is considerably
+ *              more complex, and is deferred for a future revision.
+ *
+ *      Still to be done:
+ *          Correct analysis of Return-Stack usage around Flow-Control
+ *              constructs.  Consider, for instance, the following:
+ * 
+ *          blablabla >R  yadayada IF  R> gubble ELSE flubble R>  THEN
+ * 
+ *              It is, in fact, correct, but the present scheme would
+ *              tag it as a possible error.  Conversely, something like:
+ * 
+ *          blablabla >R  yadayada IF  R> gubble THEN
+ * 
+ *              would not get tagged, even though it is actually an error.
+ * 
+ *          The current simple scheme also does not cover Return-Stack
+ *              usage within Do-Loops or before Loop elements like I and
+ *              J or UNLOOP or LEAVE.  Implementing something like that
+ *              would probably need to be integrated in with Flow-Control
+ *              constructs, and will be noted in  flowcontrol.c
+ *
+ **************************************************************************** */
+
+static void ret_stk_balance_rpt( char *before_what, bool clear_it)
+{
+    if ( ret_stk_depth != 0 )
+    {
+	char *what_flow = ret_stk_depth < 0 ? "deficit" : "excess" ;
+	char *what_phr =  before_what != NULL ? before_what : strupr(statbuf);
+
+	tokenization_error( WARNING,
+	    "Possible Return-Stack %s before %s", what_flow, what_phr);
+	in_last_colon();
 
-	return 0;
+	if ( clear_it )
+	{
+	    ret_stk_depth = 0;
+	}
+    }
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  ret_stk_access_rpt
+ *      Synopsis:       Display a Message if an attempt to access a value
+ *                          on the Return-Stack appears to occur before
+ *                          one was placed there.
+ *
+ *      Inputs:
+ *         Parameters:                NONE
+ *         Global Variables:
+ *             statbuf                Word currently being processed
+ *         Local Static Variables:
+ *             ret_stk_depth          The Return-Stack-Usage-Depth counter
+ *
+ *      Outputs:
+ *         Returned Value:             NONE
+ *
+ *      Error Detection:
+ *          Equivocal WARNING, based simply on whether the Return-Stack-
+ *              -Usage-Depth counter not positive.
+ *
+ *      Process Explanation:
+ *          Proper detection is deferred...
+ *
+ *      Still to be done:
+ *          Correct analysis of Return-Stack usage...
+ *
+ **************************************************************************** */
+
+static void ret_stk_access_rpt( void)
+{
+    if ( ret_stk_depth <= 0 )
+    {
+	tokenization_error( WARNING,
+	    "Possible Return-Stack access attempt by %s "
+		"without value having been placed there",
+		strupr(statbuf) );
+	in_last_colon();
+    }
 }
 
+
+
+/* **************************************************************************
+ *
+ *      Function name:  encode_file
+ *      Synopsis:       Input a (presumably binary) file and encode it
+ *                      as a series of strings which will be accumulated
+ *                      and encoded in a manner appropriate for a property.
+ *
+ *      Associated Tokenizer directive:        encode-file        
+ *
+ *      Error Detection:
+ *          Handled by support routines.
+ *
+ **************************************************************************** */
+
 static void encode_file( const char *filename )
 {
 	FILE *f;
 	size_t s;
-	int i=0;
+	int num_encoded=0;
 	
-	if( !(f=fopen(filename,"rb")) ) {
-		printf("%s:%d: opening '%s':\n", iname, lineno, filename );
-		ERROR;
-		return;
-	}
-	while( (s=fread(statbuf, 1, 255, f)) ) {
-		emit_token("b(\")");
-		emit_string(statbuf, s);
-		emit_token("encode-bytes");
-		if( i++ )
-			emit_token("encode+");
+	tokenization_error( INFO, "ENCODing File %s\n", filename );
+
+	f = open_expanded_file( filename, "rb", "encoding");
+	if( f != NULL )
+	{
+	    while( (s=fread(statbuf, 1, STRING_LEN_MAX, f)) )
+	    {
+		    emit_token("b(\")");
+		    emit_string(statbuf, s);
+		    emit_token("encode-bytes");
+		    if( num_encoded )
+			    emit_token("encode+");
+		    num_encoded += s;
+	    }
+	    fclose( f );
+	    tokenization_error ( INFO, "ENCODed %d bytes.\n", num_encoded);
 	}
-	fclose( f );
 }
 
+/* **************************************************************************
+ *
+ *      Function name:  check_name_length
+ *      Synopsis:       If the length of a user-defined name exceeds the
+ *                          ANSI-specified maximum of 31 characters, issue
+ *                          a message.  This is a hard-coded limit.
+ *                      Although our Tokenizer can handle longer names,
+ *                          they will cause big problems when encountered
+ *                          by an FCode interpreter.
+ *                      If the name is going to be included in the binary
+ *                          output, the message severity must be an ERROR.
+ *                      Otherwise, if the name is HEADERLESS, the severity
+ *                          can be reduced to a Warning; if the name is only
+ *                          defined in "Tokenizer Escape" mode the message
+ *                          severity can be further reduced to an Advisory.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             wlen                 Length of the newly-created word
+ *         Global Variables: 
+ *             in_tokz_esc          TRUE if in "Tokenizer Escape" mode.
+ *         Local Static Variables:
+ *             hdr_flag             State of headered-ness for name-creation
+ *
+ *      Outputs:
+ *         Returned Value:          NONE
+ *         Global Variables:        
+ *         Printout:                ERROR message if applicable.
+ *
+ *      Error Detection:
+ *             The whole point of this routine.  
+ *
+ *      Revision History:
+ *          Updated Wed, 20 Jul 2005 by David L. Paktor
+ *               Escalated from merely an informative warning to a TKERROR 
+ *          Updated Fri, 21 Oct 2005 by David L. Paktor
+ *               Adjust severity if name doesn't go into the FCode anyway...
+ *
+ **************************************************************************** */
 
-static void handle_internal(u16 tok)
+void check_name_length( signed long wlen )
 {
-	unsigned long wlen;
-	long offs1,offs2;
-	u16 itok;
-	
-#ifdef DEBUG_SCANNER
-	printf("%s:%d: debug: tokenizing control word '%s'\n",
-						iname, lineno, statbuf);
-#endif
-	switch (tok) {
-	case BEGIN:
-		emit_token("b(<mark)");
-		dpush((unsigned long)opc);
-		break;
+    if ( wlen > 31 )
+    {
+	int severity = TKERROR;
+	if ( in_tokz_esc )
+	{   severity = INFO;
+	}else{
+	    if (hdr_flag == FLAG_HEADERLESS)
+	    {   severity = WARNING;
+	    }
+	}
+	tokenization_error( severity,
+	    "ANSI Forth does not permit definition of names "
+		"longer than 31 characters.\n" );
+    }
 
-	case BUFFER:
-		create_word();
-		emit_token("b(buffer:)");
-		break;
+}
 
-	case CONST:
-		create_word();
+
+/* **************************************************************************
+ *
+ *      Function name:  definer_name
+ *      Synopsis:       Given a defining-word internal token, return
+ *                      a printable string for the definer, for use
+ *                      in an error-message.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             definer             Internal token for the defining-word
+ *             reslt_ptr           Pointer to string-pointer that takes
+ *                                     the result, if successful
+ *
+ *      Outputs:
+ *         Returned Value:         TRUE if definer was recognized
+ *         Supplied Pointers:
+ *             *reslt_ptr          If successful, points to printable string;
+ *                                     otherwise, left unchanged.
+ *
+ *
+ **************************************************************************** */
+
+static bool definer_name(fwtoken definer, char **reslt_ptr)
+{
+    bool retval = TRUE;
+    switch (definer)
+    {
+	case VARIABLE:
+	    *reslt_ptr = "VARIABLE";
+	    break;
+	case DEFER:
+	    *reslt_ptr = "DEFER";
+	    break;
+	case VALUE:
+	    *reslt_ptr = "VALUE";
+	    break;
+	case BUFFER:
+	    *reslt_ptr = "BUFFER";
+	    break;
+	case CONST:
+	    *reslt_ptr = "CONSTANT";
+	    break;
+	case COLON:
+	    *reslt_ptr = "COLON";
+	    break;
+	case CREATE:
+	    *reslt_ptr = "CREATE";
+	    break;
+	case FIELD:
+	    *reslt_ptr = "FIELD";
+	    break;
+	case MACRO_DEF:
+	    *reslt_ptr = "MACRO";
+	    break;
+	case ALIAS:
+	    *reslt_ptr = "ALIAS";
+	    break;
+	case LOCAL_VAL:
+	    *reslt_ptr = "Local Value name";
+	    break;
+	default:
+	    retval = FALSE;
+    }
+
+    return ( retval);
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  as_a_what
+ *      Synopsis:       Add the phrase "as a[n] <DEF'N_TYPE>" for the given
+ *                          definition-type to the given string buffer.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             definer                 Internal token for the defining-word
+ *             as_what                 The string buffer to which to add.
+ *
+ *      Outputs:
+ *         Returned Value:             TRUE if an assigned name was found
+ *                                         for the given definer and text
+ *                                         was added to the buffer.
+ *         Supplied Pointers:
+ *             *as_what                Text is added to this buffer.
+ *
+ *      Process Explanation:
+ *          The calling routine is responsible to make sure the size of
+ *              the buffer is adequate.  Allow 25 for this routine.
+ *          The added text will not have spaces before or after; if any
+ *              are needed, they, too, are the responsibility of the
+ *              calling routine.  The return value gives a helpful clue.
+ *
+ **************************************************************************** */
+
+bool as_a_what( fwtoken definer, char *as_what)
+{
+    char *defn_type_name;
+    bool retval = definer_name(definer, &defn_type_name);
+    if ( retval )
+    {
+	strcat( as_what, "as a");
+	/*  Handle article preceding definer name
+	 *      that starts with a vowel.
+	 */
+	/*  HACK:  Only one definer name -- ALIAS --
+	 *      begins with a vowel.  Take advantage
+	 *      of that...
+	 *  Otherwise, we'd need to do something involving
+	 *      strchr( "AEIOU", defn_type_name[0] )
+	 */
+	if ( definer == ALIAS ) strcat( as_what, "n" );
+
+	strcat( as_what, " ");
+	strcat( as_what, defn_type_name);
+    }
+    return( retval);
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  lookup_word
+ *      Synopsis:       Find the TIC-entry for the given word in the Current
+ *                          mode -- relative to "Tokenizer-Escape" -- and
+ *                          Scope into which definitions are being entered.
+ *                      Optionally, prepare text for various Message types.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             stat_name               Word to look up
+ *             where_pt1               Pointer to result-display string, part 1
+ *                                         NULL if not preparing text
+ *             where_pt2               Pointer to result-display string, part 2
+ *                                         NULL if not preparing text
+ *         Global Variables:
+ *             in_tokz_esc             TRUE if in "Tokenizer Escape" mode.
+ *             scope_is_global         TRUE if "global" scope is in effect
+ *             current_device_node     Current dev-node data-struct
+ *             ibm_locals              TRUE if IBM-style Locals are enabled
+ *
+ *      Outputs:
+ *         Returned Value:             Pointer to TIC-entry; NULL if not found
+ *         Supplied Pointers:
+ *             *where_pt1              Result display string, part 1 of 2
+ *             *where_pt2              Result display string, part 2 of 2
+ *
+ *      Process Explanation:
+ *          We will set the two-part result-display string in this routine
+ *              because only here do we know in which vocabulary the word
+ *              was found.
+ *          Pre-load the two parts of the result-display string.
+ *          If we are in "Tokenizer Escape" mode, look up the word:  first,
+ *              in the "Tokenizer Escape" Vocabulary, or, if not found,
+ *              among the "Shared" words.
+ *          Otherwise, we're in Normal" mode.  Look it up:  first, among the
+ *              Locals, if IBM-style Locals are enabled (it can possibly be
+ *              one if "Tokenizer Escape" mode was entered during a colon-
+ *              -definition); then, if it was not found and if "Device"
+ *              scope is in effect, look in the current device-node; then,
+ *              if not found, in the "core" vocabulary.
+ *          Load the second part of the result-display string with the
+ *               appropriate phrase for whereever it was found.
+ *          Then adjust the first part of the result-display string with
+ *               the definer, if known.
+ *
+ *          The two strings will be formatted to be printed adjacently,
+ *              without any additional spaces in the printf() format.
+ *          The first part of the result-display string will not start with
+ *              a space, but will have an intermediate space if necessary.
+ *          The second part of the result-display string will not start
+ *              with a space, and will contain the terminating new-line
+ *              if appropriate.  It might or might not have been built
+ *              with a call to  in_what_node().
+ *
+ *          If the calling routine displays the result-display strings,
+ *              it should follow-up with a call to  show_node_start()
+ *              This will be harmless if  in_what_node()  was not used
+ *              in the construction of the result-display string.
+ *          If the calling routine is NOT going to display the result strings,
+ *              it should pass NULLs for the string-pointer pointers.
+ *
+ *          The second part of the string consists of pre-coded phrases;
+ *              therefore, we can directly assign the pointer.
+ *          The first part of the string, however, has developed into
+ *              something constructed "on the fly".  Earlier, it, too,
+ *              had been a directly-assignable pointer; all the callers
+ *              to this routine expect that.  Rather than change all the
+ *              callers, we will assign a local buffer for it.
+ *
+ *      Extraneous Remarks:
+ *          We had to add the rule allowing where_pt1 or where_pt2 to be
+ *              NULL after we introduced the  in_what_node()  function.
+ *              We had cases where residue from a lookup for processing
+ *              showed up later in an unrelated Message.  The NULL rule
+ *              should prevent that.
+ *
+ **************************************************************************** */
+
+static char lookup_where_pt1_buf[32];
+
+tic_hdr_t *lookup_word( char *stat_name, char **where_pt1, char **where_pt2 )
+{
+    tic_hdr_t *found = NULL;
+    bool trail_space = TRUE;
+    bool doing_lookup = BOOLVAL( ( where_pt1 != NULL )
+			      && ( where_pt2 != NULL ) );
+    char *temp_where_pt2 = "in the core vocabulary.\n";
+
+    lookup_where_pt1_buf[0] = 0;             /*  Init'lz part-1 buffer  */
+
+    /*  "Core vocab" refers both to shared fwords and built-in tokens.  */
+
+    /*  Distinguish between "Normal" and "Tokenizer Escape" mode  */
+    if ( in_tokz_esc )
+    {   /*  "Tokenizer Escape" mode.  */
+	found = lookup_tokz_esc( stat_name);
+	if ( found != NULL )
+	{
+	    temp_where_pt2 = in_tkz_esc_mode;
+	}else{
+	    /*  "Core vocabulary".  */
+	    found = lookup_shared_word( stat_name);
+	}
+    }else{
+	/*  "Normal" tokenization mode  */
+	if ( ibm_locals )
+	{
+	    found = lookup_local( stat_name);
+	    if ( doing_lookup && ( found != NULL ) )
+	    {
+		trail_space = FALSE;
+		temp_where_pt2 = ".\n";
+	    }
+	}
+
+	if ( found == NULL )
+	{
+	    found = lookup_in_dev_node( stat_name);
+	    if ( found != NULL )
+	    {
+		if ( doing_lookup )
+		{
+		    temp_where_pt2 = in_what_node( current_device_node);
+		}
+	    }else{
+		/*  "Core vocabulary".  */
+		found = lookup_core_word( stat_name);
+	    }
+	}
+    }
+
+    if ( ( doing_lookup ) && ( found != NULL ) )
+    {
+	if ( as_a_what( found->fword_defr, lookup_where_pt1_buf) )
+	{
+	    if ( trail_space )
+	    {
+		strcat(lookup_where_pt1_buf, " ");
+	    }
+	}
+	*where_pt1 = lookup_where_pt1_buf;
+	*where_pt2 = temp_where_pt2;
+    }
+    return( found);
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  word_exists
+ *      Synopsis:       Check whether a given word is already defined in the
+ *                          Current mode -- relative to "Tokenizer-Escape" --
+ *                          and Scope into which definitions are being entered. 
+ *                      Used for error-reporting.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             stat_name                 Word to look up
+ *             where_pt1                 Pointer to string, part 1 of 2,
+ *                                          to display in result
+ *             where_pt2                 Pointer to string, part 2 of 2,
+ *                                          to display in result
+ *
+ *      Outputs:
+ *         Returned Value:               TRUE if the name exists.
+ *         Supplied Pointers:
+ *             *where_pt1                Result display string, part 1 of 2
+ *             *where_pt2                Result display string, part 2 of 2
+ *
+ *      Process Explanation:
+ *          If the calling routine displays the result-display strings,
+ *              it should follow-up with a call to  show_node_start()
+ *
+ *      Extraneous Remarks:
+ *          This used to be a much heftier routine; now it's just
+ *              a wrapper around  lookup_word() .
+ *
+ **************************************************************************** */
+
+bool word_exists( char *stat_name, char **where_pt1, char **where_pt2 )
+{
+    bool retval = FALSE;
+    tic_hdr_t *found = lookup_word( stat_name, where_pt1, where_pt2 );
+
+    if ( found != NULL )
+    {
+	retval = TRUE;
+    }
+
+    return( retval);
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  warn_if_duplicate
+ *      Synopsis:       Check whether a given word is already defined in
+ *                          the current mode and issue a warning if it is.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             stat_name                Word to check
+ *         Global Variables:
+ *             verbose_dup_warning      Whether to run the check at all.
+ *         Local Static Variables:
+ *             do_not_overload          FALSE if  OVERLOAD  is in effect.
+ *
+ *      Outputs:
+ *         Returned Value:              NONE
+ *         Local Static Variables:
+ *             do_not_overload          Restored to TRUE
+ *         Printout:
+ *             Warning message if a duplicate.
+ *
+ *      Error Detection:
+ *             None.  This is merely an informative warning.
+ *
+ *      Process Explanation:
+ *          "Current mode" -- meaning, whether the tokenizer is operating
+ *              in "Tokenizer Escape" mode or in normal tokenization mode --
+ *              will be recognized by the  word_exists()  function.
+ *
+ *      Extraneous Remarks:
+ *          The  OVERLOAD  directive is our best shot at creating a more
+ *              fine-grained way to temporarily bypass this test when
+ *              deliberately overloading a name.  It would be nice to have
+ *              a mechanism, comparable to the classic
+ *                     WARNING @ WARNING OFF  .....  WARNING !
+ *              that could be applied to a range of definitions, but:
+ *              (1)  That would require more of a true FORTH infrastructure;
+ *                       hence, more effort than I am willing to invest, at
+ *                       this juncture, for such a small return,
+ *              and
+ *              (2)  Most intentional-overloading ranges only cover a
+ *                       single definition anyway.
+ *
+ **************************************************************************** */
+
+void warn_if_duplicate( char *stat_name)
+{
+    if ( verbose_dup_warning && do_not_overload )
+    {
+	char *where_pt1;
+	char *where_pt2; 
+	if ( word_exists( stat_name, &where_pt1, &where_pt2) )
+	{
+	    tokenization_error( WARNING, 
+		"Duplicate definition:   %s  already exists %s%s",
+		    stat_name, where_pt1, where_pt2 );
+	    show_node_start();
+	}
+    }
+    do_not_overload = TRUE;
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  glob_not_allowed
+ *      Synopsis:       Print a Message that "XXX is not allowed."
+ *                          because Global Scope is in effect.
+ *                      Used from several places...
+ *      
+ *      Inputs:
+ *         Parameters:
+ *             severity              Severity of the Message
+ *             not_ignoring          FALSE = "Ignoring", for the part of the
+ *                                       message about "How It's being Handled"
+ *         Global Variables:
+ *             statbuf               Disallowed word currently being processed
+ *
+ *      Outputs:
+ *         Returned Value:           NONE
+ *         Printout:                 Message of given severity.
+ *
+ **************************************************************************** */
+
+static void glob_not_allowed( int severity, bool not_ignoring)
+{
+    tokenization_error( severity, "Global Scope is in effect; "
+			"%s not allowed.  %s.\n",
+			    strupr(statbuf), 
+				 not_ignoring ?
+				     "Attempting to compensate.." :
+					  "Ignoring" );
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  not_in_dict
+ *      Synopsis:       Print the message "XXX is not in dictionary."
+ *                      Used from several places...
+ *      
+ *      Inputs:
+ *         Parameters:
+ *             stat_name                Word that could not be processed
+ *
+ *      Outputs:
+ *         Returned Value:              NONE
+ *         Printout:         Error message.
+ *
+ **************************************************************************** */
+
+static void not_in_dict( char *stat_name)
+{
+    tokenization_error ( TKERROR,
+        "Word  %s  is not in dictionary.\n", stat_name);
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  tokenized_word_error
+ *      Synopsis:       Report an error when a word could not be processed
+ *                          by the tokenizer.  Messages will vary...
+ *      
+ *      Inputs:
+ *         Parameters:
+ *             stat_name                Word that could not be processed
+ *         Global Variables:
+ *             in_tokz_esc    TRUE if tokenizer is in "Tokenizer Escape" mode.
+ *
+ *      Outputs:
+ *         Returned Value:              NONE
+ *         Printout:          Error message.  Possible Advisory about
+ *
+ *      Error Detection:
+ *          Error was detected by the calling routine...
+ *
+ *      Process Explanation:
+ *          If the tokenizer is in "Tokenizer Escape" mode, the word might
+ *              be one that can be used in normal tokenization mode;
+ *          Conversely, if the tokenizer is in normal-tokenization mode,
+ *              the word might be one that can be used in the "Escape" mode.
+ *          Or, the word is completely unknown.
+ *          Recognizing the current mode is handled by  word_exists()
+ *          However, we need to test for the *converse* of the current mode,
+ *              so before we call  word_exists()  we are going to save and
+ *              invert the setting of  in_tokz_esc  (and afterwards, of
+ *              course, restore it...)
+ *
+ **************************************************************************** */
+
+static void tokenized_word_error( char *stat_name)
+{
+    char *where_pt1;
+    char *where_pt2;
+    bool found_somewhere;
+    
+    bool sav_in_tokz_esc = in_tokz_esc;
+    in_tokz_esc = INVERSE(sav_in_tokz_esc);
+
+    found_somewhere = word_exists( stat_name, &where_pt1, &where_pt2);
+    if ( found_somewhere )
+    {
+	tokenization_error ( TKERROR, "The word %s is %s recognized "
+	    "in tokenizer-escape mode.\n",
+		 stat_name, sav_in_tokz_esc ? "not" :  "only" );
+    } else {
+	not_in_dict( stat_name);
+    }
+
+    if ( INVERSE(exists_in_ancestor( stat_name)) )
+    {
+        if ( found_somewhere && sav_in_tokz_esc )
+	{
+	    tokenization_error(INFO,
+		"%s is defined %s%s", stat_name, where_pt1, where_pt2 );
+	    show_node_start();
+	}
+    }
+
+    in_tokz_esc = sav_in_tokz_esc;
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  unresolved_instance
+ *      Synopsis:       Print the "unresolved instance" message
+ *
+ *      Inputs:
+ *         Parameters:
+ *             severity                    Severity of the Message
+ *         Local Static Variables:
+ *             instance_filename           File where "instance" invoked
+ *             instance_lineno             Line number where "instance" invoked
+ *
+ *      Outputs:
+ *         Returned Value:                 NONE
+ *         Printout:          Message.
+ *
+ *      Error Detection:
+ *          Error was detected by the calling routine...
+ *
+ **************************************************************************** */
+
+static void unresolved_instance( int severity)
+{
+    tokenization_error( severity, "Unresolved \"INSTANCE\"" );
+    just_where_started( instance_filename, instance_lineno );
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  modified_by_instance
+ *      Synopsis:       Print the "[not] modified by instance" message
+ *
+ *      Inputs:
+ *         Parameters:
+ *             definer                     Internal token for the defining-word
+ *             was_modded                  FALSE if "not modified..."
+ *         Local Static Variables:
+ *             instance_filename           File where "instance" invoked
+ *             instance_lineno             Line number where "instance" invoked
+ *
+ *      Outputs:
+ *         Returned Value:                 NONE
+ *         Printout:          WARNING message.
+ *
+ *      Error Detection:
+ *          Error was detected by the calling routine...
+ *
+ **************************************************************************** */
+
+static void modified_by_instance( fwtoken definer, bool was_modded)
+{
+    char *was_not = was_modded ? "was" : "not" ;
+    char *defn_type_name;
+
+    /*  No need to check the return value  */
+    definer_name(definer, &defn_type_name);
+
+    tokenization_error ( WARNING,
+	"%s definition %s modified by \"INSTANCE\"",
+	    defn_type_name, was_not );
+    just_where_started( instance_filename, instance_lineno );
+ }
+
+/* **************************************************************************
+ *
+ *      Function name:  validate_instance
+ *      Synopsis:       If "instance" is in effect, check whether it is
+ *                          appropriate to the defining-word being called.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             definer                   Internal token for the defining-word
+ *         Local Static Variables:
+ *             is_instance               TRUE if "instance" is in effect.
+ *             instance_definer_gap      TRUE if invalid definer(s) invoked
+ *                                           since "instance" went into effect.
+ *
+ *      Outputs:
+ *         Returned Value:               NONE
+ *         Local Static Variables:
+ *             is_instance               Reset to FALSE if definer was valid.
+ *             instance_definer_gap      TRUE if definer was not valid;
+ *                                           FALSE if definer was valid.
+ *
+ *      Error Detection:
+ *          If "instance" is in effect, the only defining-words that are
+ *              valid are:  value  variable  defer  or  buffer:  Attempts
+ *              to use any other defining-word will be reported with a
+ *              WARNING, but "instance" will remain in effect.
+ *          If an invalid defining-word was invoked since "instance" went
+ *              into effect, then, when it is finally applied to a valid
+ *              definer, issue a WARNING.
+ *
+ *      Process Explanation:
+ *          Implicit in the Standard is the notion that, once INSTANCE has
+ *              been executed, it remains in effect until a valid defining-
+ *              word is encountered.  We will do the same.
+ *
+ **************************************************************************** */
+
+static void validate_instance(fwtoken definer)
+{
+    if ( is_instance )
+    {
+	bool is_error = TRUE ;
+
+	switch ( definer)
+	{
+	    case VALUE:
+	    case VARIABLE:
+	    case DEFER:
+	    case BUFFER:
+		is_error = FALSE;
+	    /*  No default needed, likewise, no breaks;      */
+	    /*  but some compilers get upset without 'em...  */
+	    default:
+		break;
+	}
+
+	if( is_error )
+	{
+	    modified_by_instance(definer, FALSE );
+	    instance_definer_gap = TRUE;
+	}else{
+	    if ( instance_definer_gap )
+	    {
+		modified_by_instance(definer, TRUE );
+	    }
+	    is_instance = FALSE;
+	    instance_definer_gap = FALSE;
+	}
+    }
+}
+    
+
+/* **************************************************************************
+ *
+ *      Function name:  trace_creation
+ *      Synopsis:       If the word being created is on the Trace List,
+ *                          display the appropriate message
+ *
+ *      Inputs:
+ *         Parameters:
+ *             definer                 Internal token for the defining-word
+ *             nu_name                 The word being created
+ *         Global Variables:
+ *             verbose                 No point in doing all this if we're
+ *                                         not showing the message anyway...
+ *             in_tokz_esc             TRUE if we are in Tokenizer-Escape mode
+ *             scope_is_global         TRUE if "global" scope is in effect
+ *             current_device_node     Current dev-node data-struct
+ *
+ *      Outputs:
+ *         Returned Value:             NONE
+ *         Printout:
+ *             Advisory Message, if the word is on the Trace List.
+ *
+ *      Process Explanation:
+ *          The order of scope-checking is important:
+ *              A Local has no scope beyond the definition in which it occurs.
+ *              Tokenizer-Escape mode supercedes "Normal" mode, and renders
+ *                  moot the differences between Global and Device scope.
+ *              Global scope is mutually exclusive with Device scope.
+ *              Device scope needs to identify where the Current device-node
+ *                  began.
+ *
+ **************************************************************************** */
+
+void trace_creation( fwtoken definer, char *nu_name)
+{
+    if ( verbose )
+    {
+	if ( is_on_trace_list( nu_name) )
+	{
+            char  as_what[96] = "";
+	    bool show_last_colon = BOOLVAL( definer == LOCAL_VAL);
+
+	    as_a_what( definer, as_what);  /*  No need to check return value. */
+
+	    /*  Scope-checking starts here, unless  show_last_colon  is TRUE.
+	     *  Come out of this with  as_what[]  filled up and
+	     *      terminated with a new-line, if appropriate,
+	     */
+	    while ( ! show_last_colon )
+	    {
+		strcat( as_what, " ");
+
+		if ( in_tokz_esc )
+		{
+		    strcat( as_what, in_tkz_esc_mode);
+		    break;
+		}
+
+		if ( scope_is_global )
+		{
+		    strcat( as_what, "with Global scope.\n");
+		}else{
+		    /*  In Device scope.  Show the Current node.   */
+		    strcat( as_what, in_what_node( current_device_node));
+		}
+		break;
+
+	    }   /*  Destination of BREAKs ...   */
+
+	    tokenization_error(INFO, "Creating %s %s", nu_name, as_what);
+
+	    if ( show_last_colon )
+	    {
+		in_last_colon();
+	    }else{
+		show_node_start();
+	    }
+
+	}
+    }
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  create_word
+ *      Synopsis:       
+ *
+ *      Inputs:
+ *         Parameters:
+ *             definer             Internal token for the defining-word
+ *         Global Variables:
+ *             control_stack_depth Number of "Control Stack" entries in effect
+ *             nextfcode           FCode-number to be assigned to the new name
+ *             statbuf             Symbol last read from the input stream
+ *             pc                  Input-source Scanning pointer
+ *             hdr_flag            State of headered-ness for name-creation
+ *             force_tokens_case   If TRUE, force token-names' case in FCode
+ *             force_lower_case_tokens
+ *                                 If  force_tokens_case  is TRUE, this
+ *                                     determines which case to force
+ *             iname               Input-source file name; for error-reporting
+ *             lineno              Input-source Line number; also for err-rep't
+ *
+ *      Outputs:
+ *         Returned Value:         TRUE if successful
+ *         Global Variables:  
+ *             nextfcode           Incremented  (by bump_fcode() )
+ *             statbuf             Advanced to next symbol; must be re-read
+ *             pc                  Advanced, then restored to previous value
+ *         Memory Allocated
+ *             Copy of the name being defined, by support routine.
+ *             Copy of input-source file name, for error-reporting
+ *         When Freed?
+ *             Copy of name being defined is freed when Current Device Vocab
+ *                 is "finished", or at end of tokenization.
+ *             Copy of input-source file name is freed at end of this routine.
+ *
+ *      Error Detection:
+ *          ERROR if already inside a colon-definition.  Discontinue
+ *              processing and return FALSE.
+ *          ERROR if inside a control-structure.  Continue processing,
+ *              though, to catch other errors, and even return TRUE;
+ *              except:  leave the new token undefined. 
+ *          Warning on duplicate name (subject to command-line control)
+ *          Message if name is excessively long; Warning if headerless.
+ *          FATAL if the value of  nextfcode  is larger than the legal
+ *              maximum for an FCode, (0x0fff).
+ *
+ *      Revision History:
+ *      Updated Thu, 24 Mar 2005 by David L. Paktor
+ *          Optional warning when name about to be created is a
+ *              duplicate of an existing name.
+ *      Updated Wed, 30 Mar 2005 by David L. Paktor
+ *          Warning when name length exceeds ANSI-specified max (31 chars).
+ *      Updated Tue, 05 Apr 2005 by David L. Paktor
+ *          Add "definer" parameter and call to  add_definer() .  Part
+ *              of the mechanism to forbid attempts to use the  TO 
+ *              directive to change values of CONSTANTs in particular
+ *              and of inappropriate targets in general.
+ *      Updated Fri, 06 May 2005 by David L. Paktor
+ *          Error-detection of   DO ...  LOOP  and  BEGIN ...  imbalance
+ *          Error-detection of  nextfcode  exceeding legal maximum (0x0fff).
+ *      Updated Wed, 20 Jul 2005 by David L. Paktor
+ *          Put Duplicate-Name-Test under command-line control...
+ *      Updated Wed, 24 Aug 2005 by David L. Paktor
+ *          Error-detection via  clear_control_structs()  routine.
+ *      Updated Tue, 10 Jan 2006 by David L. Paktor
+ *          Convert to  tic_hdr_t  type vocabulary.
+ *      Updated Thu, 20 Apr 2006 by David L. Paktor
+ *          Allow creation of new definition within body of a flow-control
+ *              structure.  (Remove error-detection via  clear_control_structs)
+ *      Updated Tue, 13 Jun 2006 by David L. Paktor
+ *          Move detection of out-of-bounds  nextfcode  to  assigning_fcode()
+ *              routine, which also detects Overlapping Ranges error.
+ *      Updated Thu, 27 Jun 2006 by David L. Paktor
+ *          Report Error for attempt to create def'n inside control structure.
+ *
+ *      Extraneous Remarks:
+ *          We must not set  incolon  to TRUE (if we are creating a colon
+ *              definition) until *AFTER* this routine has been called, due
+ *              to the initial error-checking.  If we need to detect whether
+ *              we are creating a colon definition, we can do so by testing
+ *              whether the parameter, DEFINER, equals COLON .
+ *
+ **************************************************************************** */
+
+static bool create_word(fwtoken definer)
+{
+    signed long wlen;
+    bool retval = FALSE;
+    char *defn_type_name;
+
+    /*  If already inside a colon, ERROR and discontinueprocessing    */
+    /*  If an alias to a definer is used, show the name of the alias  */
+    if ( test_in_colon(statbuf, FALSE, TKERROR, NULL) ) 
+    {
+	char defn_type_buffr[32] = "";
+	unsigned int old_lineno = lineno;    /*  For error message  */
+	bool define_token = TRUE;
+
+	{   /*  Set up definition-type text for error-message */
+
+	    /*  No need to check the return value  */
+	    definer_name(definer, &defn_type_name);
+
+	    strcat( defn_type_buffr, defn_type_name);
+	    strcat( defn_type_buffr, " definition");
+	}
+	/*  If in a control-structure, ERROR but continue processing  */
+	if ( control_stack_depth != 0 )
+	{
+	    announce_control_structs( TKERROR, defn_type_buffr, 0);
+	    /*  Leave the new token undefined.  */
+	    define_token = FALSE;
+	}
+
+	/*  Get the name of the new token  */
+	wlen = get_word();
+
+#ifdef DEBUG_SCANNER
+	printf("%s:%d: debug: defined new word %s, fcode no 0x%x\n",
+			iname, lineno, name, nextfcode);
+#endif
+	if ( wlen <= 0 )
+	{
+	    warn_unterm( TKERROR, defn_type_buffr, old_lineno);
+	}else{
+	    bool emit_token_name = TRUE;
+
+	    /*  Handle Tracing of new definitions  */
+	    trace_creation( definer, statbuf);
+
+	    /*  Other Error or Warnings as applicable  */
+	    validate_instance( definer);
+	    warn_if_duplicate( statbuf);
+	    check_name_length( wlen);
+
+	    /*  Bump FCode; error-check as applicable  */
+	    assigning_fcode();
+
+	    /*  Define the new token, unless disallowed  */
+	    add_to_current( statbuf, nextfcode, definer, define_token);
+
+	    /*  Emit appropriate FCodes:  Type of def'n,   */
+	    switch ( hdr_flag )
+	    {
+		case FLAG_HEADERS:
+		    emit_token("named-token");
+		    break;
+
+		case FLAG_EXTERNAL:
+		    emit_token("external-token");
+		    break;
+
+		default:  /*   FLAG_HEADERLESS   */
+		    emit_token("new-token");
+		    emit_token_name = FALSE;
+	    }
+
+	    /*  Emit name of token, if applicable  */
+	    if ( emit_token_name )
+	    {
+		if ( force_tokens_case )
+		{
+		    if ( force_lower_case_tokens )
+		    {
+			strlwr( statbuf);
+		    }else{
+			strupr( statbuf);
+		    }
+		}
+		emit_string((u8 *)statbuf, wlen);	
+	    }
+
+	    /*  Emit the new token's FCode   */
+	    emit_fcode(nextfcode);
+
+	    /*  Prepare FCode Assignment Counter for next definition   */
+	    bump_fcode();
+
+	    /*  Declare victory   */
+	    retval = TRUE;
+	}
+    }
+    return( retval);
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  cannot_apply
+ *      Synopsis:       Print error message of the form:
+ *                     "Cannot apply <func> to <targ>, which is a <def'n>"
+ *
+ *      Inputs:
+ *         Parameters:
+ *             func_nam                    The name of the function
+ *             targ_nam                    The name of the target
+ *             defr                        The numeric-code of the definer-type
+ *
+ *      Outputs:
+ *         Returned Value:                 NONE
+ *         Printout:
+ *             The error message is the entire printout of this routine
+ *
+ *      Error Detection:
+ *          Error was detected by calling routine
+ *
+ *      Process Explanation:
+ *          The calling routine already looked up the definer for its
+ *              own purposes, so we don't need to do that again here.
+ *
+ *      Still to be done:
+ *          If the definer-name is not found, we might still look up
+ *              the target name in the various vocabularies and use
+ *              a phrase for those.  E.g., if it is a valid token,
+ *              we could say it's defined as a "primitive".  (I'm
+ *              not sure what we'd say about an FWord...)
+ *
+ **************************************************************************** */
+
+static void cannot_apply( char *func_nam, char *targ_nam, fwtoken defr)
+{
+    char *defr_name = "" ;
+    const char *defr_phrase = ", which is defined as a " ;
+
+    if ( ! definer_name(defr, &defr_name) )
+    {
+	defr_phrase = "";
+    }
+
+    tokenization_error ( TKERROR , 
+	"Cannot apply  %s  to  %s %s%s.\n",
+	     func_nam, targ_nam, defr_phrase, defr_name );
+
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  lookup_with_definer
+ *      Synopsis:       Return pointer to data-structure of named word,
+ *                      if it's valid in Current context, and supply its
+ *                      definer.  If it's not valid in Current context,
+ *                      see if it might be a Local, and supply that definer.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             stat_name                  Name to look up
+ *             *definr                    Pointer to place to put the definer.
+ *
+ *      Outputs:
+ *         Returned Value:                Pointer to data-structure, or
+ *                                            NULL if not in Current context.
+ *         Supplied Pointers:
+ *             *definr                    Definer; possibly LOCAL_VAL
+ *
+ *      Process Explanation:
+ *          If the name is not found in the Current context, and does not
+ *              exist as a Local, *definr will remain unchanged.
+ *
+ *      Extraneous Remarks:
+ *          This is an odd duck^H^H^H^H^H^H^H^H^H^H^H^H a highly-specialized 
+ *              routine created to meet some corner-case needs engendered by
+ *              the conversion to tic_hdr_t vocabularies all around, combined
+ *              with an obsessive urge to preserve a high level of detail in
+ *              our error-messages.
+ *
+ **************************************************************************** */
+
+static tic_hdr_t *lookup_with_definer( char *stat_name, fwtoken *definr )
+{
+    tic_hdr_t *retval = lookup_current( stat_name);
+    if ( retval != NULL )
+    {
+         *definr = retval->fword_defr;
+    }else{
+        if ( exists_as_local( stat_name) ) *definr = LOCAL_VAL;
+    }
+    return ( retval );
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  validate_to_target
+ *      Synopsis:       Print a message if the intended target
+ *                          of the  TO  directive is not valid
+ *      
+ *      Inputs:
+ *         Parameters:                NONE
+ *         Global Variables:
+ *             statbuf             Next symbol to be read from the input stream
+ *             pc                  Input-source Scanning pointer
+ *
+ *      Outputs:
+ *         Returned Value:         TRUE = Allow  b(to)  token to be output.
+ *         Global Variables:
+ *             statbuf             Advanced to next symbol; must be re-read
+ *             pc                  Advanced, then restored to previous value
+ *
+ *      Error Detection:
+ *          If next symbol is not a valid target of  TO , issue ERROR    
+ *              message.  Restored  pc  will cause the next symbol to
+ *              be processed by ordinary means.
+ *          Allow  b(to)  token to be output in selected cases.  Even if
+ *              user has set the "Ignore Errors" flag, certain targets are
+ *              still too risky to be allowed to follow a  b(to)  token;
+ *              if "Ignore Errors" is not set, output won't get created
+ *              anyway.
+ *          Issue ERROR in the extremely unlikely case that "to" is the
+ *              last word in the Source.
+ *
+ *      Process Explanation:
+ *          Valid targets for a TO directive are words defined by:
+ *              DEFER, VALUE and arguably VARIABLE.  We will also allow
+ *              CONSTANT, but will still issue an Error message.
+ *          After the check, restore  pc ; this was only a look-ahead.
+ *              Also restore  lineno  and  abs_token_no 
+ *
+ *      Extraneous Remarks:
+ *          Main part of the mechanism to detect attempts to use the  TO 
+ *              directive to change the values of CONSTANTs in particular
+ *              and of inappropriate targets in general.
+ *
+ **************************************************************************** */
+
+static bool validate_to_target( void )
+{
+    signed long wlen;
+    tic_hdr_t *test_entry;
+    u8 *saved_pc = pc;
+    char *cmd_cpy = strupr( strdup( statbuf));    /*  For error message  */
+    unsigned int saved_lineno = lineno;
+    unsigned int saved_abs_token_no = abs_token_no;
+    fwtoken defr = UNSPECIFIED ;
+    bool targ_err = TRUE ;
+    bool retval = FALSE ;
+
+    wlen = get_word();
+    if ( wlen <= 0 )
+    {
+	warn_unterm( TKERROR, cmd_cpy, saved_lineno);
+    }else{
+
+	test_entry = lookup_with_definer( statbuf, &defr);
+	if ( test_entry != NULL )
+	{
+	    switch (defr)
+	    {
+		case VARIABLE:
+		    tokenization_error( WARNING,
+			"Applying %s to a VARIABLE (%s) is "
+			"not recommended; use  !  instead.\n",
+			cmd_cpy, statbuf);
+		case DEFER:
+		case VALUE:
+		    targ_err = FALSE ;
+		case CONST:
+		    retval = TRUE ;
+		/*  No default needed, likewise, no breaks;      */
+		/*  but some compilers get upset without 'em...  */
+		default:
+		    break;
+	    }
+	}
+
+	if ( targ_err )
+	{
+	    cannot_apply(cmd_cpy, strupr(statbuf), defr );
+	}
+
+	pc = saved_pc;
+	lineno = saved_lineno;
+	abs_token_no = saved_abs_token_no;
+    }
+    free( cmd_cpy);
+    return( retval);
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  you_are_here
+ *      Synopsis:       Display a generic Advisory of the Source command
+ *                          or directive encountered and being processed
+ *
+ *      Inputs:
+ *         Parameters:                NONE
+ *         Global Variables:
+ *             statbuf                The command being processed 
+ *
+ *      Outputs:
+ *         Returned Value:            NONE
+ *         Printout:
+ *             Advisory message
+ *
+ **************************************************************************** */
+
+static void you_are_here( void)
+{
+    tokenization_error( INFO,
+	"%s encountered; processing...\n",
+	    strupr(statbuf) );
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  fcode_starter
+ *      Synopsis:       Respond to one of the "FCode Starter" words
+ *      
+ *      Inputs:
+ *         Parameters:
+ *             token_name         The FCode-token for this "Starter" word
+ *             spread             The separation between tokens.
+ *             is_offs16          Whether we are using a 16-bit number
+ *                                    for branch- (and suchlike) -offsets,
+ *                                    or the older-style 8-bit offset numbers.
+ *         Global Variables:
+ *            iname               Input-File name, used to set ifile_name 
+ *                                    field of  current_device_node
+ *            lineno              Current Input line number, used to set
+ *                                    line_no field of  current_device_node
+ *         Local Static Variables:
+ *            fcode_started       If this is TRUE, we have an Error.
+ *            first_fc_starter    Control calling  reset_fcode_ranges() ;
+ *                                    only on the first fcode_starter of
+ *                                    a tokenization.
+ *
+ *      Outputs:
+ *         Returned Value:        NONE
+ *         Global Variables:
+ *            offs16              Global "16-bit-offsets" flag
+ *            current_device_node   The ifile_name and line_no fields will be
+ *                                    loaded with the current input file name
+ *                                    and line number.  This node will be the
+ *                                    top-level device-node.
+ *            FCode Ranges will be reset the first time per tokenization
+ *                that this routine is entered.
+ *            A new FCode Range will be started every time after that.
+ *         Local Static Variables:
+ *            fcode_started       Set to TRUE.  We invoke the starter only
+ *                                    once per image-block.
+ *            first_fc_starter    Reset to FALSE if not already
+ *         Memory Allocated
+ *             Duplicate of Input-File name
+ *         When Freed?
+ *             In  fcode_ender()
+ *
+ *      Error Detection:
+ *          Spread of other than 1 -- Warning message.
+ *          "FCode Starter" previously encountered -- Warning and ignore.
+ *
+ *      Question under consideration:
+ *          Do we want directives -- such as definitions of constants --
+ *              supplied before the "FCode Starter", to be considered as
+ *              taking place in "Tokenizer Escape" mode?  That would mean
+ *              the "Starter" functions must be recognized in "Tokenizer
+ *              Escape" mode.  Many ramifications to be thought through...
+ *          I think I'm coming down strongly on the side of "No".  The user
+ *              who wants to do that can very well invoke "Tokenizer Escape"
+ *              mode explicitly.
+ *
+ **************************************************************************** */
+
+static void fcode_starter( const char *token_name, int spread, bool is_offs16)
+{
+    you_are_here();
+    if ( spread != 1 )
+    {
+        tokenization_error( WARNING, "spread of %d not supported.\n", spread);
+    }
+    if ( fcode_started )
+    {
+        tokenization_error( WARNING,
+	    "Only one \"FCode Starter\" permitted per tokenization.  "
+		"Ignoring...\n");
+    } else {
+
+	emit_fcodehdr(token_name);
+	offs16 = is_offs16;
+	fcode_started = TRUE;
+
+	current_device_node->ifile_name = strdup(iname);
+	current_device_node->line_no = lineno;
+
+	if ( first_fc_starter )
+	{
+	    reset_fcode_ranges();
+	    first_fc_starter = FALSE;
+	}else{
+	    set_next_fcode( nextfcode);
+	}
+    }
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  fcode_end_err_check
+ *      Synopsis:       Do error-checking at end of tokenization,
+ *                          whether due to FCODE-END or end-of-file,
+ *                          and reset the indicators we check.
+ *
+ *      Inputs:
+ *         Parameters:                    NONE
+ *         Global Variables:
+ *             Data-Stack depth     Is anything left on the stack?
+ *
+ *      Outputs:
+ *         Returned Value:                NONE
+ *         Global Variables:
+ *             Data-Stack           Reset to empty
+ *
+ *      Error Detection:
+ *          Unresolved control structures detected by clear_control_structs()
+ *          If anything is left on the stack, it indicates some incomplete
+ *              condition; we will treat it as a Warning.
+ *
+ **************************************************************************** */
+
+static void fcode_end_err_check( void)
+{
+    bool stack_imbal = BOOLVAL( stackdepth() != 0 );
+
+	if ( stack_imbal )
+	{
+	    tokenization_error( WARNING,
+		"Stack imbalance before end of tokenization.\n");
+	}
+    clear_stack();
+    clear_control_structs("End of tokenization");
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  fcode_ender
+ *      Synopsis:       Respond to one of the "FCode Ender" words:
+ *                          The FCode-token for "End0" or "End1"
+ *                              has already been written to the
+ *                              FCode Output buffer.
+ *                          Finish the FCode header:  fill in its
+ *                              checksum and length.
+ *                          Reset the token names defined in "normal" mode
+ *                          (Does not reset the FCode-token number)
+ *
+ *      Associated FORTH words:                 END0, END1
+ *      Associated Tokenizer directive:         FCODE-END
+ *
+ *      Inputs:
+ *         Parameters:            NONE
+ *         Global Variables:
+ *             incolon            If TRUE, a colon def'n has not been completed
+ *             last_colon_filename         For error message.
+ *             last_colon_lineno           For error message.
+ *             scope_is_global             For error detection
+ *             is_instance                 For error detection
+ *
+ *      Outputs:
+ *         Returned Value:        NONE
+ *         Global Variables:
+ *             haveend            Set to TRUE
+ *             fcode_started      Reset to FALSE.  Be ready to start anew.
+ *             FCode-defined tokens, aliases and macros -- i.e., those
+ *                 *NOT* defined in tokenizer-escape mode -- are reset.
+ *                 (Also, command-line-defined symbols are preserved).
+ *             Vocabularies will be reset
+ *             Device-node data structures will be deleted
+ *             Top-level device-node ifile_name and line_no fields
+ *                 will be reset.
+ *         Memory Freed
+ *             Duplicate of Input-File name, in top-level device-node.
+ *         Printout:
+ *             Advisory message giving current value of nextfcode
+ *                 (the "FCode-token Assignment Counter")
+ *
+ *      Error Detection:
+ *          ERROR if a Colon definition has not been completed.
+ *          ERROR if "instance" is still in effect
+ *          WARNING if Global-Scope has not been terminated; compensate.
+ *
+ *      Extraneous Remarks:
+ *          In order to accommodate odd cases, such as multiple FCode blocks
+ *          within a single PCI header, this routine does not automatically
+ *          reset nextfcode  to h# 0800
+ *
+ **************************************************************************** */
+
+void fcode_ender(void)
+{
+    if ( incolon )
+    {
+	char *tmp_iname = iname;
+	iname = last_colon_filename;
+	unterm_is_colon = TRUE;
+	warn_unterm( TKERROR, "Colon Definition", last_colon_lineno);
+	iname = tmp_iname;    
+    }
+    
+    haveend = TRUE;
+
+    if ( is_instance )
+    {
+	unresolved_instance( TKERROR);
+    }
+
+    if ( scope_is_global )
+    {
+        tokenization_error( WARNING ,
+	    "No DEVICE-DEFINITIONS directive encountered before end.  "
+		"Compensating...\n");
+	resume_device_scope();
+    }
+    fcode_end_err_check();
+    reset_normal_vocabs();
+    finish_fcodehdr();
+    fcode_started = FALSE;
+
+    if ( current_device_node->ifile_name != default_top_dev_ifile_name )
+    {
+	free( current_device_node->ifile_name );
+	current_device_node->ifile_name = default_top_dev_ifile_name;
+	current_device_node->line_no = 0;
+    }
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  get_token
+ *      Synopsis:       Read the next word in the input stream and retrieve
+ *                          its FCode-token number.  If it's not a symbol to
+ *                          which a single token is assigned (e.g., if it's
+ *                          a macro), report an error.
+ *
+ *      Associated FORTH words:                   [']  '
+ *      Associated Tokenizer directive:          F[']
+ *
+ *      Inputs:
+ *         Parameters:
+ *             *tok_entry             Place to put the pointer to token entry
+ *         Global Variables:
+ *             statbuf                The command being processed 
+ *             pc                     Input stream character pointer
+ *
+ *      Outputs:
+ *         Returned Value:            TRUE if successful (i.e., no error)
+ *         Supplied Pointers:
+ *             *tok_entry             The token entry, if no error
+ *         Global Variables:
+ *             statbuf                The next word in the input stream
+ *             pc                     Restored to previous value if error
+ *
+ *      Error Detection:
+ *          The next word in the input stream is expected to be on the
+ *              same line as the directive.  The  get_word_in_line()
+ *              routine will check for that.
+ *          If the next word in the input stream is not a symbol
+ *              for which a single-token FCode number is assigned,
+ *              report an ERROR and restore PC to its previous value.
+ *
+ **************************************************************************** */
+
+static bool get_token(tic_hdr_t **tok_entry)
+{
+    bool retval = FALSE;
+    u8 *save_pc;
+
+    /*  Copy of command being processed, for error message  */
+    char cmnd_cpy[FUNC_CPY_BUF_SIZE+1];
+    strncpy( cmnd_cpy, statbuf, FUNC_CPY_BUF_SIZE);
+    cmnd_cpy[FUNC_CPY_BUF_SIZE] = 0;   /*  Guarantee null terminator. */
+
+    save_pc = pc;
+
+    if ( get_word_in_line( statbuf) )
+    {
+	fwtoken defr = UNSPECIFIED;
+
+	/*  We need to scan the newest definitions first; they
+	 *      might supercede standard ones.  We need, though,
+	 *      to bypass built-in FWords that need to trigger
+	 *      some tokenizer internals before emitting their
+	 *      synonymous FCode Tokens, (e.g., version1 , end0 ,
+	 *      and start{0-4}); if we find one of those, we will
+	 *      need to search again, specifically within the list
+	 *      of FCode Tokens.
+	 */
+	*tok_entry = lookup_with_definer( statbuf, &defr);
+	if ( *tok_entry != NULL )
+	{
+	    /*  Built-in FWords can be uniquely identified by their
+	     *      definer,  BI_FWRD_DEFN .  The definer for "shared"
+	     *      FWords is  COMMON_FWORD  but there are none of
+	     *      those that might be synonymous with legitimate
+	     *      FCode Tokens, nor are any likely ever to be...
+	     */
+	    if ( defr == BI_FWRD_DEFN )
+	    {
+	        *tok_entry = lookup_token( statbuf);
+		retval = BOOLVAL( *tok_entry != NULL );
+	    }else{
+		retval = entry_is_token( *tok_entry);
+	    }
+	}
+
+	if ( INVERSE( retval) )
+	{
+	    cannot_apply( cmnd_cpy, strupr(statbuf), defr );
+	    pc = save_pc;
+	}
+    }
+
+    return ( retval );
+}
+
+
+static void base_change ( int new_base )
+{
+    if ( incolon && ( INVERSE( in_tokz_esc) ) )
+    {
+        emit_literal(new_base );
+	emit_token("base");
+	emit_token("!");
+    } else {
+        base = new_base;
+    }
+}
+
+static void base_val (int new_base)
+{
+    u8  *old_pc;
+
+    char base_cmnd[FUNC_CPY_BUF_SIZE+1];
+    strncpy( base_cmnd, statbuf, FUNC_CPY_BUF_SIZE);
+    base_cmnd[FUNC_CPY_BUF_SIZE] = 0;  /* Guarantee NULL terminator */
+
+    old_pc=pc;
+    if ( get_word_in_line( statbuf) )
+    {
+	u8 basecpy=base;
+
+	base = new_base;
+	if ( ! handle_number() )
+	{
+	    /*  We did get a word on the line, but it's not a valid number */
+	    tokenization_error( WARNING ,
+		 "Applying %s to non-numeric value.  Ignoring.\n",
+		      strupr(base_cmnd) );
+	    pc = old_pc;
+	}
+	base=basecpy;
+    }
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  eval_string
+ *      Synopsis:       Prepare to tokenize a string, artificially generated
+ *                          by this program or created as a user-defined
+ *                          Macro.   When done, resume at existing source.
+ *                      Keep the file-name and line-number unchanged.
+ *      
+ *      Inputs:
+ *         Parameters:
+ *             inp_bufr          String (or buffer) to evaluate
+ *
+ *      Outputs:
+ *         Returned Value:       NONE
+ *         Global Variables, changed by call to init_inbuf():
+ *             start             Points to given string
+ *             pc                         ditto
+ *             end               Points to end of given string
+ *
+ *      Revision History:
+ *          Updated Thu, 23 Feb 2006 by David L. Paktor
+ *              This routine no longer calls its own instance of  tokenize()
+ *              It has become the gateway to the mechanism that makes a
+ *                  smooth transition between the body of the Macro, User-
+ *                  defined Symbol or internally-generated string and the
+ *                  resumption of processing the source file. 
+ *              A similar (but more complicated) transition when processing
+ *                  an FLOADed file will be handled elsewhere.
+ *          Updated Fri, 24 Feb 2006 by David L. Paktor
+ *              In order to support Macro-recursion protection, this routine
+ *                  is no longer the gateway for Macros; they will have to
+ *                  call push_source() directly.
+ *
+ **************************************************************************** */
+
+void eval_string( char *inp_bufr)
+{
+    push_source( NULL, NULL, FALSE);
+    init_inbuf( inp_bufr, strlen(inp_bufr));
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  finish_or_new_device
+ *      Synopsis:       Handle the shared logic for the NEW-DEVICE and
+ *                          FINISH-DEVICE commands.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             finishing_device		   TRUE for FINISH-DEVICE,
+ *					       FALSE for NEW-DEVICE
+ *         Global Variables:
+ *             incolon			     TRUE if inside a colon definition
+ *             noerrors 		     TRUE if ignoring errors
+ *             scope_is_global		     TRUE if "global scope" in effect
+ *         Local Static Variables:
+ *             is_instance		     TRUE if "instance" is in effect
+ *             dev_change_instance_warning   TRUE if warning hasn't been issued
+ *
+ *      Outputs:
+ *         Returned Value: 		     NONE
+ *         Local Static Variables:
+ *             dev_change_instance_warning   FALSE if warning is issued
+ *             instance_definer_gap	     TRUE if "instance" is in effect
+ *
+ *      Error Detection:
+ *          NEW-DEVICE and FINISH-DEVICE should not be used outside of
+ *              a colon-definition if global-scope is in effect.  Error
+ *              message; no further action unless we are ignoring errors.
+ *          Issue a WARNING if INSTANCE wasn't resolved before the current
+ *              device-node is changed.  Try not to be too repetitive...
+ *
+ *      Process Explanation:
+ *          The words NEW-DEVICE and FINISH-DEVICE may be incorporated into
+ *              a colon-definition, whether the word is defined in global-
+ *              or device- -scope.  Such an incorporation does not effect
+ *              a change in the device-node vocabulary; simply emit the token.
+ *          If we are in interpretation mode, though, we need to check for
+ *              errors before changing the device-node vocabulary:
+ *          If global-scope is in effect, we need to check whether we are
+ *              ignoring errors; if so, we will compensate by switching to  
+ *              device-scope.
+ *          If "instance" is in effect, it's "dangling".  It will remain
+ *              in effect through a device-node change, but this is very
+ *              bad style and deserves a WARNING, but only one for each
+ *              occurrence.  It would be unaesthetic, to say the least,
+ *              to have multiple messages for the same dangling "instance"
+ *              in a "finish-device   new-device" sequence.
+ *           We must be careful about the order we do things, because of
+ *              the messages printed as a side-effect of the node change...
+ *
+ *      Extraneous Remarks:
+ *          I will violate strict structure here.
+ *
+ **************************************************************************** */
+
+static void finish_or_new_device( bool finishing_device )
+{
+    if ( INVERSE( incolon ) )
+    {
+	if ( INVERSE( is_instance) )
+	{
+	    /*  Arm warning for next time:         */
+	    dev_change_instance_warning = TRUE;
+	}else{
+	    /*  Dangling "instance"                */
+	    instance_definer_gap = TRUE;
+	    /*   Warn only once.                   */
+	    if ( dev_change_instance_warning )
+	    {
+		unresolved_instance( WARNING);
+		dev_change_instance_warning = FALSE;
+	    }
+	}
+
+	/*  Note:  "Instance" cannot be in effect during "global" scope  */ 
+	if ( scope_is_global )
+	{
+	    glob_not_allowed( TKERROR, noerrors );
+	    if ( noerrors )
+	    {
+		 resume_device_scope();
+	    }else{
+		 return;
+	    }
+	}
+
+	if ( finishing_device )
+	{
+	     finish_device_vocab();
+	}else{
+	     new_device_vocab();
+	}
+    }
+    emit_token( finishing_device ? "finish-device" : "new-device" );
+	}
+	
+	
+/* **************************************************************************
+ *
+ *      Function name:  abort_quote
+ *      Synopsis:       Optionally implement the   ABORT"  function as
+ *                      though it were a macro.  Control whether to allow
+ *                      it, and which style to support, via switches set
+ *                      on the command-line at run-time.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             tok                       Numeric-code associated with the
+ *                                           FORTH word that was just read.
+ *         Global Variables:
+ *             enable_abort_quote        Whether to allow ABORT"
+ *             sun_style_abort_quote     SUN-style versus Apple-style
+ *             abort_quote_throw         Whether to use -2 THROW vs ABORT
+ *
+ *      Outputs:
+ *         Returned Value:     TRUE if it was handled
+ *         Global Variables:
+ *             report_multiline              Reset to FALSE.
+ *         Printout:
+ *             ADVISORY:   ABORT" in fcode is not defined by IEEE 1275-1994
+ *
+ *      Error Detection:
+ *          Performed by other routines.  If user selected not to
+ *              allow  ABORT" , it will simply be treated as an
+ *              unknown word.
+ *          The string following it, however, will still be consumed.
+ *
+ *      Process Explanation:
+ *          If the supplied  tok  was not  ABORTTXT , then return FALSE.
+ *          If the  enable_abort_quote  flag is FALSE, consume the
+ *              string following the Abort" token, but be careful to
+ *              leave the  Abort" token in statbuf, as it will be used
+ *              for the error message.
+ *          Otherwise, create and prepare for processing the appropriate Macro:
+ *              For Apple Style, we push the specified string onto the stack
+ *                  and do -2 THROW (and hope the stack unwinds correctly).
+ *              For Sun Style, we test the condition on top of the stack,
+ *                  and if it's true, print the specified string before we
+ *                  do the -2 THROW.
+ *          We perform the underlying operations directly:  placing an "IF"
+ *              (if Sun Style), then placing the string.  This bypasses
+ *              any issues of double-parsing, as well as of doubly checking
+ *              for a multi-line string.
+ *          Finally, we perform the operational equivalents of the remainder
+ *              of the command sequence.
+ *
+ *      Extraneous Remarks:
+ *          I would have preferred not to have to directly perform the under-
+ *              lying operations, and instead simply prepare the entire command
+ *              sequence in a buffer, but I needed to handle the case where
+ *              quote-escaped quotes are included in the string:  If the string
+ *              were simply to be reproduced into the buffer, the quote-escaped
+ *              quotes would appear as plain quote-marks and terminate the
+ *              string parsing prematurely, leaving the rest of the string
+ *              to be treated as code instead of text...
+ *          Also, the introduction of the variability of whether to do the
+ *               -2 THROW  or to compile-in the token for  ABORT  makes the
+ *              buffer-interpretation scheme somewhat too messy for my tastes.
+ *
+ **************************************************************************** */
+	
+static bool abort_quote( fwtoken tok)
+{
+    bool retval = FALSE;
+    if ( tok == ABORTTXT )
+    {
+	if ( ! enable_abort_quote )
+	{
+	    /* ABORT" is not enabled; we'd better consume the string  */
+	    char *save_statbuf;
+	    signed long wlen;
+	    save_statbuf = strdup( (char *)statbuf);
+	    wlen = get_string( FALSE);
+	    strcpy( statbuf, save_statbuf);
+	    free( save_statbuf);
+	}else{
+	    /* ABORT" is not to be used in FCODE drivers
+	     * but Apple drivers do use it. Therefore we
+	     * allow it. We push the specified string to
+	     * the stack, do -2 THROW and hope that THROW
+	     * will correctly unwind the stack.
+	     * Presumably, Apple Source supplies its own
+	     *  IF ... THEN
+	     */
+	    char *abort_string;
+	    signed long wlen;
+
+	    retval = TRUE;
+	    tokenization_error (INFO, "ABORT\" in fcode not "
+			    "defined by IEEE 1275-1994\n");
+	    test_in_colon("ABORT\"", TRUE, TKERROR, NULL);
+	    wlen=get_string( TRUE);
+
+	    if ( sun_style_abort_quote )  emit_if();
+
+	    emit_token("b(\")");
+	    emit_string(statbuf, wlen);
+	
+	    if ( sun_style_abort_quote )  emit_token("type");
+
+	    if ( abort_quote_throw )
+	    {
+		emit_literal( -2);
+		emit_token("throw");
+	    }else{
+		emit_token("abort");
+	}
+		
+	    if ( sun_style_abort_quote )  emit_then();
+	        /*  Sun Style  */
+		abort_string = " type -2 THROW THEN:" ;
+}
+	}
+    return( retval );
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  create_alias
+ *      Synopsis:       Create an alias, as specified by the user
+ *
+ *      Associated FORTH word:                 ALIAS
+ *
+ *      Inputs:
+ *         Parameters:                NONE
+ *         Global Variables:
+ *             incolon                Colon-def'n-in-progress indicator
+ *             in_tokz_esc            "Tokenizer Escape" mode indicator
+ *         Input Stream
+ *             Two words will be read.
+ *
+ *      Outputs:
+ *         Returned Value:            TRUE if succeeded.
+ *         Global Variables:    
+ *             statbuf                New name will be copied back into here.
+ *         Memory Allocated
+ *             The two words will be copied into freshly-allocated memory 
+ *                 that will be passed to the create_..._alias()  routine.
+ *         When Freed?
+ *             When Current Device Vocabulary is "finished", or at end
+ *                 of tokenization, or upon termination of program.
+ *             If not able to create alias, the copies will be freed here.
+ *
+ *      Error Detection:
+ *          If the ALIAS command was given during colon-definition, that
+ *              can be handled by this tokenizer, but it is not supported
+ *              by IEEE 1275-1994.  Issue a WARNING.
+ *          If the new name is a copy of an existing word-name, issue a warning.
+ *          If the word to which an alias is to be created does not exist
+ *              in the appropriate mode -- relative to "Tokenizer-Escape" --
+ *              that is an ERROR.
+ *          If "instance" is in effect, the ALIAS command is an ERROR.
+ *
+ *      Process Explanation:
+ *          Get two words -- the new name and the "old" word -- from the
+ *              same line of input as the ALIAS command.
+ *          Copy the new name back into statbuf for use in trace_creation.
+ *          Determine whether or not we are in "Tokenizer-Escape" mode.
+ *              Subsequent searches will take place in that same mode.
+ *          If the "new" name already exists, issue a warning.
+ *          In each vocabulary applicable to the current mode -- i.e., 
+ *                  "Tokenizer-Escape" or "Normal" -- (except:  cannot
+ *                  make aliases to "Locals"):
+ *              Try using the  create_..._alias()  routine.
+ *              If it succeeds, we are done.
+ *          IMPORTANT:  The order in which we try the vocabularies MUST
+ *              match the order in which  tokenize_one_word()  searches them. 
+ *          If all the attempts failed, the "old" word does not exist;
+ *              declare an ERROR and free up the memory that was allocated.
+ *
+ *      Extraneous Remarks:
+ *          With the separation of the  tokenizer[  state, this
+ *              function has become too complicated to keep as a
+ *              simple  CASE  in the big  SWITCH  statement anymore...
+ *
+ *          I had earlier thought that it was sufficient to create a
+ *              macro linking the "new" name to the "old" word.  There
+ *              were too many cases, though, where that didn't work.
+ *              This is cleaner.
+ *
+ *          I will not be adhering to the strict rules of structure in
+ *              this routine, as it would get me nested too deeply...
+ *
+ *      Revision History:
+ *          Updated Tue, 10 Jan 2006 by David L. Paktor
+ *              Convert to  tic_hdr_t  type vocabularies.
+ *
+ **************************************************************************** */
+
+static bool create_alias( void )
+{
+    char *new_alias ;
+
+    validate_instance(ALIAS);
+    if ( incolon )
+    {
+	 tokenization_error ( WARNING,
+	    "ALIAS during colon-definition "
+		"is not supported by IEEE 1275-1994\n");
+}
+    if ( get_word_in_line( "ALIAS") )
+    {
+
+	new_alias = strdup((char *)statbuf);
+
+	if (get_word_in_line( "ALIAS") )
+{
+	    char *old_name = strdup((char *)statbuf) ;
+
+	    /*  Copy the "new" alias name back into statbuf.
+	     *      This is a HACK ^H^H^H^H awkward way to retrofit
+	     *      support for the  trace_creation()  function.
+	     */
+	    strcpy( statbuf, new_alias);
+
+	    /*  We don't call  trace_creation()  here because we don't
+	     *      know if the creation succeeded.  However, we want
+	     *      to issue a "Duplicate" warning based on the attempt,
+	     *      even if it doesn't succeed.
+	     *  We would prefer to have the "Trace" message precede the 
+	     *      "Duplicate" warning, but we don't think it's worth
+	     *      the effort.  When it becomes worthwhile, the way to
+	     *      do it would be to factor out the block that handles
+	     *      normal-tokenization versus "Tokenizer-Escape" mode;
+	     *      condition the "Trace" message on its success-return, 
+	     *      show the "Duplicate" warning in any case, then show
+	     *      the error-message and do the cleanup conditioned on
+	     *      a failure-return.
+	     *  That will also obviate the need for a return value from
+	     *      this routine and for the copy-back into statbuf.
+	     */
+	    warn_if_duplicate(new_alias);
+
+	    /*
+	     *  Here is where we begin trying the  create_..._alias() 
+	     *      routines for the vocabularies.
+	     */
+
+	    /*
+	     *  Distinguish between "Normal" tokenization mode
+	     *  and "Tokenizer Escape" mode
+	     */
+	    if ( in_tokz_esc )
+	    {
+		if ( create_tokz_esc_alias( new_alias, old_name) )
+		    return(TRUE);
+	
+		/*
+		 *  Handle the classes of operatives that are common between
+		 *      "Tokenizer Escape" mode and "Normal" tokenization mode.
+		 *  Those classes include selected non-fcode forth constructs
+		 *     and Conditional-Compilation Operators.
+		 */
+		{
+		    tic_hdr_t *found = lookup_shared_word( old_name);
+		    if ( found != NULL )
+		    {
+			if ( create_core_alias( new_alias, old_name) )
+			    return(TRUE);
+		    }
+	}
+	    }else{
+        	/*  "Normal" tokenization mode  */
+	
+		/*  Can create aliases for "Locals", why not?  */
+		if ( create_local_alias( new_alias, old_name) )
+		    return(TRUE);
+
+		/*
+		 *  All other classes of operatives -- non-fcode forth
+		 *      constructs, Standard and user-defined fcode
+		 *      tokens, Macros, and Conditional-Compilation
+		 *      Operators, -- are included in the "currently
+		 *      active" vocabulary.
+		 */
+
+		if ( create_current_alias( new_alias, old_name) )
+		    return(TRUE);
+	
+	    }    /*  End of separate handling for normal-tokenization mode
+        	  *      versus  "Tokenizer-Escape" mode
+		  */
+
+	    /*  It's not a word, a macro or any of that other stuff.  */
+	    tokenized_word_error(old_name);
+	    free(old_name);
+	}
+	free (new_alias);
+    }
+    return(FALSE);
+}
+
+	
+/* **************************************************************************
+ *
+ *      Function name:  string_err_check
+ *      Synopsis:       Error-check after processing or Ignoring
+ *                          simple strings
+ *
+ *      Inputs:
+ *         Parameters:
+ *             is_paren           TRUE if string is Dot-Paren  .( 
+ *                                    FALSE if Ess-Quote  ( s"  )
+ *             sav_lineno         Saved Line Number, for Unterminated Error
+ *             strt_lineno        Start Line Number, for Multiline Warning
+ *         Global Variables:
+ *             noerrors 	  TRUE if ignoring errors
+ *         Local Static Variables:
+ *             got_until_eof      TRUE if reached end of buffer before delim.
+ *
+ *      Outputs:
+ *         Returned Value:        TRUE if did not reach end of buffer, or,
+ *                                    if ignoring errors, TRUE anyway.
+ *
+ *      Error Detection:
+ *          Multi-line warning, "Unterminated" Error messages, as apppropriate
+ *
+ **************************************************************************** */
+
+static  bool string_err_check( bool is_paren,
+                                  unsigned int sav_lineno,
+				      unsigned int strt_lineno )
+{
+    bool retval = noerrors ;
+    char *item_typ = is_paren ?
+	"Dot-Paren" : "Ess-Quote" ;
+    if ( got_until_eof )   /*  Crude retrofit... */
+    {
+	warn_unterm( TKERROR, item_typ, sav_lineno );
+    }else{
+	retval = TRUE;
+	warn_if_multiline( item_typ, strt_lineno );
+	}
+    return( retval);
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  handle_internal
+ *      Synopsis:       Perform the functions associated with FORTH words
+ *                      that do not map directly to a single token.  This
+ *                      is the functions that will go into the FUNCT field
+ *                      of entries in the "FWords" and "Shared Words" lists.
+ *      
+ *      Inputs:
+ *         Parameters:
+ *             pfield               Param-field of the  tic_hdr_t  -type entry
+ *                                      associated with the FORTH-Word (FWord)
+ *                                      just read that is being "handled".
+ *         Global Variables:
+ *             statbuf              The word that was just read.
+ *
+ *      Outputs:
+ *         Returned Value:          NONE
+ *         Global Variables:
+ *             statbuf              More words may be read.
+ *
+ *      Error Detection:
+ *          Too numerous to list here...
+ *
+ *      Process Explanation:
+ *          Recast the type of the param-field of a  tic_hdr_t -type
+ *              entry and rename it "tok".
+ *          The "tok" will be used as the control-expression for a
+ *              SWITCH statement with a large number of CASE labels.
+ *              Both "FWords" and "shared_words" list entries will
+ *              be processed by this routine.
+ *      
+ *      Revision History:
+ *      Updated Wed, 20 Jul 2005 by David L. Paktor
+ *          Put handling of  ABORT"  under control of a run-time
+ *              command-line switch.
+ *          Put decision to support IBM-style Locals under control
+ *              of a run-time command-line switch.
+ *      Updated Tue, 17 Jan 2006 by David L. Paktor
+ *          Convert to handler for  tic_hdr_t  type vocab entries.
+ *
+ *      Extraneous Remarks:
+ *          We would prefer to keep this function private, so we will
+ *              declare its prototype here and in the one other file
+ *              where we need it, namely, dictionary.c, rather than
+ *              exporting it widely in a  .h  file.
+ *
+ **************************************************************************** */
+
+void handle_internal( tic_param_t pfield);
+void handle_internal( tic_param_t pfield)
+{
+	fwtoken tok = pfield.fw_token;
+
+	signed long wlen;
+	unsigned int sav_lineno = lineno;    /*  For error message  */
+
+	bool handy_toggle = TRUE ;   /*  Various uses...   */
+	
+#ifdef DEBUG_SCANNER
+	printf("%s:%d: debug: tokenizing control word '%s'\n",
+						iname, lineno, statbuf);
+#endif
+	switch (tok) {
+	case BEGIN:
+		emit_begin();
+		break;
+
+	case BUFFER:
+		if ( create_word(tok) )
+		{
+		emit_token("b(buffer:)");
+		}
+		break;
+
+	case CONST:
+		if ( create_word(tok) )
+		{
 		emit_token("b(constant)");
+		}
 		break;
 
 	case COLON:
-		create_word();
+		{
+		    /*  Collect error- -detection or -reporting items,
+		     *      but don't commit until we're sure the
+		     *      creation was a success.
+		     */
+		    u16 maybe_last_colon_fcode = nextfcode ;
+		    unsigned int maybe_last_colon_lineno = lineno;
+		    unsigned int maybe_last_colon_abs_token_no = abs_token_no;
+		    unsigned int maybe_last_colon_do_depth = do_loop_depth;
+		    /*  last_colon_defname
+		     *     has to wait until after call to  create_word()
+		     */
+
+		    if ( create_word(tok) )
+		    {
+			last_colon_fcode = maybe_last_colon_fcode;
+			last_colon_lineno = maybe_last_colon_lineno;
+			last_colon_abs_token_no = maybe_last_colon_abs_token_no;
+			last_colon_do_depth = maybe_last_colon_do_depth;
+			collect_input_filename( &last_colon_filename);
+			/*  Now we can get  last_colon_defname  */
+			if ( last_colon_defname != NULL )
+			{
+			    free( last_colon_defname);
+			}
+			last_colon_defname = strdup(statbuf);
+
 		emit_token("b(:)");
 		incolon=TRUE;
+			hide_last_colon();
+			lastcolon = opc;
+		    }
+		}
 		break;
 	
 	case SEMICOLON:
+		if ( test_in_colon("SEMICOLON", TRUE, TKERROR, NULL) )
+		{
+		    ret_stk_balance_rpt( "termination,", TRUE);
+		    /*  Clear Control Structures just back to where
+		     *      the current Colon-definition began.
+		     */
+		    clear_control_structs_to_limit(
+			"End of colon-definition", last_colon_abs_token_no);
+
+		    if ( ibm_locals )
+		    {
+			finish_locals();
+			forget_locals();
+		    }
+
 		emit_token("b(;)");
 		incolon=FALSE;
+		    reveal_last_colon();
+		}
 		break;
 
 	case CREATE:
-		create_word();
+		if ( create_word(tok) )
+		{
 		emit_token("b(create)");
+		}
 		break;
 
 	case DEFER:
-		create_word();
+		if ( create_word(tok) )
+		{
 		emit_token("b(defer)");
+		}
+		break;
+
+	case ALLOW_MULTI_LINE:
+		report_multiline = FALSE;
+		break;
+
+	case OVERLOAD:
+		if ( test_in_colon(statbuf, FALSE, WARNING, NULL) )
+		{
+		    do_not_overload = FALSE;
+		}
+		break;
+
+	case DEFINED:
+		if (get_word_in_line( statbuf) )
+		{
+		    eval_user_symbol(statbuf);
+		}
+		break;
+
+	case CL_FLAG:
+		if (get_word_in_line( statbuf) )
+		{
+		     set_cl_flag( statbuf, TRUE);
+		}
+		break;
+
+	case SHOW_CL_FLAGS:
+		show_all_cl_flag_settings( TRUE);
 		break;
 
 	case FIELD:
-		create_word();
+		if ( create_word(tok) )
+		{
 		emit_token("b(field)");
+		}
 		break;
 
 	case VALUE:
-		create_word();
+		if ( create_word(tok) )
+		{
 		emit_token("b(value)");
+		}
 		break;
 		
 	case VARIABLE:
-		create_word();
+		if ( create_word(tok) )
+		{
 		emit_token("b(variable)");
-		break;
-
-	case EXTERNAL:
-		flags=FLAG_EXTERNAL;
-		break;
-
-	case TOKENIZE:
-		emit_token("b(')");
+		}
 		break;
 
 	case AGAIN:
-		emit_token("bbranch");
-		offs1=dpop()-(unsigned long)opc;
-		emit_offset(offs1);
+		emit_again();
 		break;
 
 	case ALIAS:
-		wlen=get_word();
-		name=strdup((char *)statbuf);
-		wlen=get_word();
-		alias=strdup((char *)statbuf);
-		if(lookup_macro(name))
-			printf("%s:%d: warning: duplicate alias\n", 
-							iname, lineno);
-		add_macro(name,alias);
+		if ( create_alias() )
+		{
+		    trace_creation( ALIAS, statbuf);
+		}
 		break;
 
 	case CONTROL:
-		wlen=get_word();
-		emit_token("b(lit)");
-		emit_num32(statbuf[0]&0x1f);
+		if ( get_word_in_line( statbuf) )
+		{
+		    emit_literal(statbuf[0]&0x1f);
+		}
 		break;
 
 	case DO:
 		emit_token("b(do)");
-		dpush((unsigned long)opc);
-		emit_offset(0);
-		dpush((unsigned long)opc);
+		mark_do();
 		break;
 
 	case CDO:
 		emit_token("b(?do)");
-		dpush((unsigned long)opc);
-		emit_offset(0);
-		dpush((unsigned long)opc);
+		mark_do();
 		break;
 
 	case ELSE:
-		offs2=dpop();
-		emit_token("bbranch");
-		dpush((unsigned long)opc);
-		emit_offset(0);
-		emit_token("b(>resolve)");
-		offs1=(unsigned long)opc;
-		opc=(u8 *)offs2;
-		offs2=offs1-(unsigned long)opc;
-		emit_offset(offs2);
-		opc=(u8 *)offs1;
+		emit_else();
 		break;
 
 	case CASE:
-		emit_token("b(case)");
-		dpush(0);
+		emit_case();
 		break;
 
 	case ENDCASE:
-		/* first emit endcase, then calculate offsets. */
-		emit_token("b(endcase)");
-		
-		offs1=(unsigned long)opc;
-		
-		offs2=dpop();
-		while (offs2) {
-			u16 tmp;
-			
-			opc=(u8 *)(ostart+offs2);
-
-			/* we're using an fcode offset to temporarily
-			 * store our linked list. At this point we take
-			 * the signed fcode offset as unsigned as we know
-			 * that the offset will always be >0. This code
-			 * is still broken for any case statement that
-			 * occurs after the fcode bytecode grows larger 
-			 * than 64kB
-			 */
-			tmp=receive_offset();
+		emit_endcase();
+		break;
 
-			offs2=(unsigned long)offs1-(unsigned long)opc;
+	case NEW_DEVICE:
+		handy_toggle = FALSE;
+	case FINISH_DEVICE:
+		finish_or_new_device( handy_toggle );
+		break;
 
-#if defined(DEBUG_SCANNER)
-			printf ("%s:%d: debug: endcase offset 0x%lx\n",
-				iname,lineno, (unsigned long)offs2);
-#endif
-			emit_offset(offs2);
-			offs2=tmp;
+	case FLITERAL:
+		{
+		    u32 val;
+		    val = dpop();
+		    emit_literal(val);
 		}
-		opc=(u8 *)offs1;
 		break;
 
 	case OF:
-		emit_token("b(of)");
-		dpush((unsigned long)(opc-ostart));
-		emit_offset(0);
+		emit_of();
 		break;
 
 	case ENDOF:
-		offs1=dpop();
-		emit_token("b(endof)");
-		
-		offs2=dpop();
-		dpush((unsigned long)(opc-ostart));
-		emit_offset(offs2);
-		
-		offs2=(unsigned long)(opc-ostart);
-		opc=(u8 *)(ostart+offs1);
-		offs1=offs2-offs1;
-		emit_offset(offs1);
+		emit_endof();
+		break;
 		
-		opc=(u8 *)(ostart+offs2);
+	case EXTERNAL:
+		set_hdr_flag( FLAG_EXTERNAL );
 		break;
 		
 	case HEADERLESS:
-		flags=0;
+		set_hdr_flag( FLAG_HEADERLESS );
 		break;
 	
 	case HEADERS:
-		flags=FLAG_HEADERS;
+		set_hdr_flag( FLAG_HEADERS );
 		break;
 
 	case DECIMAL:
 		/* in a definition this is expanded as macro "10 base !" */
-		if (incolon) {
-			emit_token("b(lit)");
-			emit_num32(0x0a);
-			emit_token("base");
-			emit_token("!");
-		} else
-			base=10;
+		base_change ( 0x0a );
 		break;
 		
 	case HEX:
-		if (incolon) {
-			emit_token("b(lit)");
-			emit_num32(0x10);
-			emit_token("base");
-			emit_token("!");
-		} else
-			base=16;
+		base_change ( 0x10 );
 		break;
 
 	case OCTAL:
-		if (incolon) {
-			emit_token("b(lit)");
-			emit_num32(0x08);
-			emit_token("base");
-			emit_token("!");
-		} else
-			base=8;
+		base_change ( 0x08 );
 		break;
 
 	case OFFSET16:
 		if (!offs16)
-			printf("%s:%d: switching to "
-				"16bit offsets.\n", iname, lineno);
+		{
+		    tokenization_error(INFO, "Switching to 16-bit offsets.\n");
+		}else{
+		    tokenization_error(WARNING,
+			"Call of OFFSET16 is redundant.\n");
+		}
 		emit_token("offset16");
 		offs16=TRUE;
 		break;
 
 	case IF:
-		emit_token("b?branch");
-		dpush((unsigned long)opc);
-		emit_offset(0);
+		emit_if();
+		break;
+
+/* **************************************************************************
+ *
+ *      Still to be done:
+ *          Correct analysis of Return-Stack usage within Do-Loops
+ *              or before Loop Elements like I and J or UNLOOP or LEAVE.
+ *
+ **************************************************************************** */
+	case UNLOOP:
+		emit_token("unloop");
+		must_be_deep_in_do(1);
 		break;
 
-	case CLEAVE:
 	case LEAVE:
 		emit_token("b(leave)");
+		must_be_deep_in_do(1);
+		break;
+
+	case LOOP_I:
+		emit_token("i");
+		must_be_deep_in_do(1);
+		break;
+
+	case LOOP_J:
+		emit_token("j");
+		must_be_deep_in_do(2);
 		break;
 		
 	case LOOP:
 		emit_token("b(loop)");
-		offs1=dpop();
-		offs2=offs1-(unsigned long)opc;
-		emit_offset(offs2);
-		offs1=(unsigned long)opc;
-		opc=(u8 *)dpop();
-		offs2=offs1-(unsigned long)opc;
-		emit_offset(offs2);
-		opc=(u8 *)offs1;
+		resolve_loop();
 		break;
 		
-	case CLOOP:
+	case PLUS_LOOP:
 		emit_token("b(+loop)");
-		offs1=dpop();
-		offs2=offs1-(unsigned long)opc;
-		emit_offset(offs2);
-		offs1=(unsigned long)opc;
-		opc=(u8 *)dpop();
-		offs2=offs1-(unsigned long)opc;
-		emit_offset(offs2);
-		opc=(u8 *)offs1;
-		break;
-
-	case GETTOKEN:
-		emit_token("b(')");
-		wlen=get_word();
-		itok=lookup_token((char *)statbuf);
-		if (itok==0xffff) {
-			printf("%s:%d: error: no such word '%s' in [']\n",
-					iname, lineno, statbuf);
-			ERROR;
+		resolve_loop();
+		break;
+
+
+	case INSTANCE:
+		{
+		    bool set_instance_state = FALSE;
+		    bool emit_instance = TRUE;
+		    /*  We will treat "instance" in a colon-definition as
+		     *      an error, but allow it to be emitted if we're
+		     *      ignoring errors; if we're not ignoring errors,
+		     *      there's no output anyway...
+		     */
+		    if ( test_in_colon(statbuf, FALSE, TKERROR, NULL) )
+		    {   /*   We are in interpretation (not colon) state.  */
+			/*  "Instance" not allowed during "global" scope  */ 
+			if ( scope_is_global )
+			{
+			    glob_not_allowed( WARNING, FALSE );
+			    emit_instance = FALSE;
+			}else{
+			    set_instance_state = TRUE;
+			}
+		    }
+		    if ( emit_instance )
+		    {
+			if ( set_instance_state )
+			{
+			    /*  "Instance" isn't cumulative....  */
+			    if ( is_instance )
+			    {
+				unresolved_instance( WARNING);
+			    }
+			    collect_input_filename( &instance_filename);
+			    instance_lineno = lineno;
+			    is_instance = TRUE;
+			    dev_change_instance_warning = TRUE;
+			}
+			emit_token("instance");
+		    }
 		}
-		/* FIXME check size, u16 or token */
-		emit_fcode(itok);
 		break;
 		
-	case ASCII:
-		wlen=get_word();
-		emit_token("b(lit)");
-		emit_num32(statbuf[0]);
+	case GLOB_SCOPE:
+		if ( test_in_colon(statbuf, FALSE, TKERROR, NULL) )
+		{
+		    if ( INVERSE( is_instance) )
+		    {
+			enter_global_scope();
+		    }else{
+			tokenization_error( TKERROR,
+			    "Global Scope not allowed.  "
+			    "\"Instance\" is in effect; issued" );
+			just_where_started( instance_filename,
+					        instance_lineno );
+		    }
+		}
 		break;
 
-	case CHAR:
-		if (incolon)
-			printf("%s:%d: warning: CHAR cannot be used inside "
-				"of a colon definition.\n", iname, lineno);
-		wlen=get_word();
-		emit_token("b(lit)");
-		emit_num32(statbuf[0]);
+	case DEV_SCOPE:
+		if ( test_in_colon(statbuf, FALSE, TKERROR, NULL) )
+		{
+		    resume_device_scope();
+		}
 		break;
 
+	case TICK:             /*    '    */
+		test_in_colon(statbuf, FALSE, WARNING, "[']");
+	case BRACK_TICK:       /*   [']   */
+		{
+		    tic_hdr_t *token_entry;
+		    if ( get_token( &token_entry) )
+		    {
+			emit_token("b(')");
+			/* Emit the token; warning or whatever comes gratis */
+			token_entry->funct( token_entry->pfield);
+		    }
+		}
+		break;
+
+	case F_BRACK_TICK:     /*  F['] <name>
+	        		*     emits the token-number for <name>
+				*  Mainly useful to compute the argument
+				*     to   get-token   or  set-token
+				*/
+		{
+		    tic_hdr_t *token_entry;
+		    if ( get_token( &token_entry) )
+		    {
+			/*  "Obsolete" warning doesn't come gratis here...  */
+			token_entry_warning( token_entry);
+			/*  In Tokenizer-Escape mode, push the token  */
+			if ( in_tokz_esc )
+			{
+			    dpush( token_entry->pfield.deflt_elem);
+			}else{
+			    emit_literal( token_entry->pfield.deflt_elem);
+			}
+		    }
+		}
+		break;
+
+	case CHAR:
+		handy_toggle = FALSE;
 	case CCHAR:
-		wlen=get_word();
-		emit_token("b(lit)");
-		emit_num32(statbuf[0]);
+		test_in_colon(statbuf, handy_toggle, WARNING,
+		    handy_toggle ? "CHAR" : "[CHAR]" );
+	case ASCII:
+		if ( get_word_in_line( statbuf) )
+		{
+		    emit_literal(statbuf[0]);
+		}
 		break;
 		
 	case UNTIL:
-		emit_token("b?branch");
-		emit_offset(dpop()-(unsigned long)opc);
+		emit_until();
 		break;
 
 	case WHILE:
-		emit_token("b?branch");
-		dpush((unsigned long)opc);
-		emit_offset(0);
+		emit_while();
 		break;
 		
 	case REPEAT:
-		emit_token("bbranch");
-		offs2=dpop();
-		offs1=dpop();
-		offs1-=(unsigned long)opc;
-		emit_offset(offs1);
-		
-		emit_token("b(>resolve)");
-		offs1=(unsigned long)opc;
-		opc=(u8 *)offs2;
-		emit_offset(offs1-offs2);
-		opc=(u8 *)offs1;
+		emit_repeat();
 		break;
 		
 	case THEN:
-		emit_token("b(>resolve)");
-		offs1=(unsigned long)opc;
-		opc=(u8 *)dpop();
-		offs2=offs1-(unsigned long)opc;
-		emit_offset(offs2);
-		opc=(u8 *)offs1;
+		emit_then();
 		break;
 
+	case IS:
+		tokenization_error ( INFO,
+		     "Substituting  TO  for deprecated  IS\n");
 	case TO:
+		if ( validate_to_target() )
+		{
 		emit_token("b(to)");
+		}
 		break;
 
 	case FLOAD:
+		if ( get_word_in_line( statbuf) )
 		{
-			u8 *oldstart, *oldpc, *oldend;
-			char *oldiname;
-			int oldlineno;
-
-			wlen=get_word();
+		    bool stream_ok ;
 			
-			oldstart=start; oldpc=pc; oldend=end; 
-			oldiname=iname; oldlineno=lineno;
+		    push_source( close_stream, NULL, TRUE) ;
 			
-			init_stream((char *)statbuf);
-			tokenize();
-			close_stream();
+		    tokenization_error( INFO, "FLOADing %s\n", statbuf );
 			
-			iname=oldiname; lineno=oldlineno;
-			end=oldend; pc=oldpc; start=oldstart;
+		    stream_ok = init_stream( statbuf );
+		    if ( INVERSE( stream_ok) )
+		    {
+			drop_source();
+		    }
 		}
 		break;
 
-	case STRING:
-		if (*pc++=='\n') lineno++;
-		wlen=get_string();
+	case STRING:         /*  Double-Quote ( " ) string  */
+		handy_toggle = FALSE;
+	case PSTRING:        /*  Dot-Quote  ( ." ) string   */
+		wlen=get_string( TRUE);
 		emit_token("b(\")");
-		emit_string(statbuf,wlen-1);
+		emit_string(statbuf, wlen);
+		if ( handy_toggle )
+		{
+		    emit_token("type");
+		}
 		break;
 
-	case PSTRING:
+	case SSTRING:        /*  Ess-Quote  ( s"  ) string  */
+		handy_toggle = FALSE;
+	case PBSTRING:       /*  Dot-Paren  .(   string  */
 		if (*pc++=='\n') lineno++;
-		wlen=get_string();
+		{
+		    unsigned int strt_lineno = lineno;
+		    wlen = get_until( handy_toggle ? ')' : '"' );
+		    if ( string_err_check( handy_toggle,
+		             sav_lineno, strt_lineno) )
+		    {
 		emit_token("b(\")");
-		emit_string(statbuf,wlen-1);
+			emit_string(statbuf, wlen);
+			if ( handy_toggle )
+			{
 		emit_token("type");
+			}
+		    }
+		}
 		break;
 
-	case PBSTRING:
-		if (*pc++=='\n') lineno++;
-		get_until(')');
+	case FUNC_NAME:
+		if ( test_in_colon( statbuf, TRUE, TKERROR, NULL) )
+		{
+		    if ( in_tokz_esc )
+		    {
+			tokenization_error( P_MESSAGE, "Currently" );
+			in_last_colon();
+		    }else{
 		emit_token("b(\")");
-		emit_string(statbuf,strlen((char *)statbuf)-1);
-		emit_token("type");
+			emit_string( last_colon_defname,
+		            strlen( last_colon_defname) );
+			/*  if ( hdr_flag == FLAG_HEADERLESS ) { WARNING } */
+		    }
+		}
 		break;
 
-	case SSTRING:
-		if (*pc++=='\n') lineno++;
-		get_until('"');
+	case IFILE_NAME:
 		emit_token("b(\")");
-		emit_string(statbuf,strlen((char *)statbuf)-1);
-		pc++; /* skip " */
+		emit_string( iname, strlen( iname) );
 		break;
 
-	case HEXVAL:
-		{
-			u8 basecpy=base;
-			long val;
+	case ILINE_NUM:
+		emit_literal( lineno);
+		break;
 			
-			base=0x10;
-			wlen=get_word();
-			if (!get_number(&val)) {
-				emit_token("b(lit)");
-				emit_num32(val);
-			} else {
-				printf("%s:%d: warning: illegal value in h#"
-						" ignored\n", iname, lineno);
-			}
-			base=basecpy;
-		}
+	case HEXVAL:
+		base_val (0x10);
 		break;
 		
 	case DECVAL:
-		{
-			u8 basecpy=base;
-			long val;
-
-			base=0x0a;
-			wlen=get_word();
-			if (!get_number(&val)) {
-				emit_token("b(lit)");
-				emit_num32(val);
-			} else {
-				printf("%s:%d: warning: illegal value in d#"
-						" ignored\n", iname, lineno);
-			}
-			
-			base=basecpy;
-		}
+		base_val (0x0a);
 		break;
 		
 	case OCTVAL:
+		base_val (8);
+		break;
+
+	case ASC_LEFT_NUM:
+		handy_toggle = FALSE;
+	case ASC_NUM:
+		if (get_word_in_line( statbuf) )
 		{
-			u8 basecpy=base;
-			long val;
-
-			base=0x08;
-			wlen=get_word();
-			if (!get_number(&val)) {
-				emit_token("b(lit)");
-				emit_num32(val);
+		    if ( handy_toggle )
+		    {
+			ascii_right_number( statbuf);
 			} else {
-				printf("%s:%d: warning: illegal value in o#"
-						" ignored\n", iname, lineno);
+			ascii_left_number( statbuf);
 			}
-
-			base=basecpy;
 		}
 		break;
-	case BEGINTOK:
-		intok=TRUE;
+
+	case CONDL_ENDER:   /*  Conditional directives out of context  */
+	case CONDL_ELSE:
+		tokenization_error ( TKERROR,
+		    "No conditional preceding %s directive\n",
+			strupr(statbuf) );
+		break;
+
+	case PUSH_FCODE:
+		tokenization_error( INFO,
+		    "FCode-token Assignment Counter of 0x%x "
+		    "has been saved on stack.\n", nextfcode );
+		dpush( (long)nextfcode );
 		break;
 
-	case EMITBYTE:
-		if (intok)
-			emit_byte(dpop());
-		else 
-			printf ("%s:%d: warning: emit-byte outside tokenizer"
-					" scope\n", iname, lineno);
+	case POP_FCODE:
+		pop_next_fcode();
 		break;
 
-	case NEXTFCODE:
-		if (intok)
-			nextfcode=dpop();
-		else
-			printf("%s:%d: warning: next-fcode outside tokenizer"
-					" scope\n", iname, lineno);
+	case RESET_FCODE:
+		tokenization_error( INFO,
+		    "Encountered %s.  Resetting FCode-token "
+			"Assignment Counter.  ", strupr(statbuf) );
+		list_fcode_ranges( FALSE);
+		reset_fcode_ranges();
 		break;
 		
-	case ENDTOK:
-		intok=FALSE;
+	case EXIT:
+		if ( test_in_colon( statbuf, TRUE, TKERROR, NULL)
+		     || noerrors )
+		{
+		    ret_stk_balance_rpt( NULL, FALSE);
+		    if ( ibm_locals )
+		    {
+			finish_locals ();
+		    }
+		    emit_token("exit");
+		}
+		break;
+
+	case ESCAPETOK:
+		enter_tokz_esc();
 		break;
 	
 	case VERSION1:
 	case FCODE_V1:
-		printf("%s:%d: using version1 header\n", iname, lineno);
-		emit_token("version1");
-		fcode_hdr=opc;
-		emit_fcodehdr();
-		offs16=FALSE;
+		tokenization_error( INFO, "Using version1 header "
+		    "(8-bit offsets).\n");
+		fcode_starter( "version1", 1, FALSE) ;
 		break;
 	
 	case START1:
 	case FCODE_V2:
 	case FCODE_V3: /* Full IEEE 1275 */
-		emit_token("start1");
-		fcode_hdr=opc;
-		emit_fcodehdr();
-		offs16=TRUE;
+		fcode_starter( "start1", 1, TRUE);
 		break;
 		
 	case START0:
-		printf ("%s:%d: warning: spread of 0 not supported.", 
-				iname, lineno);
-		emit_token("start0");
-		fcode_hdr=opc;
-		emit_fcodehdr();
-		offs16=TRUE;
+		fcode_starter( "start0", 0, TRUE);
 		break;
 		
 	case START2:
-		printf ("%s:%d: warning: spread of 2 not supported.", 
-			iname, lineno);
-		emit_token("start2");
-		fcode_hdr=opc;
-		emit_fcodehdr();
-		offs16=TRUE;
+		fcode_starter( "start2", 2, TRUE);
 		break;
 		
 	case START4:
-		printf ("%s:%d: warning: spread of 4 not supported.", 
-			iname, lineno);
-		emit_token("start4");
-		fcode_hdr=opc;
-		emit_fcodehdr();
-		offs16=TRUE;
+		fcode_starter( "start4", 4, TRUE);
 		break;
 		
+	case END1:
+		tokenization_error( WARNING, 
+		    "Appearance of END1 in FCode source code "
+			"is not intended by IEEE 1275-1994\n");
+		handy_toggle = FALSE;
 	case END0:
 	case FCODE_END:
-		haveend=TRUE;
-		emit_token("end0");
+		if ( handy_toggle )
+		{
+		    you_are_here();
+		}
+		emit_token( handy_toggle ? "end0" : "end1" );
+		fcode_ender();
+		FFLUSH_STDOUT
 		break;
 
-	case END1:
-		haveend=TRUE;
-		emit_token("end1");
+	case RECURSE:
+		if ( test_in_colon(statbuf, TRUE, TKERROR, NULL ) )
+		{
+		    emit_fcode(last_colon_fcode);
+		}
 		break;
 		
+
 	case RECURSIVE:
+		if ( test_in_colon(statbuf, TRUE, TKERROR, NULL ) )
+		{
+		    reveal_last_colon();
+		}
+		break;
+
+	case RET_STK_FETCH:
+		ret_stk_access_rpt();
+		emit_token( "r@");
+		break;
+
+	case RET_STK_FROM:
+		ret_stk_access_rpt();
+		bump_ret_stk_depth( -1);
+		emit_token( "r>");
+		break;
+
+	case RET_STK_TO:
+		bump_ret_stk_depth( 1);
+		emit_token( ">r");
 		break;
 
 	case PCIHDR:
-		{
-			u32 classid=dpop();
-			u16 did=dpop();
-			u16 vid=dpop();
-			
-			pci_hdr=opc;
-			emit_pcihdr(vid, did, classid);
-			
-			printf("%s:%d: PCI header vendor id=0x%04x, "
-				"device id=0x%04x, class=%06x\n",
-				iname, lineno, vid, did, classid);
-		}
+		emit_pcihdr();
 		break;
 	
 	case PCIEND:
-		if (!pci_hdr) {
-			printf("%s:%d: error: pci-header-end/pci-end "
-				"without pci-header\n", iname, lineno);
-			ERROR;
-		}
 		finish_pcihdr();
+		reset_fcode_ranges();
+		FFLUSH_STDOUT
 		break;
 
 	case PCIREV:
-		pci_revision=dpop();
-		printf("%s:%d: PCI header revision=0x%04x\n", 
-				iname, lineno, pci_revision);
+		pci_image_rev = dpop();
+		tokenization_error( INFO,
+		    "PCI header revision=0x%04x%s\n", pci_image_rev,
+			big_end_pci_image_rev ?
+			    ".  Will be saved in Big-Endian format."
+			    : ""  );
 		break;
 
 	case NOTLAST:
-		pci_is_last_image=FALSE;
-		printf("%s:%d: PCI header not last image!\n",
-				iname, lineno);
+		handy_toggle = FALSE;
+	case ISLAST:
+		dpush(handy_toggle);
+	case SETLAST:
+		{
+		    u32 val = dpop();
+		    bool new_pili = BOOLVAL( (val != 0) );
+		    if ( pci_is_last_image != new_pili )
+		    {
+			tokenization_error( INFO,
+			    new_pili ?
+				"Last image for PCI header.\n" :
+				"PCI header not last image.\n" );
+			pci_is_last_image = new_pili;
+		    }
+		}
 		break;
 		
-	case ABORTTXT:
-		/* ABORT" is not to be used in FCODE drivers
-		 * but Apple drivers do use it. Therefore we
-		 * allow it. We push the specified string to
-		 * the stack, do -2 THROW and hope that THROW
-		 * will correctly unwind the stack.
-		 */
-		
-		printf("%s:%d: warning: ABORT\" in fcode not defined by "
-				"IEEE 1275-1994.\n", iname, lineno);
-		if (*pc++=='\n') lineno++;
-		wlen=get_string();
-		
-#ifdef BREAK_COMPLIANCE
-		/* IF */
-		emit_token("b?branch");
-		
-		dpush((unsigned long)opc);
-		emit_offset(0);
-#endif
-		emit_token("b(\")");
-		emit_string(statbuf,wlen-1);
-#ifdef BREAK_COMPLIANCE
-		emit_token("type");
-#endif
-		emit_token("-2");
-		emit_token("throw");
-#ifdef BREAK_COMPLIANCE
-		/* THEN */
-		emit_token("b(>resolve)");
-		offs1=(unsigned long)opc;
-		opc=(u8 *)dpop();
-		offs2=offs1-(unsigned long)opc;
-		emit_offset(offs2);
-		opc=(u8 *)offs1;
-#endif
+	case SAVEIMG:
+		if (get_word_in_line( statbuf) )
+		{
+		    free(oname);
+		    oname = strdup( statbuf );
+		    tokenization_error( INFO,
+			"Output is redirected to file:  %s\n", oname);
+		}
 		break;
 
-	case FCODE_DATE:
+	case RESETSYMBS:
+		tokenization_error( INFO,
+		    "Resetting symbols defined in %s mode.\n",
+			in_tokz_esc ? "tokenizer-escape" : "\"normal\"");
+		if ( in_tokz_esc )
 		{
-			time_t tt;
-			char fcode_date[11];
-			
-			tt=time(NULL);
-			strftime(fcode_date, 11, "%m/%d.%Y", 
-					localtime(&tt));
-			emit_token("b(\")");
-			emit_string((u8 *)fcode_date,10);
+		    reset_tokz_esc();
+		}else{
+		    reset_normal_vocabs();
 		}	
 		break;
 
+	case FCODE_DATE:
+		handy_toggle = FALSE;
 	case FCODE_TIME:
 		{
 			time_t tt;
-			char fcode_time[9];
+		    char temp_buffr[32];
 			
 			tt=time(NULL);
-			strftime(fcode_time, 9, "%H:%M:%S", 
-					localtime(&tt));
+		    if ( handy_toggle )
+		    {
+			strftime(temp_buffr, 32, "%T %Z", localtime(&tt));
+		    }else{
+			strftime(temp_buffr, 32, "%m/%d/%Y", localtime(&tt));
+		    }
+		    if ( in_tokz_esc )
+		    {
+			tokenization_error( MESSAGE, temp_buffr);
+		    }else{
 			emit_token("b(\")");
-			emit_string((u8 *)fcode_time,8);
+			emit_string((u8 *)temp_buffr, strlen(temp_buffr) );
+		    }
 		}
 		break;
 
 	case ENCODEFILE:
-		wlen=get_word();
+		if (get_word_in_line( statbuf) )
+		{
 		encode_file( (char*)statbuf );
+		}
 		break;
 
 	default:
-		printf("%s:%d: error: Unimplemented control word '%s'\n",
-				iname, lineno, statbuf);
-		ERROR;
+	    /*  IBM-style Locals, under control of a switch  */
+	    if ( ibm_locals )
+	    {
+		bool found_it = TRUE;
+		switch (tok) {
+		    case CURLY_BRACE:
+			declare_locals( FALSE);
+			break;
+		    case DASH_ARROW:
+			assign_local();
+			break;
+		    default:
+			found_it = FALSE;
 	}
+		if ( found_it ) break;
 }
 
-void tokenize(void)
+	    /*  Down here, we have our last chance to recognize a token.
+	     *      If  abort_quote  is disallowed, we will still consume
+	     *      the string.  In case the string spans more than one
+	     *      line, we want to make sure the line number displayed
+	     *      in the error-message is the one on which the disallowed
+	     *       abort_quote  token appeared, not the one where the
+	     *      string ended; therefore, we might need to be able to
+	     *      "fake-out" the line number...
+	     */
 {
-	unsigned long wlen;
-	u16 tok;
-	u8 *mac;
-	long val;
+		bool fake_out_lineno = FALSE;
+		unsigned int save_lineno = lineno;
+		unsigned int true_lineno;
+		if ( abort_quote( tok) )
+		{   break;
+		}else{
+		    if ( tok == ABORTTXT )  fake_out_lineno = TRUE;
+		}
+		true_lineno = lineno;
+
+		if ( fake_out_lineno )  lineno = save_lineno;
+		tokenization_error ( TKERROR,
+		    "Unimplemented control word '%s'\n", strupr(statbuf) );
+		if ( fake_out_lineno )  lineno = true_lineno;
+	    }
+	}
+}
 	
-	while ((wlen=get_word())!=0) {
+/* **************************************************************************
+ *
+ *      Function name:  skip_string
+ *      Synopsis:       When Ignoring, skip various kinds of strings.  Maps
+ *                          to string-handlers in handle_internal()...
+ *
+ *      Associated FORTH words:                 Double-Quote ( " ) string
+ *                                              Dot-Quote  ( ." ) string
+ *                                              Ess-Quote  ( s"  ) string
+ *                                              Dot-Paren  .(   string
+ *                                              ABORT" (even if not enabled)
+ *             { (Local-Values declaration) and -> (Local-Values assignment)
+ *                  are also handled if  ibm_locals  is enabled.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             pfield               Param-field of the entry associated with
+ *                                      the FWord that is being Ignored.
+ *         Global Variables:
+ *             statbuf              The word that was just read.
+ *             pc                   Input-stream pointer
+ *             lineno               Line-number, used for errors and warnings
+ *             ibm_locals           TRUE if IBM-style Locals are enabled
+ *
+ *      Outputs:
+ *         Returned Value:          NONE
+ *
+ *      Error Detection:
+ *          Multi-line warnings, "Unterminated" Errors
+ *              handled by called routines
+ *
+ *      Extraneous Remarks:
+ *          We would prefer to keep this function private, too, so we
+ *              will declare its prototype here and in the one other
+ *              file where we need it, namely, dictionary.c, rather
+ *              than exporting it widely in a  .h  file.
+ *
+ **************************************************************************** */
 
-		/* Filter comments */
-		switch (statbuf[0]) {
-		case '\\':
-			pc-=wlen;
-			get_until('\n');
-			continue;
+void skip_string( tic_param_t pfield);
+void skip_string( tic_param_t pfield)
+{
+    fwtoken tok = pfield.fw_token;
+    unsigned int sav_lineno = lineno;
+    bool handy_toggle = TRUE ;   /*  Various uses...   */
 			
-		case '(':
-			/* only a ws encapsulated '(' is a stack comment */
-			if (statbuf[1])
+    switch (tok) {
+    case STRING:         /*  Double-Quote ( " ) string    */
+    case PSTRING:        /*  Dot-Quote  ( ." ) string     */
+    case ABORTTXT:       /*  ABORT", even if not enabled  */
+	get_string( FALSE);   /*  Don't truncate; ignoring anyway  */
+	/*  Will handle multi-line warnings, etc.   */
 				break;
 			
-			pc-=wlen;
-			get_until(')');
+    case SSTRING:        /*  Ess-Quote  ( s"  ) string  */
+	handy_toggle = FALSE;
+    case PBSTRING:       /*  Dot-Paren  .(   string  */
 			if (*pc++=='\n') lineno++;
+	{
+	    unsigned int strt_lineno = lineno;
+	    get_until( handy_toggle ? ')' : '"' );
+	    string_err_check( handy_toggle, sav_lineno, strt_lineno );
+	}
+	break;
+
+    default:
+	/*  IBM-style Locals, under control of a switch  */
+	if ( ibm_locals )
+	{
+	    bool found_it = TRUE;
+	    switch (tok) {
+		case CURLY_BRACE:
+		    declare_locals( TRUE);
+		    break;
+		case DASH_ARROW:
+		    get_word();
+		    break;
+		default:
+		    found_it = FALSE;
+	    }
+	    if ( found_it ) break;
+	}
+
+	tokenization_error ( FATAL,  "Program Error.  "
+	    "Unimplemented skip-string word '%s'\n", strupr(statbuf) );
+    }
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  process_remark
+ *      Synopsis:       The active function for remarks (backslash-space)
+ *                          and comments (enclosed within parens)
+ *
+ *      Associated FORTH word(s):        \   (         
+ *
+ *      Inputs:
+ *         Parameters:
+ *             TIC entry "parameter field", init'd to delimiter character.
+ *
+ *      Outputs:
+ *         Returned Value:          NONE
+ *
+ *      Error Detection:
+ *          Warning if end-of-file encountered before delimiter.
+ *          Warning if multi-line parentheses-delimited comment.
+ *
+ *      Process Explanation:
+ *          Skip until the delimiter.
+ *          If end-of-file was encountered, issue Warning.
+ *          Otherwise, and if delimiter was not new-line,
+ *              check for multi-line with Warning.
+ *
+ **************************************************************************** */
+
+void process_remark( tic_param_t pfield )
+{
+    char until_char = (char)pfield.deflt_elem ;
+    unsigned int start_lineno = lineno;
+
 #ifdef DEBUG_SCANNER
+
+    get_until(until_char);
 			printf ("%s:%d: debug: stack diagram: %s)\n",
 						iname, lineno, statbuf);
-#endif
-			continue;
-		}
+#else
 
-		/* Check whether a macro with given name exists */
+    if ( skip_until( until_char) )
+    {
+	if ( until_char == '\n' )
+	{
+	    /*  Don't need any saved line number here ...  */
+	    tokenization_error ( WARNING,
+		"Unterminated remark.\n");
+	}else{
+	    warn_unterm( WARNING, "comment", start_lineno);
+	}
+    }else{
+	if ( until_char != '\n' )
+	{
+	    pc++;
+	    warn_if_multiline( "comment", start_lineno);
+	}
+    }
+#endif  /*  DEBUG_SCANNER  */
+}
 		
-		mac=(u8 *)lookup_macro((char *)statbuf);
-		if(mac) {
-			u8 *oldstart, *oldpc, *oldend;
-#ifdef DEBUG_SCANNER
-			printf("%s:%d: debug: macro %s folds out to sequence"
-				" '%s'\n", iname, lineno, statbuf, mac);
-#endif	
-			oldstart=start; oldpc=pc; oldend=end;
-			start=pc=end=mac;
-			end+=strlen((char *)mac);
 			
-			tokenize();
+/* **************************************************************************
+ *
+ *      Function name:  filter_comments
+ *      Synopsis:       Process remarks and comments in special conditions
+ *      
+ *      Inputs:
+ *         Parameters:
+ *             inword             Current word just parsed
+ *
+ *      Outputs:
+ *         Returned Value:        TRUE if Current word is a Comment-starter.
+ *                                    Comment will be processed
+ *
+ *      Process Explanation:
+ *          We want to be able to recognize any alias the user may have
+ *              defined to a comment-delimiter, in whatever applicable
+ *              vocabulary it might be.
+ *          The active-function of any such alias will, of necessity, be
+ *              the  process_remark()  routine, defined just above.
+ *          We will search for the TIC-entry of the given word; if we don't    
+ *              find it, it's not a comment-delimiter.  If we do find it, 
+ *              and it is one, we invoke its active-function and return TRUE.
+ *          We also want to permit the "allow-multiline-comments" directive   
+ *              to be processed in the context that calls this routine, so
+ *              we will check for that condition, too.
+ *
+ **************************************************************************** */
 
-			end=oldend; pc=oldpc; start=oldstart;
+bool filter_comments( u8 *inword)
+{
+    bool retval = FALSE;
+    tic_hdr_t *found = lookup_word( inword, NULL, NULL );
 			
-			continue;
+    if ( found != NULL )
+    {
+	if ( found->funct == process_remark )
+	{
+	    found->funct( found->pfield);
+	    retval = TRUE;
+	}else{
+	    /*  Permit the "allow-multiline-comments" directive  */
+	    if ( found->funct == handle_internal )
+	    {
+	        if ( found->pfield.fw_token == ALLOW_MULTI_LINE )
+		{
+		    /*   Make sure any intended side-effects occur...  */
+		    found->funct( found->pfield);
+		    retval = TRUE;
+		}
+	    }
+	}
+    }
+    return ( retval );
 		}
 
-		/* Check whether it's a non-fcode forth construct */
 		
-		tok=lookup_fword((char *)statbuf);
-		if (tok!=0xffff) {
-#ifdef DEBUG_SCANNER
-			printf("%s:%d: debug: matched internal opcode 0x%04x\n",
-					iname, lineno, tok);
-#endif
-			handle_internal(tok);
-#ifdef DEBUG_SCANNER
-			if (verbose)
-				printf("%s:%d: debug: '%s' done.\n",
-					iname,lineno,statbuf);
-#endif
-			continue;
-		}
+/* **************************************************************************
+ *
+ *      Function name:  tokenize_one_word
+ *      Synopsis:       Tokenize the currently-obtained word
+ *                          along with whatever it consumes.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             wlen       Length of symbol just retrieved from the input stream
+ *                              This is not really used here any more; it's
+ *                              left over from an earlier implementation.
+ *         Global Variables:        
+ *             statbuf      The symbol (word) just retrieved from input stream.
+ *             in_tokz_esc  TRUE if "Tokenizer-Escape" mode is in effect; a
+ *                              different set of vocabularies from "Normal"
+ *                              mode will be checked (along with those that
+ *                              are common to both modes).  
+ *             ibm_locals   Controls whether to check for IBM-style Locals;
+ *                              set by means of a command-line switch.
+ *
+ *      Outputs:
+ *         Returned Value:      NONE
+ *         Global Variables:         
+ *             statbuf          May be incremented    
+ *             in_tokz_esc      May be set if the word just retrieved is
+ *                                  the  tokenizer[   directive. 
+ *             tic_found        
+ *
+ *      Error Detection:
+ *           If the word could neither be identified nor processed as a number,
+ *               that is an ERROR; pass it to  tokenized_word_error  for a
+ *               message.
+ *
+ *      Process Explanation:
+ *          Look for the word in each of the various lists and vocabularies
+ *              in which it might be found, as appropriate to the current
+ *              state of activity.
+ *          If found, process it accordingly.
+ *          If not found, try to process it as a number.
+ *          If cannot process it as a number, declare an error.
+ *
+ *      Revision History:
+ *          Updated Tue, 10 Jan 2006 by David L. Paktor
+ *              Convert to  tic_hdr_t  type vocabularies.
+ *          Updated Mon, 03 Apr 2006 by David L. Paktor
+ *             Replaced bulky "Normal"-vs-"Escape" block with a call
+ *                 to  lookup_word .  Attend to a small but important
+ *                 side-effect of the "handle_<vocab>" routines that
+ *                 feeds directly into the protection against self-
+ *                 -recursion in a user-defined Macro:  Set the global
+ *                 variable  tic_found  to the entry, just before we
+ *                 execute it, and we're good to go... 
+ *
+ *      Extraneous Remarks:
+ *          We trade off the strict rules of structure for simplicity
+ *              of coding.
+ *
+ **************************************************************************** */
 		
-		/* Check whether it's one of the defined fcode words */
+void tokenize_one_word( signed long wlen )
+{
 		
-		tok=lookup_token((char *)statbuf);
-		if (tok!=0xffff) {
-#ifdef DEBUG_SCANNER
-			printf("%s:%d: debug: matched fcode no 0x%04x\n",
-					iname, lineno, tok);
-#endif
-			emit_fcode(tok);
-			continue;
-		}
+    /*  The shared lookup routine now handles everything.   */
+    tic_hdr_t *found = lookup_word( statbuf, NULL, NULL );
 		
-		/* It's not a word or macro - is it a number? */
+    if ( found != NULL )
+    {
+	tic_found = found;
+	found->funct( found->pfield);
+	return ;
+    }
 		
-		if (!get_number(&val)) {
-			if (intok)
-				dpush(val);
-			else {
-				emit_fcode(lookup_token("b(lit)"));
-				emit_num32(val);
+    /*  It's not a word in any of our current contexts.
+     *      Is it a number?
+     */
+    if ( handle_number() )
+    {
+	return ;
 			}
-			continue;
+
+    /*  Could not identify - give a shout. */
+    tokenized_word_error( statbuf );
 		}
 
-		/* could not identify - bail out. */
+/* **************************************************************************
+ *
+ *      Function name:  tokenize
+ *      Synopsis:       Tokenize the current input stream.
+ *                          May be called recursively for macros and such.
+ *
+ *      Revision History:
+ *      Updated Thu, 24 Mar 2005 by David L. Paktor
+ *          Factor-out comment-filtration; apply to  gather_locals
+ *          Factor-out tokenizing a single word (for conditionals)
+ *          Separate actions of "Tokenizer-Escape" mode.
+ *
+ **************************************************************************** */
+
+void tokenize(void)
+{
+    signed long wlen = 0;
 		
-		printf("%s:%d: error: word '%s' is not in dictionary.\n",
-				iname, lineno, statbuf);
-		ERROR;
+    while ( wlen >= 0 )
+    {
+	wlen = get_word();
+	if ( wlen > 0 )
+	{
+	    tokenize_one_word( wlen );
+	}
 	}
 }
 
diff --git a/toke/scanner.h b/toke/scanner.h
new file mode 100644
index 0000000..173c907
--- /dev/null
+++ b/toke/scanner.h
@@ -0,0 +1,123 @@
+#ifndef _TOKE_SCANNER_H
+#define _TOKE_SCANNER_H
+
+/*
+ *                     OpenBIOS - free your system!
+ *                         ( FCode tokenizer )
+ *
+ *  This program is part of a free implementation of the IEEE 1275-1994
+ *  Standard for Boot (Initialization Configuration) Firmware.
+ *
+ *  Copyright (C) 2001-2005 Stefan Reinauer, <stepan@openbios.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ *
+ */
+
+/* **************************************************************************
+ *
+ *      External/Prototype definitions for Scanning functions in Tokenizer
+ *
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Module Author:  David L. Paktor    dlpaktor@us.ibm.com
+ *
+ **************************************************************************** */
+
+
+#include "types.h"
+#include "ticvocab.h"
+
+/* ************************************************************************** *
+ *
+ *      Global Variables Exported
+ *
+ **************************************************************************** */
+
+extern u8  *statbuf;           /*  The word just read from the input stream  */
+extern u8   base;	       /*  The numeric-interpretation base           */
+
+
+/* pci data */
+extern bool pci_is_last_image;
+extern u16  pci_image_rev;        /* Vendor's Image, NOT PCI Data Struct Rev */
+extern u16  pci_vpd;
+
+
+/*  Having to do with the state of the tokenization  */
+extern bool offs16;	     /*  Using 16-bit branch- (etc) -offsets  */
+extern bool in_tokz_esc;     /*  TRUE if in "Tokenizer Escape" mode   */
+extern bool incolon;	     /*  TRUE if inside a colon definition    */
+extern bool haveend;	     /*  TRUE if the "end" code was read.     */
+extern int do_loop_depth;    /*  How deep we are inside DO ... LOOP variants */
+
+/*  For special-case error detection or reporting */
+extern int lastcolon;	/*  Loc'n in output stream of latest colon-def'n.  */
+			/*  Used for error-checking of IBM-style Locals    */
+extern char *last_colon_defname;       /*  Name of last colon-definition     */
+extern char *last_colon_filename;      /*  File where last colon-def'n made  */
+extern unsigned int last_colon_lineno; /*  Line number of last colon-def'n   */
+extern bool report_multiline;          /*  False to suspend multiline warning */
+extern unsigned int last_colon_abs_token_no;
+
+/* ************************************************************************** *
+ *
+ *      Function Prototypes / Functions Exported:
+ *
+ **************************************************************************** */
+
+void	init_scanner( void );
+void	exit_scanner( void );
+void init_scan_state( void );
+void	 fcode_ender( void );
+
+bool skip_until( char lim_ch);
+void push_source( void (*res_func)(), _PTR res_parm, bool is_f_chg );
+signed long get_word( void);
+bool get_word_in_line( char *func_nam);
+bool get_rest_of_line( void);
+void warn_unterm( int severity,
+                            char *something,
+			        unsigned int saved_lineno);
+void warn_if_multiline( char *something, unsigned int start_lineno );
+void user_message( tic_param_t pfield );
+void skip_user_message( tic_param_t pfield );
+bool get_number( long *result);
+void eval_string( char *inp_bufr);
+
+void process_remark( tic_param_t pfield );
+bool filter_comments( u8 *inword);
+bool as_a_what( fwtoken definer, char *as_what);
+tic_hdr_t *lookup_word( char *stat_name, char **where_pt1, char **where_pt2 );
+bool word_exists( char *stat_name, char **where_pt1, char **where_pt2 );
+void warn_if_duplicate ( char *stat_name);
+void trace_creation( fwtoken definer, char *nu_name);
+void tokenize_one_word( signed long wlen );
+void check_name_length( signed long wlen );
+
+void	tokenize( void );
+
+/* **************************************************************************
+ *
+ *          Macro Name:   FUNC_CPY_BUF_SIZE
+ *                        Size of a temporary buffer to retain a copy of
+ *                        a function name taken from statbuf, when statbuf
+ *                        will be used to return a value, but the function
+ *                        name might still be needed for an error message.
+ *
+ **************************************************************************** */
+
+#define FUNC_CPY_BUF_SIZE  40
+
+
+#endif   /*  _TOKE_SCANNER_H    */
diff --git a/toke/stack.c b/toke/stack.c
index 4bd20f4..a58cd2f 100644
--- a/toke/stack.c
+++ b/toke/stack.c
@@ -24,93 +24,203 @@
  *
  */
 
+/* **************************************************************************
+ *         Modifications made in 2005 by IBM Corporation
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Modifications Author:  David L. Paktor    dlpaktor@us.ibm.com
+ **************************************************************************** */
+
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 
-#include "toke.h"
 #include "stack.h"
+#include "scanner.h"
+#include "errhandler.h"
 
+/* **************************************************************************
+ *
+ *          Global Variables Imported
+ *              statbuf          The word just read from the input stream
+ *
+ **************************************************************************** */
 
-#define GUARD_STACK
-#define EXIT_STACKERR
 
-#ifdef GLOBALSTACK
-#define STATIC static
-#else
-#define STATIC
-#endif
-STATIC long *dstack,*startdstack,*enddstack;
-#undef STATIC
+/* **************************************************************************
+ *
+ *          Global Variables Exported
+ *              dstack         Pointer to current item on top of Data Stack
+ *
+ **************************************************************************** */
+
+long *dstack;
+
+/* **************************************************************************
+ *
+ *      Local/Static Pointers  .....      to  ...         -> Points to ...
+ *          startdstack         Start of data-stack area  -> last possible item
+ *          enddstack           End of data-stack area    -> past first item
+ *
+ *************************************************************************** */
+
+static long *startdstack;
+static long *enddstack;
+
+void clear_stack(void)
+{
+    dstack = enddstack;
+}
 
 /* internal stack functions */
 
-int init_stack(void)
+void init_stack(void)
 {
-	startdstack=enddstack=malloc(MAX_ELEMENTS*sizeof(long));
-	enddstack+=MAX_ELEMENTS;
+	startdstack = safe_malloc(MAX_ELEMENTS*sizeof(long), "initting stack");
+	enddstack = startdstack + MAX_ELEMENTS;
 	dstack=enddstack;
-	return 0;
 }
 
-#ifdef GLOBALSTACK 
+/*  Input Param:  stat   TRUE = Underflow, FALSE = Overflow   */
+static void stackerror(bool stat)
+{
+    /*
+     *   Because all of our stack operations are protected and
+     *       we have no risk of the  dstack  pointer going into
+     *       invalid territory, this error needs not be  FATAL.
+     */
+    tokenization_error ( TKERROR , "stack %sflow at or near  %s \n",
+	 (stat)?"under":"over" , statbuf );
+}
 
-#ifdef GUARD_STACK
-static void stackerror(int stat)
+/*
+ *  Return TRUE if the stack depth is equal to or greater than
+ *      the supplied minimum requirement.  If not, print an error.
+ */
+bool min_stack_depth(int mindep)
 {
-  	printf ("FATAL: stack %sflow\n",
-		(stat)?"under":"over" );
-#ifdef EXIT_STACKERR
-	exit(-1);
-#endif
+    bool retval = TRUE ;
+    long *stack_result;
+
+    stack_result = dstack + mindep;
+    /*
+     *  The above appears counter-intuitive.  However, C compensates
+     *      for the size of the object of a pointer when it handles
+     *      address arithmetic.  A more explicit expression that would
+     *      yield the same result, might look something like this:
+     *
+     *        (long *)((int)dstack + (mindep * sizeof(long)))
+     *
+     *  I doubt that that form would yield tighter code, or otherwise
+     *      represent any material advantage...
+     */
+
+    if ( stack_result > enddstack )
+    {
+	retval = FALSE;
+	stackerror(TRUE);
+    }
+
+    return ( retval );
+}
+
+/*
+ *  Return TRUE if the stack has room for the supplied # of items
+ */
+static bool room_on_stack_for(int newdep)
+{
+    bool retval = TRUE ;
+    long *stack_result;
+
+    stack_result = dstack - newdep;
+    /*  See above note about "counter-intuitive" pointer address arithmetic  */
+
+    if ( stack_result < startdstack )
+    {
+	retval = FALSE;
+	stackerror(FALSE);
+    }
+
+    return ( retval );
 }
-#endif
 
 void dpush(long data)
 {
 #ifdef DEBUG_DSTACK
 	printf("dpush: sp=%p, data=0x%lx, ", dstack, data);
 #endif
-	*(--dstack)=data;
-#ifdef GUARD_STACK
-	if (dstack<startdstack) stackerror(0);
-#endif
+	if ( room_on_stack_for(1) )
+	{
+	    --dstack;
+	    *(dstack)=data;
+	}
 }
 
 long dpop(void)
 {
-  	long val;
+  	long val = 0;
 #ifdef DEBUG_DSTACK
 	printf("dpop: sp=%p, data=0x%lx, ",dstack, *dstack);
 #endif
-	val=*(dstack++);
-#ifdef GUARD_STACK
-	if (dstack>enddstack) stackerror(1);
-#endif
+	if ( min_stack_depth(1) )
+	{
+	    val=*(dstack);
+	    dstack++;
+	}
 	return val;
 }
 
 long dget(void)
 {
-	return *(dstack);
+  	long val = 0;
+	if ( min_stack_depth(1) )
+	{
+	    val = *(dstack);
+	}
+	return val;
 }
-#endif
 
-/* Stack helper functions */
-
-u8 *get_stackstring(void)
+long stackdepth(void)
 {
-	long size;
-	u8   *fstring, *retstring;
-
-	size=dpop();
-	fstring=(u8 *)dpop();
+    long depth;
+
+    depth = enddstack - dstack;
+    /*
+     *  Again, C's address arithmetic compensation comes into play.
+     *      See the note at  min_stack_depth()
+     *
+     *  A more explicit equivalent expression might look like this:
+     *
+     *        (((long int)enddstack - (long int)dstack) / sizeof(long))
+     *
+     *  I doubt any material advantage with that one either...
+     */
+
+    return (depth);
+}
 
-	retstring=malloc(size+1);
-	strncpy((char *)retstring, (const char *)fstring, size);
-	retstring[size]=0;
+void swap(void)
+{
+    long nos_temp;    /*  Next-On-Stack temp  */
+    if ( min_stack_depth(2) )
+    {
+	nos_temp = dstack[1];
+	dstack[1]= dstack[0];
+	dstack[0]= nos_temp;
+    }
+}
 
-	return retstring;
+void two_swap(void)
+{
+    long two_deep, three_deep;
+    if ( min_stack_depth(4) )
+    {
+	two_deep   = dstack[2];
+	three_deep = dstack[3];
+	dstack[2]  = dstack[0];
+	dstack[3]  = dstack[1];
+	dstack[1]  = three_deep;
+	dstack[0]  = two_deep;
+    }
 }
 
 
diff --git a/toke/stack.h b/toke/stack.h
index 9aa5c53..35f0eab 100644
--- a/toke/stack.h
+++ b/toke/stack.h
@@ -1,3 +1,6 @@
+#ifndef _TOKE_STACK_H
+#define _TOKE_STACK_H
+
 /*
  *                     OpenBIOS - free your system! 
  *                         ( FCode tokenizer )
@@ -24,23 +27,47 @@
  *
  */
 
-#ifdef ANSI_ONLY
-#define GLOBALSTACK
-#endif
+/* **************************************************************************
+ *         Modifications made in 2005 by IBM Corporation
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Modifications Author:  David L. Paktor    dlpaktor@us.ibm.com
+ **************************************************************************** */
+
+#include "types.h"
+
+/* ************************************************************************** *
+ *
+ *      Macros:
+ *          MAX_ELEMENTS          Size of stack area, in "elements"
+ *
+ **************************************************************************** */
 
 #define MAX_ELEMENTS 1024
 
-#ifdef GLOBALSTACK
+/* ************************************************************************** *
+ *
+ *      Global Variables Exported
+ *
+ **************************************************************************** */
+
+extern long *dstack;
+
+/* ************************************************************************** *
+ *
+ *      Function Prototypes / Functions Exported:
+ *
+ **************************************************************************** */
+
 void dpush(long data);
 long dpop(void);
 long dget(void);
-#else
-extern long *dstack,*startdstack;
-static inline void dpush(long data) { *(--dstack)=data; }
-static inline long dpop(void) { return (long)*(dstack++); }
-static inline long dget(void) { return *(dstack); }
-#endif
 
-int init_stack(void);
-u8 *get_stackstring(void);
+void clear_stack(void);
+void init_stack(void);
+
+bool min_stack_depth(int mindep);   /*  TRUE if no error  */
+long stackdepth(void);
+void swap(void);
+void two_swap(void);
 
+#endif   /*  _TOKE_STACK_H    */
diff --git a/toke/stream.c b/toke/stream.c
index dd96a53..b7793f1 100644
--- a/toke/stream.c
+++ b/toke/stream.c
@@ -24,6 +24,12 @@
  *
  */
 
+/* **************************************************************************
+ *         Modifications made in 2005 by IBM Corporation
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Modifications Author:  David L. Paktor    dlpaktor@us.ibm.com
+ **************************************************************************** */
+
 #include <stdio.h>
 #include <stdlib.h>
 #ifdef __GLIBC__
@@ -32,134 +38,1577 @@
 #include <string.h>
 #include <sys/stat.h>
 
-#include "toke.h"
+#include "emit.h"
 #include "stream.h"
+#include "errhandler.h"
+#include "toke.h"
 
-#define OUTPUT_SIZE	131072
+/* **************************************************************************
+ *
+ *      Revision History:
+ *      Updated Tue, 31 Jan 2006 by David L. Paktor
+ *          Add support for embedded Environment-Variables in path name
+ *      Updated Thu, 16 Feb 2006 David L. Paktor
+ *          Collect missing (inaccessible) filenames
+ *      Updated Thu, 16 Mar 2006 David L. Paktor
+ *          Add support for Include-Lists
+ *
+ **************************************************************************** */
 
-extern bool offs16;
-extern u16 nextfcode;
+/* **************************************************************************
+ *
+ *          Global Variables Exported
+ *              start                 Start of input-source buffer
+ *              end                   End of input-source buffer
+ *              pc                    Input-source Scanning pointer
+ *              iname                 Current Input File name
+ *              lineno                Current Line Number in Input File
+ *              ostart                Start of Output Buffer
+ *              opc                   FCode Output Buffer Position Counter
+ *              oname                 Output File name
+ *
+ **************************************************************************** */
 
-u8 *start, *pc, *end;
-char *iname;
+
+/* Input pointers, Position Counters and Length counters */
+u8 *start = NULL;
+u8 *pc;
+u8 *end;
+char *iname = NULL;
+unsigned int lineno = 0;
+unsigned int abs_token_no = 0;  /*  Absolute Token Number in all Source Input
+                                 *      Will be used to identify position
+                                 *      where colon-definition begins and
+                                 *      to limit clearing of control-structs.
+                                 */
+static unsigned int ilen;   /*  Length of Input Buffer   */
 
 /* output pointers */
-u8 *ostart, *opc, *oend, *oname;
-static unsigned int ilen;
+u8 *ostart;
+char *oname = NULL;
+unsigned int opc;           /*  Output Position Counter  */
+
+/* We want to limit exposure of this v'ble, so don't put it in  .h  file  */
+unsigned int olen;          /*  Length of Output Buffer  */
+/* We want to limit exposure of this Imported Function, likewise.  */
+void init_emit( void);
+
+/* **************************************************************************
+ *
+ *          Internal Static Variables
+ *     load_list_name       Name of the Load List File
+ *     load_list_file       (Pointer to) File-Structure for the Load List File
+ *     depncy_list_name     Name of the Dependency List File
+ *     depncy_file     (Pointer to) File-Structure for the Dependency List File
+ *     missing_list_name    Name of the Missing-Files-List File
+ *     missing_list_file    (Pointer to) File-Structure for Missing-List File
+ *     no_files_missing     TRUE if able to load all files
+ *
+ **************************************************************************** */
+
+static char *load_list_name;
+static FILE *load_list_file;
+static char *depncy_list_name;
+static FILE *depncy_file;
+static char *missing_list_name;
+static FILE *missing_list_file;
+static bool no_files_missing = TRUE;
+
+/* **************************************************************************
+ *
+ *         Private data-structure for Include-List support
+ *
+ *     Components are simply a string-pointer and a link pointer
+ *
+ **************************************************************************** */
+
+typedef struct incl_list
+{
+        char             *dir_path;
+	struct incl_list *next;
+    } incl_list_t;
+
+/* **************************************************************************
+ *
+ *          Internal Static Variables associated with Include-List support
+ *     include_list_start        Start of the Include-List
+ *     include_list_next         Next entry in Include-List to add or read
+ *     max_dir_path_len          Size of longest entry in the Include-List
+ *     include_list_full_path    Full-Path (i.e., expanded File-name with
+ *                                   Include-List Entry) that was last opened.
+ *
+ **************************************************************************** */
+static incl_list_t *include_list_start = NULL;
+static incl_list_t *include_list_next = NULL;
+static unsigned int max_dir_path_len = 0;
+static char *include_list_full_path = NULL;
+
 
-unsigned int lineno;
+/* **************************************************************************
+ *
+ *      Function name:  add_to_include_list
+ *      Synopsis:       Add an entry to the Include-List
+ *
+ *      Inputs:
+ *         Parameters:
+ *             dir_compt               Directory Component to add to Inc-List
+ *         Local Static Variables:
+ *             include_list_start      First entry in the Include-List
+ *             include_list_next       Next entry in Include-List to add
+ *             max_dir_path_len        Previous max Dir-Component Length 
+ *
+ *      Outputs:
+ *         Returned Value:             NONE
+ *         Local Static Variables:
+ *             include_list_start      Assigned a value, first time through
+ *             include_list_next       "Next" field updated with new entry,
+ *                                         then pointer updated to new entry.
+ *             max_dir_path_len        Maximum Length 
+ *         Memory Allocated
+ *             For the list-entry, and for the directory/path name to be added
+ *         When Freed?
+ *             Remains in effect through the life of the program.
+ *
+ *      Process Explanation:
+ *          Unlike most of our linked-lists, this one will be linked forward,
+ *              i.e., in the order elements are added, and will be searched
+ *              in a forward order.
+ *          This means extra code to handle the first entry.
+ *          Allocate and initialize the New Include-List Entry.
+ *          If this is the first entry, point the List-Starter at it.
+ *          Otherwise, the Last-Entry-on-the-List pointer is already valid;
+ *              point its "next" field at the New Entry.
+ *          Point the Last-Entry-on-the-List pointer at the New Entry.
+ *
+ **************************************************************************** */
 
-int init_stream( const char *name)
+void add_to_include_list( char *dir_compt)
 {
-	FILE *infile;
-	unsigned int i;
+    unsigned int new_path_len = strlen( dir_compt);
+    incl_list_t *new_i_l_e = safe_malloc( sizeof( incl_list_t),
+        "adding to include-list" );
+
+    new_i_l_e->dir_path = strdup( dir_compt);
+    new_i_l_e->next = NULL;
+
+    if ( include_list_start == NULL )
+    {
+	include_list_start = new_i_l_e;
+    }else{
+       include_list_next->next = new_i_l_e;
+    }
+    
+    include_list_next = new_i_l_e;
+    if ( new_path_len > max_dir_path_len  ) max_dir_path_len = new_path_len;
+}
+
+#define   DISPLAY_WIDTH  80
+/* **************************************************************************
+ *
+ *      Function name:  display_include_list
+ *      Synopsis:       Display the Include-List, once it's completed,
+ *                          if "verbose" mode is in effect.
+ *
+ *      Inputs:
+ *         Parameters:                    NONE
+ *         Local Static Variables:
+ *             include_list_start         First entry in the Include-List
+ *             include_list_next          Next entry, as we step through.
+ *         Macro:
+ *             DISPLAY_WIDTH              Width limit of the display
+ *
+ *      Outputs:
+ *         Returned Value:                NONE
+ *         Local Static Variables:
+ *             include_list_next          NULL, when reaches end of Incl-List
+ *         Printout:
+ *             The elements of the Include-List, separated by a space, on
+ *                 a line up to the DISPLAY_WIDTH, or on a line by itself
+ *                 if the element is wider.
+ *
+ *      Process Explanation:
+ *          The calling routine will check for the  verbose  flag.
+ *          Nothing to be done here if Include-List is NULL.
+ *          Print a header, then the list.
+ *
+ **************************************************************************** */
+
+void display_include_list( void)
+{
+    if ( include_list_start != NULL )
+    {
+        int curr_wid = DISPLAY_WIDTH;     /*  Current width; force new line  */
+	printf("\nInclude-List:");
+	include_list_next = include_list_start ;
+	while ( include_list_next != NULL )
+	{
+	    int this_wid = strlen( include_list_next->dir_path) + 1;
+	    char *separator = " ";
+	    if ( curr_wid + this_wid > DISPLAY_WIDTH )
+	    {
+	        separator = "\n\t";
+		curr_wid = 7;  /*  Allow 1 for the theoretical space  */
+	    }
+	    printf("%s%s", separator, include_list_next->dir_path);
+	    curr_wid += this_wid;
+	    include_list_next = include_list_next->next ;
+	}
+	printf("\n");
+    }
+}
+
+
+
+/* **************************************************************************
+ *
+ *          We cannot accommodate the structures of the different
+ *              routines that open files with a single function, so
+ *              we will have to divide the action up into pieces:
+ *              one routine to initialize the include-list search, a
+ *              second to return successive candidates.  The calling
+ *              routine will do the operation (stat or fopen) until
+ *              it succeeds or the list is exhausted.  Then it will
+ *              call a final routine to clean up and display messages.
+ *
+ *          I'm sure I don't need to mention that, when no include-list
+ *              is defined, these functions will still support correct
+ *              operation...
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      Function name:  init_incl_list_scan
+ *      Synopsis:       Initialize the search through the Include-List
+ *
+ *      Inputs:
+ *         Parameters:
+ *             base_name               Expanded user-supplied file-name
+ *         Local Static Variables:
+ *             include_list_start      First entry in the Include-List
+ *             max_dir_path_len        Maximum Directory Component Length 
+ *
+ *      Outputs:
+ *         Returned Value:             NONE
+ *         Local Static Variables:
+ *             include_list_next       Next entry in Include-List to read
+ *             include_list_full_path  Full-Path Buffer pointer
+ *         Memory Allocated
+ *             Full-Path Buffer        (If Include-List was defined)
+ *         When Freed?
+ *             In  finish_incl_list_scan()
+ *
+ *      Process Explanation:
+ *          The  base_name  passed to the routine is expected to have
+ *              any embedded Environment-Variables already expanded.
+ *          The Full-Path Buffer is presumed to be unallocated, and
+ *              its pointer to be NULL.
+ *          The Next-Entry-to-read pointer is also presumed to be NULL.
+ *          If an Include-List has been defined, we will allocate memory
+ *              for the Full-Path Buffer and point the Next-Entry pointer
+ *              at the Start of the List.  If not, no need to do anything.
+ *
+ **************************************************************************** */
+
+static void init_incl_list_scan( char *base_name)
+{
+    if ( include_list_start != NULL )
+    {
+	/*  Allocate memory for the file-name buffer.
+	 *      maximum path-element length plus base-name length
+	 *      plus one for the slash plus one for the ending NULL
+	 */
+	unsigned int new_path_len = max_dir_path_len + strlen( base_name) + 2;
+	include_list_full_path = safe_malloc( new_path_len,
+	    "scanning include-list" );
+	include_list_next = include_list_start;
+    }
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  scan_incl_list
+ *      Synopsis:       Prepare the next candidate in the include-list search
+ *                          Indicate when the end has been reached.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             base_name               Expanded user-supplied file-name
+ *         Local Static Variables:
+ *             include_list_full_path  Full-Path Buffer pointer
+ *             include_list_next       Next entry in Include-List to read
+ *
+ *      Outputs:
+ *         Returned Value:             TRUE if valid candidate; FALSE when done
+ *         Local Static Variables:
+ *             include_list_full_path  Next Full file-name Path to use
+ *             include_list_next       Updated to next entry in the List
+ *
+ *      Process Explanation:
+ *          Include-List Components are presumed not to require any expansion;
+ *              the Shell is expected to resolve any Environment-Variables
+ *              supplied in command-line arguments before they are passed
+ *              to the (this) application-program.
+ *          We will, therefore, not attempt to expand any Components of
+ *              the Include-List.  
+ *          If the Full-Path Buffer pointer is NULL, it indicates that no
+ *              entries have been made to the Include-List and this is our
+ *              first time through this routine in this search; we will
+ *              use the base-name as supplied, presumably relative to the
+ *              current directory.  Point the buffer-pointer at the base-
+ *              -name and return "Not Done".
+ *          Otherwise, we will look at the Next-Entry pointer:
+ *              If it is NULL, we have come to the end of the Include-List;
+ *                  whether because no Include-List was defined or because
+ *                  we have reached the end, we will return "Done".
+ *              Otherwise, we will load the Full-Path Buffer with the entry
+ *                  currently indicated by the Next-Entry pointer, advance
+ *                  it to the next entry in the List and return "Not Done".
+ *          We will supply a slash as the directory-element separator in
+ *              between the Include-List entry and the  base_name 
+ *
+ *      Extraneous Remarks:
+ *          The slash as directory-element separator works in UNIX-related
+ *              environments, but is not guaranteed in others.  I would
+ *              have preferred to specify that Include-List Components are
+ *              required to end with the appropriate separator, but that
+ *              was neither acceptable nor compatible with existing practice
+ *              in other utilities, and the effort to programmatically
+ *              determine the separator used by the Host O/S was too much
+ *              for such a small return.  And besides, we already have so
+ *              many other UNIX-centric assumptions hard-coded into the
+ *              routines in this file (dollar-sign to signify Environment
+ *              Variables, period for file-name-extension separator, etc.)
+ *              that it's just too much of an uphill battle anymore...
+ *
+ **************************************************************************** */
+
+static bool scan_incl_list( char *base_name)
+{
+    bool retval = FALSE;   /*  default to "Done"  */
 	
+    if ( include_list_full_path == NULL )
+    {
+	include_list_full_path = base_name;
+	retval = TRUE;
+    }else{
+	if ( include_list_next != NULL )
+	{
+
+	    /*  Special case:  If the next Directory Component is
+	     *      an empty string, do not prepend a slash; that
+	     *      would either become a root-based absolute path,
+	     *      or, if the base-name is itself an absolute path,
+	     *      it would be a path that begins with two slashes,
+	     *      and *some* Host Operating Systems ***REALLY***
+	     *      DO NOT LIKE that!
+	     */
+	    if ( strlen( include_list_next->dir_path) == 0 )
+	    {
+		sprintf( include_list_full_path, "%s", base_name);
+	    }else{
+		sprintf( include_list_full_path, "%s/%s",
+	            include_list_next->dir_path, base_name);
+	    }
+	    include_list_next = include_list_next->next;
+	    retval = TRUE;
+	}
+    }
+
+    return( retval);
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  finish_incl_list_scan
+ *      Synopsis:       Clean up after a search through the Include-List
+ *                          Display appropriate messages.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             op_succeeded            TRUE if intended operation was ok.
+ *             
+ *         Local Static Variables:
+ *             include_list_start      Non-NULL if Include-List was defined
+ *
+ *      Outputs:
+ *         Returned Value:             NONE
+ *         Local Static Variables:
+ *             include_list_full_path  Reset to NULL
+ *             include_list_next       Reset to NULL
+ *         Memory Freed
+ *             Full-Path Buffer        (If Include-List was defined)
+ *         Printout:
+ *             If file was found in Include-List, Advisory showing where.
+ *
+ **************************************************************************** */
+
+static void finish_incl_list_scan( bool op_succeeded)
+{
+    if ( include_list_start != NULL )
+    {
+	if ( op_succeeded )
+	{
+	    tokenization_error( INFO,
+		"File was found in %s\n" ,include_list_full_path );
+	}
+	free( include_list_full_path);
+    }
+    include_list_full_path = NULL;
+    include_list_next = NULL;
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  open_incl_list_file
+ *      Synopsis:       Look in the Include-List, if one is defined, for
+ *                          the file whose name is given and open it.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             base_name               Expanded user-supplied file-name
+ *             mode                    Mode-string to use; usually "r" or "rb"
+ *         Local Static Variables:
+ *             include_list_full_path  Full Path to use in fopen atttempt
+ *
+ *      Outputs:
+ *         Returned Value:             File structure pointer; NULL if failed
+ *         Local Static Variables:
+ *             include_list_full_path  Full Path used, if succeeded
+ *
+ *      Error Detection:
+ *          Calling routine will detect and report Errors.
+ *
+ *      Process Explanation:
+ *          This routine will initialize and step through Include-List.
+ *              Calling routine will be responsible for "finishing" the
+ *              Include-List search, as well as any Advisory messages.
+ *
+ **************************************************************************** */
+
+static FILE *open_incl_list_file( char *base_name, char *mode)
+{
+    FILE *retval = NULL;
+
+    init_incl_list_scan( base_name);
+    while ( scan_incl_list( base_name) )
+    {
+        retval = fopen( include_list_full_path, mode);
+	if ( retval != NULL )
+	{
+	    break; 
+	}
+    }
+
+    return (retval);
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  stat_incl_list_file
+ *      Synopsis:       Look in the Include-List, if defined, for given file,
+ *                          and collect its statistics.
+ *                      
+ *
+ *      Inputs:
+ *         Parameters:
+ *             base_name               Expanded user-supplied file-name
+ *             file_info               Pointer to STAT structure
+ *         Local Static Variables:
+ *             include_list_full_path  Full Path to use in file-status atttempt
+ *
+ *      Outputs:
+ *         Returned Value:             TRUE if succeeded.
+ *         Local Static Variables:
+ *             include_list_full_path  Full Path used, if succeeded
+ *         Supplied Pointers:
+ *             *file_info              File-statistics structure from STAT call
+ *
+ *      Error Detection:
+ *          Calling routine will detect and report Errors.
+ *          
+ *      Process Explanation:
+ *          This routine will initialize and step through Include-List.
+ *              Calling routine will be responsible for "finishing" the
+ *              Include-List search, as well as any Advisory messages.
+ *
+ **************************************************************************** */
+
+static bool stat_incl_list_file( char *base_name, struct stat *file_info)
+{
+    bool retval = FALSE;
+    int stat_reslt = -1;    /*  Success = 0   */
+
+    init_incl_list_scan( base_name);
+    while ( scan_incl_list( base_name) )
+    {
+        stat_reslt = stat( include_list_full_path, file_info);
+	if ( stat_reslt == 0 )
+	{
+	    retval = TRUE;
+	    break; 
+	}
+    }
+
+    return (retval);
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  init_inbuf
+ *      Synopsis:       Set the given buffer as the current input source
+ *      
+ *      Inputs:
+ *         Parameters:
+ *             inbuf         Pointer to start of new input buffer
+ *             buflen        Length of new input buffer
+ *
+ *      Outputs:
+ *         Returned Value:    NONE
+ *         Global Variables:
+ *             start             Points to given buffer
+ *             end               Points to end of new input buffer
+ *             pc                Re-initialized      
+ *
+ **************************************************************************** */
+
+void init_inbuf(char *inbuf, unsigned int buflen)
+{
+    start = inbuf;
+    pc = start;
+    end = pc + buflen;
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  could_not_open
+ *      Synopsis:       Report the "Could not open" Message for various Files.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             severity                  Severity of message, WARNING or ERROR
+ *             fle_nam                   Name of file
+ *             for_what                  Phrase after "... for "
+ *
+ *      Outputs:
+ *         Returned Value:               NONE
+ *         Printout:
+ *             Message of indicated severity.
+ *
+ *      Error Detection:
+ *          Error already detected; reported here.
+ *
+ **************************************************************************** */
+
+static void could_not_open(int severity, char *fle_nam, char *for_what)
+{
+    tokenization_error( severity, "Could not open file %s for %s.\n",
+	fle_nam, for_what);
+
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  file_is_missing
+ *      Synopsis:       Add the given File to the Missing-Files-List.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             fle_nam                   Name of file
+ *         Local Static Variables:
+ *             missing_list_file         Missing-Files-List File Structure
+ *                                           May be NULL if none was opened
+ *
+ *      Outputs:
+ *         Returned Value:               NONE
+ *         Local Static Variables:
+ *             no_files_missing         Set FALSE
+ *         File Output:
+ *             Write File name to Missing-Files-List (if one was opened)
+ *
+ *      Error Detection:
+ *          Error already detected; reported here.
+ *
+ **************************************************************************** */
+
+static void file_is_missing( char *fle_nam)
+{
+    if ( missing_list_file != NULL )
+    {
+	fprintf( missing_list_file, "%s\n", fle_nam);
+	no_files_missing = FALSE;
+    }
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  add_to_load_lists
+ *      Synopsis:       Add the given input file-name to the Load-List File,
+ *                      and the Full File path to the Dependency-List File.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             in_name                  Name of given input Source File
+ *         Local Static Variables:
+ *             load_list_file           Load List File Structure pointer
+ *             depncy_file              Dependency-List File Structure ptr
+ *                            Either may be NULL if the file was not opened.
+ *             include_list_full_path   Full Path to where the file was found.
+ *
+ *      Outputs:
+ *         Returned Value:               NONE
+ *         File Output:
+ *             Write given file-name to Load-List file (if one was opened)
+ *             Write File Path to Dependency-List file (if one was opened)
+ *
+ *      Process Explanation:
+ *          Write into the Load-List file the input Source Filename in the
+ *              same form -- i.e., unexpanded -- as was supplied by the User.
+ *          Write into the Dependency-List file the full expanded path, as
+ *              supplied by the program to the Host Operating System.
+ *
+ **************************************************************************** */
+
+static void add_to_load_lists( const char *in_name)
+{
+    if ( load_list_file != NULL )
+    {
+	fprintf( load_list_file, "%s\n", in_name);
+    }
+    if ( depncy_file != NULL )
+    {
+	fprintf( depncy_file, "%s\n", include_list_full_path);
+    }
+}
+
+
+/* **************************************************************************
+ *
+ *      In the functions that support accessing files whose path-names
+ *          contain embedded Environment-Variables, the commentaries
+ *          will refer to this process, or to inputs that require it,
+ *          using variants of the term "expand".
+ *
+ *      We will also keep some of the relevant information as Local
+ *          Static Variables.
+ *
+ **************************************************************************** */
+
+static char expansion_buffer[ 2*GET_BUF_MAX];
+static bool was_expanded;
+static int expansion_msg_severity = INFO;
+
+/* **************************************************************************
+ *
+ *      Function name:  expanded_name
+ *      Synopsis:       Advisory message to display filename expansion.
+ *
+ *      Inputs:
+ *         Parameters:
+ *         Local Static Variables:
+ *             was_expanded              TRUE if expansion happened
+ *             expansion_buffer          Buffer with result of expansion
+ *             expansion_msg_severity    Whether it's an ordinary Advisory
+ *                                           or we force a message.
+ *
+ *      Outputs:
+ *         Returned Value:               NONE
+ *             
+ *         Printout:
+ *             Advisory message showing expansion, if expansion happened
+ *             Otherwise, nothing.
+ *
+ **************************************************************************** */
+
+static void expanded_name( void )
+{
+    if ( was_expanded )
+    {
+	tokenization_error( expansion_msg_severity,
+	    "File name expanded to:  %s\n", expansion_buffer);
+    }
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  expansion_error
+ *      Synopsis:       Supplemental message to display filename expansion.
+ *                      Called after an expanded-filename failure was reported.
+ *
+ *      Inputs:
+ *         Parameters:
+ *         Global Variables:
+ *             verbose                   Set by "-v" switch
+ *
+ *      Outputs:
+ *         Returned Value:               NONE
+ *         Printout:
+ *             Advisory message showing expansion, if applicable
+ *                 and if wasn't already shown.
+ *
+ *      Error Detection:
+ *          Called after Error was reported.
+ *
+ *      Process Explanation:
+ *          Presumptions are that:
+ *              An Error message, showing the user-supplied form of the
+ *                  pathname is also being displayed
+ *              An advisory message showing the pathname expansion may
+ *                  have been displayed during the expansion process,
+ *                  if  verbose  was TRUE.
+ *          The purpose of this routine is to display the expansion if
+ *              it had not already just been displayed, i.e., if  verbose
+ *              is not set to TRUE:  Temporarily force the display of an
+ *              Advisory message.
+ *
+ *      Extraneous Remarks:
+ *          If this routine is called before the Error message is displayed,
+ *              the verbose and non-verbose versions of the Log-File will
+ *              match up nicely...
+ *
+ **************************************************************************** */
+
+static void expansion_error( void )
+{
+    if ( INVERSE( verbose) )
+    {
+	expansion_msg_severity |= FORCE_MSG;
+	expanded_name();
+	expansion_msg_severity ^= FORCE_MSG;
+    }
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  expand_pathname
+ *      Synopsis:       Perform the expansion of a path-name that may contain
+ *                          embedded Environment-Variables
+ *
+ *      Inputs:
+ *         Parameters:
+ *             input_pathname           The user-supplied filename
+ *         Global/Static MACRO:
+ *             GET_BUF_MAX              Size of expansion buffer is twice this.
+ *
+ *      Outputs:
+ *         Returned Value:              Pointer to expanded name, or to
+ *                                          input if no expansion needed.
+ *                                      NULL if error.
+ *         Local Static Variables:
+ *             was_expanded             TRUE if expansion needed and succeeded
+ *             expansion_buffer         Result of expansion
+ *         Printout:
+ *             Advisory message showing expansion
+ *             Presumption is that an Advisory giving the user-supplied
+ *                 pathname was already printed.
+ *
+ *      Error Detection:
+ *          Syntax error.  System might print something; it might not be
+ *              captured, even to a log-file.  System failure return might
+ *              be the only program-detectable indication.  Display ERROR
+ *              message and return NULL pointer.  Calling routine will
+ *              display the user-supplied pathname in its Error message
+ *              indicating failure to open the file.
+ *
+ *      Process Explanation:
+ *          Generally speaking, we will let the Shell expand the Environment
+ *              Variables embedded in the user-supplied pathname.
+ *          First, though, we will see if the expansion is necessary:  Look
+ *              for the telltale character, '$', in the input string.  If
+ *              it's not there, there are no Env't-V'bles, and no expansion
+ *              is necessary.  Return the pointer to the input string and
+ *              we're done.  Otherwise.....
+ *          Acquire a temporary file-name.  Construct a string of the form:
+ *                      echo input_string > temp_file_name
+ *              and then issue that string as a command to the Shell.
+ *          If that string generates a system-call failure, report an ERROR.
+ *          Open the temporary file and read its contents.  That will be
+ *              the expansion of the input string.  If its length exceeds
+ *              the capacity of the expansion buffer, it's another ERROR.
+ *          (Of course, don't forget to delete the temporary file.)
+ *          Place the null-byte marker at the end of the expanded name,
+ *              trimming off the terminating new-line.
+ *          Success.  Display the expanded name (as an Advisory message)
+ *              Return the pointer to the expansion buffer and set the flag.
+ *              (Did I mention don't forget to delete the temporary file?)
+ *
+ *      Extraneous Remarks:
+ *          This implementation approach turned out to be the simplest and
+ *              cleanest way to accomplish our purpose.  It also boasts the
+ *              HUGE advantage of not requiring re-invention of a well-used
+ *              (proverbial) wheel.  Plus, any variations allowed by the
+ *              shell (e.g.,: $PWD:h ) are automatically converted, too,
+ *              depending on the System shell (e.g., not for Bourne shell).
+ *          In order to spare you, the maintenance programmer, unnecessary
+ *              agony, I will list a few other approaches I tested, with a
+ *              brief note about the results of each:
+ *          (1)
+ *          I actually tried parsing the input line and passing each component
+ *              V'ble to the getenv() function, accumulating the results into
+ *              a conversion buffer.  I needed to check for every possible
+ *              delimiter, and handle curly-brace enclosures.  The resultant
+ *              code was *UGLY* ... you'd be appalled!  The only good spot was
+ *              that I was able to compensate for an open-curly-brace without
+ *              a corresponding close-curly-brace (if close-c-b wasn't found,
+ *              resume the search for other delimiters...) which, apparently,
+ *              the System does not or will not do.  It was, however, too
+ *              small a compensation for all the awfulness entailed overall.
+ *
+ *          I tried various approaches to using the Environment-Variables to
+ *              convert and retrieve the input string:
+ *          (2)
+ *          Create a command-string that would set an Env't V'ble to the
+ *              input-string, and pass the command-string to the system() call,
+ *              then retrieve the Env't V'ble thus set via getenv().  No dice;
+ *              the system() call operated in a separate sub-shell and could
+ *              not export its Env't upwards.
+ *          (3)
+ *          Use the setenv() command to set an Env't V'ble to the input-string
+ *              and retrieve it via getenv().  The returned string matched the
+ *              input-string without converting it.
+ *          (4)
+ *          Use the setenv() command to set an Env't V'ble to a string like:
+ *                      `echo input_string`
+ *              Again, the string retrieved via getenv() exactly matched the
+ *              unconverted command-string, back-quotes and all.
+ *
+ *          Of course, the equivalents of (2), (3) and (4) worked as desired
+ *              when tested as direct commands to the Shell.  UNIX can be
+ *              funny that way...
+ *
+ *          Oh!  Also:  we will slightly stretch the rules of well-structured
+ *              code.
+ *
+ **************************************************************************** */
+
+static char *expand_pathname( const char *input_pathname)
+{
+    static const int buffer_max = GET_BUF_MAX * 2;
+
+    char *retval = (char *)input_pathname;
+    was_expanded = FALSE;
+
+    /*  If no '$' is found, expansion is unnecessary.  */
+    if ( strchr( input_pathname, '$') != NULL )
+    {
+	FILE *temp_file;
+	int syst_stat;
+	const char *temp_file_name = tmpnam( NULL);
+
+	/*  Use the expansion buffer for our temporary command string  */
+	sprintf( expansion_buffer,
+	    "echo %s>%s\n", input_pathname, temp_file_name);
+	syst_stat = system( expansion_buffer);
+	if ( syst_stat != 0 )
+	{
+	    tokenization_error( TKERROR,
+		"Expansion Syntax.\n");
+	    /*  The "File-Opening" error message will show the input string */
+	    return( NULL);
+	}
+
+	temp_file = fopen( temp_file_name, "r");  /*  Cannot fail.   */
+	syst_stat = fread( expansion_buffer, 1, buffer_max, temp_file);
+	/*  Error test.  Length of what we read is not a good indicator;
+	 *      it's limited anyway by buffer_max.
+	 *  Valid test is if last character read was the new-line.
+	 */
+	if ( expansion_buffer[syst_stat-1] != '\n' )
+	{
+	    tokenization_error( TKERROR,
+		"Expansion buffer overflow.  Max length is %d.\n",
+		    buffer_max);
+	    retval = NULL;
+	}else{
+	    expansion_buffer[syst_stat-1] =0;
+	    was_expanded = TRUE;
+	    retval = expansion_buffer;
+	    expanded_name();
+	}
+
+	fclose( temp_file);
+	remove( temp_file_name);
+    }
+
+    return( retval);
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  open_expanded_file
+ *      Synopsis:       Open a file, expanding Environment-Variables that
+ *                          may be embedded in the given path-name.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             path_name              The user-supplied path-name
+ *             mode                   Mode-string to use; usually "r" or "rb"
+ *             for_what               Phrase to use in Messages
+ *
+ *      Outputs:
+ *         Returned Value:            Pointer to FILE structure; NULL if failed
+ *         Local Static Variables:
+ *             was_expanded          TRUE if expansion happened
+ *             expansion_buffer      Result of expansion
+ *         Printout:
+ *             Advisory message showing expansion
+ *
+ *      Error Detection:
+ *          If expansion or system-call for file-open failed,
+ *              report Error and return NULL.
+ *
+ **************************************************************************** */
+
+FILE *open_expanded_file( const char *path_name, char *mode, char *for_what)
+{
+
+    FILE *retval = NULL;
+
+    char *infile_name = expand_pathname( path_name);
+    if ( infile_name != NULL )
+    {
+        retval = open_incl_list_file( infile_name, mode);
+    }
+
+    if ( retval == NULL )
+    {
+        expansion_error();
+	tokenization_error ( TKERROR,
+	    "Failed to open file %s for %s\n", path_name, for_what );
+    }
+
+    finish_incl_list_scan( BOOLVAL( retval != NULL) );
+
+    return( retval);
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  init_stream
+ *      Synopsis:       Open a file and make it the current source.
+ *                      This is called, not only at the start of tokenization,
+ *                      but also when a subsidiary file is FLOADed.
+ *      
+ *      Inputs:
+ *         Parameters:
+ *             name                     Name of the new Input File to open
+ *                                          May be path-name containing
+ *                                          embedded Environment-Variables.
+ *         Global Variables:
+ *             oname                    NULL if opening Primary Input File
+ *         Local Static Variables:
+ *             include_list_full_path   Full Path to where the file was found
+ *
+ *      Outputs:
+ *         Returned Value:    TRUE = opened and read file successfully
+ *         Global Variables     (Only changed if successful):
+ *             iname                    Set to new Input File name
+ *             lineno                   Re-initialized to 1
+ *         Local Static Variables:
+ *             no_files_missing         Set FALSE if couldn't read input file
+ *             include_list_full_path   Retains full-path if file opened was
+ *                      the Primary Input File (as contrasted with an FLoaded
+ *                      Source file), in which case a call to  init_output()
+ *                      is expected; the Full-Path Buffer will be freed there.
+ *         Memory Allocated
+ *             Duplicate of Input File name (becomes  iname  )
+ *             A fresh input buffer; input file is copied to it.
+ *                 Becomes  start  by action of call to  init_inbuf().
+ *         When Freed?
+ *             By  close_stream()
+ *         File Output:
+ *             Write new Input File name to Load-List file.
+ *             Writing to Missing-Files-List File if failure,
+ *                 or Full File path to Dependency-List File,
+ *                 is handled by called routine.
+ *         Other Exotic Effects:
+ *             Force a flush of  stdout  before printing ERROR messages
+ *             
+ *      Error Detection:
+ *          Failure to open or read Input file:  ERROR; suppress output;
+ *              write Input File name to Missing-Files-List File.
+ *
+ *      Process Explanation:
+ *          Free local buffer on failure.
+ *          Caller should only invoke  close_stream()  if this call succeeded.
+ *          Some filesystems use zeros for new-line; we need to convert
+ *              those zeros to line-feeds.
+ *          Similarly for files that have carr-ret/line-feed; the carr-ret
+ *              will cause havoc; replace it w/ a space.
+ *      
+ *      Revision History:
+ *      Updated Thu, 07 Apr 2005 by David L. Paktor
+ *          Restructured.  If opened file, close it, even if can't read it.
+ *          Return TRUE on success.
+ *          Caller examines return value.    
+ *      Updated Wed, 13 Jul 2005 by David L. Paktor
+ *          Replace carr-rets with spaces.   
+ *      Updated Sun, 27 Nov 2005 by David L. Paktor
+ *          Write new Input File name to Load-List file. 
+ *      Updated Tue, 31 Jan 2006 by David L. Paktor
+ *          Add support for embedded Environment-Variables in path name
+ *      Updated Thu, 16 Feb 2006 David L. Paktor
+ *          Collect missing (inaccessible) filenames
+ *      Updated Fri, 17 Mar 2006 David L. O'Paktor
+ *          Add support for Include-List search
+ *
+ *      Still to be done:
+ *          Set a flag when carr-ret has been replaced by space;
+ *              when a string crosses a line, if this flag is set,
+ *              issue a warning that an extra space has been inserted.
+ *
+ **************************************************************************** */
+
+bool init_stream( const char *name)
+{
+    FILE *infile;
+    u8 *newbuf;
 	struct stat finfo;
+    bool stat_succ = FALSE;
+    bool tried_stat = FALSE;
+    bool retval = FALSE;
+    bool inp_fil_acc_err = FALSE;
+    bool inp_fil_open_err = FALSE;
+    bool inp_fil_read_err = FALSE;
+
+    char *infile_name = expand_pathname( name);
+
+    if ( (infile_name != NULL) )
+    {
+	tried_stat = TRUE;
+	stat_succ = stat_incl_list_file( infile_name, &finfo);
+    }
+
+    if ( INVERSE( stat_succ) )
+    {
+	inp_fil_acc_err = TRUE;
+    }else{
 	
-	if (stat(name,&finfo))
-		return -1;
+	infile = fopen( include_list_full_path, "r");
+	if ( infile == NULL )
+	{
+	    inp_fil_open_err = TRUE;
+	}else{
 	
 	ilen=finfo.st_size;
-	start=malloc(ilen+1);
-	if (!start)
-		return -1;
+	    newbuf = safe_malloc(ilen+1, "initting stream");
 
-        infile=fopen(name,"r");
-        if (!infile)
-                return -1;
+	    if ( fread( newbuf, ilen, 1, infile) != 1 )
+	    {
+		inp_fil_read_err = TRUE;
+		free( newbuf );
+	    } else {
+		unsigned int i;
 
-	if (fread(start, ilen, 1, infile)!=1) {
-		free(start);
-		return -1;
+		retval = TRUE ;
+		/*  Replace zeroes in the file with LineFeeds. */
+		/*  Replace carr-rets with spaces.  */
+		for (i=0; i<ilen; i++)
+		{
+		    char test_c = newbuf[i];
+		    if ( test_c == 0    ) newbuf[i] = 0x0a;
+		    if ( test_c == 0x0d ) newbuf[i] = ' ';
 	}
+		newbuf[ilen]=0;
 
+		init_inbuf(newbuf, ilen);
+
+		/*   If the -l option was specified, write the name of the
+		 *       new input-file to the Load-List file...  UNLESS
+		 *       this is the first time through and we haven't yet
+		 *       opened the Load-List file, in which case we'll
+		 *       just open it here and wait until we create the
+		 *       output-file name (since the Load-List file name
+		 *       depends on the output-file name anyway) before
+		 *       we write the initial input-file name to it.
+		 */
+		/*   Looking for the option-flag _and_ for a non-NULL value
+		 *       of the file-structure pointer is redundandundant:
+		 *       The non-NULL pointer is sufficient, once the List
+		 *       File has been created...
+		 */
+		/*   Same thing applies if the -P option was specified,
+		 *       for the Dependency-List file, except there we'll
+		 *       write the full path to where the file was found.
+		 */
+		/*   We have a routine to do both of those.   */
+		add_to_load_lists( name);
+		/*
+		 *   And... there's one slight complication:  If this is
+		 *       the first time through, (i.e., we're opening the
+		 *       Primary Input File) then we haven't yet opened the
+		 *       Dependency-List file, and we need to preserve the
+		 *       Full file-name Buffer until the call to  init_output()
+		 *       where the include-list scan will be "finish"ed.
+		 *   Actually, we want to postpone "finish"ing the inc-l scan
+		 *       for several reasons beyond the Dependency-List file, 
+		 *       such as completing the File Name Announcement first.
+		 *   A NULL output-name buffer is our indicator.
+		 */
+		if ( oname == NULL )
+		{
+		    /*  Quick way to suppress "finish"ing the i-l scan */
+		    tried_stat = FALSE; 
+		}
+	    }
 	fclose(infile);
+	}
+    }
 	
-	/* no zeroes within the file. */
-	for (i=0; i<ilen; i++) {
-		/* start[i]=start[i]?start[i]:0x0a; */
-		start[i] |= (((signed char)start[i] - 1) >> 7) & 0x0a;
+    FFLUSH_STDOUT	/*   Do this first  */
+    /*  Now we can deliver our postponed error and advisory messages  */
+    if ( INVERSE( retval) )
+    {
+	file_is_missing( (char *)name);
+	if ( inp_fil_acc_err )
+	{
+	    expansion_error();
+	    tokenization_error( TKERROR, 
+		"Could not access input file %s\n", name);
+	}else{
+	    if ( inp_fil_open_err )
+	    {
+		expansion_error();
+		could_not_open( TKERROR, (char *)name, "input");
+	    }else{
+		if ( inp_fil_read_err )
+		{
+		    expansion_error();
+		    tokenization_error( TKERROR, 
+			"Could not read input file %s\n", name);
+		}
+	    }
+	}
 	}
-	start[ilen]=0;
 	
-	pc=start; 
-	end=pc+ilen;
+    if ( tried_stat )
+    {
+        finish_incl_list_scan( stat_succ);
+    }
 
+    /*  Don't change the input file name and line-number until after
+     *      the Advisory showing where the file was found.
+     */
+    if ( retval )
+    {
 	iname=strdup(name);
-	
 	lineno=1;
+    }
 	
-	return 0;
+    return ( retval );
 	
 }
 
-int init_output( const char *in_name, const char *out_name )
+/* **************************************************************************
+ *
+ *      Function name:  extend_filename 
+ *      Synopsis:       Change the filename to the given extension
+ *
+ *      Inputs:
+ *         Parameters:
+ *             base_name                  Name of the Input Base File
+ *             new_ext                    New ext'n (with leading period)
+ *
+ *      Outputs:
+ *         Returned Value:                Result filename
+ *         Memory Allocated
+ *             Buffer for result filename
+ *         When Freed?
+ *             At end of Tokenization, by  close_output().
+ *
+ *      Process Explanation:
+ *          If the Input Base File Name has an extension, it will be replaced
+ *              with the given new extension.  If not, the new extension will
+ *              simply be appended.
+ *          If the Input Base File Name has an extension that matches the
+ *              new extension, a duplicate of the extension will be appended.
+ *
+ *      Extraneous Remarks:
+ *          I only recently added protection against the situation where the
+ *              Input Base File Name has no extension, but the Directory Path
+ *              leading to it has a period in one of the directory names.
+ *              Granted, this is a rare case, but not altogether impossible;
+ *              I would have done it earlier except for the fact that the
+ *              separator between directories may vary with different Host
+ *              Operating Systems.
+ *          However, at this point we have UNIX-centric assumptions hard-
+ *              -coded in to so many other places that we might as well
+ *              go with the slash here too.
+ *
+ **************************************************************************** */
+
+static char *extend_filename( const char *base_name, const char *new_ext)
 {
-	const char *ext;
+    char *retval;
+    char *ext;
   	unsigned int len; /* should this be size_t? */
+    const char *root;
+
+    root = strrchr(base_name, '/');
+    if ( root == NULL )  root = base_name;
+
+    ext = strrchr(root, '.');
+    if ( ext != NULL )
+    {
+        if ( strcasecmp(ext, new_ext) == 0 )
+	{
+	    ext = NULL;
+	}
+    }
+
+    len = ext ? (ext - base_name) : (unsigned int)strlen(base_name) ;
+    retval = safe_malloc(len+strlen(new_ext)+1, "extending file-name");
+    memcpy( retval, base_name, len);
+    retval[len] = 0;
+    strcat(retval, new_ext);
 
+    return( retval);
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  init_output
+ *      Synopsis:       After the Input Source File has been opened, assign 
+ *                          the name for the Binary Output File; initialize
+ *                          the FCode Output Buffer; assign names for the
+ *                          FLoad List, Dependency-List, and Missing-Files
+ *                          List files; open them and write their first
+ *                          entries to them.
+ *                     Announce the Input and various output file names.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             in_name                  Name of the Input Source File
+ *             out_name                 Name of the Binary Output File, if
+ *                                          specified on the Command Line,
+ *                                          or NULL if not.
+ *         Global Variables:
+ *             fload_list               Whether to create an FLoad-List file
+ *             dependency_list          Whether to create a Dependency-List file
+ *         Local Static Variables:
+ *             include_list_full_path   Full Path to the Input Source File;
+ *                                          should still be valid from opening
+ *                                          of Primary Source Input file, for
+ *                                          first entry to Dependency-List file.
+ *
+ *      Outputs:
+ *         Returned Value:              NONE
+ *         Global Variables:
+ *             oname                    Binary Output File Name
+ *             ostart                   Start of FCode Output Buffer
+ *             opc                      FCode Output Buffer Position Counter
+ *             abs_token_no             Initialized to 1
+ *         Local Static Variables:
+ *             load_list_name           Name of the Load List File
+ *             load_list_file           FLoad List File Structure pointer
+ *             depncy_list_name         Name of the Dependency List File ptr
+ *             depncy_file              Dependency List File Structure
+ *             missing_list_name        Name of the Missing-Files-List File
+ *             missing_list_file        Missing-Files-List File Structure
+ *             no_files_missing         Initialized to TRUE
+ *         Memory Allocated
+ *             Binary Output File Name Buffer
+ *             FCode Output Buffer
+ *             FLoad List File Name Buffer
+ *             Dependency List File Name Buffer
+ *             
+ *         When Freed?
+ *             In  close_output()
+ *         File Output:
+ *             FLoad List or Dependency List files are opened (if specified).
+ *                 Primary Source Input file name and path, respectively,
+ *                 are written as the first entry to each.
+ *         Printout:
+ *             (Announcement of input file name has already been made)
+ *             Announce binary output, fload- and dependency- -list file names
+ *
+ *      Error Detection:
+ *          Failure to open FLoad List or Dependency List file:  ERROR;
+ *              suppress binary output.  Further attempts to write to
+ *              FLoad List or Dependency List files are prevented by
+ *              the respective FILE_structure pointers being NULL.
+ *          Failure to open Missing-Files-List file:  WARNING
+ *
+ *      Process Explanation:
+ *          If no Output File Name was specified on the Command Line, the
+ *              name of the Binary (FCode) Output File will be derived
+ *              from the name of the Input File by replacing its extension
+ *              with  .fc , or, if  the Input File had no extension, by
+ *              merely appending the extension  .fc 
+ *          In the odd case where the Input File name has an extension
+ *              of  .fc, we will merely append another  .fc  extension.
+ *          If  fload_list  is TRUE (i.e., the "-l" option was specified on
+ *              the command-line, the FLoad List File name will be derived
+ *              from the name of the Output File by the same rules, only with
+ *              an extension of  .fl   Open the FLoad List File.  Write the
+ *              name of the initial input file to the FLoad List File.
+ *          Similarly if the "-P" command-line option was specified, the name
+ *              of the Dependency List File will be derived with an extension
+ *              of  .P  Open it and write the Full Path for the initial input
+ *              file to it.  NOTE:  To do that, we need to have preserved the
+ *              Full Path-name Buffer from the call to  init_stream()   We
+ *              will "finish" it here, after we've used it.
+ *          The Missing-Files-List File will be created if either option was
+ *              specified.  Its name will be derived similarly, with an
+ *              extension of  .fl.missing
+ *
+ **************************************************************************** */
+
+void init_output( const char *in_name, const char *out_name )
+{
 	/* preparing output */
 
-	if( out_name )
-		oname = (u8 *)strdup( out_name );
-	else {
-		ext=strrchr(in_name, '.');
-		len=ext ? (unsigned int)(ext-in_name) : (unsigned int)strlen(in_name) ;
-		oname=malloc(len+4);
-		memcpy(oname, in_name, len);
-		oname[len] = 0;
-		strcat((char *)oname, ".fc");
+	if( out_name != NULL )
+	{
+		oname = strdup( out_name );
+	}else{
+		oname = extend_filename( in_name, ".fc"); 
 	}
 	
 	/* output buffer size. this is 128k per default now, but we
 	 * could reallocate if we run out. KISS for now.
 	 */
-	ostart=malloc(OUTPUT_SIZE);
-	if (!ostart) {
-		free(oname);
-		free(start);
-		return -1;
+	olen = OUTPUT_SIZE;
+	ostart=safe_malloc(olen, "initting output buffer");
+
+	opc = 0;
+	init_emit();  /* Init'l'zns needed by our companion file, emit.c  */
+
+	printf("Binary output to %s ", oname);
+	if ( fload_list )
+	{
+	    load_list_name = extend_filename( oname, ".fl");
+	    load_list_file = fopen( load_list_name,"w");
+	    printf("  FLoad-list to %s ", load_list_name);
+	}
+	if ( dependency_list )
+	{
+	    depncy_list_name = extend_filename( oname, ".P");
+	    depncy_file = fopen( depncy_list_name,"w");
+	    printf("  Dependency-list to %s ", depncy_list_name);
 	}
+	printf("\n");
 
-	opc=oend=ostart;
-	oend+=OUTPUT_SIZE;
+	add_to_load_lists( in_name);
 	
-	/* We're beginning a new output file, so we have to
-	 * start our own fcode numbers at 0x800 again. 
-	 */
-	nextfcode=0x800;
+	/*  Let's avoid collisions between stdout and stderr  */
+	FFLUSH_STDOUT
+
+	/*  Now we can deliver our advisory and error messages  */
 	
-	return 0;
+	{
+	    /* Suspend showing filename in advisory and error messages. */
+	    char *temp_iname = iname;
+	    iname = NULL; 
+	
+	    finish_incl_list_scan( TRUE);
+
+	    if ( fload_list && (load_list_file == NULL) )
+	    {
+	    	could_not_open( TKERROR, load_list_name, "Load-List");
+		free( load_list_name);
+	    }
+	    if ( dependency_list && (depncy_file == NULL) )
+	    {
+	    	could_not_open( TKERROR, depncy_list_name,
+		    "Dependency-List");
+		free( depncy_list_name);
 }
 
-int close_stream(void)
+	    if ( fload_list || dependency_list )
+	    {
+		missing_list_name = extend_filename( oname, ".fl.missing");
+		missing_list_file = fopen( missing_list_name,"w");
+		no_files_missing = TRUE;
+
+		if ( missing_list_file == NULL )
+		{
+		    could_not_open( WARNING, missing_list_name,
+			"Missing-Files List" );
+	            free( missing_list_name);
+		}
+	    }
+	    iname = temp_iname;
+	}
+	abs_token_no = 1;
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  increase_output_buffer
+ *      Synopsis:       Reallocate the Output Buffer to double its prior size 
+ *
+ *      Inputs:
+ *         Parameters:                  NONE
+ *         Global Variables:
+ *             ostart                   Start-address of current Output Buffer
+ *             olen                     Current size of the Output Buffer
+ *         Local Static Variables:
+ *
+ *      Outputs:
+ *         Returned Value:                 NONE
+ *         Local Static Variables:
+ *             olen                     Doubled from value at input
+ *             ostart                   Start-address of new Output Buffer
+ *         Memory Allocated
+ *             A new FCode Output Buffer, using the  realloc()  facility.
+ *         When Freed?
+ *             In  close_output()
+ *         Memory Freed
+ *             Former FCode Output Buffer, also by means of  realloc() 
+ *
+ *         Printout:
+ *             Advisory message that this is taking place.
+ *
+ *      Error Detection:
+ *          FATAL if  realloc()  fails.
+ *          FATAL if output buffer has been expanded to a size beyond
+ *              what an INT can express.  Unlikely? maybe; impossible? no...
+ *
+ *      Process Explanation:
+ *          Because we are allowing the Output Buffer to be relocated, we
+ *              must take care to limit the exposure to external routines
+ *              of its actual address.  All references to locations within
+ *              the Output Buffer should be made in terms of an _offset_.
+ *
+ *      Extraneous Remarks:
+ *          Unfortunately, it is not feasible to completely isolate the
+ *              actual address of the Output Buffer, but we will keep the
+ *              exposure limited to the routines in  emit.c
+ *          Similarly, it wasn't feasible to keep this routine isolated,
+ *              nor the variable  olen  , but we will limit their exposure.
+ *
+ **************************************************************************** */
+void increase_output_buffer( void );  /*  Keep the prototype local  */
+void increase_output_buffer( void )
+{
+    u8 *newout;
+
+    if ( olen == 0 )
+    {
+	tokenization_error( FATAL,
+		"Output Buffer reallocation overflow.");
+    }else{
+	unsigned int rea_len;
+	olen = olen * 2;
+	rea_len = olen;
+	if ( rea_len == 0 )   rea_len = (unsigned int)-1;
+	tokenization_error( INFO,
+	    "Output Buffer overflow.  "
+		"Relocating and increasing to %d bytes.\n", rea_len);
+
+	newout = realloc(ostart, rea_len);
+	if ( newout == NULL)
+	{
+	    tokenization_error( FATAL,
+		"Could not reallocate %d bytes for Output Buffer", rea_len);
+	}
+
+	ostart = newout;
+    }
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  close_stream
+ *      Synopsis:       Free-up the memory used for the current input file
+ *                          whenever it is closed.  Reset pointers and
+ *                          line-counter.  Close files as necessary.
+ *
+ *      The dummy parameter is there to accommodate Macro-recursion protection. 
+ *          It's a long story; don't get me started...
+ *
+ **************************************************************************** */
+
+void close_stream( _PTR dummy)
 {
 	free(start);
 	free(iname);
-	return 0;	
+	start = NULL;
+	iname = NULL;
+	lineno = 0;
 }
 
-int close_output(void)
+/* **************************************************************************
+ *
+ *      Function name:  close_output
+ *      Synopsis:       Write the Binary Output file, if appropriate.
+ *                          Return a "Failure" flag.
+ *
+ **************************************************************************** */
+
+
+bool close_output(void)
+{
+    bool retval = TRUE;  /*  "Failure"  */
+    if ( error_summary() )
+    { 
+	if ( opc == 0 )
 {
+	    retval = FALSE;  /*  "Not a problem"  */
+	}else{
 	FILE *outfile;
-	unsigned int len;
 
-	len=(unsigned long)opc-(unsigned long)ostart;
+	    outfile=fopen( oname,"w");
+	    if (!outfile)
+	    {
+		/*  Don't do this as a  tokenization_error( TKERROR
+		 *      because those are all counted, among other reasons...
+		 */ 
+		printf( "Could not open file %s for output.\n", oname);
+	    }else{
 	
-	outfile=fopen((char *)oname,"w");
-	if (!outfile) {
-		printf("toke: error opening output file.\n");
-		return -1;
+		if ( fwrite(ostart, opc, 1, outfile) != 1 )
+		{
+		    tokenization_error( FATAL, "While writing output.");
 	}
 	
-	if(fwrite(ostart, len, 1, outfile)!=1)
-		printf ("toke: error while writing output.\n");
-
 	fclose(outfile);
 
-	printf("toke: wrote %d bytes to bytecode file '%s'\n", len, oname);
+		printf("toke: wrote %d bytes to bytecode file '%s'\n",
+		    opc, oname);
+		retval = FALSE;  /*  "No problem"  */
+	    }
+	}
+    }
 	
 	free(oname);
-	return 0;
+    free(ostart);
+    oname = NULL;
+    ostart = NULL;
+    opc = 0;
+    olen = OUTPUT_SIZE;
+
+    if ( load_list_file != NULL )
+    {
+	fclose(load_list_file);
+	free(load_list_name);
+    }
+    if ( depncy_file != NULL )
+    {
+	fclose(depncy_file);
+	free(depncy_list_name);
+    }
+    if ( missing_list_file != NULL )
+    {
+	fclose( missing_list_file);
+	if ( no_files_missing )
+	{
+	    remove( missing_list_name);
+	}
+	free( missing_list_name);
+    }
+
+    load_list_file = NULL;
+    load_list_name = NULL;
+    missing_list_file = NULL;
+    missing_list_name = NULL;
+    depncy_file = NULL;
+    depncy_list_name = NULL;
+
+    return ( retval );
 }
 
diff --git a/toke/stream.h b/toke/stream.h
index 010c7fc..cd11e9b 100644
--- a/toke/stream.h
+++ b/toke/stream.h
@@ -1,3 +1,6 @@
+#ifndef _H_STREAM
+#define _H_STREAM
+
 /*
  *                     OpenBIOS - free your system! 
  *                         ( FCode tokenizer )
@@ -24,15 +27,68 @@
  *
  */
 
-#ifndef _H_STREAM
-#define _H_STREAM
+/* **************************************************************************
+ *         Modifications made in 2005 by IBM Corporation
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Modifications Author:  David L. Paktor    dlpaktor@us.ibm.com
+ **************************************************************************** */
 
-int init_stream( const char *name );
-int close_stream(void);
-int init_output( const char *inname, const char *outname );
-int close_output(void);
+#include "types.h"
 
-extern unsigned int 	lineno;
+/* **************************************************************************
+ *
+ *          Exported Global Variables
+ *
+ **************************************************************************** */
+
+/* input pointers */
+extern u8 *start;
+extern u8 *pc;
+extern u8 *end;
 extern char		*iname;
+extern unsigned int lineno;         /* Line Number within current input file  */
+extern unsigned int abs_token_no;   /* Absolute Token Number in Source Input  */
+
+/* output pointers */
+extern char *oname;         /* output file name  */
+
+extern unsigned int opc;    /* output buffer position counter  */
+
+/* **************************************************************************
+ *
+ *    Note that the variables  ostart  and  olen , as well as the routine
+ *         increase_output_buffer  are not listed here.
+ *
+ *    We would have preferred to isolate them completely, but we would have
+ *        to disrupt the organization of  emit.c  (which we'd rather not);
+ *        in order to avoid exporting them any more widely than necessary,
+ *        we will declare them  extern  only in the file where they are
+ *        unavoidably needed.
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *          Macro Name:    OUTPUT_SIZE
+ *                        Initial size of the Output Buffer
+ *
+ **************************************************************************** */
+
+#define OUTPUT_SIZE	131072
+
+
+/* **************************************************************************
+ *
+ *          Exported Functions
+ *
+ **************************************************************************** */
+
+void add_to_include_list( char *dir_compt);
+void display_include_list( void);
+FILE *open_expanded_file( const char *path_name, char *mode, char *for_what);
+bool init_stream( const char *name );
+void close_stream( _PTR dummy);
+void init_output( const char *inname, const char *outname );
+bool close_output(void);
+void init_inbuf(char *inbuf, unsigned int buflen);
 
 #endif   /* _H_STREAM */
diff --git a/toke/strsubvocab.c b/toke/strsubvocab.c
new file mode 100644
index 0000000..ddb6139
--- /dev/null
+++ b/toke/strsubvocab.c
@@ -0,0 +1,337 @@
+/*
+ *                     OpenBIOS - free your system!
+ *                         ( FCode tokenizer )
+ *
+ *  This program is part of a free implementation of the IEEE 1275-1994
+ *  Standard for Boot (Initialization Configuration) Firmware.
+ *
+ *  Copyright (C) 2001-2005 Stefan Reinauer, <stepan@openbios.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ *
+ */
+
+/* **************************************************************************
+ *
+ *      General-purpose support functions for
+ *          String-Substitution-type vocabularies
+ *
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Module Author:  David L. Paktor    dlpaktor@us.ibm.com
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      A String-Substitution vocabulary, as the name implies, is one in
+ *          in which each an entry consists of two strings;  one that is
+ *          sought, and one that is returned as a substitute.  Macros and
+ *          aliases are implemented this way, as are also user-supplied
+ *          command-line symbol definitions.
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      Functions Exported:
+ *          init_str_sub_vocab     Initialize a String-Substitution vocab
+ *          add_str_sub_entry      Add an entry to a Str-Subst vocab
+ *          lookup_str_sub         Look for a name in a String-Substitution
+ *                                     vocab, return the substitution string.
+ *          exists_in_str_sub      Confirm whether a given name exists in a
+ *                                     String-Substitution vocabulary
+ *          create_str_sub_alias   Duplicate the behavior of one name with
+ *                                     another name.  Return a "success" flag.
+ *          reset_str_sub_vocab    Reset a given Str-Subst vocab to its initial
+ *                                    "Built-In" position.
+ *
+ *
+ **************************************************************************** */
+
+#include <stdio.h>
+#include <stdlib.h>
+#if defined(__linux__) && ! defined(__USE_BSD)
+#define __USE_BSD
+#endif
+#include <string.h>
+
+#include "errhandler.h"
+#include "strsubvocab.h"
+
+
+/* **************************************************************************
+ *
+ *      Function name:  init_str_sub_vocab
+ *      Synopsis:       Dynamically initialize the link-pointers
+ *                          of the.given String-Substitution vocabulary
+ *      
+ *      Inputs:
+ *         Parameters:
+ *             str_sub_vocab_tbl   Pointer to the initial Str-Subst vocab array
+ *             max_indx            Maximum Index of the initial array.
+ *
+ *      Outputs:
+ *         Returned Value:          None
+ *         Global Variables:
+ *              The link-fields of the initial Str-Subs vocab array entries
+ *                  will be filled in.
+ *
+ **************************************************************************** */
+
+void init_str_sub_vocab( str_sub_vocab_t *str_sub_vocab_tbl, int max_indx)
+{
+    int indx;
+    for ( indx = 1 ; indx < max_indx ; indx++ )
+    {
+        str_sub_vocab_tbl[indx].next = &str_sub_vocab_tbl[indx-1];
+    }
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  add_str_sub_entry
+ *      Synopsis:       Add an entry to the given Str-Subst vocab
+ *      
+ *      Inputs:
+ *         Parameters:         Pointer to:
+ *             ename               space containing the name of the entry
+ *             subst_str           space containing the substitution string
+ *             *str_sub_vocab      the "tail" of the Str-Subst vocab-list 
+ *
+ *      Outputs:
+ *         Returned Value:          NONE
+ *         Supplied Pointers:
+ *             *str_sub_vocab       Will point to new entry
+ *         Memory Allocated:
+ *             Memory for the new entry will be allocated.
+ *         When Freed?
+ *             When reset_str_sub_vocab() is applied to the same vocab-list.
+ *                 In some instances, the new entry will be freed upon end
+ *                 of tokenization; in others, only on termination of program.
+ *
+ *      Error Detection:
+ *          Failure to allocate memory is a Fatal Error.
+ *
+ *      Process Explanation:
+ *          The name and substitution-string pointers are presumed to already
+ *              point to stable memory-spaces.  Memory will be allocated
+ *              for the entry itself; its pointers will be entered and the
+ *              given pointer-to-the-tail-of-the-vocabulary will be updated.
+ *
+ *      Extraneous Remarks:
+ *          This might have been where we would have checked for re-aliasing,
+ *              but the introduction of the approach to aliasing embodied in
+ *              the various  create_..._alias()  routines neatly bypasses it.
+ *
+ **************************************************************************** */
+
+void add_str_sub_entry( char *ename,
+                            char *subst_str,
+			        str_sub_vocab_t **str_sub_vocab )
+{
+    str_sub_vocab_t *new_entry;
+
+    new_entry = safe_malloc(sizeof(str_sub_vocab_t), "adding str_sub_entry");
+    new_entry->name   =  ename;
+    new_entry->alias  =  subst_str;
+    new_entry->next   = *str_sub_vocab;
+
+    *str_sub_vocab = new_entry;
+
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  lookup_str_sub
+ *      Synopsis:       Look for a name in the given Str-Subst vocabulary
+ *      
+ *      Inputs:
+ *         Parameters:
+ *             tname                The "target" name for which to look
+ *             str_sub_vocab        The Str-Subst vocab-list
+ *
+ *      Outputs:
+ *         Returned Value:          Pointer to the substitution string, or
+ *                                      NULL pointer if name not found.
+ *                                  May be NULL if subst'n string is NULL.
+ *
+ **************************************************************************** */
+
+char *lookup_str_sub( char *tname, str_sub_vocab_t *str_sub_vocab )
+{
+    str_sub_vocab_t *curr;
+    char *retval = NULL;
+
+    for (curr = str_sub_vocab ; curr != NULL ; curr=curr->next)
+    {
+        if ( strcasecmp(tname, curr->name) == 0 )
+	{
+	    retval = curr->alias;
+	    break;
+	}
+    }
+    return ( retval ) ;
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  exists_in_str_sub
+ *      Synopsis:       Confirm whether a given name exists in a given
+ *                          String-Substitution vocabulary
+ *      
+ *      Inputs:
+ *         Parameters:
+ *             tname                The "target" name for which to look
+ *             str_sub_vocab        Pointer to the Str-Subst vocab-list
+ *
+ *      Outputs:
+ *         Returned Value:     TRUE if the name is found
+ *
+ *      Extraneous Remarks:
+ *          Because the Returned Value of lookup_str_sub() may be NULL for 
+ *              other reasons than that the name was not found, we cannot
+ *              rely on that routine, and must replicate the outer-shell
+ *              of its structure.
+ *
+ **************************************************************************** */
+
+bool exists_in_str_sub( char *tname, str_sub_vocab_t *str_sub_vocab )
+{
+    str_sub_vocab_t *curr;
+    bool retval = FALSE;
+
+    for (curr = str_sub_vocab ; curr != NULL ; curr=curr->next)
+    {
+        if ( strcasecmp(tname, curr->name) == 0 )
+	{
+	    retval = TRUE;
+	    break;
+	}
+    }
+    return ( retval );
+
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  create_str_sub_alias
+ *      Synopsis:       Create an Alias in a String-Substitution vocabulary
+ *                          Return a "success" flag.
+ *
+ *      Associated FORTH word:                 ALIAS
+ *
+ *      Inputs:
+ *         Parameters:
+ *             old_name             Name of existing entry
+ *             new_name             New name for which to create an entry
+ *             *str_sub_vocab       Pointer to "tail" of Str-Subst vocab-list
+ *
+ *      Outputs:
+ *         Returned Value:          TRUE if  old_name  found in str_sub_vocab
+ *         Supplied Pointers:
+ *             *str_sub_vocab       Will be updated to point to the new entry
+ *         Memory Allocated:
+ *             A copy of the "old" name's substitution string.
+ *         When Freed?
+ *             When reset_str_sub_vocab() is applied to the same vocab-list.
+ *                 In some instances, the new entry will be freed when the
+ *                 device-node in which it was created is "finish"ed; in
+ *                 others, only on termination of the program.
+ *
+ *      Process Explanation:
+ *          The "new" name is presumed to point to a stable memory-space.
+ *          If the given "old" name exists in the given Str-Subst vocab-list,
+ *              duplicate the substitution string into newly-allocated memory
+ *              and pass the duplicated string and the "new" name along to
+ *              the  add_str_sub_entry()  routine and return TRUE.
+ *          If the given "old" name does not exist in the given vocab-list,
+ *              return FALSE.
+ *
+ *      Extraneous Remarks:
+ *          This neatly bypasses the question of re-aliasing...  ;-)
+ *
+ *          We can rely on testing for a returned NULL from lookup_str_sub()
+ *              because we won't be applying this routine to any vocabulary
+ *              that permits a NULL in its substitution string.
+ *
+ **************************************************************************** */
+
+bool create_str_sub_alias(char *new_name,
+                              char *old_name,
+			          str_sub_vocab_t **str_sub_vocab )
+{
+    bool retval = FALSE;
+    char *old_subst_str = lookup_str_sub( old_name, *str_sub_vocab );
+    if ( old_subst_str != NULL )
+    {
+        char *new_subst_str = strdup(old_subst_str );
+	add_str_sub_entry(new_name, new_subst_str, str_sub_vocab );
+	retval = TRUE ;
+    }
+
+    return ( retval );
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  reset_str_sub_vocab
+ *      Synopsis:       Reset a given Str-Subst vocab to its initial
+ *                         "Built-In" position.
+ *      
+ *      Inputs:
+ *         Parameters:
+ *            *str_sub_vocab         Pointer to the Str-Subst vocab-list 
+ *             reset_position        Position to which to reset the list
+ *
+ *      Outputs:
+ *         Returned Value:          NONE
+ *         Supplied Pointers:
+ *             *str_sub_vocab       Reset to given "Built-In" position.
+ *         Memory Freed
+ *             All memory allocated by user-definitions will be freed
+ *
+ *      Process Explanation:
+ *          The "stable memory-spaces" to which the name and substitution
+ *              string pointers point are presumed to have been acquired
+ *              by allocation of memory, which is reasonable for entries
+ *              created by the user as opposed to the built-in entries,
+ *              which we are, in any case, not releasing.
+ *          The substitution-string pointer may be null; watch out when
+ *              we free() it; not all C implementations forgive that.
+ *
+ **************************************************************************** */
+
+void reset_str_sub_vocab(
+            str_sub_vocab_t **str_sub_vocab ,
+	             str_sub_vocab_t *reset_position )
+{
+    str_sub_vocab_t *next_t;
+
+    next_t = *str_sub_vocab;
+    while ( next_t != reset_position  )
+    {
+	next_t = (*str_sub_vocab)->next ;
+
+	free( (*str_sub_vocab)->name );
+	if ( !(*str_sub_vocab)->alias )
+	{
+	    free( (*str_sub_vocab)->alias );
+	}
+	free( *str_sub_vocab );
+	*str_sub_vocab = next_t ;
+    }
+}
+
diff --git a/toke/strsubvocab.h b/toke/strsubvocab.h
new file mode 100644
index 0000000..5b404da
--- /dev/null
+++ b/toke/strsubvocab.h
@@ -0,0 +1,85 @@
+#ifndef _TOKE_STRSUBVOCAB_H
+#define _TOKE_STRSUBVOCAB_H
+
+
+/*
+ *                     OpenBIOS - free your system!
+ *                         ( FCode tokenizer )
+ *
+ *  This program is part of a free implementation of the IEEE 1275-1994
+ *  Standard for Boot (Initialization Configuration) Firmware.
+ *
+ *  Copyright (C) 2001-2005 Stefan Reinauer, <stepan@openbios.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ *
+ */
+
+/* **************************************************************************
+ *
+ *      Headers, general-purpose support structures, function prototypes
+ *          and macros for String-Substitution-type vocabularies.
+ *
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Module Author:  David L. Paktor    dlpaktor@us.ibm.com
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      Structures:
+ *          str_sub_vocab_t        Entry in a String-Substitution-type vocab 
+ *
+ *      Macros:
+ *          BUILTIN_STR_SUB        Add an entry to the initial Str-Sub vocab.
+ *
+ **************************************************************************** */
+
+#include "types.h"
+
+
+typedef struct str_sub_vocab {
+	u8  *name;
+	u8  *alias;
+	struct str_sub_vocab *next;
+} str_sub_vocab_t;
+
+#if  0     /*  On the way out   */
+/*
+ *          BUILTIN_STR_SUB        Add an entry to the initial Str-Sub vocab.
+ *
+ *      Arguments:  (Both are strings)
+ *          princ         Principal name by which the string is known
+ *          subst         Substitution-string that replaces the Principal.
+ */
+#define BUILTIN_STR_SUB(princ, subst)    \
+     { princ , subst , (str_sub_vocab_t *)NULL  }
+#endif     /*  On the way out   */
+
+
+void init_str_sub_vocab( str_sub_vocab_t *str_sub_vocab_tbl,
+			            int max_indx);
+void add_str_sub_entry( char *ename,
+                        	    char *subst_str,
+			        	str_sub_vocab_t **str_sub_vocab );
+char *lookup_str_sub( char *tname, str_sub_vocab_t *str_sub_vocab );
+bool create_str_sub_alias(char *new_name,
+                        	     char *old_name,
+			        	 str_sub_vocab_t **str_sub_vocab );
+bool exists_in_str_sub( char *tname, str_sub_vocab_t *str_sub_vocab );
+void reset_str_sub_vocab( str_sub_vocab_t **str_sub_vocab ,
+	        		     str_sub_vocab_t *reset_position );
+
+
+#endif   /*  _TOKE_STRSUBVOCAB_H    */
diff --git a/toke/ticvocab.c b/toke/ticvocab.c
new file mode 100644
index 0000000..5214f8f
--- /dev/null
+++ b/toke/ticvocab.c
@@ -0,0 +1,426 @@
+/*
+ *                     OpenBIOS - free your system!
+ *                         ( FCode tokenizer )
+ *
+ *  This program is part of a free implementation of the IEEE 1275-1994
+ *  Standard for Boot (Initialization Configuration) Firmware.
+ *
+ *  Copyright (C) 2001-2005 Stefan Reinauer, <stepan@openbios.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ *
+ */
+
+/* **************************************************************************
+ *
+ *      General-purpose support functions for
+ *      Threaded Interpretive Code (T. I. C.)-type vocabularies
+ *
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Module Author:  David L. Paktor    dlpaktor@us.ibm.com
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      We are going to implement a strategy that takes better advantage
+ *          of the concept of Threaded Interpretive Code  (well, okay,
+ *          it won't really be interpretive ... )  We will use it to
+ *          implement a small (but expandable) subset of FORTH-like
+ *          commands in Tokenizer-Escape mode, as well as a few other
+ *          things, such as conditional-tokenization.
+ *
+ *      The Threaded Interpretive Code Header data structure is described
+ *          in detail in the accompanying  ticvocab.h  header-file.
+ *
+ *      In most cases, the contents of a beginning portion of the vocabulary
+ *          are known at compile-time, and later parts are added by the
+ *          user at run-time.  (The linked-list structure is needed to allow
+ *          for that.)  We can initialize the known start of the vocabulary
+ *          easily, except for the link-pointers, as an array.
+ *      We can either explicitly state an index for each entry's link-pointer
+ *          to the previous entry (which can become a problem to maintain) or
+ *          have a function to initialize the links dynamically, at run-time.
+ *      I think I will (regretfully, resignedly) choose the latter.
+ *          
+ *      We will define a few general-purpose functions for dealing with
+ *          T. I. C. -type vocabularies.  Eventually, it might be a good
+ *          idea to convert all the vocabularies to this structure...
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *
+ *      Revision History:
+ *          Mon, 19 Dec 2005 by David L. Paktor
+ *          Begin converting most, if not all, of the vocabularies to
+ *              T. I. C. -type structure.
+ *
+ **************************************************************************** */
+
+
+/* **************************************************************************
+ *
+ *      Functions Exported:
+ *          init_tic_vocab        Initialize a TIC_HDR -type vocabulary
+ *          add_tic_entry         Add an entry to a TIC_HDR -type vocabulary
+ *          lookup_tic_entry      Look for a name in a TIC_HDR -type vocabulary
+ *          handle_tic_vocab      Perform a function in a TIC_HDR -type vocab
+ *          exists_in_tic_vocab   Confirm whether a given name exists in a
+ *                                    TIC_HDR -type vocabulary
+ *          create_tic_alias      Duplicate the behavior of one name with
+ *                                     another name.  Return a "success" flag.
+ *          reset_tic_vocab       Reset a given TIC_HDR -type vocabulary to
+ *                                    its "Built-In" position.
+ *
+ **************************************************************************** */
+
+
+/* **************************************************************************
+ *
+ *          Global Variables Exported
+ *              tic_found       The entry, in a TIC_HDR -type vocabulary,
+ *                                  that has just been found and is being 
+ *                                  "handled".  Needed for protection against
+ *                                  recursion in a User-defined Macro (which
+ *                                  should occur only rarely).
+ *
+ **************************************************************************** */
+
+
+#include <stdlib.h>
+#include <string.h>
+#include "ticvocab.h"
+#include "errhandler.h"
+
+tic_hdr_t *tic_found;
+
+/* **************************************************************************
+ *
+ *      Function name:  init_tic_vocab
+ *      Synopsis:       Dynamically initialize the link-pointers
+ *                          of the.given TIC_HDR -type vocabulary
+ *
+ *      Inputs:
+ *         Parameters:
+ *             tic_vocab_tbl       Pointer to the initial TIC_HDR vocab array
+ *             max_indx            Maximum Index of the initial array.
+ *             tic_vocab_ptr       Pointer to the vocab "tail"
+ *
+ *      Outputs:
+ *         Returned Value:         None
+ *         Global Variables:
+ *              The link-fields of the initial TIC_HDR vocab array entries
+ *                  will be filled in.
+ *         Supplied Pointers:
+ *             *tic_vocab_ptr       Points to the last element in the array
+ *
+ *      Process Explanation:
+ *          The value that  tic_vocab_ptr  has upon entry to the routine
+ *              (which may point to the end of another array which is to
+ *              precede this one in the voacbulary) gets entered into
+ *              the link-pointer field of the first element of the array.
+ *          For this reason, it is important that all TIC_HDR vocabulary
+ *              pointers that will be pased to this routine have their
+ *              initial values explicitly declared NULL. 
+ *
+ **************************************************************************** */
+
+void init_tic_vocab( tic_hdr_t *tic_vocab_tbl,
+                         int max_indx,
+			     tic_hdr_t **tic_vocab_ptr)
+{
+    int indx;
+    for ( indx = 0 ; indx < max_indx ; indx++ )
+    {
+        tic_vocab_tbl[indx].next = *tic_vocab_ptr;
+	*tic_vocab_ptr = &tic_vocab_tbl[indx];
+    }
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  add_tic_entry
+ *      Synopsis:       Add an entry to the given TIC_HDR -type vocabulary
+ *
+ *      Inputs:
+ *         Parameters:
+ *             tname         Pointer to space containing the name of the entry
+ *             tfunct        Pointer to the routine the new entry will call
+ *             tparam        The "parameter field" value (may be a pointer)
+ *             fw_defr       FWord Token of the entry's Definer
+ *             pfldsiz       Size of "param field" (if a pointer to alloc'd mem)
+ *             ign_fnc       Pointer to "ignoring" routine for new entry
+ *             tic_vocab     Pointer to ptr to "tail" of T.I.C.-type vocab-list 
+ *
+ *      Outputs:
+ *         Returned Value:          NONE
+ *         Supplied Pointers:
+ *             *tic_vocab           Will point to new entry
+ *         Memory Allocated:
+ *             For the new entry.
+ *         When Freed?
+ *             When reset_tic_vocab() is applied to the same vocab-list.
+ *
+ *      Error Detection:
+ *          Failure to allocate memory is a Fatal Error.
+ *
+ *      Process Explanation:
+ *          The name pointer is presumed to already point to a stable,
+ *              newly-allocated memory-space.  If the parameter field is
+ *              actually a pointer, it, too, is presumed to already have
+ *              been allocated.
+ *          Memory will be allocated for the entry itself; its pointers
+ *              will be entered and the given pointer-to-the-tail-of-the-
+ *              -vocabulary will be updated to point to the new entry.
+ *
+ **************************************************************************** */
+
+void add_tic_entry( char *tname,
+                        void (*tfunct)(),
+                             TIC_P_DEFLT_TYPE tparam,
+                                 fwtoken fw_defr,
+				     int pfldsiz,
+                                         void (*ign_fnc)(),
+                                             tic_hdr_t **tic_vocab )
+{
+    tic_hdr_t *new_entry;
+
+    new_entry = safe_malloc(sizeof(tic_hdr_t), "adding tic_entry");
+    new_entry->name              =  tname;
+    new_entry->next              = *tic_vocab;
+    new_entry->funct             =  tfunct;
+    new_entry->pfield.deflt_elem =  tparam;
+    new_entry->fword_defr        =  fw_defr;
+    new_entry->ign_func          =  ign_fnc;
+    new_entry->pfld_size         =  pfldsiz;
+
+    *tic_vocab = new_entry;
+
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  lookup_tic_entry
+ *      Synopsis:       Look for a name in the given TIC_HDR -type vocabulary
+ *
+ *      Inputs:
+ *         Parameters:
+ *             tname                The "target" name for which to look
+ *             tic_vocab            Pointer to the T. I. C. -type vocabulary
+ *
+ *      Outputs:
+ *         Returned Value:          Pointer to the relevant entry, or
+ *                                      NULL if name not found.
+ *
+ *      Extraneous Remarks:
+ *          We don't set the global  tic_found  here because this routine
+ *              is not always called when the found function is going to
+ *              be executed; sometimes it is called for error-detection,
+ *              for instance...
+ *
+ **************************************************************************** */
+ 
+tic_hdr_t *lookup_tic_entry( char *tname, tic_hdr_t *tic_vocab )
+{
+    tic_hdr_t *curr ;
+
+    for (curr = tic_vocab ; curr != NULL ; curr=curr->next)
+    {
+        if ( strcasecmp(tname, curr->name) == 0 )
+	{
+	    break;
+	}
+    }
+
+    return ( curr ) ;
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  exists_in_tic_vocab
+ *      Synopsis:       Confirm whether the given name exists in the
+ *                      given TIC_HDR -type vocabulary
+ *
+ *      Inputs:
+ *         Parameters:
+ *             tname                The name for which to look
+ *             tic_vocab            Pointer to the T. I. C. -type vocabulary
+ *
+ *      Outputs:
+ *         Returned Value:          TRUE if name is found,
+ *
+ **************************************************************************** */
+
+bool exists_in_tic_vocab( char *tname, tic_hdr_t *tic_vocab )
+{
+    tic_hdr_t *found ;
+    bool retval = FALSE;
+
+    found = lookup_tic_entry( tname, tic_vocab );
+    if ( found != NULL )
+    {
+	retval = TRUE;
+    }
+
+    return ( retval );
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  create_tic_alias
+ *      Synopsis:       Create an Alias in a TIC_HDR -type vocabulary
+ *                          Return a "success" flag.
+ *
+ *      Associated FORTH word:                 ALIAS
+ *
+ *      Inputs:
+ *         Parameters:
+ *             old_name             Name of existing entry
+ *             new_name             New name for which to create an entry
+ *             *tic_vocab           Pointer to the "tail" of the
+ *                                      T. I. C. -type vocab-list 
+ *
+ *      Outputs:
+ *         Returned Value:          TRUE if  old_name  found in given vocab
+ *         Supplied Pointers:
+ *             *tic_vocab           Will be updated to point to the new entry
+ *         Memory Allocated:
+ *             For the new entry, by the support routine.
+ *         When Freed?
+ *             When reset_tic_vocab() is applied to the same vocab-list.
+ *
+ *      Process Explanation:
+ *          Both the "old" and "new" names are presumed to already point to
+ *              stable, freshly allocated memory-spaces.
+ *          Even if the "old" entry's  pfld_size  is not zero, meaning its
+ *              param-field is a pointer to allocated memory, we still do
+ *              not need to copy it into a freshly allocated memory-space,
+ *              as long as we make the new alias-entry's  pfld_size  zero:
+ *              the reference to the old space will work, and the old
+ *              entry's param-field memory space will not be freed with
+ *              the alias-entry but only with the "old" entry.
+ *
+ **************************************************************************** */
+
+bool create_tic_alias( char *new_name, char *old_name, tic_hdr_t **tic_vocab )
+{
+    tic_hdr_t *found ;
+    bool retval = FALSE;
+
+    found = lookup_tic_entry( old_name, *tic_vocab );
+    if ( found != NULL )
+    {
+	add_tic_entry( new_name, found->funct,
+			   found->pfield.deflt_elem,
+			       found->fword_defr,
+			           0, found->ign_func, tic_vocab );
+	retval = TRUE;
+    }
+
+    return ( retval );
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  handle_tic_vocab
+ *      Synopsis:       Perform the function associated with the given name
+ *                      in the given TIC_HDR -type vocabulary
+ *
+ *      Inputs:
+ *         Parameters:
+ *             tname                The "target" name for which to look
+ *             tic_vocab            Pointer to the T. I. C. -type vocabulary
+ *
+ *      Outputs:
+ *         Returned Value:   TRUE if the given name is valid in the given vocab
+ *         Global Variables:
+ *             tic_found            Points to the TIC entry of the "target"
+ *                                      name, if it was found; else, NULL.
+ *         Global Behavior:
+ *             Whatever the associated function does...
+ *
+ *      Process Explanation:
+ *          Find the name and execute its associated function.
+ *          If the name is not in the given vocabulary, return
+ *              an indication; leave it to the calling routine
+ *              to decide how to proceed.
+ *
+ **************************************************************************** */
+ 
+bool handle_tic_vocab( char *tname, tic_hdr_t *tic_vocab )
+{
+    bool retval = FALSE;
+    
+    tic_found = lookup_tic_entry( tname, tic_vocab );
+    if ( tic_found != NULL )
+    {
+        tic_found->funct( tic_found->pfield);
+	retval = TRUE;
+    }
+
+    return ( retval ) ;
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  reset_tic_vocab
+ *      Synopsis:       Reset a given TIC_HDR -type vocabulary to
+ *                          its given "Built-In" position.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             *tic_vocab            Pointer to the T. I. C.-type vocab-list
+ *             reset_position        Position to which to reset the list
+ *
+ *      Outputs:
+ *         Returned Value:         NONE
+ *         Supplied Pointers:
+ *             *tic_vocab          Reset to given "Built-In" position.
+ *         Memory Freed
+ *             All memory allocated by user-definitions will be freed
+ *
+ *      Process Explanation:
+ *          The "stable memory-spaces" to which the name and parameter
+ *              field pointers point are presumed to have been acquired
+ *              by allocation of memory, which is reasonable for entries
+ *              created by the user as opposed to the built-in entries,
+ *              which we are, in any case, not releasing.
+ *          The parameter-field size field tells us whether we need to
+ *              free()  the parameter-field pointer.
+ *
+ **************************************************************************** */
+
+void reset_tic_vocab( tic_hdr_t **tic_vocab, tic_hdr_t *reset_position )
+{
+    tic_hdr_t *next_t;
+
+    next_t = *tic_vocab;
+    while ( next_t != reset_position  )
+    {
+	next_t = (*tic_vocab)->next ;
+
+	free( (*tic_vocab)->name );
+	if ( (*tic_vocab)->pfld_size != 0 )
+	{
+	    free( (*tic_vocab)->pfield.chr_ptr );
+	}
+	free( *tic_vocab );
+	*tic_vocab = next_t ;
+    }
+}
diff --git a/toke/ticvocab.h b/toke/ticvocab.h
new file mode 100644
index 0000000..0d41466
--- /dev/null
+++ b/toke/ticvocab.h
@@ -0,0 +1,478 @@
+#ifndef _TOKE_TICVOCAB_H
+#define _TOKE_TICVOCAB_H
+
+/*
+ *                     OpenBIOS - free your system!
+ *                         ( FCode tokenizer )
+ *
+ *  This program is part of a free implementation of the IEEE 1275-1994
+ *  Standard for Boot (Initialization Configuration) Firmware.
+ *
+ *  Copyright (C) 2001-2005 Stefan Reinauer, <stepan@openbios.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ *
+ */
+
+/* **************************************************************************
+ *
+ *      General-purpose support structures and function prototypes for
+ *          Threaded Interpretive Code (T. I. C.)-type vocabularies.
+ *          See ticvocab.c
+ *
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Module Author:  David L. Paktor    dlpaktor@us.ibm.com
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      Structures:
+ *
+ *      The Threaded Interpretive Code Header data structure consists of:
+ *          (1)  A pointer to the function name as seen in the source
+ *          (2)  A link to the next (well, preceding) element
+ *          (3)  A Pointer to the routine to run as the function's behavior
+ *               during active processing.  It takes the "parameter field"
+ *               item as its argument and has no return-value.
+ *          (4)  The "parameter field" item, which will be passed as an
+ *               argument to the function. It may be an FCode- or FWord-
+ *               -token, or an item of another type, or a pointer to data.
+ *               The function may re-cast it as needed.
+ *          (5)  The "Definer" of the entry; a member of the subset of FWord-
+ *               -tokens that may be Definers.
+ *          (6)  A Pointer to a routine to be run when the word is encountered
+ *               in a Conditional Compilation section that is being ignored.
+ *               Certain functions still need to be recognized in that state,
+ *               and will require special behaviors; those that can be simply
+ *               ignored will have a NULL pointer in this field.  The function
+ *               in this field, also, takes the "parameter field" item as its
+ *               argument and has no return-value.
+ *          (7)  The size of the data pointed to by the "parameter field" item,
+ *               if it is a pointer to allocated data; used to allocate space
+ *               for a copy of the p.f. when making an alias, and to indicate
+ *               whether the space needs to be freed.  Automatic procedures
+ *               are too often fooled, so we don't leave things to chance...
+ *      To accommodate C's insistence on strong-typing, we might need
+ *          to define different "parameter field" structure-types; see
+ *          description of "Parameter Field as a union", below.
+ *
+ *      It's not an exact name, but we'll still call it a T. I. C. Header
+ *
+ *      We will use this structure for most of our vocabularies...
+ *
+ ****************************************************************************
+ *
+ *     The "Parameter Field" is a union of several alternative types,
+ *         for convenience, to avert excessive type-casting.  It may
+ *         either be the Parameter Data itself (if it is small enough)
+ *         or a pointer to Parameter Data.
+ *     In the case where the Parameter Field is the data itself, or is a
+ *         pointer to hard-coded (non-allocated) data, the "size" field
+ *         will be zero, to indicate that no space allocation is required.
+ *     The types are (starting with the default for initialization)
+ *         A long integer (including an FCode Token)
+ *         An FWord Token
+ *         A pointer to a boolean variable
+ *         A pointer to a character or a character string
+ *         If the parameter field value is intended to be a single character,
+ *             it must be recast as a long integer, in order to preserve
+ *             portability across big- and little- -endian platforms.
+ *
+ **************************************************************************** */
+
+/* ************************************************************************** *
+ *
+ *      Macros:
+ *          NO_PARAM_TIC       Create an entry in the initial "Built-In"
+ *                                 portion of a TIC-type vocabulary with
+ *                                 an empty "param field".
+ *          NO_PARAM_IGN       Create an entry with an empty "param field"
+ *                                 whose action- and "Ignore"- -functions
+ *                                 are the same.
+ *          VALPARAM_TIC       " ... with a literal value for the "param field"
+ *          DUALFUNC_TIC       " ... with a literal "param" and both an action-
+ *                                 and an "Ignore"- -function.
+ *          DUFNC_FWT_PARM      A  tic_fwt_hdr_t -type entry with a literal
+ *                                 "param" and both an action-function and an
+ *                                 "Ignore"-function.
+ *          FWORD_TKN_TIC      " ... with an FWord Token for the "param field"
+ *          DUALFUNC_FWT_TIC   " " ... and both action- and "Ignore"- -function
+ *          BUILTIN_MAC_TIC    A  tic_mac_hdr_t -type entry with a Macro-
+ *                                 -Substitution-String "param"
+ *          BUILTIN_BOOL_TIC   A  tic_bool_hdr_t -type entry with a boolean-
+ *                                 -variable-pointer "param"
+ *
+ **************************************************************************** */
+
+#include "types.h"
+#include "dictionary.h"
+
+/* **************************************************************************
+ *
+ *      In order to work around C's limitations regarding data-typing
+ *          during initialization, we need to create some alternative
+ *          data-structures that exactly match the layout of  tic_hdr_t
+ *          as defined above, but have a different default-type for
+ *          the parameter field.
+ *      I apologize in advance for any maintenance awkwardnesses this
+ *          might engender; I would have come up with a more convenient
+ *          way to do this if I could.  At least, the pieces that need
+ *          to be co-ordinated are in close proximity to each other...
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      The differences are all centered in the "parameter field" of
+ *          the TIC header structure.  In order to make sure all the
+ *          alternative types map smoothly into each other, we will
+ *          create a series of "union" types, differing only in what
+ *          their default type is.  We will keep the "parameter field"
+ *          item the size of a Long Integer.
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      This form is the default type.
+ *
+ **************************************************************************** */
+
+#define TIC_P_DEFLT_TYPE  long
+typedef union tic_param
+    {
+	TIC_P_DEFLT_TYPE  deflt_elem ;  /*  The "default element" aspect.  */
+	long              long_val ;    /*  Explicitly specifying "long"   */
+	fwtoken           fw_token ;    /*  FWord Token                    */
+	bool             *bool_ptr ;    /*  Pointer to a boolean variable  */
+	char             *chr_ptr  ;    /*  Pointer to a character string  */
+
+	/*  The "character value" aspect behaves differently on big-
+	 *      versus little- -endian platforms (for initialization,
+	 *      anyway), so we cannot actually use it.
+	 *  Keep this commented-out, as a reminder.
+	 */
+     /* char             char_val ;    */
+	/*  We will recast "character value" as an integer.  */
+
+    } tic_param_t ;
+
+typedef struct tic_hdr
+    {
+        char             *name;
+	struct tic_hdr   *next;
+	void            (*funct)();      /*  Function for active processing  */
+	tic_param_t       pfield;
+	fwtoken           fword_defr;    /*  FWord Token of entry's Definer  */
+	void            (*ign_func)();   /*  Function in "Ignored" segment   */
+	int               pfld_size;
+    }  tic_hdr_t ;
+
+/* **************************************************************************
+ *
+ *      This form is for initialization of an FWord Token list.
+ *
+ **************************************************************************** */
+
+#define TIC_FWT_P_DEFLT_TYPE  fwtoken
+typedef union tic_fwt_param
+    {
+	TIC_FWT_P_DEFLT_TYPE  deflt_elem ;  /*  "Default element" aspect.  */
+	long              long_val ;    /*  Long integer                   */
+	fwtoken           fw_token ;    /*  Explicit FWord Token           */
+	bool             *bool_ptr ;    /*  Pointer to a boolean variable  */
+	char             *chr_ptr  ;    /*  Pointer to a character string  */
+    } tic_fwt_param_t ;
+
+typedef struct tic_fwt_hdr
+    {
+        char               *name;
+	struct tic_fwt_hdr *next;
+	void              (*funct)();    /*  Function for active processing  */
+	tic_fwt_param_t     pfield;
+	fwtoken             fword_defr;  /*  FWord Token of entry's Definer  */
+	void              (*ign_func)(); /*  Function in "Ignored" segment   */
+	int                 pfld_size;
+    }  tic_fwt_hdr_t ;
+
+
+/* **************************************************************************
+ *
+ *      The third form is for initialization of Built-in Macros.  Its
+ *          default parameter field type is a pointer to a compiled-in
+ *          (i.e., constant) character string.  Its  pfld_size  can be
+ *          left as zero, because no allocated-memory copies of the
+ *          string will be needed, even for aliases.  (User-created
+ *          macros, however, will need to allocate strings; we will
+ *          deal with that elsewhere...)
+ *
+ **************************************************************************** */
+
+#define TIC_MAC_P_DEFLT_TYPE  char *
+typedef union tic_mac_param
+    {
+	TIC_MAC_P_DEFLT_TYPE  deflt_elem ;  /*  "Default element" aspect.  */
+	long              long_val ;    /*  Long integer                   */
+	fwtoken           fw_token ;    /*  FWord Token                    */
+	bool             *bool_ptr ;    /*  Pointer to a boolean variable  */
+	char            *chr_ptr ;      /*  Explicit Pointer to char str.  */
+    } tic_mac_param_t ;
+
+typedef struct tic_mac_hdr
+    {
+        char               *name;
+	struct tic_mac_hdr *next;
+	void              (*funct)();
+	tic_mac_param_t     pfield;
+	fwtoken             fword_defr;
+	void              (*ign_func)();
+	int                 pfld_size;
+    }  tic_mac_hdr_t ;
+
+/* **************************************************************************
+ *
+ *      The next form is for initialization of Condtionals.  Its default
+ *          parameter field type is a pointer to a boolean variable.
+ *
+ **************************************************************************** */
+
+#define TIC_BOOL_P_DEFLT_TYPE  bool *
+typedef union tic_bool_param
+    {
+	TIC_BOOL_P_DEFLT_TYPE deflt_elem ;  /*  "Default element" aspect.  */
+	long              long_val ;    /*  Long integer                   */
+	fwtoken           fw_token ;    /*  FWord Token                    */
+	bool             *bool_ptr ;    /*  Explicit Ptr to boolean v'ble  */
+	char             *chr_ptr  ;    /*  Pointer to a character string  */
+    } tic_bool_param_t ;
+
+typedef struct tic_bool_hdr
+    {
+        char                *name;
+	struct tic_bool_hdr *next;
+	void               (*funct)();
+	tic_bool_param_t     pfield;
+	fwtoken              fword_defr;
+	void               (*ign_func)();
+	int                  pfld_size;
+    }  tic_bool_hdr_t ;
+
+
+
+/* **************************************************************************
+ *
+ *      Various macros to create an entry in the initial "Built-In" portion
+ *           of a vocabulary-list, specified as an array of one of the
+ *           matching forms of a T. I. C. Header; each macro adjusts type
+ *           casting as needed.
+ *      In all cases, the "size" field will be set to zero, indicating that
+ *         the "param field" item is either the complete data or a pointer
+ *         to a hard-coded (non-allocated) data item.
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *          Macro Name:   NO_PARAM_TIC
+ *                        Create an entry in the initial "Built-In" portion
+ *                            of a TIC_HDR -type vocabulary with an empty
+ *                            "param field"
+ *                            
+ *   Arguments:
+ *       nam      (string)         Name of the entry as seen in the source
+ *       func     (routine-name)   Name of internal function to call
+ *
+ **************************************************************************** */
+#define NO_PARAM_TIC(nam, func )  \
+  { nam , (tic_hdr_t *)NULL , func , { 0 }, UNSPECIFIED , NULL , 0 }
+
+
+/* **************************************************************************
+ *          Macro Name:   NO_PARAM_IGN
+ *                        Create an entry with an empty "param field"
+ *                            whose action-function and "Ignore"-function
+ *                            are the same.
+ *                            
+ *   Arguments:
+ *       nam      (string)         Name of the entry as seen in the source
+ *       func     (routine-name)   Name of internal function to call for both
+ *
+ *
+ **************************************************************************** */
+#define NO_PARAM_IGN(nam, func )  \
+  { nam , (tic_hdr_t *)NULL , func , { 0 }, UNSPECIFIED , func , 0 }
+
+
+/* **************************************************************************
+ *
+ *      Variations on the above, to compensate for Type-Casting complications
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *          Macro Name:   VALPARAM_TIC
+ *                        Create an entry in the initial "Built-In" portion
+ *                            of a TIC_HDR -type vocabulary with a literal
+ *                            value for the "param field" and a specifiable
+ *                            "definer".
+ *   Arguments:
+ *       nam      (string)         Name of the entry as seen in the source
+ *       func     (routine-name)   Name of internal function to call
+ *       pval     (integer)        The "param field" item
+ *       definr   (fword_token)    "Definer" of the entry
+ *
+ *      The "param field" item will be recast to the required default type.
+ *
+ **************************************************************************** */
+
+#define VALPARAM_TIC(nam, func, pval, definr )  \
+    { nam , (tic_hdr_t *)NULL , func ,  \
+        { (TIC_P_DEFLT_TYPE)(pval) }, definr , NULL , 0 }
+
+
+/* **************************************************************************
+ *          Macro Name:   DUALFUNC_TIC
+ *                        Create an entry in the initial "Built-In" portion
+ *                            of a TIC_HDR -type vocabulary with both an
+ *                            "active" and an "ignoring" function, a literal
+ *                            value for the "param field" and a specifiable
+ *                            "definer".
+ *                            
+ *   Arguments:
+ *       nam      (string)         Name of the entry as seen in the source
+ *       afunc    (routine-name)   Name of internal "active" function
+ *       pval     (integer)        The "param field" item
+ *       ifunc    (routine-name)   Name of "ignoring" function
+ *       definr   (fword_token)    "Definer" of the entry
+ *
+ *      The "param field" item will be recast to the required default type.
+ *
+ **************************************************************************** */
+#define DUALFUNC_TIC(nam, afunc, pval, ifunc, definr )  \
+    { nam , (tic_hdr_t *)NULL , afunc ,  \
+        { (TIC_P_DEFLT_TYPE)(pval) }, definr , ifunc , 0 }
+
+/*  Similar but a  tic_fwt_hdr_t  type structure  */
+#define DUFNC_FWT_PARM(nam, afunc, pval, ifunc, definr )  \
+    { nam , (tic_fwt_hdr_t *)NULL , afunc ,  \
+        { (TIC_FWT_P_DEFLT_TYPE)(pval) }, definr , ifunc , 0 }
+
+
+/* **************************************************************************
+ *          Macro Name:   FWORD_TKN_TIC
+ *                        Create an entry in the initial "Built-In" portion
+ *                            of an FWord Token list of  tic_fwt_hdr_t  type.
+ *                            
+ *   Arguments:
+ *       nam         (string)         Name of the entry as seen in the source
+ *       func        (routine-name)   Name of internal function to call
+ *       fw_tokval   (fword_token)    Value of the FWord Token
+ *       definr      (fword_token)    "Definer" of the entry
+ *
+ *      The "param field" item should not need be recast.
+ *
+ **************************************************************************** */
+
+#define FWORD_TKN_TIC(nam, func, fw_tokval, definr )    \
+    { nam , (tic_fwt_hdr_t *)NULL , func , { fw_tokval }, definr , NULL , 0 }
+
+/* **************************************************************************
+ *          Macro Name:   DUALFUNC_FWT_TIC
+ *                        Create an entry in the initial "Built-In" portion
+ *                            of an FWord Token list of  tic_fwt_hdr_t  type
+ *                            with both an action- and an "Ignore"- -function.
+ *                            
+ *   Arguments:
+ *       nam         (string)         Name of the entry as seen in the source
+ *       afunc       (routine-name)   Name of internal "Action" function
+ *       fw_tokval   (fword_token)    Value of the FWord Token
+ *       ifunc       (routine-name)   Name of "ignoring" function
+ *       definr      (fword_token)    "Definer" of the entry
+ *
+ *      The "param field" item should not need be recast.
+ *
+ **************************************************************************** */
+#define DUALFUNC_FWT_TIC(nam, afunc, fw_tokval, ifunc, definr )    \
+    { nam , (tic_fwt_hdr_t *)NULL , afunc , { fw_tokval }, definr , ifunc , 0 }
+
+/* **************************************************************************
+ *          Macro Name:   BUILTIN_MAC_TIC
+ *                        Create an entry in the initial "Built-In" portion
+ *                            of a Macros vocabulary of  tic_mac_hdr_t  type.
+ *                            
+ *   Arguments:
+ *       nam         (string)         Name of the entry as seen in the source
+ *       func        (routine-name)   Name of internal function to call
+ *       alias       (string)         Macro-Substitution string
+ *
+ *      The "param field" item should not need be recast.
+ *      The "definer" will be MACRO_DEF
+ *      Builtin Macros do not need to be expanded while Ignoring, so
+ *          the ign_func will be NULL
+ *
+ **************************************************************************** */
+
+#define BUILTIN_MAC_TIC(nam, func, alias )    \
+    { nam , (tic_mac_hdr_t *)NULL , func , { alias }, MACRO_DEF , NULL , 0 }
+
+
+/* **************************************************************************
+ *          Macro Name:   BUILTIN_BOOL_TIC
+ *                        Create an entry in the initial "Built-In" portion
+ *                            of a Condtionals list of  tic_bool_hdr_t  type.
+ *                            
+ *   Arguments:
+ *       nam         (string)          Name of the entry as seen in the source
+ *       func        (routine-name)    Name of internal function to call
+ *       bool_vbl    (boolean v'ble)   Name of the boolean variable.
+ *
+ *      The "param field" item should not need be recast.
+ *      For all of the Condtionals, the "Ignoring" function is the same
+ *          as the "Active" function.
+ *      The "definer" will be COMMON_FWORD
+ *
+ **************************************************************************** */
+
+#define BUILTIN_BOOL_TIC(nam, func, bool_vbl )    \
+    { nam , (tic_bool_hdr_t *)NULL , func , { &bool_vbl },   \
+        COMMON_FWORD , func , 0 }
+
+
+/* **************************************************************************
+ *
+ *     Exported Variables and Function Prototypes the rest of the way...
+ *
+ **************************************************************************** */
+
+extern tic_hdr_t *tic_found;
+
+void init_tic_vocab( tic_hdr_t *tic_vocab_tbl,
+                         int max_indx,
+			     tic_hdr_t **tic_vocab_ptr);
+void add_tic_entry( char *tname,
+                        void (*tfunct)(),
+                             TIC_P_DEFLT_TYPE tparam,
+                                 fwtoken fw_defr,
+				     int pfldsiz,
+                                         void (*ign_fnc)(),
+                                             tic_hdr_t **tic_vocab );
+tic_hdr_t *lookup_tic_entry( char *tname, tic_hdr_t *tic_vocab );
+bool exists_in_tic_vocab( char *tname, tic_hdr_t *tic_vocab );
+bool handle_tic_vocab( char *tname, tic_hdr_t *tic_vocab );
+bool create_tic_alias( char *new_name,
+                                  char *old_name,
+				      tic_hdr_t **tic_vocab );
+void reset_tic_vocab( tic_hdr_t **tic_vocab, tic_hdr_t *reset_position );
+
+#endif   /*  _TOKE_TICVOCAB_H    */
diff --git a/toke/toke.c b/toke/toke.c
index b6b590f..d9739a0 100644
--- a/toke/toke.c
+++ b/toke/toke.c
@@ -7,7 +7,7 @@
  *  This program is part of a free implementation of the IEEE 1275-1994 
  *  Standard for Boot (Initialization Configuration) Firmware.
  *
- *  Copyright (C) 2001-2005 by Stefan Reinauer <stepan@openbios.org>
+ *  Copyright (C) 2001-2006 by Stefan Reinauer <stepan@openbios.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -24,6 +24,12 @@
  *
  */
 
+/* **************************************************************************
+ *         Modifications made in 2005 by IBM Corporation
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Modifications Author:  David L. Paktor    dlpaktor@us.ibm.com
+ **************************************************************************** */
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -34,47 +40,214 @@
 #include <getopt.h>
 #endif
 
+#include "types.h"
 #include "toke.h"
 #include "stream.h"
 #include "stack.h"
 #include "emit.h"
 
-#define TOKE_VERSION "0.6.10"
+#define TOKE_VERSION "1.0.0"
+
+#include "vocabfuncts.h"
+#include "scanner.h"
+#include "errhandler.h"
+#include "usersymbols.h"
+#include "clflags.h"
+#include "tracesyms.h"
+
+#define CORE_COPYR   "(C) Copyright 2001-2006 Stefan Reinauer.\n" \
+		     "(C) Copyright 2006 coresystems GmbH <info@coresystems.de>"
+#define IBM_COPYR    "(C) Copyright 2005 IBM Corporation.  All Rights Reserved."
+
+/*  Temporary hack during development...  See DATE_STAMP  line below... */
+#ifdef DEVEL
+#include "date_stamp.h"
+#endif /*  DEVEL  */
+
+/* **************************************************************************
+ *
+ *     Global Variables Exported:
+ *        verbose          If true, enable optional messages.
+ *        noerrors         If true, create binary even if error(s) encountered.
+ *        fload_list       If true, create an "FLoad-List" file
+ *        dependency_list  If true, create a "Dependencies-List" file
+ *
+ **************************************************************************** */
+
+bool verbose         = FALSE;
+bool noerrors        = FALSE;
+bool fload_list      = FALSE;
+bool dependency_list = FALSE;
 
-int verbose=0;
-int noerrors=0;
+/* **************************************************************************
+ *
+ *              Internal Static Variables
+ *         outputname    Name of output file supplied on command-line
+ *                           with the optional  -o  switch.
+ *              Internal System Variable
+ *         optind        Index into argv vector of first param after options,
+ *                           from which input file names will be taken.
+ *
+ **************************************************************************** */
 
+static char *outputname = NULL;
+
+/* **************************************************************************
+ *
+ *    Print the copyright message.
+ *
+ **************************************************************************** */
 static void print_copyright(void)
 {
-        printf( "Welcome to toke - OpenBIOS tokenizer v%s\nCopyright (c)"
-		" 2001-2005 by Stefan Reinauer <stepan@openbios.org>\n"
+	printf( "Welcome to toke - OpenBIOS tokenizer v" TOKE_VERSION "\n"
+		CORE_COPYR "\n" IBM_COPYR "\n"
 		"This program is free software; you may redistribute it "
 		"under the terms of\nthe GNU General Public License. This "
-		"program has absolutely no warranty.\n\n", TOKE_VERSION);
+		"program has absolutely no warranty.\n\n");
+#ifdef DEVEL
+        /*  Temporary hack during development... */
+	printf( "\tTokenizer Compiled " DATE_STAMP "\n" );
+#endif /*  DEVEL  */
+
 }
 
+/* **************************************************************************
+ *
+ *      Function name:    usage
+ *      Synopsis:         Print convenient usage-help message
+ *
+ **************************************************************************** */
+
 static void usage(char *name)
 {
-	printf("usage: %s [-v] [-i] [-o target] <forth-file>\n\n",name);
-	printf("  -v|--verbose          print debug messages\n");
-	printf("  -i|--ignore-errors    don't bail out after an error\n");
+	printf("usage: %s [-v] [-i] [-l] [-P] [-o target] <[-d name[=value]]> "
+				"<[-f [no]flagname]> <[-I dir-path]> "
+				"<[-T symbol]> <forth-file>\n\n",name);
+	printf("  -v|--verbose          print Advisory messages\n");
+	printf("  -i|--ignore-errors    don't suppress output after errors\n");
+	printf("  -l|--load-list        create list of FLoaded file names\n");
+	printf("  -P|--dependencies     create dePendency-list file\n");
+	printf("  -o|--output-name      send output to filename given\n");
+	printf("  -d|--define           create user-defined symbol\n");
+	printf("  -f|--flag             set (or clear) Special-Feature flag\n");
+	printf("  -I|--Include          add a directory to the Include-List\n");
+	printf("  -T|--Trace            add a symbol to the Trace List\n");
 	printf("  -h|--help             print this help message\n\n");
-
+	printf("  -f|--flag    help     Help for Special-Feature flags\n");
 }
 
-int main(int argc, char **argv)
+/* **************************************************************************
+ *
+ *      Function name:    get_args
+ *      Synopsis:         Parse the Command-Line option switches
+ *      
+ *      Inputs:
+ *         Parameters:                  NONE
+ *         Global Variables:
+ *                    argc      Counter of command-line arguments
+ *                    argv      Vector pointing to command-line arguments
+ *         Command-Line Items:  The entire command-line will be parsed
+ *
+ *      Outputs:
+ *         Returned Value:              NONE
+ *         Global Variables:
+ *                verbose	     set by "-v" switch
+ *                noerrors           set by "-i" switch
+ *                fload_list         set by "-l" switch
+ *                dependency_list    set by "-P" switch
+ *         Internal Static Variables
+ *                outputname         set by "-o" switch
+ *         Internal System Variable
+ *                optind             Index into argv vector of the position
+ *                                       from which to take input file names.
+ *         Printout:
+ *                (Copyright was already printed by the main body as a
+ *                    matter of course, rather than here depending on
+ *                    the Verbose flag, because  getopt()  prints its
+ *                    own error messages and we want to be sure to show
+ *                    the Copyright notice before any error messages.)
+ *                Rules for Usage and Flags-list or Flags-help display:
+ *                  Usage message on Help-Request or error.
+ *                  Ask for usage help, get Usage plus list of Flag Names.
+ *                  Ask for Flags-help alone, get Flags-help (names plus
+ *                      explanations)
+ *                  Ask for usage help and for Flags-help, get Usage plus
+ *                      Flags-help, without redundant list of Flag Names.
+ *                  Any help-request, exit Zero
+ *                  Error in Option switches, or missing input-file name,
+ *                      get error-description plus Usage
+ *                  Error in Flag Names, get list of Flag Names.
+ *                  Any error, exit One.
+ *         Behavior:
+ *                Exit (non-failure) after printing "Help" message
+ *
+ *      Error Detection:     Exit with failure status on:
+ *          Unknown Option switches or Flag Names
+ *          Missing input file name
+ *
+ *      Process Explanation:
+ *           The following switches are recognized:
+ *               v
+ *               h
+ *               ?
+ *               i
+ *               I
+ *               l
+ *               P
+ *               o
+ *               d
+ *               f
+ *               T
+ *           The conditions they set remain in effect through
+ *               the entire program run.
+ *
+ *      Revision History:
+ *          Updated Fri, 15 Jul 2005 by David L. Paktor
+ *              Don't bail on first invalid option.
+ *              Flags to control special features
+ *              Usage messages for "special-feature" flags
+ *          Updated Mon, 18 Jul 2005 by David L. Paktor
+ *              Fine-tune Usage and Flags-list or Flags-help display.
+ *          Updated Sun, 27 Nov 2005 by David L. Paktor
+ *              Add FLoad-List flag
+ *          Updated Wed, 29 Nov 2005 by David L. Paktor
+ *              Make getopt() case-insensitive
+ *          Updated Fri, 17 Mar 2006 by David L. O'Paktor
+ *              Make getopt() case-sensitive again,
+ *                  add include-list support and dePendency-list switch
+ *
+ *      Extraneous Remarks:
+ *          We were originally thinking about defining various classes
+ *              of "Warning" Messages and (somehow) controlling their
+ *              display, but now that we have "special-feature" flags
+ *              that control the generation of specific messages, that
+ *              step has become unnecessary...
+ *
+ **************************************************************************** */
+
+static void get_args( int argc, char **argv )
 {
-	const char *optstring="vhio:?";
-	char *outputname = NULL;
+	const char *optstring="vhilPo:d:f:I:T:?";
 	int c;
+	int argindx = 0;
+	bool inval_opt = FALSE;
+	bool help_mssg = FALSE;
+	bool cl_flag_error = FALSE;
 
 	while (1) {
 #ifdef __GLIBC__
 		int option_index = 0;
 		static struct option long_options[] = {
 			{ "verbose", 0, 0, 'v' },
-			{ "ignore-errors", 0, 0, 'i' },
 			{ "help", 0, 0, 'h' },
+			{ "ignore-errors", 0, 0, 'i' },
+			{ "load-list",     0, 0, 'l' },
+			{ "dependencies",  0, 0, 'P' },
+			{ "output-name",   1, 0, 'o' },
+			{ "define",        1, 0, 'd' },
+			{ "flag",          1, 0, 'f' },
+			{ "Include",       1, 0, 'I' },
+			{ "Trace",         1, 0, 'T' },
 			{ 0, 0, 0, 0 }
 		};
 
@@ -86,63 +259,169 @@ int main(int argc, char **argv)
 		if (c == -1)
 			break;
 
+		argindx++;
 		switch (c) {
 		case 'v':
-			verbose=1;
+			verbose=TRUE;
 			break;
 		case 'o':
 			outputname = optarg;
 			break;
 		case 'i':
-			noerrors=1;
+			noerrors = TRUE;
+			break;
+		case 'l':
+			fload_list = TRUE;
+			break;
+		case 'P':
+			dependency_list = TRUE;
+			break;
+		case 'd':
+			{
+			    char *user_symb = optarg;
+			    add_user_symbol(user_symb);
+			}
+			break;
+		case 'f':
+			cl_flag_error = set_cl_flag(optarg, FALSE) ;
+			break;
+		case 'I':
+			{
+			    char *incl_list_elem = optarg;
+			    add_to_include_list(incl_list_elem);
+			}
+			break;
+		case 'T':
+			add_to_trace_list(optarg);
 			break;
-		case 'h':
 		case '?':
-			print_copyright();
-			usage(argv[0]);
-			return 0;		
+			/*  Distinguish between a '?' from the user
+			 *  and one  getopt()  returned
+			 */
+			if ( argv[argindx][1] != '?' )
+			{
+			    inval_opt = TRUE;
+			    break;
+			}
+		case 'h':
+		case 'H':
+			 help_mssg = TRUE;		
+			break;
 		default:
-			print_copyright();
+			/*  This is never executed
+			 *  because  getopt()  prints the
+			 *    "unknown option -- X"
+			 *  message and returns a '?'
+			 */
 			printf ("%s: unknown options.\n",argv[0]);
 			usage(argv[0]);
-			return 1;
+			exit( 1 );
 		}
 	}
 
-	if (verbose)
-		print_copyright();
+	if ( help_mssg )
+	{
+	    usage(argv[0]);
+	    if ( ! clflag_help )
+	    {
+	        list_cl_flag_names();
+	    }
+	}
+	if ( clflag_help )  cl_flags_help();
+	if ( help_mssg || clflag_help )
+	{
+	    exit( 0 );
+	}
 
-	if (optind >= argc) {
-		print_copyright();
-		printf ("%s: filename missing.\n",argv[0]);
+	if ( inval_opt )      printf ("unknown options.\n");
+	if (optind >= argc)   printf ("Input file name missing.\n");
+	if ( inval_opt || (optind >= argc) )
+	{
 		usage(argv[0]);
-		return 1;
+	}
+	if ( cl_flag_error )  list_cl_flag_names();
+
+	if ( inval_opt || (optind >= argc) || cl_flag_error )
+	{
+	    exit( 1);
 	}
 
+	if (verbose)
+	{
+	    list_user_symbols();
+	    list_cl_flag_settings();
+	    display_include_list();
+	}
+	save_cl_flags();
+}
+
+/* **************************************************************************
+ *
+ *      Main body of program.  Return 0 for success, 1 for failure.
+ *
+ *      Still to be done:
+ *          Devise a syntax to allow the command-line to specify multiple
+ *              input files together with an output file name for each.
+ *          Currently, the syntax allows only one output file name to be
+ *              specified; when multiple input file names are specified,
+ *              the specification of an output file name is disallowed,
+ *              and only the default output file names are permitted.
+ *              While this works around the immediate problem, a more
+ *              elegant solution could be devised...
+ *
+ **************************************************************************** */
+
+int main(int argc, char **argv)
+{
+	int retval = 0;
+
+	print_copyright();
+	get_args( argc, argv );
+
 	init_stack();
 	init_dictionary();
-	init_macros();
+
 	init_scanner();
 	
-	while (optind < argc) {
-		if (init_stream(argv[optind])) {
-			printf ("%s: warning: could not open file \"%s\"\n",
-					argv[0], argv[optind]);
-			optind++;
-			continue;
+	if ( outputname != NULL )
+	{
+	    if ( argc > optind + 1 )
+	    {
+	    /*  Multiple input file names w/ single output file name  */
+		/*  Work-around  */
+		printf( "Cannot specify single output file name "
+			"with multiple input file names.\n"
+			"Please either remove output-file-name specification,\n"
+			"or use multiple commands.\n");
+	        exit ( -2 );
+	    }
 		}
+
+	for ( ; optind < argc ; optind++ )
+	{
+	    bool stream_ok ;
+
+	    printf("\nTokenizing  %s   ", argv[optind]);
+	    init_error_handler();
+	    stream_ok = init_stream( argv[optind]);
+	    if ( stream_ok )
+	    {
 		init_output(argv[optind], outputname);
 
+		init_scan_state();
+
+		reset_vocabs();
+		reset_cl_flags();
+
 		tokenize();
 		finish_headers();
 		
-		close_output();
-		close_stream();
-		
-		optind++;
+		close_stream( NULL);
+		if ( close_output() )  retval = 1;
+	    }
 	}
 	
 	exit_scanner();
-	return 0;
+	return retval;
 }
 
diff --git a/toke/toke.h b/toke/toke.h
index 16450d1..2c4bc56 100644
--- a/toke/toke.h
+++ b/toke/toke.h
@@ -1,3 +1,6 @@
+#ifndef _TOKE_TOKE_H
+#define _TOKE_TOKE_H
+
 /*
  *                     OpenBIOS - free your system! 
  *                         ( FCode tokenizer )
@@ -24,30 +27,25 @@
  *
  */
 
-#ifndef _H_TOKE
-#define _H_TOKE
+/* **************************************************************************
+ *         Modifications made in 2005 by IBM Corporation
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Modifications Author:  David L. Paktor    dlpaktor@us.ibm.com
+ **************************************************************************** */
 
-#define u8 unsigned char
-#define u16 unsigned short
-#define u32 unsigned int
-#define s16 short
-#define bool int
-#define TRUE (-1)
-#define FALSE (0)
-#define ANSI_ONLY
 
-extern void	init_scanner( void );
-extern void	exit_scanner( void );
+#include "types.h"
 
-extern void	init_dictionary( void );
-extern void	init_macros( void );
-extern void	tokenize( void );
 
-extern u16	lookup_token(char *name);
-extern u16	lookup_fword(char *name);
-extern char	*lookup_macro(char *name);
-extern int	add_token(u16 number, char *name);
+/* ************************************************************************** *
+ *
+ *      Global Variables Exported
+ *
+ **************************************************************************** */
 
-extern int	add_macro(char *name, char *alias);
+extern bool verbose;
+extern bool noerrors;
+extern bool fload_list;
+extern bool dependency_list;
 
-#endif   /* _H_TOKE */
+#endif   /* _TOKE_TOKE_H */
diff --git a/toke/tokzesc.c b/toke/tokzesc.c
new file mode 100644
index 0000000..a45f952
--- /dev/null
+++ b/toke/tokzesc.c
@@ -0,0 +1,771 @@
+/*
+ *                     OpenBIOS - free your system!
+ *                         ( FCode tokenizer )
+ *
+ *  This program is part of a free implementation of the IEEE 1275-1994
+ *  Standard for Boot (Initialization Configuration) Firmware.
+ *
+ *  Copyright (C) 2001-2005 Stefan Reinauer, <stepan@openbios.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ *
+ */
+
+/* **************************************************************************
+ *
+ *      Process activity inside "Tokenizer Escape" mode.
+ *
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Module Author:  David L. Paktor    dlpaktor@us.ibm.com
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      Functions Exported:
+ *          init_tokz_esc_vocab      Initialize the relevant vocabulary.
+ *          enter_tokz_esc           Enter "Tokenizer Escape" mode
+ *          handle_tokz_esc          Perform a function in the
+ *                                       "Tokenizer Escape" Vocabulary
+ *          exists_in_tokz_esc       Confirm whether a given name exists in 
+ *                                       the "Tokz_Esc_Vocabulary"
+ *          create_tokz_esc_alias    Add an alias to "Tokenizer Escape" space
+ *          reset_tokz_esc           Reset the "Tokenizer Escape" Vocabulary
+ *                                      to its "Built-In" position.
+ *
+ **************************************************************************** */
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include "ticvocab.h"
+#include "tokzesc.h"
+#include "stack.h"
+#include "emit.h"
+#include "stream.h"
+#include "scanner.h"
+#include "errhandler.h"
+#include "strsubvocab.h"
+#include "nextfcode.h"
+
+#undef TOKZTEST     /*  Define for testing only; else undef   */
+#ifdef TOKZTEST         /*  For testing only   */
+   #include "vocabfuncts.h"
+   #include "date_stamp.h"
+#endif                  /*  For testing only   */
+
+/* **************************************************************************
+ *
+ *          Global Variables Imported
+ *              in_tokz_esc    State of the tokenization operation.
+ *                                Value is FALSE if it's operating normally
+ *                                or TRUE if it's in "Tokenizer Escape" mode.
+ *              nextfcode  
+ *              statbuf    
+ *              dstack         Pointer to current item on top of Data Stack.   
+ *              base           Current tokenizer numeric conversion radix
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      We are going to implement a mini-forth using a strategy based
+ *          on the concept of Threaded Interpretive Code  (well, okay,
+ *          it won't really be interpretive ... )
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *              Internal Static Variables -- (well, almost)
+ *      tokz_esc_vocab        Pointer to "tail" of "Tokenizer Escape" Vocab
+ *
+ *      While we would prefer to keep  tokz_esc_vocab  private to this file,
+ *          we find we need it in one other place, namely, macros.c
+ *      We will declare it "extern" within that file, rather than
+ *          exporting it widely by including it in a  .h  file
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      We will define and initialize a structure consisting of all the
+ *          functions we initially support for "Tokenizer Escape" mode,
+ *          called  tokz_esc_vocab_tbl  for "Tokenizer Escape Vocab Table".
+ *      I expect we can initialize its body, but I don't think there's a
+ *          convenient way in "C" to initialize its links; we'll have to
+ *          do that dynamically, at run-time.  Oh, well...
+ *
+ *      We'll call the pointer to it the "Tokenizer Escape" Vocabulary.
+ *          We have to declare it here, because we need to refer to it in
+ *          a function that will be entered into the Table.
+ *
+ *      We would like to pre-initialize it; to do so, we would have to
+ *          declare it extern here, then later create its instance and
+ *          assign its initial value.  That would be all well and good,
+ *          except that some linkers don't handle that very well, so, to
+ *          accommodate those, we have to include its initialization in
+ *          the same routine where we initialize the Table's links.
+ *
+ *      Revision History:
+ *          Updated Wed, 04 Jan 2006 by David L. Paktor
+ *          Initialization of tokz_esc_vocab is now included with
+ *              the call to  init_tic_vocab()
+ *
+ **************************************************************************** */
+
+tic_hdr_t *tokz_esc_vocab = NULL ;
+
+/* **************************************************************************
+ *
+ *      We'll give short prologs to the simpler functions that will be
+ *          used in the "Tokenizer Escape" Vocabulary.
+ *
+ *      All these take, as an argument, the "parameter field" pointer.
+ *          To satisfy C's strong-typing, it will always be declared
+ *          of a consistent type.  The routine itself can internally
+ *          recast -- or ignore -- it, as needed.
+ *      Many of these will refer to the Global Variable  statbuf .  It
+ *          all such cases, it is used for Error reporting.
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      Function name:  enter_tokz_esc
+ *      Synopsis:       When you start "Tokenizer Escape" mode.
+ *
+ *      Associated Tokenizer directive:        TOKENIZER[
+ *
+ *      Process Explanation:
+ *          Enter "Tokenizer Escape" mode ...  Save the current tokenizer
+ *              numeric conversion radix, and set the radix to sixteen
+ *              (hexadecimal)
+ *
+ **************************************************************************** */
+
+static int saved_base ;    /*  Place to save the numeric conversion radix  */
+
+void enter_tokz_esc( void )
+{
+    saved_base = base ;
+    base = 16;
+    in_tokz_esc = TRUE;
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  end_tokz_esc
+ *      Synopsis:       When you've reached the end of "Tokenizer Escape" mode.
+ *
+ *      Associated Tokenizer directive:        ]TOKENIZER
+ *
+ *      Process Explanation:
+ *          Exit "Tokenizer Escape" mode, resume "Normal"-mode behavior.
+ *              Restore the tokenizer numeric conversion radix to the value
+ *              saved by tokenizer[ and exit "Tokenizer Escape" mode . . .
+ *
+ **************************************************************************** */
+
+static void end_tokz_esc( tic_param_t pfield )
+{
+    in_tokz_esc = FALSE;
+    base = saved_base ;
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  tokz_esc_emit_byte
+ *      Synopsis:       Emit the byte found on the data-stack
+ *                      
+ *      Associated Tokenizer directive:        EMIT-BYTE
+ *                      
+ *      Error Detection:
+ *          If number on stack is larger than a byte:  Truncate and Warn
+ *
+ **************************************************************************** */
+
+static void tokz_esc_emit_byte ( tic_param_t pfield )
+{
+    long num_on_stk = dpop();
+    u8 byt_to_emit = (u8)num_on_stk;
+    if ( byt_to_emit != num_on_stk )
+    {
+        tokenization_error( WARNING,
+	    "Value on stack for %s command is 0x%0x.  "
+		"Truncating to 0x%02x.\n",
+		     strupr(statbuf), num_on_stk, byt_to_emit);
+    }
+    user_emit_byte(byt_to_emit);
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  get_fcode_from_stack
+ *      Synopsis:       Retrieve an FCode value from the data-stack.
+ *                          Indicate if erroneous
+ *
+ *      Inputs:
+ *         Parameters:
+ *             the_num           Pointer to where to put the number
+ *             the_action        Phrase to be used in ERROR message
+ *         Data-Stack Items:
+ *             Top:              Value to be retrieved
+ *
+ *      Outputs:
+ *         Returned Value:       TRUE if number is within valid FCode range
+ *         Supplied Pointers:
+ *             *the_num          Value retrieved from the data-stack
+ *
+ *      Error Detection:
+ *          If the number on the stack is larger than 16 bits, truncate
+ *              it, with a WARNING message.
+ *          If the (possibly truncated) number from the stack is larger
+ *              than the legal maximum for an FCode (0x0fff), or
+ *              less than the legal minimum (0x0800), issue an ERROR,
+ *              leave the_num unchanged and return FALSE.
+ *
+ **************************************************************************** */
+
+static bool get_fcode_from_stack( u16 *the_num, char *the_action)
+{
+    bool retval = FALSE;
+    long num_on_stk = dpop();
+    u16 test_fcode = (u16)num_on_stk;
+    if ( test_fcode != num_on_stk )
+    {
+        tokenization_error( WARNING,
+	    "Value on stack for %s command is 0x%0x.  "
+		"Truncating to 0x%03x.\n",
+		     strupr(statbuf), num_on_stk, test_fcode);
+    }
+    if ( ( test_fcode >= 0x800 ) && ( test_fcode <= 0xfff ) )
+    {
+	retval = TRUE;
+	*the_num = test_fcode;
+    }else{	tokenization_error( TKERROR, "Attempt to %s "
+	    "0x%x, which violates limit specified by IEEE-1275.  "
+		"Disallowing.\n", the_action, test_fcode );
+    }
+    return( retval );
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  tokz_esc_next_fcode
+ *      Synopsis:       Set the next-fcode to the value on the data-stack
+ *                      
+ *      Associated Tokenizer Directive:          next-fcode
+ *                      
+ *      Error Detection:
+ *          If the number on the stack is not legal for an FCode, as
+ *              detected by  get_fcode_from_stack(), issue an ERROR
+ *              message and don't change nextfcode.
+ *
+ *         Printout:
+ *             Advisory showing change in FCode token Assignment Counter
+ *
+ **************************************************************************** */
+
+static void tokz_esc_next_fcode( tic_param_t pfield )
+{
+    u16 test_fcode;
+
+    if ( get_fcode_from_stack( &test_fcode, "set next fcode to") )
+    {
+	if ( test_fcode == nextfcode )
+	{
+	    tokenization_error( INFO, "FCode-token Assignment Counter "
+		"is unchanged from 0x%x.\n",
+		    nextfcode);
+	}else{
+	    tokenization_error( INFO, "FCode-token Assignment Counter "
+		"was 0x%x; has been %s to 0x%x.\n",
+		    nextfcode,
+			test_fcode > nextfcode ? "advanced" : "reset",
+			    test_fcode );
+	    set_next_fcode( test_fcode);
+	}
+    }
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  tokz_emit_fcode
+ *      Synopsis:       Emit the value on the data-stack as an FCode token
+ *                      
+ *      Associated Tokenizer Directive:          emit-fcode
+ *                      
+ *      Error Detection:
+ *          If the number on the stack is not legal for an FCode, as
+ *              detected by  get_fcode_from_stack(), issue an ERROR
+ *              message and don't emit anything.
+ *
+ *         Printout:
+ *             Advisory showing FCode being emitted.
+ *
+ **************************************************************************** */
+
+static void tokz_emit_fcode( tic_param_t pfield )
+{
+    u16 test_fcode;
+
+    if ( get_fcode_from_stack( &test_fcode, "Emit FCode value of") )
+    {
+	tokenization_error( INFO,
+	    "Emitting FCode value of 0x%x\n", test_fcode);
+	emit_fcode( test_fcode);
+    }
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  zero_equals
+ *      Synopsis:       Boolean-inversion of item on top of stack.
+ *                      If zero, make it minus-one; if non-zero, make it zero. 
+ *
+ *      Associated FORTH word-name:          0=
+ *
+ **************************************************************************** */
+
+static void  zero_equals ( tic_param_t pfield )
+{
+    *dstack = (*dstack == 0) ? -1 : 0 ;
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  tokz_esc_swap
+ *      Synopsis:       "Tokenizer Escape" mode-time data-stack SWAP operation
+ *                      
+ *      Associated FORTH word-name:          swap
+ *
+ **************************************************************************** */
+
+static void  tokz_esc_swap ( tic_param_t pfield )
+{
+    swap();
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  tokz_esc_two_swap
+ *      Synopsis:       "Tokenizer Escape" mode-time data-stack 2SWAP operation
+ *                      
+ *      Associated FORTH word-name:          2swap
+ *
+ **************************************************************************** */
+
+static void  tokz_esc_two_swap ( tic_param_t pfield )
+{
+    two_swap();
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  tokz_esc_noop
+ *      Synopsis:       "Tokenizer Escape" mode-time non-operation
+ *                      
+ *      Associated FORTH word-name:          noop
+ *
+ **************************************************************************** */
+
+static void  tokz_esc_noop ( tic_param_t pfield )
+{
+    return;
+}
+
+#ifdef TOKZTEST         /*  For testing only   */
+
+   static void  tokz_esc_emit_string( tic_param_t pfield )
+   {
+      int lenny ;
+      lenny = strlen ( pfield.chr_ptr );
+      emit_token("b(\")");
+      emit_string(pfield.chr_ptr, lenny);
+   }
+
+#endif                  /*  For testing only   */
+
+/* **************************************************************************
+ *
+ *      Function name:  do_constant
+ *      Synopsis:       The function to perform when a named constant
+ *                          that was defined in "Tokenizer Escape" mode
+ *                          is invoked in "Tokenizer Escape" mode
+ *
+ *      Associated FORTH word:                 A user-defined constant
+ *      
+ *      Inputs:
+ *         Parameters:
+ *             The param-field of the table-entry contains
+ *                 the value of the constant
+ *
+ *      Outputs:
+ *         Returned Value:         NONE
+ *         Items Pushed onto Data-Stack:
+ *             Top:              The table-entry's param-field's value
+ *
+ *      Error Detection:
+ *          An attempt, while operating in normal tokenization mode, to invoke
+ *              a named constant that was defined in "Tokenizer Escape" mode
+ *              will be detected by the main scanning loop, and need not
+ *              concern us here.
+ *
+ **************************************************************************** */
+
+static void do_constant ( tic_param_t pfield )
+{
+    dpush( pfield.long_val );
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  create_constant
+ *      Synopsis:       Create a user-defined constant that will be
+ *                          recognized in "Tokenizer Escape" mode
+ *
+ *      Associated FORTH word-name:             CONSTANT  (when issued
+ *                                                  in "Tokenizer Escape" mode)
+ *
+ *      Inputs:
+ *         Parameters:                NONE
+ *         Global Variables:
+ *             statbuf         The constant's name will be taken from the
+ *                                 next word in the input stream.
+ *             do_constant     The function assigned to the definition
+ *             tokz_esc_vocab  The "Tokenizer Escape" Vocabulary pointer
+ *         Data-Stack Items:
+ *             Top:            The constant's value is popped from the stack
+ *
+ *      Outputs:
+ *         Returned Value:            NONE
+ *         Global Variables:
+ *             statbuf         Advanced to the next word in the input stream.
+ *             tokz_esc_vocab      Updated to point to new vocab entry.
+ *         Memory Allocated:
+ *             for the name and for the new entry.
+ *         When Freed?
+ *             When RESET-SYMBOLS is issued in "Tokenizer Escape" mode,
+ *                or upon end of tokenization.
+ *         Data-Stack, # of Items Popped:             1
+ *
+ *      Error Detection:
+ *          Failure to allocate memory is a Fatal Error.
+ *          Warning on excessively long name
+ *          Warning on duplicate name
+ *          Name to be defined not in same file, ERROR
+ *
+ *      Process Explanation:
+ *          Get the next word, STRDUP it (which implicitly allocates memory). 
+ *              Get the number popped off the stack.
+ *              Pass the pointer and the value to the add_tic_entry() routine.
+ *
+ **************************************************************************** */
+
+static void create_constant( tic_param_t pfield )
+{
+    char *c_name_space ;          /*  Space for copy of the name    */
+    long valu ;                   /*  Value, popped off the stack   */
+    signed long wlen;
+
+    /*  Get the name that is to be defined  */
+    wlen = get_word();
+    if ( wlen <= 0 )
+    {
+	warn_unterm( TKERROR, "Constant definition", lineno);
+	return;
+    }
+
+    valu = dpop();
+
+    /*  If ever we implement more than just this one
+     *      defining-word in "Tokenizer Escape" mode,
+     *      the lines from here to the end of the
+     *      routine should be re-factored...
+     */
+    trace_creation( CONST, statbuf);
+
+    warn_if_duplicate( statbuf );
+    check_name_length( wlen );
+
+    c_name_space = strdup( statbuf );
+
+    add_tic_entry(
+	 c_name_space,
+	     do_constant,
+		  (TIC_P_DEFLT_TYPE)valu,
+		       CONST ,
+			   0 , NULL,
+		               &tokz_esc_vocab );
+
+}
+
+/* **************************************************************************
+ *
+ *      Let's create usable named constants for "Tokenizer Escape" mode.
+ *          It's useful, it's easy and ...  well, you get the idea.
+ *
+ **************************************************************************** */
+/*  I don't think we need to any more
+static const int zero = 0 ;
+static const int minus_one = -1 ;
+static const char double_quote = '"' ;
+static const char close_paren = ')' ;
+ *  Except for this next one, of course...   */
+#ifdef TOKZTEST        /*  For testing only   */
+   static const char date_me[] =  DATE_STAMP;
+#endif                 /*  For testing only   */
+
+/* **************************************************************************
+ *
+ *      Here, at long last, we define and initialize the structure containing
+ *          all the functions we support in "Tokenizer Escape" mode.
+ *      Let's call it the "Tokenizer Escape Vocabulary Table" and the
+ *          pointer to it, the "Tokenizer Escape" Vocabulary.
+ *      We can initialize the start of the "Tokenizer Escape" Vocabulary
+ *          easily, except for the link-pointers, as an array.
+ *
+ **************************************************************************** */
+
+#define TKZESC_CONST(nam, pval)   \
+                        VALPARAM_TIC(nam, do_constant, pval, CONST )
+#define TKZ_ESC_FUNC(nam, afunc, pval, ifunc)   \
+                        DUALFUNC_TIC(nam, afunc, pval, ifunc, UNSPECIFIED)
+
+static tic_hdr_t tokz_esc_vocab_tbl[] = {
+    NO_PARAM_IGN( "]tokenizer" , end_tokz_esc                           ) ,
+
+    /*  An IBM-ish synonym.  */
+    NO_PARAM_IGN( "f]"         , end_tokz_esc                           ) ,
+    /*  An alternate synonym.  */
+    NO_PARAM_IGN( "]f"         , end_tokz_esc                           ) ,
+
+    NO_PARAM_TIC( "emit-byte"  , tokz_esc_emit_byte                     ) ,
+    NO_PARAM_TIC( "next-fcode" , tokz_esc_next_fcode                    ) ,
+    NO_PARAM_TIC( "emit-fcode" , tokz_emit_fcode                        ) ,
+    NO_PARAM_TIC( "constant"   , create_constant                        ) ,
+    NO_PARAM_TIC( "0="         , zero_equals                            ) ,
+    NO_PARAM_TIC( "swap"       , tokz_esc_swap                          ) ,
+    NO_PARAM_TIC( "2swap"      , tokz_esc_two_swap                      ) ,
+    NO_PARAM_TIC( "noop"       , tokz_esc_noop                          ) ,
+    TKZESC_CONST( "false"      ,  0                                     ) ,
+    TKZESC_CONST( "true"       , -1                                     ) ,
+    TKZ_ESC_FUNC( ".("         , user_message, ')', skip_user_message   ) ,
+    TKZ_ESC_FUNC( ".\""        , user_message, '"', skip_user_message   ) ,
+#ifdef TOKZTEST        /*  For testing only   */
+    /*  Data is a pointer to a constant string in the compiler;    */
+    /*      no need to copy, hence data_size can remain zero.      */
+    /*  We could almost use the Macro macro, except for the type.  */
+    TKZ_ESC_FUNC( "emit-date"  , tokz_esc_emit_string, date_me , NULL   ) ,
+#endif                 /*  For testing only   */
+};
+
+/* **************************************************************************
+ *
+ *      Also, keep a pointer to the "Built-In" position of
+ *          the "Tokenizer Escape" Vocabulary
+ *
+ **************************************************************************** */
+
+static const tic_hdr_t *built_in_tokz_esc =
+    &tokz_esc_vocab_tbl[(sizeof(tokz_esc_vocab_tbl)/sizeof(tic_hdr_t))-1];
+
+/* **************************************************************************
+ *
+ *      Function name:  init_tokz_esc_vocab
+ *      Synopsis:       Initialize the "Tokenizer Escape" Vocabulary
+ *                          link-pointers dynamically.
+ *
+ **************************************************************************** */
+
+void init_tokz_esc_vocab ( void )
+{
+    static const int tokz_esc_vocab_max_indx =
+	 sizeof(tokz_esc_vocab_tbl)/sizeof(tic_hdr_t) ;
+
+    tokz_esc_vocab = NULL ;   /*  Belt-and-suspenders...  */
+    init_tic_vocab(tokz_esc_vocab_tbl,
+                       tokz_esc_vocab_max_indx,
+		           &tokz_esc_vocab );
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  handle_tokz_esc
+ *      Synopsis:       Perform a function in the "Tokenizer Escape" Vocabulary
+ *                      Indicate whether the name is valid in this vocabulary.
+ *                      Handle "Tokenizer Escape" aliases implicitly.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             tname                The name to handle
+ *         Global Variables:  
+ *             tokz_esc_vocab       Pointer to "Tokenizer Escape" Vocabulary 
+ *
+ *      Outputs:
+ *         Returned Value:   TRUE if the given name is valid in tokz_esc
+ *
+ *      Process Explanation:
+ *          Find the name and execute its associated function.
+ *          If the name is not in the "Tokenizer Escape" Vocabulary,
+ *              let the calling routine determine whether to try it
+ *              out as a number or to print an error message.
+ *
+ **************************************************************************** */
+
+bool handle_tokz_esc( char *tname )
+{
+    bool retval = handle_tic_vocab( tname, tokz_esc_vocab );
+    return ( retval ) ;
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  lookup_tokz_esc
+ *      Synopsis:       Return a pointer to the data-structure of the named
+ *                      word in the"Tokenizer Escape" Vocabulary
+ *
+ *      Inputs:
+ *         Parameters:
+ *             name                 The given name for which to look
+ *         Local Static Variables:
+ *             tokz_esc_vocab       Pointer to "Tokenizer Escape" Vocabulary  
+ *
+ *      Outputs:
+ *         Returned Value:     TRUE if name is found,
+ *
+ **************************************************************************** */
+
+tic_hdr_t *lookup_tokz_esc(char *name)
+{
+    tic_hdr_t *retval = lookup_tic_entry( name, tokz_esc_vocab );
+    return ( retval );
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  exists_in_tokz_esc
+ *      Synopsis:       Confirm whether a given name exists in the
+ *                          "Tokenizer Escape" Vocabulary
+ *
+ *      Inputs:
+ *         Parameters:
+ *             name                 The given name to confirm
+ *         Global Variables:  
+ *             tokz_esc_vocab       Pointer to "Tokenizer Escape" Vocabulary  
+ *
+ *      Outputs:
+ *         Returned Value:     TRUE if name is found,
+ *
+ **************************************************************************** */
+
+bool exists_in_tokz_esc(char *name)
+{
+    bool retval = exists_in_tic_vocab( name, tokz_esc_vocab );
+    return ( retval );
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  create_tokz_esc_alias
+ *      Synopsis:       Create an alias in the "Tokenizer Escape" Vocabulary
+ *
+ *      Associated FORTH word:              ALIAS (in "Tokenizer Escape" mode)
+ *
+ *      Inputs:
+ *         Parameters:
+ *             old_name             Name of existing entry
+ *             new_name             New name for which to create an entry
+ *
+ *      Outputs:
+ *         Returned Value:          TRUE if  old_name  found in "Tok Esc" vocab
+ *         Global Variables:    
+ *             tokz_esc_vocab       Will point to the new entry
+ *         Memory Allocated:
+ *             Memory for the new entry will be allocated
+ *                 by the support routine
+ *         When Freed?
+ *             When RESET-SYMBOLS is issued in "Tokenizer Escape" mode,
+ *                or upon end of tokenization.
+ *
+ **************************************************************************** */
+
+bool create_tokz_esc_alias(char *new_name, char *old_name)
+{
+    bool retval = create_tic_alias( new_name, old_name, &tokz_esc_vocab );
+    return ( retval );
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  reset_tokz_esc
+ *      Synopsis:       Reset the "Tokenizer Escape" Vocabulary to
+ *                          its "Built-In" position.
+ *
+ *      Associated Tokenizer directive:       RESET-SYMBOLS  (when issued
+ *                                                in "Tokenizer Escape" mode)
+ *
+ *      Inputs:
+ *         Parameters:                 NONE
+ *         Global Variables:
+ *             tokz_esc_vocab      Pointer to "Tokenizer Escape" Vocabulary
+ *             built_in_tokz_esc   Pointer to "Built-In" position
+ *
+ *      Outputs:
+ *         Returned Value:             NONE
+ *         Global Variables:
+ *             tokz_esc_vocab      Reset to "Built-In" position
+ *         Memory Freed
+ *             Memory will be freed by the support routine
+ *
+ **************************************************************************** */
+
+void reset_tokz_esc( void )
+{
+    reset_tic_vocab( &tokz_esc_vocab, (tic_hdr_t *)built_in_tokz_esc);
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  pop_next_fcode
+ *      Synopsis:       Vector off to the  tokz_esc_next_fcode  function,
+ *                      but without the pseudo-param.  A retro-fit...
+ *
+ *      Associated Tokenizer directive:   FCODE-POP  (issued in either mode)
+ *
+ *      Inputs:
+ *         Parameters:                    NONE
+ *         Data-Stack Items:
+ *             Top:                       Next FCode value, presumably saved
+ *                                            by an  FCODE-PUSH  issued earlier.
+ *
+ *      Outputs:
+ *         Returned Value: 
+ *         Global Variables:
+ *             nextfcode                  FCode token Assignment Counter
+ *
+ **************************************************************************** */
+
+void pop_next_fcode( void)
+{
+   tic_param_t dummy_param;
+   tokz_esc_next_fcode( dummy_param);
+}
diff --git a/toke/tokzesc.h b/toke/tokzesc.h
new file mode 100644
index 0000000..21c74da
--- /dev/null
+++ b/toke/tokzesc.h
@@ -0,0 +1,50 @@
+#ifndef _TOKE_TOKZESC_H
+#define _TOKE_TOKZESC_H
+
+/*
+ *                     OpenBIOS - free your system!
+ *                         ( FCode tokenizer )
+ *
+ *  This program is part of a free implementation of the IEEE 1275-1994
+ *  Standard for Boot (Initialization Configuration) Firmware.
+ *
+ *  Copyright (C) 2001-2005 Stefan Reinauer, <stepan@openbios.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ *
+ */
+
+/* **************************************************************************
+ *
+ *      External and Prototype definitions for functions that process
+ *          activity in "Tokenizer Escape" mode
+ *
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Module Author:  David L. Paktor    dlpaktor@us.ibm.com
+ *
+ **************************************************************************** */
+
+#include "types.h"
+#include "ticvocab.h"
+
+void init_tokz_esc_vocab( void );
+bool create_tokz_esc_alias(char *new_name, char *old_name);
+void enter_tokz_esc( void );
+bool handle_tokz_esc( char *tname );
+tic_hdr_t *lookup_tokz_esc(char *name);
+bool exists_in_tokz_esc(char *name);
+void reset_tokz_esc( void );
+void pop_next_fcode( void);
+
+#endif   /*  _TOKE_TOKZESC_H    */
diff --git a/toke/tracesyms.c b/toke/tracesyms.c
new file mode 100644
index 0000000..1577708
--- /dev/null
+++ b/toke/tracesyms.c
@@ -0,0 +1,172 @@
+/*
+ *                     OpenBIOS - free your system!
+ *                         ( FCode tokenizer )
+ *
+ *  This program is part of a free implementation of the IEEE 1275-1994
+ *  Standard for Boot (Initialization Configuration) Firmware.
+ *
+ *  Copyright (C) 2001-2005 Stefan Reinauer, <stepan@openbios.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ *
+ */
+
+/* **************************************************************************
+ *
+ *      Support routines for "Trace-Symbols" debugging feature
+ *
+ *      (C) Copyright 2006 IBM Corporation.  All Rights Reserved.
+ *      Module Author:  David L. Paktor    dlpaktor@us.ibm.com
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      Functions Exported:
+ *          add_to_trace_list         Add the given name to the Trace List
+ *          show_initial_traces       Show pre-defined names the user
+ *                                        asked to Trace (if any)
+ *          is_on_trace_list          Indicate whether the given name is
+ *                                        on the Trace List
+ *
+ **************************************************************************** */
+
+#include <string.h>
+
+#include "tracesyms.h"
+#include "errhandler.h"
+
+
+/* **************************************************************************
+ *
+ *          Internal Static Variables
+ *     trace_list     Pointer to last entry in the Trace List linked-list
+ *                        data structure
+ *              
+ *              
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      Internal (Static) Structures:
+ *          trace_entry_t           Linked-list of entries in the Trace List
+ *
+ *   Fields:
+ *       tracee              Name of the symbol to be traced
+ *       prev                Pointer to previous entry in the linked-list
+ *
+ **************************************************************************** */
+
+typedef struct trace_entry {
+      char *tracee;
+      struct trace_entry *prev;
+} trace_entry_t;
+
+static trace_entry_t *trace_list = NULL;
+
+
+
+/* **************************************************************************
+ *
+ *      Function name:  add_to_trace_list
+ *      Synopsis:       Add the given name to the Trace List
+ *                      
+ *
+ *      Inputs:
+ *         Parameters:
+ *             trace_symb            Name of the symbol to be added
+ *         Local Static Variables:
+ *             trace_list           Pointer to the Trace List
+ *
+ *      Outputs:
+ *         Returned Value:          NONE
+ *         Local Static Variables:
+ *             trace_list           Points to new entry in Trace List
+ *         Memory Allocated
+ *             For Trace List entry
+ *             For copy of Symbol Name
+ *         When Freed?
+ *             Never.  Well, only on termination of the program.  Trace-list
+ *                 endures for the entire batch of tokenizations.
+ *
+ *      Error Detection:
+ *          Memory allocation failure is a FATAL error.
+ *
+ **************************************************************************** */
+
+void add_to_trace_list( char *trace_symb)
+{
+    trace_entry_t *new_t_l_entry = safe_malloc( sizeof( trace_entry_t),
+        "adding to trace-list");
+    new_t_l_entry->tracee = strdup( trace_symb);
+    new_t_l_entry->prev = trace_list;
+
+    trace_list = new_t_l_entry;
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  is_on_trace_list
+ *      Synopsis:       Indicate whether the given name is on the Trace List
+ *
+ *      Inputs:
+ *         Parameters:
+ *             symb_name            Symbol-name to test
+ *         Local Static Variables:
+ *             trace_list           Pointer to the Trace List
+ *
+ *      Outputs:
+ *         Returned Value:          TRUE if Symbol-name is on the Trace List
+ *
+ **************************************************************************** */
+
+bool is_on_trace_list( char *symb_name)
+{
+    bool retval = FALSE;
+    trace_entry_t *test_entry = trace_list;
+    while ( test_entry != NULL )
+    {
+        if ( strcasecmp( symb_name, test_entry->tracee) == 0 )
+	{
+	    retval = TRUE;
+	    break;
+	}
+	test_entry = test_entry->prev;
+    }
+    return ( retval );
+}
+
+
+/* **************************************************************************
+ *
+ *      Still to be done:
+ *          Implement a function -- name it  show_initial_traces  --
+ *              that will show any pre-defined names the user asked
+ *              to Trace.  That is, if any of the names the user asked
+ *              to Trace belongs to a pre-defined function, macro or
+ *              directive, then, at the beginning of the output, issue 
+ *              Advisory Messages identifying the scope of those names.
+ * 
+ *          E.g, if the user had  -T 3DUP  -T SWAP   the function would
+ *              issue Messages like:
+ *          3DUP is pre-defined as a Macro with Global scope
+ *          SWAP is pre-defined with Global scope
+ *          SWAP is pre-defined in Tokenizer-Escape mode
+ * 
+ *          The names would, of course, remain on the Trace List and
+ *              any re-definitions of them would be reported.
+ *
+ **************************************************************************** */
diff --git a/toke/tracesyms.h b/toke/tracesyms.h
new file mode 100644
index 0000000..b50f7fe
--- /dev/null
+++ b/toke/tracesyms.h
@@ -0,0 +1,48 @@
+#ifndef _TOKE_TRACESYMS_H
+#define _TOKE_TRACESYMS_H
+
+/*
+ *                     OpenBIOS - free your system!
+ *                         ( FCode tokenizer )
+ *
+ *  This program is part of a free implementation of the IEEE 1275-1994
+ *  Standard for Boot (Initialization Configuration) Firmware.
+ *
+ *  Copyright (C) 2001-2005 Stefan Reinauer, <stepan@openbios.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ *
+ */
+
+/* **************************************************************************
+ *
+ *      External/Prototype/Structure definitions for "Trace-Symbols" feature
+ *
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Module Author:  David L. Paktor    dlpaktor@us.ibm.com
+ *
+ **************************************************************************** */
+
+#include "types.h"
+
+/* ************************************************************************** *
+ *
+ *      Function Prototypes / Functions Exported:
+ *
+ **************************************************************************** */
+
+void add_to_trace_list( char *trace_symb);
+bool is_on_trace_list( char *symb_name);
+
+#endif   /*  _TOKE_TRACESYMS_H    */
diff --git a/toke/usersymbols.c b/toke/usersymbols.c
new file mode 100644
index 0000000..f0acbf5
--- /dev/null
+++ b/toke/usersymbols.c
@@ -0,0 +1,363 @@
+/*
+ *                     OpenBIOS - free your system!
+ *                         ( FCode tokenizer )
+ *
+ *  This program is part of a free implementation of the IEEE 1275-1994
+ *  Standard for Boot (Initialization Configuration) Firmware.
+ *
+ *  Copyright (C) 2001-2005 Stefan Reinauer, <stepan@openbios.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ *
+ */
+
+/* **************************************************************************
+ *
+ *      General-purpose support functions for
+ *          User-defined command-line compilation-control symbols
+ *
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Module Author:  David L. Paktor    dlpaktor@us.ibm.com
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      The syntax for user-defined command-line compilation-control symbols
+ *          is <NAME>[=<VALUE>]
+ *
+ *      The name is always required; the equal-sign and value is optional.
+ *          If you wish the "value" to contain spaces or quotes, you can
+ *          accomplish that using the shell escape conventions.
+ *
+ *      The operations that can be performed upon these symbols will be
+ *          described by the operators that use them as operands, but,
+ *          broadly speaking, the tests will either be to simply verify
+ *          the existence of a symbol, or to evaluate the defined value.
+ *
+ *      Once a symbol is defined on the command-line, it stays in effect
+ *          for the duration of the entire batch of tokenizations (i.e.,
+ *          if there are multiple input files named on the command line).
+ *          Also, there are no symbols defined at the outset.  Therefore,
+ *          there is no need for either an "init" or a "reset" routine.
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      User-defined command-line compilation-control symbols are
+ *          implemented as a String-Substitution-type vocabulary.
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      Functions Exported:
+ *          add_user_symbol            Add a user-defined symbol to the list
+ *          lookup_user_symbol         Look for a user-defined symbol, return
+ *                                         the assigned value.
+ *          exists_as_user_symbol      Confirm whether a given name exists
+ *                                         as a user-defined symbol.
+ *          eval_user_symbol           Tokenize the value assigned to a user
+ *                                         symbol.
+ *          list_user_symbols          Print the list of user-defined symbols
+ *                                         for the Logfile.
+ *
+ **************************************************************************** */
+
+/* **************************************************************************
+ *
+ *      Still to be done:
+ *          Convert the handling of user-defined symbols to the T.I.C.
+ *              data-structure and its support routines.  This should
+ *              eliminate any further need of String-Substitution-type
+ *              vocabularies.  User-defined symbols will, however, still
+ *              need to be a separate vocabulary from the Global, because
+ *              they are required to stay in effect for the duration of
+ *              the entire batch of tokenizations...
+ *          (Afterthought:  This is only true for user-defined symbols that
+ *              were created on the command-line; if we ever allow symbols
+ *              to be defined in the Source file, they should be as volatile
+ *              as anything else that comes from a source file...
+ *           Putting source-file-derived user-defined symbols into the Global
+ *              Vocabulary could be a quasi-simple way to accomplish this.)
+ *
+ *          Enable the definition of user-symbols from the Source file, using
+ *              a syntax like:  [define] symbol   or  [define] symbol=<value>
+ *              (How to allow spaces into the <value>?  Maybe make the syntax
+ *              [define] symbol = <value components to end of line> 
+ *              delimited in a manner similar to Macro definitions.
+ *          There might be a need to be able to  [undefine]  a user-symbol
+ *              that would entail defining an  unlink_tic_entry  function.
+ *              Not difficult; just keeping this around as a reminder...
+ *
+ **************************************************************************** */
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#if defined(__linux__) && ! defined(__USE_BSD)
+#define __USE_BSD
+#endif
+#include <string.h>
+
+#include "errhandler.h"
+#include "strsubvocab.h"
+#include "usersymbols.h"
+#include "scanner.h"
+
+
+/* **************************************************************************
+ *
+ *              Internal Static Variables
+ *      user_symbol_list          Pointer to the "tail" of the list of
+ *                                    user-defined symbols.
+ *      user_symbol_count         Count of how many are defined
+ *
+ **************************************************************************** */
+
+static str_sub_vocab_t *user_symbol_list = NULL;
+static int user_symbol_count = 0;
+
+/* **************************************************************************
+ *
+ *      Function name:  add_user_symbol
+ *      Synopsis:       Add a user-defined symbol to the list
+ *
+ *      Inputs:
+ *         Parameters:
+ *             raw_symb             The string as supplied on the command-line.
+ *         Local Static Variables:
+ *             user_symbol_list     Pointer to the list of user-defined symbols.
+ *
+ *      Outputs:
+ *         Returned Value:                NONE
+ *         Local Static Variables:
+ *             user_symbol_list     Will be updated.
+ *             user_symbol_count    Will be incremented
+ *         Memory Allocated:
+ *             for the string(s) and the new entry
+ *         When Freed?
+ *             Never.  Well, only on termination of the program.  User-defined
+ *                 symbols endure for the entire batch of tokenizations.
+ *
+ *      Process Explanation:
+ *          The string in  raw_symb  may or may not include the optional
+ *              equal-sign and value pair.  If the equal-sign is present,
+ *              the remainder of the string will become the "value" that
+ *              will be returned by the "lookup" routine.
+ *          Memory for the name string and for the value, if there is one,
+ *              will be allocated here, in one step.  Memory for the data
+ *              structure itself will be allocated by the support routine.
+ *
+ **************************************************************************** */
+
+void add_user_symbol(char *raw_symb)
+{
+    char *symb_nam;
+    char *symb_valu;
+
+    symb_nam = strdup(raw_symb);
+    symb_valu = strchr(symb_nam,'=');
+    if ( symb_valu != NULL )
+    {
+	*symb_valu = 0;
+	symb_valu++;
+    }
+    add_str_sub_entry(symb_nam, symb_valu, &user_symbol_list );
+    user_symbol_count++;
+}
+
+
+/* **************************************************************************
+ *
+ *      Function name:  lookup_user_symbol
+ *      Synopsis:       Look for the given name as user-defined symbol, return
+ *                          the assigned value.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             symb_nam             The name for which to look.
+ *         Local Static Variables:
+ *             user_symbol_list     Pointer to the list of user-defined symbols.
+ *
+ *      Outputs:
+ *         Returned Value:          Pointer to the "value" string, or NULL
+ *                                      pointer if the name was not found.
+ *                                  May also be NULL if "value" is NULL.
+ *
+ **************************************************************************** */
+ 
+char *lookup_user_symbol(char *symb_nam)
+{
+    char *symb_valu;
+
+    symb_valu = lookup_str_sub(symb_nam, user_symbol_list );
+    return (symb_valu);
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  exists_as_user_symbol
+ *      Synopsis:       Confirm whether a given name exists
+ *                      as a user-defined symbol.
+ *
+ *      Inputs:
+ *         Parameters:
+ *             symb_nam             The name for which to look.
+ *         Local Static Variables:
+ *             user_symbol_list     Pointer to the list of user-defined symbols.
+ *
+ *      Outputs:
+ *         Returned Value:      TRUE if the name is found
+ *
+ **************************************************************************** */
+
+bool exists_as_user_symbol(char *symb_nam)
+{
+    bool retval;
+
+    retval = exists_in_str_sub(symb_nam, user_symbol_list );
+    return (retval);
+}
+
+/* **************************************************************************
+ *
+ *      Function name:  eval_user_symbol
+ *      Synopsis:       Tokenize the value assigned to a user-symbol.
+ *
+ *      Associated Tokenizer directive (synonyms):      [DEFINED]
+ *                                                      #DEFINED
+ *                                                      [#DEFINED]
+ *
+ *      Syntax Notes:
+ *          (1)  The User-Defined-Symbol must appear
+ *                   on the same line as the directive.
+ *          (2)  This is not (yet) implemented in contexts that
+ *                   directly read input from the stream, e.g.,
+ *                   after  [']  or after  H#  etc.
+ *
+ *      Inputs:
+ *         Parameters:       
+ *             symbol               The User-Defined-Symbol to evaluate
+ *         Local Static Variables:
+ *             user_symbol_list     Pointer to the list of user-defined symbols.
+ *
+ *      Outputs:
+ *         Returned Value:          NONE
+ *         The assigned value will be tokenized.
+ *
+ *      Error Detection:
+ *          Calling routine is responsible for verifying that the user-symbol
+ *              is on the same line as the directive.
+ *          WARNING if the symbol is not found or has no assigned value. 
+ *
+ *      Process Explanation:
+ *          Look up the parameter in the User Symbol List, and retrieve
+ *              its associated value.
+ *          If it is not found, or if it has no associated value, issue
+ *              a WARNING and do nothing further.  Otherwise...
+ *          Interpret the associated value as though it were source.
+ *
+ *      Still to be done:
+ *          Hook-in this routine to the processing of:  [']  F[']  H#  FLOAD
+ *              etc., and wherever else it might be needed or useful.
+ *
+ **************************************************************************** */
+
+void eval_user_symbol(char *symbol )
+{
+    char *symb_valu;
+    symb_valu = lookup_user_symbol(symbol );
+    if ( symb_valu == NULL )
+    {
+        tokenization_error ( WARNING,
+	    "No value assigned to command-line symbol %s\n", symbol );
+    }else{
+	eval_string( symb_valu );
+    }
+
+}
+/* **************************************************************************
+ *
+ *      Function name:  list_user_symbols
+ *      Synopsis:       Print the list of user symbols for the Logfile.
+ *      
+ *      Inputs:
+ *         Parameters:              NONE
+ *         Local Static Variables:
+ *             user_symbol_list     Pointer to the list of user-defined symbols.
+ *             user_symbol_count    Count of user-defined symbols.
+ *
+ *      Outputs:
+ *         Returned Value:          NONE
+ *         Printout:                List of user symbols and their definitions;
+ *                                      nothing if user_symbol_list is NULL.
+ *
+ *      Process Explanation:
+ *          We want to display the symbols in the same order they were created.
+ *          We will:
+ *              Allocate a temporary array of pointers.
+ *              Step backwards through the linked-list of symbols, and
+ *                  enter their pointers into the array.
+ *              Collect the maximum length of the symbol names.
+ *              Step through the array in the reverse order, printing
+ *                  as we go.
+ *                  Use the max name length to space the equal-signs evenly 
+ *              Free the temporary array.
+ *
+ **************************************************************************** */
+
+void list_user_symbols(void )
+{
+    str_sub_vocab_t *curr;
+
+    if ( user_symbol_list != NULL )
+    {
+	/*  Collect the pointers and max length  */
+	str_sub_vocab_t **symb_ptr;
+	int indx = 0;
+	int maxlen = 0;
+	
+	symb_ptr = (str_sub_vocab_t **)safe_malloc(
+	   (sizeof(str_sub_vocab_t *) * user_symbol_count),
+	       "collecting user-symbol pointers" );
+	
+	for (curr = user_symbol_list ; curr != NULL ; curr=curr->next)
+	{
+            symb_ptr[indx] = curr;
+	    indx++;
+	    if ( strlen(curr->name) > maxlen ) maxlen = strlen(curr->name);
+	}
+	
+	/*  Now print 'em out  */
+	printf("\nUser-Defined Symbols:\n");
+	while ( indx > 0 )
+	{
+	    indx--;
+	    curr = symb_ptr[indx];
+	    printf("\t%s",curr->name);
+	    if ( curr->alias != NULL )
+	    {
+	        int strindx;
+		for ( strindx = strlen(curr->name) ;
+		      strindx < maxlen ; strindx++ ) printf(" ");
+		printf(" = %s",curr->alias);
+	    }
+	    printf("\n");
+	}
+	free(symb_ptr);
+    }
+}
diff --git a/toke/usersymbols.h b/toke/usersymbols.h
new file mode 100644
index 0000000..26d2869
--- /dev/null
+++ b/toke/usersymbols.h
@@ -0,0 +1,46 @@
+#ifndef _TOKE_USERSYMBOLS_H
+#define _TOKE_USERSYMBOLS_H
+
+
+/*
+ *                     OpenBIOS - free your system!
+ *                         ( FCode tokenizer )
+ *
+ *  This program is part of a free implementation of the IEEE 1275-1994
+ *  Standard for Boot (Initialization Configuration) Firmware.
+ *
+ *  Copyright (C) 2001-2005 Stefan Reinauer, <stepan@openbios.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ *
+ */
+
+/* **************************************************************************
+ *
+ *      Prototype/External Declarations for general-purpose functions
+ *          for support of User-defined command-line compilation-control
+ *          symbols, as defined in  usersymbols.c
+ *
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Module Author:  David L. Paktor    dlpaktor@us.ibm.com
+ *
+ **************************************************************************** */
+
+void add_user_symbol(char *raw_symb);
+char *lookup_user_symbol(char *symb_nam);
+bool exists_as_user_symbol(char *symb_nam);
+void eval_user_symbol(char *symbol );
+void list_user_symbols(void );
+
+#endif   /* _TOKE_USERSYMBOLS_H    */
diff --git a/toke/vocabfuncts.h b/toke/vocabfuncts.h
new file mode 100644
index 0000000..eb46e79
--- /dev/null
+++ b/toke/vocabfuncts.h
@@ -0,0 +1,92 @@
+#ifndef _TOKE_VOCABFUNCTS_H
+#define _TOKE_VOCABFUNCTS_H
+
+/*
+ *                     OpenBIOS - free your system!
+ *                         ( FCode tokenizer )
+ *
+ *  This program is part of a free implementation of the IEEE 1275-1994
+ *  Standard for Boot (Initialization Configuration) Firmware.
+ *
+ *  Copyright (C) 2001-2005 Stefan Reinauer, <stepan@openbios.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ *
+ */
+
+/* **************************************************************************
+ *
+ *      External/Prototype definitions for Vocabulary functions
+ *           in dictionary.c for Tokenizer
+ *
+ *      (C) Copyright 2005 IBM Corporation.  All Rights Reserved.
+ *      Module Author:  David L. Paktor    dlpaktor@us.ibm.com
+ *
+ **************************************************************************** */
+
+
+#include "types.h"
+#include "ticvocab.h"
+
+
+/* ************************************************************************** *
+ *
+ *      Global Variables Exported
+ *
+ **************************************************************************** */
+
+extern bool scope_is_global;
+
+/* ************************************************************************** *
+ *
+ *      Function Prototypes / Functions Exported:
+ *
+ **************************************************************************** */
+
+
+tic_hdr_t *lookup_core_word( char *tname);
+bool exists_in_core( char *name);
+bool handle_core_word( char *tname );
+bool create_core_alias( char *new_name, char *old_name);
+
+void enter_global_scope( void );
+void resume_device_scope( void );
+
+tic_hdr_t *lookup_current( char *name);
+bool exists_in_current( char *tname);
+bool handle_current( char *tname );
+tic_hdr_t *lookup_in_dev_node( char *tname);
+void add_to_current( char *name,
+                           TIC_P_DEFLT_TYPE fc_token,
+			       fwtoken definer,
+			           bool define_token);
+void hide_last_colon ( void );
+void reveal_last_colon ( void );
+bool create_current_alias( char *new_name, char *old_name );
+
+void emit_token( const char *fc_name);
+tic_hdr_t *lookup_token( char *tname);
+bool entry_is_token( tic_hdr_t *test_entry );
+void token_entry_warning( tic_hdr_t *t_entry);
+
+tic_hdr_t *lookup_shared_word( char *tname);
+bool handle_shared_word( char *tname );
+tic_hdr_t *lookup_shared_f_exec_word( char *tname);
+
+void init_dictionary( void );
+void reset_normal_vocabs( void );
+void reset_vocabs( void );
+
+
+#endif   /*  _TOKE_VOCABFUNCTS_H    */