openbios/fcode-utils/detok/addfcodes.c

Branch - branch -master- tag -v1.0.3v1.0.2v1.0.1v1.0.0

• 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

• detok/addfcodes.c

• /*
   *                     OpenBIOS - free your system!
   *                        ( FCode detokenizer )
   *
   *  This program is part of a free implementation of the IEEE 1275-1994
   *  Standard for Boot (Initialization Configuration) Firmware.
   *
   *  Copyright (C) 2001-2010 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
   *
   */
  
  /* **************************************************************************
   *
   *      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.
   *          Mon, 16 Oct 2006 by David L. Paktor
   *              Add "special function" words.  So far, only one added:
   *                   double-literal   Infrastructure will support
   *                  adding others as needed.
   *
   **************************************************************************** */
  
  
  /* **************************************************************************
   *
   *          Global Variables Imported
   *              indata                Buffer into which the file will be read
   *              stream_max            Size of the file buffer.
   *
   **************************************************************************** */
  
  
  /* **************************************************************************
   *
   *          Global Variables Exported :
   *
   *          For "special function" identification, we will need to
   *              export Global Variables, each of which is a pointer
   *              to the address of the FCode field of the entry in
   *              the Special Functions List for that function.
   *              
   *                Variable                 Associated Name
   *              double_lit_code          double-literal
   *
   **************************************************************************** */
  
  #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
   *     spcl_func_list         List of reserved Special Function names
   *     spcl_func_count        Number of reserved Special Function names
   *
   **************************************************************************** */
  
  static char *current_vfc_line;
  static u8 *vfc_remainder;
  static int vfc_line_no = 0;
  static u8 *vfc_buf_end;
  
  /*  Special Functions List  */
  /*  Initial fcode-field value of  -1  guarantees they won't be used  */
  token_t spcl_func_list[]  =  {
  	TOKEN_ENTRY( -1, "double(lit)" ),  /*  Entry  [0]  */
  };
  
  static const int spcl_func_count = (sizeof(spcl_func_list)/sizeof(token_t)) ;
  
  /*  Global Variables for "special function" identification  */
  /*  Each is a pointer to the FCode field of the entry in
   *              the Special Functions List for that function.
   */
  
  u16 *double_lit_code = &spcl_func_list[0].fcode;
  
  
  /* **************************************************************************
   *
   *      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 = (char *)vfc_remainder;
  		vfc_remainder = (u8 *)strchr((const char *)current_vfc_line, '\n');
  		*vfc_remainder = 0;
  		vfc_remainder++;
  		vfc_line_no++;
  		skip_whitespace((char **)&current_vfc_line);
  		if (*current_vfc_line == 0)
  			continue;	/*  Blank line */
  		if (*current_vfc_line == '#')
  			continue;	/*  Comment  */
  		if (*current_vfc_line == '\\')
  			continue;	/*  Comment  */
  		retval = TRUE;
  		break;		/*  Found something  */
  	}
  	return (retval);
  }
  
  /* **************************************************************************
   *
   *      Function name:  vfc_splash
   *      Synopsis:       Print a "splash" message to show that we
   *                          are processing Vendor-Specific FCodes,
   *                          but only once.
   *
   *      Inputs:
   *         Parameters:
   *             vf_file_name            Vendor-Specific FCodes file name
   *         Local Static Variables:
   *             did_not_splash          Control printing; once only.
   *
   *      Outputs:
   *         Returned Value:             None
   *         Local Static Variables:
   *             did_not_splash          FALSE after first call.
   *         Printout:
   *             "Splash" message...
   *
   **************************************************************************** */
  static bool did_not_splash = TRUE;
  static void vfc_splash(char *vf_file_name)
  {
  	if (did_not_splash) {
  		/*  Temporary substring buffer                */
  		/*  Guarantee that the malloc will be big enough.  */
  		char *strbfr = malloc(strlen(vf_file_name) + 65);
  		sprintf(strbfr,
  			"Reading additional FCodes from file:  %s\n",
  			vf_file_name);
  		printremark(strbfr);
  		free(strbfr);
  		did_not_splash = FALSE;
  	}
  }
  
  /* **************************************************************************
   *
   *      Function name:  add_fcodes_from_list
   *      Synopsis:       Add Vendor-Specific FCodes from the named file
   *                          to the permanent resident dictionary.
   *
   *      Inputs:
   *         Parameters:
   *             vf_file_name            Vendor-Specific FCodes file name
   *         Global Variables:
   *             verbose                 "Verbose" flag.
   *             indata                  Start of file buffer
   *             stream_max              Size of the file buffer.
   *
   *      Outputs:
   *         Returned Value:             TRUE if FCodes have actually been added
   *         Global Variables:
   *             check_tok_seq           Cleared to FALSE, then restored to TRUE
   *         Local Static Variables:
   *             vfc_remainder           Initted to start of file buffer
   *             vfc_buf_end             Initted to end of file buffer
   *         Memory Allocated
   *             Permanent copy of FCode Name
   *         When Freed?
   *             Never.  Rmeains until program termination.
   *         Printout:
   *             If verbose, "Splash" line and count of added entries.
   *
   *      Error Detection:
   *          Fail to open or read Vendor-FCodes file -- Exit program
   *          Improperly formatted input line -- print message and ignore
   *          FCode value out of valid range -- print message and ignore
   *          FCode value already in use -- print message and ignore
   *
   *      Process Explanation:
   *          Valid lines are formatted with the FCode number first
   *              and the name after, one entry per line.  Extra text
   *              after the name will be ignored, so an extra "comment"
   *              is permitted.  The FCode number must be in hex, with
   *              an optional leading  0x  or  0X   For example:  0X407
   *          The valid range for the FCode numbers is 0x010 to 0x7ff.
   *              Numbers above 0x800 infringe upon the area 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.
   *          Names may not be longer than 31 characters.
   *          Certain names will be reserved for special functions.
   *              Those names will be entered in the  detok_table 
   *              with a value of  -1  and again in the static 
   *              table associated with this function, below, to
   *              supply the variable that will be used to match
   *              the name with the special function.
   *             
   *
   **************************************************************************** */
  
  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;
  
  		/*  For each line of input, we need to check that we have
  		 *      two strings, one of which is the number and the
  		 *      second of which is the name.  We will check for
  		 *      the various formats allowed for the number
  		 */
  
  		/*    Start with a lower-case  0x    */
  		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;
  		}
  
  		/*    Check if the name is on the "Special Functions List"  */
  		{
  			bool found_spf = FALSE;
  			int indx;
  			for (indx = 0; indx < spcl_func_count; indx++) {
  				if ( strcmp( vs_fc_name, spcl_func_list[indx].name) == 0 ) {
  					char strbuf[64];
  					found_spf = TRUE;
  					spcl_func_list[indx].fcode = vs_fc_number;
  					link_token( &spcl_func_list[indx]);
  					added_fc_count++;
  					sprintf( strbuf,  "Added Special Function FCode "
  						 "number 0x%03x, name %s\n", vs_fc_number, vs_fc_name);
  					printremark( strbuf);
  					break;
  				}
  			}
  
  			if (found_spf) 
  				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[32]; 
  		sprintf(strbfr,
  			"Added %d FCode numbers\n", added_fc_count);
  		printremark(strbfr);
  	}
  
  	close_stream();
  	check_tok_seq = TRUE;
  	return (retval);
  }
  

Download