/*======================================================================*/
/*  Calculator INPUT Command Routine(s)                                 */
/*======================================================================*/

#include stdio
#include ctype

/* calculator common definitions */

#include "calc_include.h"

/* definition of variable(s) */

int  default_value_flag;
char input_prompt[80];
char input_symbol[strsize];
char *end_quoted_string;
char *start_quoted_string;

struct token_struct input_value;
struct token_struct default_value;

enum tokentype input_data_type;

/* definition of external variable(s) */

extern int debug_flag;
extern int error_flag;
extern int vms_error_flag;

extern struct token_struct numeric_value;


/*----------------------------------------------------------------------*/
/*  Execute The INPUT Command                                           */
/*                                                                      */
/*  Parameter  Description                                              */
/*                                                                      */
/*  options    processing option flags                                  */
/*  stringcnt  length of input string                                   */
/*  stringptr  address of input string                                  */
/*  tokencnt   length of current token                                  */
/*  tokenptr   address of current token                                 */
/*  character  character value of character token                       */
/*  number     binary value of numeric token                            */
/*  parameter  user supplied argument                                   */
/*                                                                      */
/*----------------------------------------------------------------------*/
                      
int execute_input_command (options,stringcnt,stringptr,tokencnt,
                           tokenptr,character,number,parameter)
int  options,stringcnt,tokencnt,number,parameter;
char character,stringptr[],tokenptr[];
{
   int  idx,status;
   char answer[80];
                                                            
   /* do not execute the command if any errors occured */

   if (error_flag) return 1;

   /* ask the user for a response */

   printf("%s ",input_prompt);
   gets(answer);

   if (debug_flag)
      printf ("Answer:     %s\n",answer);

   /* check if the default value should be substituted */

   if (strlen(answer)==0)
      {
      if (default_value_flag == TRUE)
        {
        input_value = default_value;
        if (debug_flag) printf("Input value set to default\n");
        }
      else
        {
         error_flag = TRUE;
         printf("-- No default value defined\n");
         return 1;
         }
      }
   else
      {
      /* extract the input numeric value */

      if (input_data_type == INTEGER)         /* integer data */
         {
         status = sscanf(answer,"%d",&input_value.idata);
         if ((status&1)!=1)
            {
            error_flag = TRUE;
            printf("-- Invalid input value\n");
            if (vms_error_flag) syserror(status);
            return 1;
            }
         else
            {
            input_value.type = INTEGER;
            }
         }
      else  if (input_data_type == FLOAT)     /* float data */
         {
         status = sscanf(answer,"%f",&input_value.fdata);
         if ((status&1)!=1)
            {
            error_flag = TRUE;
            printf("-- Invalid input value\n");
            if (vms_error_flag) syserror(status);
            return 1;
            }
         else
            {
            input_value.type = FLOAT;
            }
         }
      else                                    /* illegel data */
         {
         error_flag = TRUE;
         printf("-- Internal error in INPUT command\n");
         return 1;
         }
      }
 
  if (debug_flag)
      {      
      if (input_value.type == INTEGER)
         {
         printf ("Input type  INTEGER\n");
         printf ("Input value %d\n",input_value.idata);
         }
      else if (input_value.type == FLOAT)
         {
         printf ("Input type  FLOAT\n");
         printf ("Input value %f\n",input_value.fdata);
         }
      else
         {
         printf ("Input type  UNKNOWN\n");
         }
      }

   /* store the input data in the input symbol */

   status = insert_symbol(&idx,input_value,input_symbol);

    return 1;
}


/*----------------------------------------------------------------------*/
/*  Define the INPUT Command Initial values                             */
/*                                                                      */
/*  Parameter  Description                                              */
/*                                                                      */
/*  options    processing option flags                                  */
/*  stringcnt  length of input string                                   */
/*  stringptr  address of input string                                  */
/*  tokencnt   length of current token                                  */
/*  tokenptr   address of current token                                 */
/*  character  character value of character token                       */
/*  number     binary value of numeric token                            */
/*  parameter  user supplied argument                                   */
/*                                                                      */
/*----------------------------------------------------------------------*/

int input_setup (options,stringcnt,stringptr,tokencnt,
                 tokenptr,character,number,parameter)
int  options,stringcnt,tokencnt,number,parameter;
char character,stringptr[],tokenptr[];
{
   input_value.type   = UNKNOWN;
   default_value.type = UNKNOWN;
   input_data_type    = INTEGER;
   default_value_flag = FALSE;

   if (debug_flag)
      {
      printf ("Token:      %.*s\n",tokencnt,tokenptr);
      printf ("Input default data type is INTEGER\n");
      }

   return 1;
}


/*----------------------------------------------------------------------*/
/*  Get The INPUT Command Prompt From Command String                    */
/*                                                                      */
/*  Parameter  Description                                              */
/*                                                                      */
/*  options    processing option flags                                  */
/*  stringcnt  length of input string                                   */
/*  stringptr  address of input string                                  */
/*  tokencnt   length of current token                                  */
/*  tokenptr   address of current token                                 */
/*  character  character value of character token                       */
/*  number     binary value of numeric token                            */
/*  parameter  user supplied argument                                   */
/*                                                                      */
/*----------------------------------------------------------------------*/

int get_input_prompt (options,stringcnt,stringptr,tokencnt,
                      tokenptr,character,number,parameter)
int  options,stringcnt,tokencnt,number,parameter;
char character,stringptr[],tokenptr[];
{
   int i,j,l;

   l = end_quoted_string - start_quoted_string - 1;

   if (l > 80) l = 80;

   for (i=0,j=1;i<l;i++,j++)
      input_prompt[i] = start_quoted_string[j];

   input_prompt[l] = '\0';

   if (debug_flag)
      printf ("Prompt      %s\n",input_prompt);

   return 1;
}


/*----------------------------------------------------------------------*/
/*  Get the INPUT Command Symbol From The Command String                */
/*                                                                      */
/*  Parameter  Description                                              */
/*                                                                      */
/*  options    processing option flags                                  */
/*  stringcnt  length of input string                                   */
/*  stringptr  address of input string                                  */
/*  tokencnt   length of current token                                  */
/*  tokenptr   address of current token                                 */
/*  character  character value of character token                       */
/*  number     binary value of numeric token                            */
/*  parameter  user supplied argument                                   */
/*                                                                      */
/*----------------------------------------------------------------------*/

int get_input_symbol (options,stringcnt,stringptr,tokencnt,
                      tokenptr,character,number,parameter)
int  options,stringcnt,tokencnt,number,parameter;
char character,stringptr[],tokenptr[];
{
   int i,limit;

   if (debug_flag)
      printf ("Symbol:     %.*s\n",tokencnt,tokenptr);

   if (tokencnt > strsize - 1)
      limit = strsize - 1;
   else
      limit = tokencnt;

   for (i=0;i<limit;i++) input_symbol[i] = _toupper(tokenptr[i]);
   input_symbol[limit] = '\0';

   return 1;
}


/*----------------------------------------------------------------------*/
/*  Get The Position Of The Start Of A Quoted String                    */
/*                                                                      */
/*  Parameter  Description                                              */
/*                                                                      */
/*  options    processing option flags                                  */
/*  stringcnt  length of input string                                   */
/*  stringptr  address of input string                                  */
/*  tokencnt   length of current token                                  */
/*  tokenptr   address of current token                                 */
/*  character  character value of character token                       */
/*  number     binary value of numeric token                            */
/*  parameter  user supplied argument                                   */
/*                                                                      */
/*----------------------------------------------------------------------*/

int quoted_string_start (options,stringcnt,stringptr,tokencnt,
                         tokenptr,character,number,parameter)
int  options,stringcnt,tokencnt,number,parameter;
char character,stringptr[],tokenptr[];
{
   start_quoted_string = tokenptr;

   if (debug_flag) printf ("Token:      %.*s\n",tokencnt,tokenptr);

   return 1;
}


/*----------------------------------------------------------------------*/
/*  Get The Position Of The End Of A Quoted String                      */
/*                                                                      */
/*  Parameter  Description                                              */
/*                                                                      */
/*  options    processing option flags                                  */
/*  stringcnt  length of input string                                   */
/*  stringptr  address of input string                                  */
/*  tokencnt   length of current token                                  */
/*  tokenptr   address of current token                                 */
/*  character  character value of character token                       */
/*  number     binary value of numeric token                            */
/*  parameter  user supplied argument                                   */
/*                                                                      */
/*----------------------------------------------------------------------*/

int quoted_string_end (options,stringcnt,stringptr,tokencnt,
                       tokenptr,character,number,parameter)
int  options,stringcnt,tokencnt,number,parameter;
char character,stringptr[],tokenptr[];
{
   end_quoted_string = tokenptr;

   if (debug_flag) printf ("Token:      %.*s\n",tokencnt,tokenptr);

   return 1;
}


/*----------------------------------------------------------------------*/
/*  INPUT Command FLOAT Qualifier                                       */
/*                                                                      */
/*  Parameter  Description                                              */
/*                                                                      */
/*  options    processing option flags                                  */
/*  stringcnt  length of input string                                   */
/*  stringptr  address of input string                                  */
/*  tokencnt   length of current token                                  */
/*  tokenptr   address of current token                                 */
/*  character  character value of character token                       */
/*  number     binary value of numeric token                            */
/*  parameter  user supplied argument                                   */
/*                                                                      */
/*----------------------------------------------------------------------*/

int input_float (options,stringcnt,stringptr,tokencnt,
                 tokenptr,character,number,parameter)
int  options,stringcnt,tokencnt,number,parameter;
char character,stringptr[],tokenptr[];
{
   input_data_type = FLOAT;

   if (debug_flag)
      {
      printf ("Token:      %.*s\n",tokencnt,tokenptr);
      printf ("Input data type is FLOAT\n");
      }

   return 1;
}


/*----------------------------------------------------------------------*/
/*  INPUT Command INTEGER Qualifier                                     */
/*                                                                      */
/*  Parameter  Description                                              */
/*                                                                      */
/*  options    processing option flags                                  */
/*  stringcnt  length of input string                                   */
/*  stringptr  address of input string                                  */
/*  tokencnt   length of current token                                  */
/*  tokenptr   address of current token                                 */
/*  character  character value of character token                       */
/*  number     binary value of numeric token                            */
/*  parameter  user supplied argument                                   */
/*                                                                      */
/*----------------------------------------------------------------------*/

int input_integer (options,stringcnt,stringptr,tokencnt,
                   tokenptr,character,number,parameter)
int  options,stringcnt,tokencnt,number,parameter;
char character,stringptr[],tokenptr[];
{
   input_data_type = INTEGER;

   if (debug_flag)
      {
      printf ("Token:      %.*s\n",tokencnt,tokenptr);
      printf ("Input data type is INTEGER\n");
      }

   return 1;
}


/*----------------------------------------------------------------------*/
/*  INPUT Command DEFAULT Value                                         */
/*                                                                      */
/*  Parameter  Description                                              */
/*                                                                      */
/*  options    processing option flags                                  */
/*  stringcnt  length of input string                                   */
/*  stringptr  address of input string                                  */
/*  tokencnt   length of current token                                  */
/*  tokenptr   address of current token                                 */
/*  character  character value of character token                       */
/*  number     binary value of numeric token                            */
/*  parameter  user supplied argument                                   */
/*                                                                      */
/*----------------------------------------------------------------------*/

int input_default (options,stringcnt,stringptr,tokencnt,
                   tokenptr,character,number,parameter)
int  options,stringcnt,tokencnt,number,parameter;
char character,stringptr[],tokenptr[];
{
   default_value_flag = TRUE;

   default_value = numeric_value;

   if (debug_flag)
      {
      printf ("Token:      %.*s\n",tokencnt,tokenptr);
      if (default_value.type == UNKNOWN)
         {
         printf("Num Type    UNKNOWN\n");
         }
      if (default_value.type == INTEGER)
         {
         printf("Num Type    INTEGER\n");
         printf("Num Value   %d\n",default_value.idata);
         }
      if (default_value.type == FLOAT)
         {
         printf("Num Type    FLOAT\n");
         printf("Num Value   %f\n",default_value.fdata);
         }
      }

   return 1;
}