Author: stepan Date: 2006-08-18 14:47:12 +0200 (Fri, 18 Aug 2006) New Revision: 76
Added: fcode-utils/detok/addfcodes.c fcode-utils/detok/addfcodes.h fcode-utils/detok/pcihdr.c fcode-utils/detok/printformats.c fcode-utils/toke/clflags.c fcode-utils/toke/clflags.h fcode-utils/toke/conditl.c fcode-utils/toke/conditl.h fcode-utils/toke/devnode.c fcode-utils/toke/devnode.h fcode-utils/toke/errhandler.c fcode-utils/toke/errhandler.h fcode-utils/toke/flowcontrol.c fcode-utils/toke/flowcontrol.h fcode-utils/toke/macros.h fcode-utils/toke/nextfcode.c fcode-utils/toke/nextfcode.h fcode-utils/toke/parselocals.c fcode-utils/toke/parselocals.h fcode-utils/toke/scanner.h fcode-utils/toke/strsubvocab.c fcode-utils/toke/strsubvocab.h fcode-utils/toke/ticvocab.c fcode-utils/toke/ticvocab.h fcode-utils/toke/tokzesc.c fcode-utils/toke/tokzesc.h fcode-utils/toke/tracesyms.c fcode-utils/toke/tracesyms.h fcode-utils/toke/usersymbols.c fcode-utils/toke/usersymbols.h fcode-utils/toke/vocabfuncts.h Removed: fcode-utils/detok/Rules.make fcode-utils/toke/Rules.make Modified: fcode-utils/detok/Makefile fcode-utils/detok/decode.c fcode-utils/detok/detok.c fcode-utils/detok/detok.h fcode-utils/detok/dictionary.c fcode-utils/detok/stream.c fcode-utils/detok/stream.h fcode-utils/romheaders/Makefile fcode-utils/romheaders/romheaders.c fcode-utils/toke/Makefile fcode-utils/toke/dictionary.c fcode-utils/toke/dictionary.h fcode-utils/toke/emit.c fcode-utils/toke/emit.h fcode-utils/toke/macros.c fcode-utils/toke/scanner.c fcode-utils/toke/stack.c fcode-utils/toke/stack.h fcode-utils/toke/stream.c fcode-utils/toke/stream.h fcode-utils/toke/toke.c fcode-utils/toke/toke.h Log: initial merge of David Paktor's fine work.
I redid all of the Makefiles and fixed some minor issues with the code.
Modified: fcode-utils/detok/Makefile =================================================================== --- fcode-utils/detok/Makefile 2006-08-18 09:45:11 UTC (rev 75) +++ fcode-utils/detok/Makefile 2006-08-18 12:47:12 UTC (rev 76) @@ -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
Deleted: fcode-utils/detok/Rules.make =================================================================== --- fcode-utils/detok/Rules.make 2006-08-18 09:45:11 UTC (rev 75) +++ fcode-utils/detok/Rules.make 2006-08-18 12:47:12 UTC (rev 76) @@ -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" - -
Added: fcode-utils/detok/addfcodes.c =================================================================== --- fcode-utils/detok/addfcodes.c (rev 0) +++ fcode-utils/detok/addfcodes.c 2006-08-18 12:47:12 UTC (rev 76) @@ -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( ¤t_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); +}
Added: fcode-utils/detok/addfcodes.h =================================================================== --- fcode-utils/detok/addfcodes.h (rev 0) +++ fcode-utils/detok/addfcodes.h 2006-08-18 12:47:12 UTC (rev 76) @@ -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 */
Modified: fcode-utils/detok/decode.c =================================================================== --- fcode-utils/detok/decode.c 2006-08-18 09:45:11 UTC (rev 75) +++ fcode-utils/detok/decode.c 2006-08-18 12:47:12 UTC (rev 76) @@ -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 */
-extern u16 fcode; +/* ************************************************************************** + * + * 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... + * + **************************************************************************** */
+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;
-static u8 *unnamed=(u8 *)"(unnamed-fcode)"; +jmp_buf eof_exception;
-void pretty_string(u8 *string) +static int fclen; +static const char *unnamed = "(unnamed-fcode)" ; + +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();
+ output_token(); offs=get_offset(); - output_token(); - printf("0x%x\n",offs); + + /* 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 @@ { 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); + string=get_name(&len); + token = next_token(); + printf("%s 0x%03x\n", string, token); + add_token(token,string); }
-static void external_token(void) +static void bquote(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); -} - -static void bquote(void) -{ - u8 *string; - - /* get forth string ( [len] [char0] ... [charn] ) */ - string=get_string(); - output_token(); - pretty_string(string); + pretty_print_string(); printf("\n"); - free(string); }
static void blit(void) { u32 lit;
+ output_token(); lit=get_num32(); - output_token(); printf("0x%x\n",lit); }
@@ -204,56 +410,81 @@ 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 @@ case 0x0c2: /* b(;) */ case 0x0b2: /* b(>resolve) */ case 0x0c5: /* b(endcase) */ + indent--; decode_default(); - indent--; break; case 0x015: /* b(loop) */ case 0x016: /* b(+loop) */ case 0x0c6: /* b(endof) */ + indent--; decode_offset(); - indent--; break; case 0x017: /* b(do) */ case 0x018: /* b/?do) */ @@ -295,38 +526,274 @@ 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 ); } } +}
-int detokenize(void) +/* ************************************************************************** + * + * 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. + * + **************************************************************************** */ + +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 ); + } +}
- decode_lines(); - printf ("\ detokenizing finished after %d of %d bytes.\n", - get_streampos(), fclen ); +/* ************************************************************************** + * + * 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. + * + **************************************************************************** */
- return 0; +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(); + + } + } + + +}
Modified: fcode-utils/detok/detok.c =================================================================== --- fcode-utils/detok/detok.c 2006-08-18 09:45:11 UTC (rev 75) +++ fcode-utils/detok/detok.c 2006-08-18 12:47:12 UTC (rev 76) @@ -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 @@ { "all", 0, 0, 'a' }, { "linenumbers", 0, 0, 'n' }, { "offsets", 0, 0, 'o' }, + { "fcodes", 1, 0, 'f' }, { 0, 0, 0, 0 } };
@@ -99,24 +118,31 @@
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 @@ }
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 @@ init_dictionary(); + if ( add_vfcodes ) + { + if ( add_fcodes_from_list( vfc_filnam) ) + { + freeze_dictionary(); + } + } + while (optind < argc) { if (init_stream(argv[optind])) {
Modified: fcode-utils/detok/detok.h =================================================================== --- fcode-utils/detok/detok.h 2006-08-18 09:45:11 UTC (rev 75) +++ fcode-utils/detok/detok.h 2006-08-18 12:47:12 UTC (rev 76) @@ -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 */
Modified: fcode-utils/detok/dictionary.c =================================================================== --- fcode-utils/detok/dictionary.c 2006-08-18 09:45:11 UTC (rev 75) +++ fcode-utils/detok/dictionary.c 2006-08-18 12:47:12 UTC (rev 76) @@ -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 @@ 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 @@ 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; +}
Added: fcode-utils/detok/pcihdr.c =================================================================== --- fcode-utils/detok/pcihdr.c (rev 0) +++ fcode-utils/detok/pcihdr.c 2006-08-18 12:47:12 UTC (rev 76) @@ -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 ); +}
Added: fcode-utils/detok/printformats.c =================================================================== --- fcode-utils/detok/printformats.c (rev 0) +++ fcode-utils/detok/printformats.c 2006-08-18 12:47:12 UTC (rev 76) @@ -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) ; +} +
Modified: fcode-utils/detok/stream.c =================================================================== --- fcode-utils/detok/stream.c 2006-08-18 09:45:11 UTC (rev 75) +++ fcode-utils/detok/stream.c 2006-08-18 12:47:12 UTC (rev 76) @@ -24,20 +24,60 @@ * */
+/* ************************************************************************** + * 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 bool offs16; -extern u32 fcpos; +extern jmp_buf eof_exception;
+/* ************************************************************************** + * + * 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;
-static u8 *indata, *pc, *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;
+ int init_stream(char *name) { FILE *infile; @@ -62,119 +102,455 @@ 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 (get_num8()); + 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. + * + **************************************************************************** */
-int scnt=0; -u8 *get_string(void) +u8 *get_string(u8 *len) { - u8 *data; - u8 size; - unsigned int i; + char *retval; + + *len = get_num8(); + retval = get_bytes((int)*len);
- get_byte(); - size=inbyte; + return (retval); +}
- scnt++;
- data=malloc(size+2); - if (!data) printf ("No more memory.\n"); - data[0]=size; +/* ************************************************************************** + * + * 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) +{ + char *str_start; + char *retval; + u8 sav_byt;
- for (i=1; i<size+1; i++) { - get_byte(); - data[i]=inbyte; + str_start = get_string( len ); + + sav_byt = *pc; + *pc = 0; + + retval = strdup(str_start); + *pc = sav_byt; + + 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; + } +}
Modified: fcode-utils/detok/stream.h =================================================================== --- fcode-utils/detok/stream.h 2006-08-18 09:45:11 UTC (rev 75) +++ fcode-utils/detok/stream.h 2006-08-18 12:47:12 UTC (rev 76) @@ -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 */
Modified: fcode-utils/romheaders/Makefile =================================================================== --- fcode-utils/romheaders/Makefile 2006-08-18 09:45:11 UTC (rev 75) +++ fcode-utils/romheaders/Makefile 2006-08-18 12:47:12 UTC (rev 76) @@ -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
-.SUFFIXES: .c .o +SOURCES = romheaders.c ../shared/classcodes.c
+.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
Modified: fcode-utils/romheaders/romheaders.c =================================================================== --- fcode-utils/romheaders/romheaders.c 2006-08-18 09:45:11 UTC (rev 75) +++ fcode-utils/romheaders/romheaders.c 2006-08-18 12:47:12 UTC (rev 76) @@ -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 +#include "pcihdr.h"
-#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; - 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);
-/* dump the rom headers */ +/* 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); + */ + 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 @@ } 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 @@ 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 @@
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 @@ 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; }
Modified: fcode-utils/toke/Makefile =================================================================== --- fcode-utils/toke/Makefile 2006-08-18 09:45:11 UTC (rev 75) +++ fcode-utils/toke/Makefile 2006-08-18 12:47:12 UTC (rev 76) @@ -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
-include $(TOPDIR)/Rules.make +CC = gcc +STRIP = strip +INCLUDES = -I../shared +#CFLAGS = -O2 -g -Wall +CFLAGS = -Os -Wall -Wno-pointer-sign -DSYS_IS_GNU_Linux +LDFLAGS =
-CC = gcc -CFLAGS = -O2 -Wall -W -ansi -pedantic -# CFLAGS = -O -g -Wall -ansi -pedantic +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
-# CFLAGS := $(CFLAGS) -DDEBUG_SCANNER -# CFLAGS := $(CFLAGS) -DDEBUG_DSTACK +all: .dependencies $(PROGRAM)
-OBJECTS= toke.o stack.o stream.o dictionary.o macros.o scanner.o emit.o +$(PROGRAM): $(OBJS) + $(CC) -o $(PROGRAM) $(OBJS) $(LDFLAGS) + $(STRIP) -s $(PROGRAM)
-.SUFFIXES: .c .o +clean: + rm -f $(OBJS) *~
-all: main toke - @cd $(BUILDDIR) && strip toke - @echo -e "\nOpenBIOS tokenizer toke build finished\n" +distclean: clean + rm -f $(PROGRAM) .dependencies + +.dependencies: *.c + @$(CC) $(CFLAGS) $(INCLUDES) -MM *.c > .dependencies
-# 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)" ) +.PHONY: all clean distclean
-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 \ - ) +-include .dependencies
-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 +.c.o: + $(CC) -c $(CFLAGS) $(INCLUDES) $< -o $@ +
Deleted: fcode-utils/toke/Rules.make =================================================================== --- fcode-utils/toke/Rules.make 2006-08-18 09:45:11 UTC (rev 75) +++ fcode-utils/toke/Rules.make 2006-08-18 12:47:12 UTC (rev 76) @@ -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" - -
Added: fcode-utils/toke/clflags.c =================================================================== --- fcode-utils/toke/clflags.c (rev 0) +++ fcode-utils/toke/clflags.c 2006-08-18 12:47:12 UTC (rev 76) @@ -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; + } +}
Added: fcode-utils/toke/clflags.h =================================================================== --- fcode-utils/toke/clflags.h (rev 0) +++ fcode-utils/toke/clflags.h 2006-08-18 12:47:12 UTC (rev 76) @@ -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 */
Added: fcode-utils/toke/conditl.c =================================================================== --- fcode-utils/toke/conditl.c (rev 0) +++ fcode-utils/toke/conditl.c 2006-08-18 12:47:12 UTC (rev 76) @@ -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 ); +} +
Added: fcode-utils/toke/conditl.h =================================================================== --- fcode-utils/toke/conditl.h (rev 0) +++ fcode-utils/toke/conditl.h 2006-08-18 12:47:12 UTC (rev 76) @@ -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 */
Added: fcode-utils/toke/devnode.c =================================================================== --- fcode-utils/toke/devnode.c (rev 0) +++ fcode-utils/toke/devnode.c 2006-08-18 12:47:12 UTC (rev 76) @@ -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 ); +}
Added: fcode-utils/toke/devnode.h =================================================================== --- fcode-utils/toke/devnode.h (rev 0) +++ fcode-utils/toke/devnode.h 2006-08-18 12:47:12 UTC (rev 76) @@ -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 */
Modified: fcode-utils/toke/dictionary.c =================================================================== --- fcode-utils/toke/dictionary.c 2006-08-18 09:45:11 UTC (rev 75) +++ fcode-utils/toke/dictionary.c 2006-08-18 12:47:12 UTC (rev 76) @@ -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"
-typedef struct token { - u8 *name; - u16 fcode; - struct token *next; -} token_t; +/* ************************************************************************** + * + * 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. + * + **************************************************************************** */
-static token_t *dictionary=NULL; -static token_t *forthwords=NULL;
-static u16 lookup_token_dict(char *name, token_t *dict) + +/* ************************************************************************** + * + * 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. */ + + +/* ************************************************************************** + * + * 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. + * + **************************************************************************** */ + +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 ) ; }
-u16 lookup_token(char *name) +/* ************************************************************************** + * + * 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 lookup_token_dict(name, dictionary); + return exists_in_tic_vocab( name, global_voc_dict_ptr ); }
-u16 lookup_fword(char *name) +/* ************************************************************************** + * + * 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 ) { - return lookup_token_dict(name, forthwords); + bool retval; + + retval = handle_tic_vocab( tname, global_voc_dict_ptr ); + + return ( retval ) ; }
-static int add_token_dict(u16 number, char *name, token_t **dict) + +/* ************************************************************************** + * + * 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) { - token_t *curr; + bool retval = create_tic_alias( new_name, old_name, &global_voc_dict_ptr); + return ( retval ); +}
- curr=malloc(sizeof(token_t)); - if(!curr) { - printf("Out of memory while adding token.\n"); - exit(-ENOMEM); +/* ************************************************************************** + * + * 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 ) +{ + 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; + } +} + +void resume_device_scope( void ) +{ + 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) ); + } + +} + +/* ************************************************************************** + * + * 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) ) +{ + 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 + * + **************************************************************************** */ + +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 ); + }
-int add_token(u16 number, char *name) + +/* ************************************************************************** + * + * 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) { - return add_token_dict(number, name, &dictionary); + tic_hdr_t *retval = NULL; + + if ( INVERSE(scope_is_global) ) +{ + retval = lookup_tic_entry( tname, *current_definitions); } + return ( retval ); +}
-static int add_special(u16 number, char *name) + +/* ************************************************************************** + * + * 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) { - return add_token_dict(number, name, &forthwords); + 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 init_dictionary(void) + +void hide_last_colon ( 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" ); + 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; + +} + +void reveal_last_colon ( void ) +{ + /* We call this function either when the colon-definition is + * completed, or when "recursive"-ness is intentional. + */ + *current_definitions = save_current ; +} + + +/* ************************************************************************** + * + * 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 ) +{ + 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 ); +} + +/* ************************************************************************** + * + * 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" ); + 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" ) +};
- 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"); +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""); + 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") ,
- add_special(ENCODEFILE, "encode-file"); + /* 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(); +}
Modified: fcode-utils/toke/dictionary.h =================================================================== --- fcode-utils/toke/dictionary.h 2006-08-18 09:45:11 UTC (rev 75) +++ fcode-utils/toke/dictionary.h 2006-08-18 12:47:12 UTC (rev 76) @@ -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 +/* ************************************************************************** + * 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 END0 0xdb -#define END1 0xdc -#define CHAR 0xdd -#define CCHAR 0xde -#define ABORTTXT 0xdf +/* ************************************************************************** + * + * 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. + * + **************************************************************************** */
-#define NEXTFCODE 0xef +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 ,
-#define ENCODEFILE 0xf0 + ret_stk_from , + ASC_NUM , /* Convert char seq to number */ + ASC_LEFT_NUM , /* same, only left-justified. */
-#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 + 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 */
Modified: fcode-utils/toke/emit.c =================================================================== --- fcode-utils/toke/emit.c 2006-08-18 09:45:11 UTC (rev 75) +++ fcode-utils/toke/emit.c 2006-08-18 12:47:12 UTC (rev 76) @@ -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"
-extern bool offs16; -extern int verbose; -extern u8 *ostart, *opc, *oend; +/* ************************************************************************** + * + * Global Variables Imported + * verbose Enable optional messages, set by "-v" switch + * noerrors "Ignore Errors" flag, set by "-i" switch + * + **************************************************************************** */
-/* PCI data */ -extern u16 pci_vpd, pci_revision; -extern bool pci_is_last_image;
-/* header pointers */ -extern u8 *fcode_hdr; -extern u8 *pci_hdr; +/* ************************************************************************** + * + * Macro to zero-fill a field of the size of the given structure + * into the Output Buffer using the emit_byte() routine. + * + **************************************************************************** */
-extern bool haveend; +#define EMIT_STRUCT(x) {int j; for (j=0; j < sizeof(x) ; j++ ) emit_byte(0); }
-u16 lookup_token(char *name);
-static bool little_endian(void) +/* ************************************************************************** + * + * 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 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) -{ - 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); - } +/* ************************************************************************** + * + * 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. + * + **************************************************************************** */
- /* move pointers */ - opc=newout+(opc-ostart); - ostart=newout; - oend=ostart+newsize; +static void emit_byte(u8 data) +{ + if ( opc == olen) + { + increase_output_buffer(); } - *opc=data; + + *(ostart+opc) = data ; opc++; - - return 0; }
-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) +static void emit_num32(u32 num) { - return emit_fcode(lookup_token((char *)name)); -} - -int 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) +/* ************************************************************************** + * + * 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. + * + **************************************************************************** */ + +void user_emit_byte(u8 data) { - emit_byte(num>>8); - emit_byte(num&0xff); - - return 0; + 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 ; + }
- /* len */ - emit_num32(0); + fcode_header_t *fcode_hdr;
- return 0; + fcode_start_ob_off = opc; + emit_token( starter_name ); + + fcode_hdr_ob_off = opc; + fcode_hdr = (fcode_header_t *)(ostart+fcode_hdr_ob_off); + + EMIT_STRUCT(fcode_header_t); + + fcode_body_ob_off = opc; + + /* Format = 8 means we comply with IEEE 1275-1994 */ + fcode_hdr->format = 0x08; + }
-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]; + length = opc - fcode_start_ob_off;
- dpush((unsigned long)opc); - opc=fcode_hdr+1; - emit_num16(checksum); - emit_num32(len); - opc=(u8 *)dpop(); + 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); + /* 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: + */
- /* 20 bytes of padding */ - for (i=0; i<20; i++) emit_byte(0x00); + 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); + emit_pci_rom_hdr();
- return 0; + 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); + LITTLE_ENDIAN_WORD_STORE(pci_data_blk->vpd, pci_vpd);
- /* 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); + /* 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(); }
Modified: fcode-utils/toke/emit.h =================================================================== --- fcode-utils/toke/emit.h 2006-08-18 09:45:11 UTC (rev 75) +++ fcode-utils/toke/emit.h 2006-08-18 12:47:12 UTC (rev 76) @@ -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 +/* ************************************************************************** + * 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"
-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); +/* ************************************************************************** + * 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 */
Added: fcode-utils/toke/errhandler.c =================================================================== --- fcode-utils/toke/errhandler.c (rev 0) +++ fcode-utils/toke/errhandler.c 2006-08-18 12:47:12 UTC (rev 76) @@ -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 ); +} +
Added: fcode-utils/toke/errhandler.h =================================================================== --- fcode-utils/toke/errhandler.h (rev 0) +++ fcode-utils/toke/errhandler.h 2006-08-18 12:47:12 UTC (rev 76) @@ -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 */
Added: fcode-utils/toke/flowcontrol.c =================================================================== --- fcode-utils/toke/flowcontrol.c (rev 0) +++ fcode-utils/toke/flowcontrol.c 2006-08-18 12:47:12 UTC (rev 76) @@ -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); +}
Added: fcode-utils/toke/flowcontrol.h =================================================================== --- fcode-utils/toke/flowcontrol.h (rev 0) +++ fcode-utils/toke/flowcontrol.h 2006-08-18 12:47:12 UTC (rev 76) @@ -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 */
Modified: fcode-utils/toke/macros.c =================================================================== --- fcode-utils/toke/macros.c 2006-08-18 09:45:11 UTC (rev 75) +++ fcode-utils/toke/macros.c 2006-08-18 12:47:12 UTC (rev 76) @@ -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); +}
- return curr?(char *)curr->alias:NULL; + +/* ************************************************************************** + * + * 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 ; + + +/* ************************************************************************** + * + * 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
- macros=curr; - return 0; +/* ************************************************************************** + * + * Initialization macro definition + * + **************************************************************************** */ + +#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#>"); + if ( failure ) + { + tokenization_error( TKERROR, + "%s directive expects name and definition on the same line\n", + strupr(func_cpy)); + } + free( func_cpy); +}
- /* 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"); + +/* ************************************************************************** + * + * 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); + +}
Added: fcode-utils/toke/macros.h =================================================================== --- fcode-utils/toke/macros.h (rev 0) +++ fcode-utils/toke/macros.h 2006-08-18 12:47:12 UTC (rev 76) @@ -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 */
Added: fcode-utils/toke/nextfcode.c =================================================================== --- fcode-utils/toke/nextfcode.c (rev 0) +++ fcode-utils/toke/nextfcode.c 2006-08-18 12:47:12 UTC (rev 76) @@ -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++; +}
Added: fcode-utils/toke/nextfcode.h =================================================================== --- fcode-utils/toke/nextfcode.h (rev 0) +++ fcode-utils/toke/nextfcode.h 2006-08-18 12:47:12 UTC (rev 76) @@ -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 */
Added: fcode-utils/toke/parselocals.c =================================================================== --- fcode-utils/toke/parselocals.c (rev 0) +++ fcode-utils/toke/parselocals.c 2006-08-18 12:47:12 UTC (rev 76) @@ -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; + } +}
Added: fcode-utils/toke/parselocals.h =================================================================== --- fcode-utils/toke/parselocals.h (rev 0) +++ fcode-utils/toke/parselocals.h 2006-08-18 12:47:12 UTC (rev 76) @@ -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 */
Modified: fcode-utils/toke/scanner.c =================================================================== --- fcode-utils/toke/scanner.c 2006-08-18 09:45:11 UTC (rev 75) +++ fcode-utils/toke/scanner.c 2006-08-18 12:47:12 UTC (rev 76) @@ -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) +#include "parselocals.h"
-extern u8 *start, *pc, *end, *opc, *ostart; -extern int verbose, noerrors; +/* ************************************************************************** + * + * Some VERY IMPORTANT global variables follow + * + **************************************************************************** */
-u8 *statbuf=NULL; -u16 nextfcode; -u8 base=0x0a; +u8 *statbuf=NULL; /* The word just read from the input stream */ +u8 base=0x0a; /* The numeric-interpretation base */
-/* header pointers */ -u8 *fcode_hdr=NULL; -u8 *pci_hdr=NULL; - /* 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; +}
- return str; + +/* ************************************************************************** + * + * 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; }
-static unsigned long get_word(void) +/* ************************************************************************** + * + * 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 ; + + drop_source(); + } + return( retval); +} + + +/* ************************************************************************** + * + * 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;
- pc=skipws(pc); - if (pc>=end) + if ( need_to_pop_source ) + { + pop_result = pop_source(); + } + + 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 @@ 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];
- len=(unsigned long)pc-(unsigned long)safe; - if (len>1023) { - printf("%s:%d: error: buffer overflow\n", iname, lineno); - ERROR; + /* 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. + * + **************************************************************************** */ + +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,265 +963,3486 @@ *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 ) { - u8 val, pval[3]; + 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) +{ + 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); + }
- for(;;) { - while (!isxdigit(*pc) && (*pc) != ')') - pc++; + 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--; + }
- pval[0]=*pc; - if (pval[0]==')') - break; + } /* End of the "default" clause */ + } /* End of the "switch" statement */
- pc++; /* this cannot be a \n */ + if ( write_val ) add_byte_to_string( val, walk );
- 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'; + } + /* Pick up the next char after the '"' (Quote) */ + c=*pc; + switch (c) + { + case '(': + pc++; /* skip the '(' */ + run = get_sequence(&walk); 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++; - 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); } - if (*pc++=='\n') lineno++; + /* 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; + } + } } - *(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>255?255:len; + return len ; }
-static int get_number(long *result) + +/* ************************************************************************** + * + * 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 ) { - u8 lbase, *until; - long val; + 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";
- lbase=intok?0x10:base; - val=parse_number(statbuf,&until, lbase); + 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 + * + **************************************************************************** */ + +void skip_user_message( tic_param_t pfield ) +{ + char delim = (char)pfield.deflt_elem ; + handle_user_message( delim, FALSE); +} + + + +/* ************************************************************************** + * + * 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 *until; + long val; + bool retval = FALSE ; + + 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 int create_word(void) +static void set_hdr_flag( headeredness new_flag) { - unsigned long wlen; + 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... */ + }
- if (incolon) { - printf("%s:%d: error: creating words not allowed " - "in colon definition.\n", iname, lineno); - ERROR; + 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. + * + **************************************************************************** */ + +void init_scan_state( void) +{ + 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. + * + **************************************************************************** */ + +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."; } + 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 ); +} + +/* ************************************************************************** + * + * 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(); + + 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 num_encoded=0; - wlen=get_word(); - name=strdup((char *)statbuf); + 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); + } +} + +/* ************************************************************************** + * + * 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... + * + **************************************************************************** */ + +void check_name_length( signed long wlen ) +{ + 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" ); + } + +} + + +/* ************************************************************************** + * + * 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 - 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"); + 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" ); + } - emit_fcode(nextfcode); - nextfcode++; + +/* ************************************************************************** + * + * 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;
- return 0; + 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 ); +}
-static void encode_file( const char *filename ) + +/* ************************************************************************** + * + * 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 ) { - FILE *f; - size_t s; - int i=0; + 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); - if( !(f=fopen(filename,"rb")) ) { - printf("%s:%d: opening '%s':\n", iname, lineno, filename ); - ERROR; - return; + /* + * 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); + } } - while( (s=fread(statbuf, 1, 255, f)) ) { - emit_token("b(")"); - emit_string(statbuf, s); - emit_token("encode-bytes"); - if( i++ ) - emit_token("encode+"); + }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); } - fclose( f ); + 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 void handle_internal(u16 tok) +static bool string_err_check( bool is_paren, + unsigned int sav_lineno, + unsigned int strt_lineno ) { - unsigned long wlen; - long offs1,offs2; - u16 itok; + 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", @@ -443,727 +4450,1087 @@ #endif switch (tok) { case BEGIN: - emit_token("b(<mark)"); - dpush((unsigned long)opc); + emit_begin(); break;
case BUFFER: - create_word(); + if ( create_word(tok) ) + { emit_token("b(buffer:)"); + } break;
case CONST: - create_word(); + 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); + emit_endcase(); + break;
- /* 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(); + case NEW_DEVICE: + handy_toggle = FALSE; + case FINISH_DEVICE: + finish_or_new_device( handy_toggle ); + break;
- offs2=(unsigned long)offs1-(unsigned long)opc; - -#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)"); + emit_endof(); + break; - 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); - - 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;
- case CLEAVE: +/* ************************************************************************** + * + * 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 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; + resolve_loop(); 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; + + 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 ILINE_NUM: + emit_literal( lineno); + break; + case HEXVAL: - { - u8 basecpy=base; - long val; - - 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; - } + 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 EMITBYTE: - if (intok) - emit_byte(dpop()); - else - printf ("%s:%d: warning: emit-byte outside tokenizer" - " scope\n", iname, lineno); + 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 NEXTFCODE: - if (intok) - nextfcode=dpop(); - else - printf("%s:%d: warning: next-fcode outside tokenizer" - " scope\n", iname, lineno); + case POP_FCODE: + pop_next_fcode(); break; + + 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 ); } + } }
Added: fcode-utils/toke/scanner.h =================================================================== --- fcode-utils/toke/scanner.h (rev 0) +++ fcode-utils/toke/scanner.h 2006-08-18 12:47:12 UTC (rev 76) @@ -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 */
Modified: fcode-utils/toke/stack.c =================================================================== --- fcode-utils/toke/stack.c 2006-08-18 09:45:11 UTC (rev 75) +++ fcode-utils/toke/stack.c 2006-08-18 12:47:12 UTC (rev 76) @@ -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 ); } -#endif
+/* + * 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 ); +} + 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; + long depth;
- size=dpop(); - fstring=(u8 *)dpop(); + 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... + */
- retstring=malloc(size+1); - strncpy((char *)retstring, (const char *)fstring, size); - retstring[size]=0; + return (depth); +}
- return retstring; +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; + } }
+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; + } +}
+
Modified: fcode-utils/toke/stack.h =================================================================== --- fcode-utils/toke/stack.h 2006-08-18 09:45:11 UTC (rev 75) +++ fcode-utils/toke/stack.h 2006-08-18 12:47:12 UTC (rev 76) @@ -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 */
Modified: fcode-utils/toke/stream.c =================================================================== --- fcode-utils/toke/stream.c 2006-08-18 09:45:11 UTC (rev 75) +++ fcode-utils/toke/stream.c 2006-08-18 12:47:12 UTC (rev 76) @@ -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 "emit.h" +#include "stream.h" +#include "errhandler.h" #include "toke.h" -#include "stream.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 */
-unsigned int lineno; +/* 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);
-int init_stream( const char *name) +/* ************************************************************************** + * + * 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 { - FILE *infile; - unsigned int i; + 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; + + +/* ************************************************************************** + * + * 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. + * + **************************************************************************** */ + +void add_to_include_list( char *dir_compt) +{ + 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 ); }
Modified: fcode-utils/toke/stream.h =================================================================== --- fcode-utils/toke/stream.h 2006-08-18 09:45:11 UTC (rev 75) +++ fcode-utils/toke/stream.h 2006-08-18 12:47:12 UTC (rev 76) @@ -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 */
Added: fcode-utils/toke/strsubvocab.c =================================================================== --- fcode-utils/toke/strsubvocab.c (rev 0) +++ fcode-utils/toke/strsubvocab.c 2006-08-18 12:47:12 UTC (rev 76) @@ -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 ; + } +} +
Added: fcode-utils/toke/strsubvocab.h =================================================================== --- fcode-utils/toke/strsubvocab.h (rev 0) +++ fcode-utils/toke/strsubvocab.h 2006-08-18 12:47:12 UTC (rev 76) @@ -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 */
Added: fcode-utils/toke/ticvocab.c =================================================================== --- fcode-utils/toke/ticvocab.c (rev 0) +++ fcode-utils/toke/ticvocab.c 2006-08-18 12:47:12 UTC (rev 76) @@ -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 ; + } +}
Added: fcode-utils/toke/ticvocab.h =================================================================== --- fcode-utils/toke/ticvocab.h (rev 0) +++ fcode-utils/toke/ticvocab.h 2006-08-18 12:47:12 UTC (rev 76) @@ -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 */
Modified: fcode-utils/toke/toke.c =================================================================== --- fcode-utils/toke/toke.c 2006-08-18 09:45:11 UTC (rev 75) +++ fcode-utils/toke/toke.c 2006-08-18 12:47:12 UTC (rev 76) @@ -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"
-int verbose=0; -int noerrors=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; + +/* ************************************************************************** + * + * 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' }, + { "help", 0, 0, 'h' }, { "ignore-errors", 0, 0, 'i' }, - { "help", 0, 0, 'h' }, + { "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 @@ 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 '?': + /* Distinguish between a '?' from the user + * and one getopt() returned + */ + if ( argv[argindx][1] != '?' ) + { + inval_opt = TRUE; + break; + } case 'h': - case '?': - print_copyright(); - usage(argv[0]); - return 0; + 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; }
Modified: fcode-utils/toke/toke.h =================================================================== --- fcode-utils/toke/toke.h 2006-08-18 09:45:11 UTC (rev 75) +++ fcode-utils/toke/toke.h 2006-08-18 12:47:12 UTC (rev 76) @@ -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 */
Added: fcode-utils/toke/tokzesc.c =================================================================== --- fcode-utils/toke/tokzesc.c (rev 0) +++ fcode-utils/toke/tokzesc.c 2006-08-18 12:47:12 UTC (rev 76) @@ -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); +}
Added: fcode-utils/toke/tokzesc.h =================================================================== --- fcode-utils/toke/tokzesc.h (rev 0) +++ fcode-utils/toke/tokzesc.h 2006-08-18 12:47:12 UTC (rev 76) @@ -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 */
Added: fcode-utils/toke/tracesyms.c =================================================================== --- fcode-utils/toke/tracesyms.c (rev 0) +++ fcode-utils/toke/tracesyms.c 2006-08-18 12:47:12 UTC (rev 76) @@ -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. + * + **************************************************************************** */
Added: fcode-utils/toke/tracesyms.h =================================================================== --- fcode-utils/toke/tracesyms.h (rev 0) +++ fcode-utils/toke/tracesyms.h 2006-08-18 12:47:12 UTC (rev 76) @@ -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 */
Added: fcode-utils/toke/usersymbols.c =================================================================== --- fcode-utils/toke/usersymbols.c (rev 0) +++ fcode-utils/toke/usersymbols.c 2006-08-18 12:47:12 UTC (rev 76) @@ -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); + } +}
Added: fcode-utils/toke/usersymbols.h =================================================================== --- fcode-utils/toke/usersymbols.h (rev 0) +++ fcode-utils/toke/usersymbols.h 2006-08-18 12:47:12 UTC (rev 76) @@ -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 */
Added: fcode-utils/toke/vocabfuncts.h =================================================================== --- fcode-utils/toke/vocabfuncts.h (rev 0) +++ fcode-utils/toke/vocabfuncts.h 2006-08-18 12:47:12 UTC (rev 76) @@ -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 */
-
svnï¼ openbios.org