openbios/fcode-utils/toke/toke.c

• Show log

  Commit

• Hash : d89219a0
  Author :
  Date : 2017-06-08T18:57:07
  

  Update contact information Remove obsolete email addresses and add OpenBIOS mailing list information. Signed-off-by: Stefan Reinauer <stefan.reinauer@coreboot.org>

Download

• toke/toke.c

• /*
   *                     OpenBIOS - free your system! 
   *                         ( FCode tokenizer )
   *                          
   *  toke.c - main tokenizer loop and parameter parsing.
   *  
   *  This program is part of a free implementation of the IEEE 1275-1994 
   *  Standard for Boot (Initialization Configuration) Firmware.
   *
   *  Copyright (C) 2001-2010 by Stefan Reinauer
   *
   *  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
   *
   */
  
  /* **************************************************************************
   *         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>
  #endif
  
  #include "types.h"
  #include "toke.h"
  #include "stream.h"
  #include "stack.h"
  #include "emit.h"
  
  #define TOKE_VERSION "1.0.3"
  
  #include "vocabfuncts.h"
  #include "scanner.h"
  #include "errhandler.h"
  #include "usersymbols.h"
  #include "clflags.h"
  #include "tracesyms.h"
  
  #define CORE_COPYR   "(C) Copyright 2001-2010 Stefan Reinauer.\n" \
  		     "(C) Copyright 2006 coresystems GmbH"
  #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 - FCode 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 v2. "
  		"This 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] [-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");
  }
  
  /* **************************************************************************
   *
   *      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="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' },
  			{ "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 }
  		};
  
  		c = getopt_long (argc, argv, optstring,
  				 long_options, &option_index);
  #else
  		c = getopt (argc, argv, optstring);
  #endif
  		if (c == -1)
  			break;
  
  		argindx++;
  		switch (c) {
  		case 'v':
  			verbose=TRUE;
  			break;
  		case 'o':
  			outputname = optarg;
  			break;
  		case 'i':
  			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 'H':
  			 help_mssg = TRUE;		
  			break;
  		default:
  			/*  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]);
  			exit( 1 );
  		}
  	}
  
  	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 ( inval_opt )      printf ("unknown options.\n");
  	if (optind >= argc)   printf ("Input file name missing.\n");
  	if ( inval_opt || (optind >= argc) )
  	{
  		usage(argv[0]);
  	}
  	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();
  	}
  	show_trace_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_error_handler();
  
  	init_stack();
  	init_dictionary();
  
  	init_scanner();
  	
  	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_stream( NULL);
  		if ( close_output() )  retval = 1;
  	    }
  	}
  	
  	exit_scanner();
  	return retval;
  }
  
  

Download