static char *RCSid = "$Id: parse_keys.c,v 1.1 2000/01/14 22:49:16 jwm Exp $";
/***********************************************************************
  parse_keys.c
  **********************************************************************
  Description:  Contains functions which provide fundamental operations for
  patient data tape exchange.  Modules included are:

	space_remove_and_cap()	removes imbedded spaces from a string and
				converts it to upper case

	strip_string()		removes all leading and trailing spaces from
				a null terminated text string
				
	parse_key()		determines the key index from a passed in list
				of keywords
	
	parse_value()		determines the value index for a key value,
				if any.
	
	extract_line()		extract text line out of an AAPM formatted
				text buffer block and removes the <cr/lf>
				line terminator.
	
	expand_key()		expands legal abbreviations into their full
				text equivalent (only supports '#' for now).
	
	extract_ints()		extracts integer(s) from a text string using
				AAPM supported delimiters between values.
	
	extract_floats()	extracts integer(s) from a text string using
				AAPM supported delimiters between values.
	
	remove_quotes()		removes all quoted strings from ASCII data
				text buffered line.
					  
        read_comment_string()	reads a string from a text file and strips off
				any <nl> terminator and any comments (comments
				are all text following a ';' in the string)
	
	read_aapm_dose_values()	reads a line of doses from an AAPM formatted
				dose file and extracts the dose values into
				an array.  Handles buffered data files.
		
    
  ************************
  Revision History:
  $Log: parse_keys.c,v $
 * Revision 1.1  2000/01/14  22:49:16  jwm
 * Remove comments originating in other development trees
 *
 * Revision 1.0  2000/01/14  22:34:49  jwm
 * Initial revision
  =================================================================== */



/* Include Files */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
#include <ctype.h>
#include <math.h>
#include "sitedata.h"
#define NOT_MAIN
#include "exchkeys.h"
#include "patexchange.h"

#define LINE_LENGTH_LIMIT 80

/***********************************************************************
  space_remove_and_cap()
  **********************************************************************
  Functional Description:
  Removes all spaces from a string and converts all characters to uppercase.
  *********************************************************************/

void space_remove_and_cap	/* REMOVE SPACES AND FORCE TO UPPER CASE */
  (
   char *string		/* STRING TO STRIP AND CONVERT TO UPPERCASE */
   )

  {
  char temp_string[120];	/* TEMPORARY STRING */
  char *ptr;			/* POINTER FOR STRTOK'ING THROUGH STRING */
  int length;			/* LENGTH OF STRING TO FORCE TO UPPER CASE */
  int i;				/* LOOP COUNTER */
  
  /* MAKE A LOCAL COPY FOR MANIPULATION */
  strcpy( temp_string, string );
  
  /* BREAK THE STRING INTO TOKENS COPYING THE PIECES BACK TO string */
  ptr = strtok( temp_string, " " );
  
  /* IF ptr IS NULL, NO SPACES EXIST */
  if ( ptr == NULL )
    return;
  
  /* COPY THE BEGINNING OF THE STRING */
  strcpy( string, ptr );
  
  /* UNTIL ptr IS NULL, KEEP MOVING STRING PIECES */
  while( (ptr = strtok( NULL, " " )) != NULL )
    {
    strcat( string, ptr );
    }
  
  /* FORCE THE RETURNED STRING TO UPPERCASE */
  length = strlen( string );
  for ( i=0; i<length; i++ )
    string[i] = (char)toupper( (int)string[i] );
  }

/**************** End of space_remove_and_cap() ***********************/

/***********************************************************************
  strip_string()
  **********************************************************************
  Functional Description:
  Removes all leading and trailing spaces from a string.
  *********************************************************************/

void strip_string	/* REMOVE LEADING/TRAILING SPACES */
  (
   char *string		/* STRING TO STRIP */
   )

  {
  char temp_string[120];	/* TEMPORARY STRING */
  int i;				/* LOOP COUNTER */
  int start;			/* OFFSET OF FIRST NON-SPACE (TAB) */
  int stop;			/* END OFFSET OF LAST NON-SPACE */
  
  /* MAKE A LOCAL COPY FOR MANIPULATION */
  strcpy( temp_string, string );

  /* FIND THE FIRST NON-SPACE */
  for ( start=0; start<strlen( temp_string ); start++ )
    {
    if ( temp_string[start] != ' ' && temp_string[start] != '\t' )
      break;
    }

  /* FIND THE LAST NON-SPACE */
  for ( stop=(strlen(temp_string)-1); stop>start; stop-- )
    {
    if ( temp_string[stop] != ' ' && temp_string[stop] != '\t' )
      break;
    }
    
  /* COPY THE APPROPRIATE PIECES INTO THE STRING RETURNED */
  for ( i=start; i<=stop; i++ )
    string[i-start] = temp_string[i];

  /* NULL TERMINATE THE STRING */
  string[i-start] = '\0';

  }

/**************** End of space_remove_and_cap() ***********************/

/***********************************************************************
  parse_key()
  **********************************************************************
  Functional Description:
  Returns the index of the key in the character string passed in.
  ************************
  Processing:
  Parses a key/value line with := separators into a key and a value
  string.  The key is evaluated for equivalence with known keys and
  the index number+1 of the key is returned.  The value string
  returned is dynamically allocated and includes everything to the
  right of the separator.

  Returns the index of the key, or a -1 if the key is not in list.
  ************************
  Programmer Notes:
  * <ALL NOTES BULLETTED WITH A "*">
  END
  *********************************************************************/

int parse_key		/* GET KEY INDEX NUMBER AND VALUE STRING */
  (
   char *string,			/* STRING PASSED IN */
   char *keylist[],			/* LIST OF KNOWN KEYS */
   int num_keys,			/* NUMBER OF KEYS IN LIST */
   char **value_string			/* PORTION TO RIGHT OF := SEPARATOR */
   )

  {
  char *ptr;			/* POINTER TO SEPARATOR STRING */
  char temp_string[MAX_LINE_LENGTH];	/* TEMP COPY OF PASSED IN STRING */
  int i;			/* LOOP COUNTER */
  char *break_ptr;		/* POINTER TO NEXT STRING SEGMENT */
  
  /* DUPLICATE THE STRING */
  strcpy( temp_string, string );
  
  /* ENSURE THAT A SEPARATOR EXISTS */
  if ( (ptr = strstr( temp_string, ":=" )) == NULL )
    /* THIS IS NOT A DELIMITED LINE.  RETURN ekUNDEFINEDKEY */
    return( num_keys-1 );	/* SHOULD POINT TO AN UNDEFINED KEY */
  
  /* PULL THE KEY OFF, REMOVE ALL SPACES AND FORCE TO UPPERCASE */
  *ptr = '\0';
  space_remove_and_cap( temp_string );

  /* EXPAND ANY SPECIAL CHARACTERS */
  if ( expand_key( temp_string ) != SUCCESS )
    return( FAILURE );
  
  /* SEARCH ALL KEYS FOR A MATCH */
  for ( i=0; i<num_keys; i++ )
    {
    if ( strcmp( temp_string, keylist[i] ) == 0 )
      {
      /* PUT VALUE STRING IN THE APPROPRIATE PLACE */
      break_ptr = strstr( string, ":=" ) + 2;
      if ( strlen( break_ptr ) > 0 )
	{
	strip_string( break_ptr );
	*value_string = dup_string( break_ptr );
	}
      else
	*value_string = NULL;
      return( i );
      }
    }
  
  /* NO MATCH WAS FOUND.  RETURN A -1 */
  return( -1 );
  }

/********************** End of parse_key() ****************************/

/***********************************************************************
  parse_value()
  **********************************************************************
  Functional Description:
  Determines the index of the value of the key value string in the
  key value list passed in.
  ************************
  Processing:
  The string (after spaces are removed and it is converted to upper case) is
  evaluated for equivalence with known key values and the index number+1 of
  the key is returned.

  Returns the index of the key value, or a -1 if the string is not in
  the key value list.

  *********************************************************************/

int parse_value		/* GET KEY VALUE INDEX NUMBER */
  (
   char *string,			/* STRING PASSED IN */
   char *keyvaluelist[],		/* LIST OF KNOWN KEYS */
   int num_value_keys			/* NUMBER OF KEYS IN LIST */
   )

  {
  char temp_string[120];	/* TEMP COPY OF PASSED IN STRING */
  int i;			/* LOOP COUNTER */

  /* DUPLICATE THE STRING */
  strcpy(temp_string, string);
  
  /* PULL THE KEY OFF, REMOVE ALL SPACES AND FORCE TO UPPERCASE */
  space_remove_and_cap( temp_string );
  
  /* SEARCH ALL KEYS FOR A MATCH */
  for ( i=0; i<num_value_keys; i++ )
    {
    if ( strcmp( temp_string, keyvaluelist[i] ) == 0 )
      return( i );
    }
  
  /* NO MATCH WAS FOUND.  RETURN A -1 */
  return( -1 );
  }

/********************** End of parse_value() **************************/

/***********************************************************************
  extract_line()
  **********************************************************************
  Functional Description:
  Extracts a line of text out of a data block removing the <cr/lf> line
  terminator.
  ************************
  Processing:
  Searches the block data beginning at offset and returns a null
  terminated string.  The lines are delimited with <cr/lf> pairs.
  *********************************************************************/

int extract_line
  (
   char *data_block,		/* DATA BLOCK WITH LINES IN IT */
   int *offset,			/* OFFSET IN THE BLOCK */
   int max_offset,		/* MAXIMUM+1 VALUE FOR OFFSET */
   char *buffer,		/* AREA TO PUT STRING */
   int max_buffer_length	/* MAXIMUM BUFFER LENGTH */
   )
  {
  int state;			/* STATE OF TEXT BEING READ FROM BLOCK */
  int position;			/* INDEX IN BUFFER FOR TEXT COPY */
  int error_count;              /* FLAG FOR REPORTING LONG STRINGS */

  /* INITIALIZE ERROR COUNT */
  error_count = 0;

  /* RETURN FAILURE IF WE ARE ALREAD BEYOND BUFFER LIMITS */
  if ( *offset >= max_offset )
    return( FAILURE );
  
  /* SEARCH ONE CHARACTER AT A TIME FOR <CR/LF> */
  state = position = 0;
  while( state < 2 && *offset < max_offset )
    {
    switch( data_block[*offset] )
      {
    case 13:			/* CARRIAGE RETURN */
      if ( state != 0 )
	{
	sprintf( aapm_log_string, "Error.  CR found after LF or CR" );
	aapm_status( eAAPM_ERROR, aapm_log_string );
	buffer[position] = '\0';
	return( FAILURE );
	}
      state = 1;
      break;

    case 10:			/* LINE FEED */
      if ( state != 1 )
	{
	sprintf( aapm_log_string, "Error.  LF found before CR" );
	aapm_status( eAAPM_ERROR, aapm_log_string );
	/* TERMINATE THE LINE READ SO FAR */
	buffer[position] = '\0';
	return( FAILURE );
	}
      state = 2;
      break;

    case 0:			/* SKIP NULLS */
    case '\t':			/* SKIP TABS ALSO */
      break;
      
    default:
      buffer[position] = data_block[*offset];
      if ( position >= max_buffer_length )
	{
	sprintf( aapm_log_string, "Error. String too long for buffer (%d)",
		position );
	aapm_status( eAAPM_ERROR, aapm_log_string );
	buffer[position] = '\0';
	return( FAILURE );
	}
      if ( position >= LINE_LENGTH_LIMIT && error_count == 0 )
      {
      sprintf( aapm_log_string, "String exceeds 80 char length (CONTINUING)" );
      aapm_status( eAAPM_ERROR, aapm_log_string );
      error_count = 1;
      }
      position++;
      break;
      }

    /* INCREMENT THE DATA BLOCK INDEX */
    (*offset)++;
    }

  /* NULL TERMINATE THE STRING */
  buffer[position] = '\0';
  return( SUCCESS );
	
  }

/******************** End of extract_line() ***************************/

/***********************************************************************
  expand_key()
  **********************************************************************
  Functional Description:
  Expands special characters in a keyword or value string into the
  appropriate textual substitute.
  *********************************************************************/

int expand_key
  (
   char *string			/* KEY STRING TO BE EXPANDED */
   )
  {
  char temp_string[MAX_LINE_LENGTH];   	/* TEMPORARY STORAGE STRING */
  static char *number="NUMBER";
  int position, i, j;			/* INDICES */
  int num_to_process;
  int total_length;

  /* ENSURE THAT THE STRING IS SHORT ENOUGH */
  total_length = strlen( string );
  if ( total_length >= MAX_LINE_LENGTH )
    return( FAILURE );
  strcpy( temp_string, string );
  
  /* SEARCH FOR SPECIAL CHARACTERS */
  position = 0;
  num_to_process = strlen( temp_string );
  for (i=0; i<num_to_process; i++ )
    {
    switch( temp_string[i] )
      {
    case '#':			/* EXPANDS TO THE WORD "NUMBER" */
      /* INCREASE THE STRING'S OVERALL LENGTH AND ENSURE IT IS SHORT ENOUGH */
      total_length += strlen( number );
      if ( total_length >= MAX_LINE_LENGTH )
	return( FAILURE );
      for ( j=0; j<strlen(number); j++ )
	{
	string[position] = number[j];
	position++;
	}
      break;

    default:
      string[position] = temp_string[i];
      position++;
      break;
      }
    }
  /* NULL TERMINATE THE STRING */
  string[position] = '\0';
  return( SUCCESS );
  }
/********************** End of expand_key() ***************************/

/***********************************************************************
  extract_ints()
  **********************************************************************
  Functional Description:
  Extracts as many integers from a character string as exist up to the
  max_array.
  *********************************************************************/

int extract_ints
  (
   char *string,	/* STRING CONTAINING INTS */
   int *array,		/* ARRAY TO FILL WITH VALUES EXTRACTED */
   int max_array	/* MAXIMUM # OF ARRAY MEMBERS ALLOWED */
   )

  {
  int count;			/* # OF VALUES EXTRACTED */
  char tmp_string[121];		/* TEMP STRING HOLDER */
  char *ptr;			/* TEMPORARY STRING POINTER */
  int len;			/* LENGTH OF INPUT STRING */

  /* CHECK INPUT STRING SIZE */
  if( (len = strlen(string)) > 120)
    {
    printf("**** In extract_ints(): string too long = %d ****",len);
    exit(1);
    }

  /* EXTRACT ALL QUOTED STRINGS, LEAVING ONLY THE GOOD STUFF */
  remove_quotes( string, tmp_string );

  /* EXTRACT ALL VALUES EXPECTING A SPACE OR COMMA DELIMITER */
  ptr = strtok( tmp_string, " ," );
  count = 0;
  while( ptr != NULL )
    {
    array[count] = atoi( ptr );
    if( ++count >= max_array )
      break;	/* We've already got the request filled */
    ptr = strtok( NULL, " ," );
    }

  return( count );
  }
/********************* End of extract_ints() **************************/

/***********************************************************************
  extract_floats()
  **********************************************************************
  Functional Description:
  Extracts floating point value(s) from a character string.
  *********************************************************************/

int extract_floats
  (
   char *string,	/* STRING CONTAINING INTS */
   float *array,	/* ARRAY TO FILL WITH VALUES EXTRACTED */
   int max_array	/* MAXIMUM # OF ARRAY MEMBERS ALLOWED */
   )

  {
  int count;			/* # OF VALUES EXTRACTED */
  char tmp_string[121];		/* TEMP STRING HOLDER */
  char *ptr;			/* TEMP STRING POINTER */
  int len;			/* LENGTH OF INPUT STRING */

  /* CHECK INPUT STRING SIZE */
  if( (len = strlen(string)) > 120)
    {
    printf("**** In extract_floats(): string too long = %d ****",len);
    exit(1);
    }

  /* EXTRACT ALL QUOTED STRINGS, LEAVING ONLY THE GOOD STUFF */
  remove_quotes( string, tmp_string );

  /* EXTRACT ALL VALUES EXPECTING A SPACE OR COMMA DELIMITER */
  ptr = strtok( tmp_string, " ," );
  count = 0;
  while( ptr != NULL )
    {
    array[count] = atof( ptr );
    if( ++count >= max_array )
      break;	/* We've already got the request filled */
    ptr = strtok( NULL, " ," );
    }

  return( count );
  }
/********************** End of extract_floats() ***********************/

/***********************************************************************
  remove_quotes()
  **********************************************************************
  Functional Description:
  Extracts all quoted (") strings from a string and returns the rest.
  *********************************************************************/

void remove_quotes
  (
   char *source,		/* SOURCE STRING */
   char *dest			/* DESTINATION STRING MUST BE SAME SIZE AS
				   SOURCE STRING */
   )
  {
  int length;			/* LENGTH OF SOURCE STRING */
  int i;			/* SOURCE STRING CHARACTER INDEX */
  int j;			/* DEST STRING CHARACTER INDEX */
  int cur_quote;		/* FLAG FOR CHARACTERS IN QUOTED FIELD (1)
				   OR OUTSIDE QUOTED FIELD (0) */

  /* COPY SOURCE TO DEST 1 CHAR AT A TIME */
  length = strlen( source );

  /* SET FLAG SO THAT FIRST CHARACTER IS NOT IN QUOTED SECTION */
  cur_quote = j = 0;
  for ( i=0; i<length; i++ )
    {
    if ( source[i] == '\"' )
      {		/* A QUOTED SECTION IS BEGINNING OR ENDING */
      if ( cur_quote == 0 )
	cur_quote = 1;		/* BEGINNING */
      else
	cur_quote = 0;		/* ENDING */
      }

    else
      {			/* COPY CHARACTER IF NOT INSIDE QUOTES */
      if ( cur_quote == 0 )
	{	/* ONLY COPY CHARACTER IF NOT IN QUOTED STRING */
	dest[j] = source[i];
	j++;
	}
      }
    }

  /* NULL TERMINATE THE DESTINATION STRING */
  dest[j] = '\0';
  
  }

/********************** End of remove_quotes() ************************/

/***********************************************************************
  read_comment_string()
  **********************************************************************
  Functional Description:
  Reads a string from the passed file pointer and returns it without any
  <nl> character and with any comment (delimited by ';') stripped off.
  *********************************************************************/

int read_comment_string
  (
   char *string,		/* STRING TO READ INTO */
   int length,			/* MAXIMUM LENGTH OF STRING */
   FILE *input			/* INPUT FILE STREAM POINTER */
   )
  {
  char *ptr;			/* POINTER TO COMMENT START */
  /* READ THE STRING */
  if ( read_string( string, length, input ) != SUCCESS )
    return( FAILURE );

  /* STRIP OFF ANY COMMENT */
  ptr = strchr( string, ';' );
  if ( ptr != NULL )
    *ptr = '\0';
  
  return( SUCCESS );
  }

/********************** End of read_comment_string() ******************/

/***********************************************************************
  read_aapm_dose_values()
  **********************************************************************
  Functional Description:
  Reads a text string out of a text block in memory.  If a null length
  string is returned, and the pointer is at the end of the block, it
  reads in the next block of data.
  *********************************************************************/

int read_aapm_dose_values
  (
   FILE *input,			/* INPUT FILE STREAM POINTER */
   dosedist_t *doses,		/* DOSE STRUCTURE */
   float *array,		/* ARRAY TO PUT VALUES INTO */
   int max_array		/* MAXIMUM NUMBER OF ENTRIES IN ARRAY */
   )
	     
  {
  char string[82];		/* TEXT READING STRING */
  
  /* READ THE NEXT STRING OUT OF THE BUFFER */
  while ( extract_line( doses->data_block, &(doses->offset), doses->block_size,
		    string, 82 ) != SUCCESS )
    {
    /* READ IN THE NEXT BUFFER IF OUT OF DATA AND MORE EXISTS */
    if ( doses->cur_block >= doses->total_blocks )
      {
      sprintf( aapm_log_string, "Premature EOF for doses" );
      aapm_status( eAAPM_ERROR, aapm_log_string );
      return( -1 );
      }
    else
      {
      /* READ IN THE NEXT BLOCK AND TRY AGAIN */
      if ( fread( (void *)doses->data_block, (size_t)1,
		 (size_t)doses->block_size, input) != doses->block_size )
	{
	sprintf( aapm_log_string, "Error reading block #%d of dose text data",
		doses->cur_block );
	aapm_status( eAAPM_ERROR, aapm_log_string );
	return( -1 );
	}
      /* RESET THE OFFSET AND CURRENT BLOCK NUMBER */
      doses->cur_block++;
      doses->offset = 0;
      }
    }	/* END OF WHILE LOOP */

  /* READ DOSE VALUES OUT OF THE ARRAY AND RETURN THE NUMBER OF VALUES READ */
  return( extract_floats( string, array, max_array ));

  }

/****************** End of read_aapm_dose_values() ******************/

/********************* End of parse_keys.c ****************************/