bwBASIC/bwbasic.c

/***************************************************************
  
        bwbasic.c       Main Program File
                        for Bywater BASIC Interpreter
  
                        Copyright (c) 1993, Ted A. Campbell
                        Bywater Software
  
                        email: tcamp@delphi.com
  
        Copyright and Permissions Information:
  
        All U.S. and international rights are claimed by the author,
        Ted A. Campbell.
  
   This software is released under the terms of the GNU General
   Public License (GPL), which is distributed with this software
   in the file "COPYING".  The GPL specifies the terms under
   which users may copy and use the software in this distribution.
  
   A separate license is available for commercial distribution,
   for information on which you should contact the author.
  
***************************************************************/

/*---------------------------------------------------------------*/
/* NOTE: Modifications marked "JBV" were made by Jon B. Volkoff, */
/* 11/1995 (eidetics@cerf.net).                                  */
/*                                                               */
/* Those additionally marked with "DD" were at the suggestion of */
/* Dale DePriest (daled@cadence.com).                            */
/*                                                               */
/* Version 3.00 by Howard Wulf, AF5NE                            */
/*                                                               */
/* Version 3.10 by Howard Wulf, AF5NE                            */
/*                                                               */
/*---------------------------------------------------------------*/



#include "bwbasic.h"

GlobalType * My = NULL;

static char * DefaultErrorMessage[ 80 ] = 
{
   /* 00 */ ""
,  /* 01 */ "NEXT without FOR"
,  /* 02 */ "Syntax error"
,  /* 03 */ "RETURN without GOSUB"
,  /* 04 */ "Out of DATA"
,  /* 05 */ "Illegal function call"
,  /* 06 */ "Overflow"
,  /* 07 */ "Out of memory"
,  /* 08 */ "Undefined line"
,  /* 09 */ "Subscript out of range"
,  /* 10 */ "Redimensioned array"
,  /* 11 */ "Division by zero"
,  /* 12 */ "Illegal direct"
,  /* 13 */ "Type mismatch"
,  /* 14 */ "Out of string space"
,  /* 15 */ "String too long"
,  /* 16 */ "String formula too complex"
,  /* 17 */ "Can't continue"
,  /* 18 */ "Undefined user function"
,  /* 19 */ "No RESUME"
,  /* 20 */ "RESUME without error"
,  /* 21 */ "Unprintable error"
,  /* 22 */ "Missing operand"
,  /* 23 */ "Line buffer overflow"
,  /* 24 */ ""
,  /* 25 */ ""
,  /* 26 */ "FOR without NEXT"
,  /* 27 */ ""
,  /* 28 */ ""
,  /* 29 */ "WHILE without WEND"
,  /* 30 */ "WEND without WHILE"
,  /* 31 */ "EXIT FUNCTION without FUNCTION"
,  /* 32 */ "END FUNCTION without FUNCTION"
,  /* 33 */ "EXIT SUB without SUB"
,  /* 34 */ "END SUB without SUB"
,  /* 35 */ "EXIT FOR without FOR"
,  /* 36 */ ""
,  /* 37 */ ""
,  /* 38 */ ""
,  /* 39 */ ""
,  /* 40 */ ""
,  /* 41 */ ""
,  /* 42 */ ""
,  /* 43 */ ""
,  /* 44 */ ""
,  /* 45 */ ""
,  /* 46 */ ""
,  /* 47 */ ""
,  /* 48 */ ""
,  /* 49 */ ""
,  /* 50 */ "Field overflow"
,  /* 51 */ "Internal error"
,  /* 52 */ "Bad file number"
,  /* 53 */ "File not found"
,  /* 54 */ "Bad file mode"
,  /* 55 */ "File already open"
,  /* 56 */ ""
,  /* 57 */ "Disk I/O error"
,  /* 58 */ "File already exists"
,  /* 59 */ ""
,  /* 60 */ ""
,  /* 61 */ "Disk full"
,  /* 62 */ "Input past end"
,  /* 63 */ "Bad record number"
,  /* 64 */ "Bad file name"
,  /* 65 */ ""
,  /* 66 */ "Direct statement in file"
,  /* 67 */ "Too many files"
,  /* 68 */ ""
,  /* 69 */ ""
,  /* 70 */ "Variable Not Declared"
,  /* 71 */ ""
,  /* 72 */ ""
,  /* 73 */ "Advanced Feature"
,  /* 74 */ ""
,  /* 75 */ ""
,  /* 76 */ ""
,  /* 77 */ ""
,  /* 78 */ ""
,  /* 79 */ ""
};


static char    *Banner[] = {
             "########  ##    ## ##      ##    ###    ######## ######## ########            ",
             "##     ##  ##  ##  ##  ##  ##   ## ##      ##    ##       ##     ##           ",
             "##     ##   ####   ##  ##  ##  ##   ##     ##    ##       ##     ##           ",
             "########     ##    ##  ##  ## ##     ##    ##    ######   ########            ",
             "##     ##    ##    ##  ##  ## #########    ##    ##       ##   ##             ",
             "##     ##    ##    ##  ##  ## ##     ##    ##    ##       ##    ##            ",
             "########     ##     ###  ###  ##     ##    ##    ######## ##     ##           ",
             "                                                                              ",
             "                                                                              ",
             "                                    ########     ###     ######  ####  ###### ",
             "                                    ##     ##   ## ##   ##    ##  ##  ##    ##",
             "                                    ##     ##  ##   ##  ##        ##  ##      ",
             "                                    ########  ##     ##  ######   ##  ##      ",
             "                                    ##     ## #########       ##  ##  ##      ",
             "                                    ##     ## ##     ## ##    ##  ##  ##    ##",
             "                                    ########  ##     ##  ######  ####  ###### ",
             "                                                                              ",
             "Bywater BASIC Interpreter, version 3.10                                       ",
             "Copyright (c) 1993, Ted A. Campbell                                           ",
             "Copyright (c) 1995-1997, Jon B. Volkoff                                       ",
             "Copyright (c) 2014-2016, Howard Wulf, AF5NE                                   ",
             "                                                                              ",
             NULL
};


int
bwx_DEBUG(const char *A)
{
   /* 
   ** -- RECURSION WARNING -- 
   ** -- DO NOT SEND IT TO BACK TO BWBASIC --  
   ** This is DEBUG output.  
   ** Send it to a file, OutputDebugString, or fputs() 
   */
   if (My->MaintainerDebugOn)
   {
      if (My->MaintainerDebugFile == NULL)
      {
         My->MaintainerDebugFile = fopen(DEBUGFILENAME, "w");
      }
      if (My->MaintainerDebugFile != NULL)
      {
         fputs(A, My->MaintainerDebugFile);
         fputs("\n", My->MaintainerDebugFile);
         fflush(My->MaintainerDebugFile);
      }
      else
      {
         /* unable to open DEBUG file, so send the message to My->SYSOUT->cfp */
         if( My->SYSOUT != NULL )
         {
            if( My->SYSOUT->cfp != NULL )
            {
               fputs( A, My->SYSOUT->cfp );
               fputs( "\n", My->SYSOUT->cfp );
               fflush( My->SYSOUT->cfp );
            }
         }
      }
   }
   return 0;
}


/***************************************************************
  
      FUNCTION:       bwx_terminate()
  
   DESCRIPTION:    This function terminates program execution.
  
***************************************************************/

void
bwx_terminate(void)
{
   bwx_DEBUG(__FUNCTION__);
   exit(0);
}



/***************************************************************
  
   FUNCTION:       break_handler()
  
   DESCRIPTION:    This function is called by break_mes()
         and handles program interruption by break
         (or by the STOP command).
  
***************************************************************/

void
break_handler(void)
{
   bwx_DEBUG(__FUNCTION__);

   My->AutomaticLineNumber = 0;
   My->AutomaticLineIncrement = 0;

   if (My->IsInteractive)
   {
      /* INTERACTIVE: terminate program */

      /* reset all stack counters */
      bwb_clrexec();
      SetOnError(0);

      My->err_number = -1; /* in break_handler() */


      /* reset the break handler */
      signal(SIGINT, break_mes);

      longjmp(My->mark, -1);


      return;
   }
   /* NOT INTERACTIVE:  terminate immediately */
   bwx_terminate();
}

/***************************************************************
  
   FUNCTION:       break_mes()
  
   DESCRIPTION:    This function is called (a) by a SIGINT
         signal or (b) by bwb_STOP via bwx_STOP.
         It prints an error message then calls
         break_handler() to terminate the program.
  
***************************************************************/

void
break_mes(int x /* Parameter 'x' is never used */ )
{
   /* break_mes() is FATAL */
   bwx_DEBUG(__FUNCTION__);
   if (My->err_number < 0)  /* do not make a bad situation worse */
   {
      /* an error has already ben reported */
   }
   else
   {
      prn_xprintf("\n");
      if( My->CurrentVersion->OptionVersionBitmask & ( C77 ) )
      {
         if( is_empty_filename( My->progfile ) == FALSE )
         {
            prn_xprintf("FILE:");
            prn_xprintf(My->progfile);
            prn_xprintf(", ");
         }
      }
      prn_xprintf("Program interrupted at line");
      if( My->ThisLine != NULL )
      {
         if ( BasicLineNumberMin <= My->ThisLine->number &&  My->ThisLine->number <= BasicLineNumberMax )
         {
            char            tbuf[33];
            sprintf(tbuf, "%d", My->ThisLine->number);
            prn_xprintf(" ");
            prn_xprintf(tbuf);
         }
      }
      prn_xprintf("\n");
   }
   break_handler();
}

void
bwx_STOP(void)
{
   bwx_DEBUG(__FUNCTION__);
   break_mes(0);
}


/***************************************************************
  
      FUNCTION:       bwx_signon()
  
   DESCRIPTION:    This function prints out the sign-on
         message for bwBASIC.
  
***************************************************************/


int
bwx_signon(void)
{

   /* NOT called if a file is provided on the command line */
   int             i;
   bwx_DEBUG(__FUNCTION__);
   for (i = 0; Banner[i] != NULL; i++)
   {
      prn_xprintf(Banner[i]);
      prn_xprintf("\n");
   }

   return TRUE;

}



BasicNumberType
bwx_TIMER(BasicNumberType Seconds)
{
   /* Return a number representing Seconds in the future.  Seconds >= 0.
    * Seconds may be non-integer, such as 0.001 or 86399.999. The
    * maximum allowed Seconds is DBL_MAX. This is used two ways: 1) in
    * bwb_TIMER(), the ON TIMER count (>0)  is used to determine the
    * expiration time. In this case, simply return what the value will
    * be in the future. Note that ON TIMER enforces Seconds > (1 /
    * CLOCKS_PER_SEC) 2) in bwb_execline(), zero (=0) is used to
    * determine the current time and compare it to #1. In this case,
    * simply return what the value is now. Both the resolution of the
    * timer, and frequency of update, are implementation defined. */
   bwx_DEBUG(__FUNCTION__);
   if (Seconds < 0)
   {
      WARN_INTERNAL_ERROR;
      return 0;
   }
   else
   {
      BasicNumberType Result;
      Result = clock();
      Result /= CLOCKS_PER_SEC;
      Result += Seconds;
      return Result;
   }
}

void
CleanLine(char *buffer)
{
   /* cleanup the line, so it is easier to parse */
   char           *newbuffer;

   bwx_DEBUG(__FUNCTION__);


   if( buffer == NULL )
   {
      /* do nothing */
      return;
   }
   if( buffer[0] == BasicNulChar )
   {
      /* do nothing */
      return;
   }
      
   /* remove CR/LF */
   newbuffer = bwb_strchr( buffer, '\r' );
   if( newbuffer != NULL )
   {
      *newbuffer = BasicNulChar;
   }
   newbuffer = bwb_strchr( buffer, '\n' );
   if( newbuffer != NULL )
   {
      *newbuffer = BasicNulChar;
   }
   
   /* remove ALL embedded control characters */
   /* if you want a control character, then use CHR$ */
   newbuffer = buffer;
   while (*newbuffer != BasicNulChar)
   {
      if( bwb_isprint( *newbuffer ) )
      {
         /* OK */
      }
      else
      {
         *newbuffer = ' ';
      }
      newbuffer++;
   }
   /* LTRIM$ */
   newbuffer = buffer;
   if (*newbuffer != BasicNulChar)
   {
      /* not an empty line, so remove one (or more) leading spaces */
      while (*newbuffer == ' ')
      {
         newbuffer++;
      }
      if (newbuffer > buffer)
      {
         bwb_strcpy(buffer, newbuffer);
      }
   }
   /* RTRIM$ */
   newbuffer = buffer;
   if (*newbuffer != BasicNulChar)
   {
      /* not an empty line, so remove one (or more) trailing spaces */
      char           *E;

      E = bwb_strchr(newbuffer, BasicNulChar);
      E--;
      while (E >= newbuffer && *E == ' ')
      {
         *E = BasicNulChar;
         E--;
      }
   }
}


/***************************************************************
  
   FUNCTION:       bwb_init()
  
   DESCRIPTION:    This function initializes bwBASIC.
  
***************************************************************/

void
bwb_init( void )
{
   register int    n;
   static char     start_buf[] = "\0";
   static char     end_buf[] = "\0";
   bwx_DEBUG(__FUNCTION__);


   My->IsCommandLineFile = FALSE;
   My->ExternalInputFile = NULL; /* for automated testing, TAPE command */
   My->IsPrinter = FALSE; /* CBASIC-II: CONSOLE and LPRINTER commands */

    bwb_strcpy( My->progfile, "" );
    
    bwb_memset( &My->bwb_start, 0, sizeof(LineType) );
    bwb_memset( &My->bwb_end  , 0, sizeof(LineType) );
    bwb_memset( &My->user_line, 0, sizeof(LineType) );


   My->bwb_start.number = BasicLineNumberMin - 1;
   My->bwb_start.next = &My->bwb_end;
   My->bwb_start.position = 0;
   My->bwb_start.buffer = start_buf;

   My->bwb_end.number = BasicLineNumberMax + 1;
   My->bwb_end.next = &My->bwb_end;
   My->bwb_end.position = 0;
   My->bwb_end.buffer = end_buf;

   My->user_line.number = BasicLineNumberMin - 1;
   My->user_line.next = &My->bwb_end;
   My->user_line.position = 0;
   My->user_line.buffer = NULL;

   My->data_line = &My->bwb_start;
   My->data_pos = 0;

   My->stack_head = NULL;
   My->stack_level = 0;

   My->field_head = NULL;

#if NEW_VIRTUAL
   My->virtual_head = NULL;
#endif /* NEW_VIRTUAL */
   My->ThisLine = &My->bwb_start;

    
   SortAllCommands();
   SortAllFunctions();
   SortAllOperators();


   /* Memory allocation */
   if ((My->bwb_ebuf = CALLOC(BasicStringLengthMax + 1, sizeof(char), "bwb_init")) == NULL)
   {
      WARN_OUT_OF_MEMORY;
      return;
   }
   if ((My->read_line = CALLOC(BasicStringLengthMax + 1, sizeof(char), "bwb_init")) == NULL)
   {
      WARN_OUT_OF_MEMORY;
      return;
   }
   if ((My->SYSIN = CALLOC(1, sizeof(FileType), "bwb_init")) == NULL)
   {
      WARN_OUT_OF_MEMORY;
      return;
   }
   if ((My->SYSOUT = CALLOC(1, sizeof(FileType), "bwb_init")) == NULL)
   {
      WARN_OUT_OF_MEMORY;
      return;
   }
   if ((My->SYSPRN = CALLOC(1, sizeof(FileType), "bwb_init")) == NULL)
   {
      WARN_OUT_OF_MEMORY;
      return;
   }

   /* initialize tables of variables, functions */
   var_init();
   fnc_init();
   fslt_init();
   OptionVersionSet(0);

   My->SYSIN->mode = DEVMODE_INPUT;
   My->SYSIN->width = 80;
   My->SYSIN->col = 1;
   My->SYSIN->row = 1;
   My->SYSIN->delimit = ',';
   My->SYSIN->cfp = stdin;

   My->SYSOUT->mode = DEVMODE_OUTPUT;
   My->SYSOUT->width = 80;
   My->SYSOUT->col = 1;
   My->SYSOUT->row = 1;
   My->SYSOUT->delimit = ',';
   My->SYSOUT->cfp = stdout;

   My->SYSPRN->mode = DEVMODE_OUTPUT;
   My->SYSPRN->width = 80;
   My->SYSPRN->col = 1;
   My->SYSPRN->row = 1;
   My->SYSPRN->delimit = ',';
   My->SYSPRN->cfp = stderr;


   My->LPRINT_NULLS = 0;
   My->SCREEN_ROWS = 24;

   /* OPEN #0 is an ERROR. */
   /* CLOSE #0 is an ERROR. */
   /* WIDTH #0, 80 is the same as WIDTH 80. */
   /* LPRINT and LLIST are sent to bwx_LPRINT() */

   /* default variable type */
   for (n = 0; n < 26; n++)
   {
      My->DefaultVariableType[n] = BasicDoubleSuffix;
   }
   /* default COMMAND$(0-9) */   
   for( n = 0; n < 10; n++ )
   {
      My->COMMAND5[n] = NULL;
   } 
}


void strupper(char *C)
{
   if (C == NULL)
   {
      return;
   }
   while (*C)
   {
      *C = bwb_toupper(*C);
      C++;
   }
}

void strlower(char *C)
{
   if (C == NULL)
   {
      return;
   }
   while (*C)
   {
      *C = bwb_tolower(*C);
      C++;
   }
}

/***************************************************************
  
        FUNCTION:       main()
  
        DESCRIPTION:    As in any C program, main() is the basic
                        function from which the rest of the
                        program is called. Some environments,
         however, provide their own main() functions
         (Microsoft Windows (tm) is an example).
         In these cases, the following code will
         have to be included in the initialization
         function that is called by the environment.
  
***************************************************************/

void
bwb_single_step( char * buffer )
{
   bwx_DEBUG(__FUNCTION__);

   CleanLine(buffer);
   if ( buffer[0] == BasicNulChar )
   {
      /* empty -- do nothing */
   }
   else
   if (is_ln(buffer) == FALSE)
   {
      /* If there is no line number, then execute the line as received */
      /* RUN */
      bwb_Warning_Clear();
      SetOnError(0);
      bwb_xtxtline(buffer);
   }
   else
   if (is_numconst(buffer) == TRUE)
   {
      /*-----------------------------------------------------------------*/
      /* Another possibility: if buffer is a numeric constant,           */
      /* then delete the indicated line number (JBV)                     */
      /*-----------------------------------------------------------------*/
      /* DELETE ... */
      int             LineNumber;

      LineNumber = atoi(buffer);
      bwb_Warning_Clear();
      SetOnError(0);
      sprintf(buffer, "delete %d", LineNumber);
      bwb_xtxtline(buffer);
   }
   else
   {
      /* If there is a line number, then add it to the BASIC program */
      /* 100 REM */
      bwb_ladd(buffer, &My->bwb_start);
   }

   while( My->stack_head != NULL )
   {
      bwb_execline();
   }
}


static void execute_profile( char * FileName /*, int IsRequired */  )
{
   FILE           *profile;

   My->NextValidLineNumber = BasicLineNumberMin;   
   profile = fopen( FileName, "r" );
   if ( profile == NULL )
   {
      /* NOT FOUND */
      /* OPTIONAL */
      return;
   }
   /* FOUND */
   if (My->IsInteractive)
   {
      /* set a buffer for jump: program execution returns to this point in
       * case of a jump (error, interrupt, or finish program) */
      My->program_run = 0;
      signal(SIGINT, break_mes);
      setjmp(My->mark);
      if (My->program_run > 0)
      {
         /* error in PROFILE */
         exit( 1 );
      }
      My->program_run++;
   }

   /* 
   The profile only exists to allow 
   setting the BWB... variables 
   and executing OPTION ... commands
   No other use is supported. 
   */
   {
      int             Loop;
   
      Loop = TRUE;
      if (feof(profile))
      {
         Loop = FALSE;
      }
      while (Loop == TRUE)
      {
         My->read_line[0] = BasicNulChar;
         fgets(My->read_line, BasicStringLengthMax, profile);
   
         /* be sure that this is not EOF with a NULL line */
         if (feof(profile))
         {
            Loop = FALSE;
         }
         else
         {
            bwb_single_step(My->read_line);
         }
      }
      fclose( profile ); /* profile != NULL */
      profile = NULL;

   }
}

static void mark_preset_variables( void )
{
   /* mark all existing variables as preset */
   /* this includes the BWB.* variables and all variables declared in any PROFILE */
   VariableType *v;

   for (v = My->var_head; v != NULL; v = v->next)
   {
      v->VariableFlags |= VARIABLE_PRESET;
      v->VariableFlags |= VARIABLE_COMMON;   
   }
}


static void execute_program( char * FileName )
{
   My->NextValidLineNumber = BasicLineNumberMin;   
   My->IsCommandLineFile = TRUE;
   if( bwb_fload( FileName ) == FALSE )
   {
      sprintf(My->bwb_ebuf, "Failed to open file %s\n", FileName); fputs( My->bwb_ebuf, My->SYSOUT->cfp );
      /* the file load has failed, so do NOT run the program */
      exit(1);
   }
   if (My->err_number < 0 /* file load failed */ )
   {
      /* the file load has failed, so do NOT run the program */
      exit(1);
   }
   bwb_RUN(&My->bwb_start);
}

int
main(int argc, char **argv)
{
   int i;

   My = calloc( 1, sizeof( GlobalType ) );
   if( My == NULL )
   {
      puts( "My == NULL" );
      return 1;
   }
   My->CurrentVersion = &bwb_vertable[ 0 ]; 
   My->IsInteractive = TRUE;
   My->OptionSleepValue = 1;
   My->OptionIndentValue = 2;
   My->OptionTerminalType = C_OPTION_TERMINAL_NONE;
   My->OptionRoundType = C_OPTION_ROUND_BANK;
   My->NextValidLineNumber = BasicLineNumberMin;
   My->IncludeLevel = 0; /* %INCLUDE */
   
   bwx_DEBUG(__FUNCTION__);

   bwb_init();
   if (My->err_number < 0 /* bwb_init() failed */ )
   {
      /* FATAL */
      return 1;
   }
   /* Signon message banner */
   if (argc < 2)
   {
      /* no parameters */
      if (My->IsInteractive)
      {
         bwx_signon();
      }
      else
      {
         /* if INTERACTIVE is FALSE, then we must have a program file */
         fputs( "Program file not specified\n", My->SYSOUT->cfp );
         return 1;
      }
   }

   /* initialize preset variables */
   if (My->IsInteractive)
   {
      /* set a buffer for jump: program execution returns to this point in
       * case of a jump (error, interrupt, or finish program) */
      My->program_run = 0;
      signal(SIGINT, break_mes);
      setjmp(My->mark);
      if (My->program_run > 0)
      {
         /* error in profile */
         return 1;
      }
      My->program_run++;
   }
   
   sprintf( My->read_line, "LET %s = \"%s\"", DEFVNAME_EDITOR, DEF_EDITOR );
   bwb_single_step(My->read_line);

   sprintf( My->read_line, "LET %s = \"%s\"", DEFVNAME_FILES, DEF_FILES );
   bwb_single_step(My->read_line);

   sprintf( My->read_line, "LET %s = \"%s\"", DEFVNAME_IMPL, IMP_IDSTRING );
   bwb_single_step(My->read_line);

   sprintf( My->read_line, "LET %s = \"%s\"", DEFVNAME_PROMPT, PROMPT );
   bwb_single_step(My->read_line);

   sprintf( My->read_line, "LET %s = \"%s\"", DEFVNAME_RENUM, DEF_RENUM );
   bwb_single_step(My->read_line);

   sprintf( My->read_line, "LET %s = %d", DEFVNAME_COLORS, DEF_COLORS );
   bwb_single_step(My->read_line);


   /* check to see if there is a program file: but do this only the first time around! */


#if PROFILE
   execute_profile( PROFILENAME );
#endif


   for( i = 1; i < argc; i++ )
   {
      /* 
      SYNTAX:    bwbasic
      SYNTAX:    bwbasic --tape TapefileName.txt
      SYNTAX:    bwbasic --profile ProfileName.txt
      SYNTAX:    bwbasic program.bas
      SYNTAX:    bwbasic --tape tapefile.inp --profile profile.bas program.bas 
      */
      if( bwb_stricmp( argv[i], "--tape" ) == 0 
      ||  bwb_stricmp( argv[i], "-t"     ) == 0 
      ||  bwb_stricmp( argv[i], "/tape"  ) == 0 
      ||  bwb_stricmp( argv[i], "/t"     ) == 0 
      )
      {
         i++;
         if( i < argc )
         {
            /* --tape filename */
            My->ExternalInputFile = fopen(argv[i], "r");
         }
      }
      else
      if( bwb_stricmp( argv[i], "--profile" ) == 0 
      ||  bwb_stricmp( argv[i], "-p"        ) == 0 
      ||  bwb_stricmp( argv[i], "/profile"  ) == 0 
      ||  bwb_stricmp( argv[i], "/p"        ) == 0 
      )
      {
         i++;
         if( i < argc )
         {
            /* --profile filename */
            execute_profile( argv[i] );
         }
      }
      else
      {
         /* program */
         mark_preset_variables();
         {
            int j = i;
            int n = 0;
            for( n = 0; n < 10 && j < argc; n++, j++ )
            {
               My->COMMAND5[n] = argv[j];
            } 
         }
         execute_program( argv[i] );
         break;
      }
   }   

   if (My->IsInteractive)
   {
      /* set a buffer for jump: program execution returns to this point in
       * case of a jump (error, interrupt, or finish program) */
      My->program_run = 0;
      signal(SIGINT, break_mes);
      setjmp(My->mark);
      if (My->program_run > 0)
      {
         /* error in console mode */
      }
      My->program_run++;
   }

   /* main program loop */
   My->NextValidLineNumber = BasicLineNumberMin;   
   mark_preset_variables();
   while (!feof(My->SYSIN->cfp)) /* condition !feof( My->SYSIN->cfp ) added in v1.11 */
   {
      bwb_mainloop();
   }

   bwx_terminate();  /* allow ^D (Unix) exit with grace */

   return 0;
}



/***************************************************************
  
   FUNCTION:       bwb_interact()
  
   DESCRIPTION:   This function gets a line from the user
         and processes it.
  
***************************************************************/

int
bwb_interact(void)
{
   char LineExists = ' ';
   char prompt[BasicStringLengthMax + 1]; 

   bwx_DEBUG(__FUNCTION__);

   /* take input from keyboard */
   if( My->AutomaticLineNumber > 0 && My->AutomaticLineIncrement > 0 )
   {
      /* AUTO 100, 10 */
      LineType * l;
      for (l = &My->bwb_start; l != &My->bwb_end; l = l->next)
      {
         if( l->number == My->AutomaticLineNumber )
         {
            /* FOUND */
            LineExists = '*';
            break;
         }
         else
         if( l->number > My->AutomaticLineNumber )
         {
            /* NOT FOUND */
            LineExists = ' ';
            break;
         }
      }
      sprintf(prompt,"%d%c", My->AutomaticLineNumber, LineExists );
   }
   else
   {
      VariableType *v; 

      if( (v = var_find(DEFVNAME_PROMPT,0,FALSE)) == NULL )
      {
         bwb_strcpy(prompt, PROMPT);
      }
      else
      {
         VariantType variant;

         if( var_get( v, &variant ) == FALSE )
         {
            bwb_strcpy(prompt, PROMPT);
         }
         else
         {
            if( variant.TypeChar == '$' )
            {
               bwb_strcpy( prompt, variant.Buffer );
               RELEASE( (&variant) );
            }
            else
            {
               bwb_strcpy(prompt, PROMPT);
            }
         }
      }
   }
   bwx_input(prompt, My->read_line);
   CleanLine(My->read_line);   /* JBV */

   My->NextValidLineNumber = BasicLineNumberMin;


   if( My->AutomaticLineNumber > 0 && My->AutomaticLineIncrement > 0 )
   {
       if( My->read_line[0] != BasicNulChar )
       {
           /* non-empty response */
           if( bwb_stricmp( My->read_line, "MAN" ) == 0 )
           {
               /* MAN terminates AUTO mode */
               My->AutomaticLineNumber = 0;
               My->AutomaticLineIncrement = 0;
           }
           else
           {
               /* overwrite any existing line */
               char tbuf[BasicStringLengthMax + 1];
        
               sprintf(tbuf,"%d ", My->AutomaticLineNumber );
               bwb_strcat( tbuf, My->read_line );
               bwb_ladd(tbuf, &My->bwb_start);
               My->AutomaticLineNumber += My->AutomaticLineIncrement;
           }
       }
       else
       {
           /* empty response */
           if( LineExists == '*' )
           {
               /*
               An empty response with an existing line,
               causes AUTO to continue with the next line,
               leaving the current line intact.
               */
               My->AutomaticLineNumber += My->AutomaticLineIncrement;
           }
           else
           {
               /* 
               An empty response with a non-existing line,
               causes AUTO to terminate.
               */
               My->AutomaticLineNumber = 0;
               My->AutomaticLineIncrement = 0;
           }
       }
   }
   else
   if (is_ln(My->read_line) == FALSE)
   {
      /* If there is no line number, execute the line as received */
      /* RUN */
      bwb_Warning_Clear();
      SetOnError(0);
      bwb_xtxtline(My->read_line);
   }
   else
   if (is_numconst(My->read_line) == TRUE)
   {
      /*-----------------------------------------------------------------*/
      /* Another possibility: if My->read_line is a numeric constant,
       * delete */
      /* the indicated line number (JBV)                                 */
      /*-----------------------------------------------------------------*/
      /* DELETE ... */
      int             LineNumber;
      LineNumber = atoi(My->read_line);
      bwb_Warning_Clear();
      SetOnError(0);
      sprintf(My->read_line, "delete %d", LineNumber);
      bwb_xtxtline(My->read_line);
   }
   else
   {
      /* If there is a line number, add the line to the file in memory */
      bwb_ladd(My->read_line, &My->bwb_start);
   }

   return TRUE;

}




/***************************************************************
  
      FUNCTION:       bwb_fload()
  
      DESCRIPTION:   This function loads a BASIC program
         file into memory given a FILE pointer.
  
***************************************************************/

static void FixQuotes( char * buffer )
{
   /* fix unbalanced quotes */
   /* 'buffer' shall be declared "char buffer[BasicStringLengthMax + 1]". */
   int p;
   int QuoteCount = 0;
   
   p = 0;
   while( buffer[p] != BasicNulChar )
   {
      if( buffer[p] == BasicQuoteChar )
      {
         QuoteCount++;
      }
      p++;
      if( p > BasicStringLengthMax )
      {
         p = BasicStringLengthMax;
         buffer[p] = BasicNulChar;
      }
   }
   if( QuoteCount & 1 )
   {
      /* odd == missing trailing quote */
      if( p > BasicStringLengthMax )
      {
         p = BasicStringLengthMax;
      }
      buffer[p] = BasicQuoteChar;
      p++;
      buffer[p] = BasicNulChar;
   }
}

extern int bwb_fload ( char * FileName )
{
   FILE * file = NULL;
   int             Loop;
   bwx_DEBUG(__FUNCTION__);

   /*
   Just in case you are wondering...
   Although this handles the most common cases, it does not handle all possible cases.
   The correct solution is to provide the actual filename (with extension),
   as it exists in the operating system.
   */
   file = NULL;
   if( FileName == NULL /* My->progfile */ )
   {
      /* the FileName is already in My->progfile */
      if (My->progfile[0] == BasicNulChar)
      {
         return FALSE;
      }
      if (file == NULL)
      {
         /* AS-IS */
         file = fopen(My->progfile, "r");
      }
      if (file == NULL)
      {
         /* UPPERCASE */
         strupper(My->progfile);
         file = fopen(My->progfile, "r");
      }
      if (file == NULL)
      {
         /* LOWERCASE */
         strlower(My->progfile);
         file = fopen(My->progfile, "r");
      }
      /* do NOT add extensions to existing filenames */
      if (file == NULL)
      {
         /* NOT FOUND */
         return FALSE;
      }
   }
   else
   {
      if (FileName[0] == BasicNulChar)
      {
         return FALSE;
      }
      if( My->IncludeLevel > 0 )
      {
         /* %INCLUDE filename */
         if (file == NULL)
         {
            /* AS-IS */
            file = fopen( FileName, "r");
         }
         if (file == NULL)
         {
            /* UPPERCASE */
            strupper(FileName);
            file = fopen( FileName, "r");
         }
         if (file == NULL)
         {
            /* LOWERCASE */
            strlower(FileName);
            file = fopen( FileName, "r");
         }
         /* do NOT add extensions to %INCLUDE filenames */
      }
      else
      {
         if (file == NULL)
         {
            /* AS-IS */
            bwb_strcpy(My->progfile, FileName);
            file = fopen(My->progfile, "r");
         }
         if (file == NULL)
         {
            /* UPPERCASE */
            bwb_strcpy(My->progfile, FileName);
            strupper(My->progfile);
            file = fopen(My->progfile, "r");
         }
         if (file == NULL)
         {
            /* LOWERCASE */
            bwb_strcpy(My->progfile, FileName);
            strlower(My->progfile);
            file = fopen(My->progfile, "r");
         }
         if (file == NULL)
         {
            /* UPPERCASE + EXTENSION */
            bwb_strcpy(My->progfile, FileName);
            bwb_strcat(My->progfile, ".BAS");
            strupper(My->progfile);
            file = fopen(My->progfile, "r");
         }
         if (file == NULL)
         {
            /* LOWERCASE + EXTENSION */
            bwb_strcpy(My->progfile, FileName);
            bwb_strcat(My->progfile, ".bas");
            strlower(My->progfile);
            file = fopen(My->progfile, "r");
         }
      }
      if (file == NULL)
      {
         /* NOT FOUND */
         return FALSE;
      }
   }
   My->NextValidLineNumber = BasicLineNumberMin;
   Loop = TRUE;
   if (feof(file))
   {
      Loop = FALSE;
   }
   while (Loop == TRUE)
   {
      My->read_line[0] = BasicNulChar;
      fgets(My->read_line, BasicStringLengthMax, file);
      if (file == My->SYSIN->cfp)
      {
         ResetConsoleColumn();
      }
      /* be sure that this is not EOF with a NULL line */
      if (feof(file))
      {
         Loop = FALSE;
      }
      else
      {
         CleanLine(My->read_line);
         if ( My->read_line[0] != BasicNulChar )
         {
            if( My->CurrentVersion->OptionVersionBitmask & ( C77 ) )
            {
               /* SYNTAX: %INCLUDE literal.file.name */

               const char Magic_Word[] = "%INCLUDE";
               int Magic_Length = bwb_strlen( Magic_Word );
               if( bwb_strnicmp( My->read_line, Magic_Word, Magic_Length ) == 0 )
               {
                  int Result;
                  int p = Magic_Length;
                  char varname[ BasicNameLengthMax + 1 ];
                  
                  if( buff_read_varname( My->read_line, &p, varname ) == FALSE )
                  {
                     fputs( "Did not find filename after %INCLUDE\n", My->SYSOUT->cfp );
                     fputs( My->read_line, My->SYSOUT->cfp );
                     return FALSE;
                  }
                  if( buff_is_eol( My->read_line, &p ) == FALSE )
                  {
                     fputs( "Found garbage after %INCLUDE\n", My->SYSOUT->cfp );
                     fputs( My->read_line, My->SYSOUT->cfp );
                     return FALSE;
                  }
                  My->IncludeLevel++; /* %INCLUDE */
                  Result = bwb_fload( varname );
                  My->IncludeLevel--; /* %INCLUDE */
                  if( Result == FALSE )
                  {
                     fputs( "Failed to load file\n", My->SYSOUT->cfp );
                     fputs( My->read_line, My->SYSOUT->cfp );
                     return FALSE;
                  }
               }
               else
               {
                  bwb_ladd(My->read_line, &My->bwb_start);
               }
            }
            else
            {
               bwb_ladd(My->read_line, &My->bwb_start);
            }
         }
      }
   }

   /* close file stream */

   fclose(file); /* file != NULL */

   My->NextValidLineNumber = BasicLineNumberMin;

   return TRUE;
}


static char * FindClassicStatementEnd(char *C)
{
   /* 
    * find the end of the current statement
    */
   
   bwx_DEBUG(__FUNCTION__);


   if( My->CurrentVersion->OptionStatementChar == BasicNulChar && My->CurrentVersion->OptionCommentChar == BasicNulChar )
   {
      /* DO NOTHING: Multi-statment lines are not possible */
      return NULL;
   }
   /* skip line number */
   while (bwb_isdigit(*C))
   {
      C++;
   }
   /* skip spaces */
   while (*C == ' ')
   {
      C++;
   }
   if( IS_CHAR( *C, My->CurrentVersion->OptionCommentChar ) )
   {
      /* The entire line is a comment */
      return NULL;
   }
   if (bwb_strnicmp(C, "REM", 3) == 0)
   {
      /* The entire line is a comment */
      return NULL;
   }
   if( (My->CurrentVersion->OptionFlags & OPTION_LABELS_ON) && (My->CurrentVersion->OptionStatementChar != BasicNulChar) )
   {
      /* determine if this line is a LABEL */
      int p;
      char label[BasicNameLengthMax + 1];

      p = 0;
      if( buff_read_label( C, &p, label ) )
      {
         buff_skip_spaces( C, &p );
         if( buff_skip_char( C, &p, My->CurrentVersion->OptionStatementChar ) )
         {
            if( buff_is_eol( C, &p ) )
            {
               /* The entire line is a label */
               /* LABEL : \0 */
               return NULL;
            }
         }
      }
   }
   /* not a special case, so split on the first unquoted OptionCommentChar or OptionStatementChar */
   while (*C != BasicNulChar)
   {
      if (*C == BasicQuoteChar)
      {
         /* skip leading quote */
         C++;
         while (*C != BasicQuoteChar && *C != BasicNulChar)
         {
            /* skip string constant */
            C++;
         }
         if (*C == BasicQuoteChar)
         {
            /* skip trailing quote */
            C++;
         }
      }
      else
      if ( IS_CHAR( *C, My->CurrentVersion->OptionCommentChar ) /* ', ! */ )
      {
         /* FOUND */
         return C;
      }
      else
      if ( IS_CHAR( *C, My->CurrentVersion->OptionStatementChar ) /* :, \ */ )
      {
         /* FOUND */
         return C;
      }
      else
      {
         C++;
      }
   }
   /* NOT FOUND */
   return NULL;
}


static void ImportClassicIfThenElse(char *InBuffer)
{
/*
**
** Determine the type of IF command:
**
** a) STANDARD: 
**    IF x THEN line ELSE line
**
** b) CLASSIC:
**    IF x THEN stmt(s) ELSE stmt(s)
**
** c) STRUCTURED:
**    IF x THEN
**       stmts
**    ELSE
**      stmts
**    END IF
**
** The STANDARD and STRUCTURED forms
** are natively supported.
**
** The CLASSIC form is converted to
** the STRUCTURED form.
**
*/

#define NULLCHAR     BasicNulChar
#define QUOTECHAR    BasicQuoteChar
#define COLONCHAR    My->CurrentVersion->OptionStatementChar
#define SPACECHAR    ' '
   int             i;

   int             nIF = 0;
   int             nTHEN = 0;
   int             nELSE = 0;
   int             nENDIF = 0;

#define NO_COMMAND    0
#define IF_COMMAND    1
#define THEN_COMMAND  2
#define ELSE_COMMAND  3
#define ENDIF_COMMAND 4
   int             LastCommand = NO_COMMAND;

   char            REM[] = "REM ";
   char            IF[] = "IF ";
   char            THEN[] = "THEN ";
   char            THEN2[] = "THEN";
   char            ELSE[] = "ELSE ";
   char            ENDIF[] = "END IF";
   char            GOTO[] = "GOTO ";
   char            DATA[] = "DATA ";
   char            CASE[] = "CASE ";
   char            OutBuffer[BasicStringLengthMax + 1];
   char           *Input = InBuffer;
   char           *Output = OutBuffer;
   char            LastChar = COLONCHAR;

   int             REM_len = bwb_strlen(REM);
   int             IF_len = bwb_strlen(IF);
   int             THEN_len = bwb_strlen(THEN);
   int             THEN2_len = bwb_strlen(THEN2);
   int             ELSE_len = bwb_strlen(ELSE);
   int             ENDIF_len = bwb_strlen(ENDIF);
   int             GOTO_len = bwb_strlen(GOTO);
   int             DATA_len = bwb_strlen(DATA);
   int             CASE_len = bwb_strlen(CASE);

#define OUTPUTCHAR( c ) { *Output = c; Output++; }
#define COPYCHAR  { LastChar = *Input; *Output = *Input; Output++; Input++; }
#define COPY_LINENUMBER  while( bwb_isdigit( *Input )       ) COPYCHAR;
#define COPY_SPACES      while( *Input == SPACECHAR     ) COPYCHAR;
#define COPY_IF          for( i = 0; i < IF_len; i++    ) COPYCHAR;
#define COPY_THEN        for( i = 0; i < THEN_len; i++  ) COPYCHAR;
#define COPY_THEN2       for( i = 0; i < THEN2_len; i++ ) COPYCHAR;
#define COPY_ELSE        for( i = 0; i < ELSE_len; i++  ) COPYCHAR;
#define COPY_ENDIF       for( i = 0; i < ENDIF_len; i++ ) COPYCHAR;
#define FORCE_ENDIF      for( i = 0; i < ENDIF_len; i++ ) OUTPUTCHAR( ENDIF[ i ] );
#define FORCE_GOTO       for( i = 0; i < GOTO_len; i++  ) OUTPUTCHAR( GOTO[ i ] );
#define FORCE_COLON if( LastChar != COLONCHAR ) OUTPUTCHAR( COLONCHAR );

   bwx_DEBUG(__FUNCTION__);

   if( My->CurrentVersion->OptionStatementChar == BasicNulChar )
   {
      /* DO NOTHING: All IFs must be STANDARD or STRUCTURED */
      return;
   }


   COPY_LINENUMBER;
   COPY_SPACES;
   LastChar = COLONCHAR;


   while (*Input != NULLCHAR)
   {
      if (*Input == My->CurrentVersion->OptionCommentChar)
      {
         /* comment */
         break;
      }
      else
      if (*Input == QUOTECHAR)
      {
         /* string constant */
         COPYCHAR;
         while (*Input != QUOTECHAR && *Input != NULLCHAR)
         {
            COPYCHAR;
         }
         if (*Input == QUOTECHAR)
         {
            COPYCHAR;
         }
         COPY_SPACES;
      }
      else
      if (bwb_isalnum(LastChar))
      {
         /* can NOT be the start of a command */
         COPYCHAR;
      }
      else
      if (!bwb_isalpha(*Input))
      {
         /* can NOT be the start of a command */
         COPYCHAR;
      }
      else
      if (bwb_strnicmp(Input, REM, REM_len) == 0)
      {
         break;
      }
      else
      if (bwb_strnicmp(Input, DATA, DATA_len) == 0)
      {
         /* DATA ... */
         break;
      }
      else
      if (bwb_strnicmp(Input, CASE, CASE_len) == 0)
      {
         /* CASE ... */
         break;
      }
      else
      if (bwb_strnicmp(Input, IF, IF_len) == 0)
      {
         /* IF */
         LastCommand = IF_COMMAND;
         nIF++;
         COPY_IF;
         COPY_SPACES;
      }
      else
      if (bwb_strnicmp(Input, GOTO, GOTO_len) == 0 && nIF > nTHEN)
      {
         /* I F 
          *
          * x GO T O 
          *
          * li n e 
          *
          * EL S E 
          *
          * li n e */
         LastCommand = THEN_COMMAND;
         nTHEN++;
         COPY_THEN;
         COPY_SPACES;
         COPY_LINENUMBER;
         COPY_SPACES;
         if (bwb_strnicmp(Input, ELSE, ELSE_len) == 0)
         {
            /* E L S E 
             *
             * Li n e N u m b e r */
            COPY_ELSE;
            COPY_SPACES;
            COPY_LINENUMBER;
            COPY_SPACES;
         }
         /* I S 
          *
          * ST A N D A R D , 
          *
          * NO T 
          *
          * CL A S S I C */
         nENDIF++;
         LastCommand = ENDIF_COMMAND;
      }
      else
      if (bwb_strnicmp(Input, THEN, THEN_len) == 0)
      {
         /* T H E N */
         LastCommand = THEN_COMMAND;
         nTHEN++;
         COPY_THEN;
         COPY_SPACES;
         if (bwb_isdigit(*Input))
         {
            /* * 
             *
             * a  * ) 
             *
             * ST A N D A R D : *   
             *
             * IF 
             * x TH E N 
             *
             * li n e 
             *
             * EL S E 
             *
             * li n e * 
             *
             *
             */
            char           *SavedInput;
            char           *SavedOutput;
            SavedInput = Input;
            SavedOutput = Output;

            COPY_LINENUMBER;
            COPY_SPACES;
            if (bwb_strnicmp(Input, ELSE, ELSE_len) == 0)
            {
               /* E L S E 
                *
                * Li n e N u m b e r */
               COPY_ELSE;
               COPY_SPACES;
               if (bwb_isdigit(*Input))
               {
                  COPY_LINENUMBER;
                  COPY_SPACES;
                  /* I S 
                   *
                   * ST A N D A R D , 
                   *
                   * NO T 
                   *
                   * CL A S S I C */
                  nENDIF++;
                  LastCommand = ENDIF_COMMAND;
               }
               else
               {
                  /* I F 
                   *
                   * x TH E N 
                   *
                   * li n e 
                   *
                   * EL S E 
                   *
                   * st m t s */
                  Input = SavedInput;
                  Output = SavedOutput;
                  FORCE_COLON;
                  FORCE_GOTO;
                  COPY_LINENUMBER;
                  COPY_SPACES;
               }
            }
            else
            {
               /* I S 
                *
                * ST A N D A R D , 
                *
                * NO T 
                *
                * CL A S S I C */
               nENDIF++;
               LastCommand = ENDIF_COMMAND;
            }
         }
         else
         if (*Input == My->CurrentVersion->OptionCommentChar || *Input == NULLCHAR)
         {
            /* I S 
             *
             * ST R U C T U R E D , 
             *
             * NO T 
             *
             * CL A S S I C */
            nENDIF++;
            LastCommand = ENDIF_COMMAND;
         }
         else
         {
            /* * 
             *
             * b  * ) 
             *
             * CL A S S I C : *   
             *
             * IF 
             * x TH E N 
             *
             * st m t ( s ) 
             *
             * EL S E 
             *
             * st m t ( s ) * 
             *
             *
             */
         }
         FORCE_COLON;
      }
      else
      if (bwb_strnicmp(Input, THEN2, THEN2_len) == 0)
      {
         /* t r a i l i n g 
          *
          * TH E N ? */
         char           *PeekInput;

         PeekInput = Input;
         PeekInput += THEN2_len;
         while( *PeekInput == ' ' )
         {
             PeekInput++;
         }
         if (*PeekInput == My->CurrentVersion->OptionCommentChar || *PeekInput == NULLCHAR)
         {
            /* I S 
             *
             * ST R U C T U R E D , 
             *
             * NO T 
             *
             * CL A S S I C */
            nTHEN++;
            COPY_THEN2;
            nENDIF++;
            LastCommand = ENDIF_COMMAND;
            FORCE_COLON;
         }
         else
         {
            /* T H E N x y z , 
             *
             * TH E N 1 2 3 */
         }
      }
      else
      if (bwb_strnicmp(Input, ELSE, ELSE_len) == 0)
      {
         /* E L S E */
         if (LastCommand == ELSE_COMMAND)
         {
            /* w e 
             *
             * ne e d 
             *
             * an 
             * EN D I F 
             *
             * he r e */
            FORCE_COLON;
            FORCE_ENDIF;
            FORCE_COLON;
            nENDIF++;
         }
         LastCommand = ELSE_COMMAND;
         nELSE++;
         FORCE_COLON;
         COPY_ELSE;
         FORCE_COLON;
         COPY_SPACES;
         if (bwb_isdigit(*Input))
         {
            /* I F 
             *
             * x TH E N 
             *
             * st m t ( s ) 
             *
             * EL S E 
             *
             * Li n e N u m b e r */
            FORCE_GOTO;
            COPY_LINENUMBER;
            COPY_SPACES;
         }
         FORCE_COLON;
      }
      else
      if (bwb_strnicmp(Input, ENDIF, ENDIF_len) == 0)
      {
         /* E N D 
          *
          * IF */
         LastCommand = ENDIF_COMMAND;
         nENDIF++;
         COPY_ENDIF;
         FORCE_COLON;
      }
      else
      {
         /* w a s 
          *
          * NO T 
          *
          * th e 
          *
          * st a r t 
          *
          * of 
          * a co m m a n d */
         COPYCHAR;
      }
   }
   /* end of input */
   if (nENDIF < nIF)
   {
      while (nENDIF < nIF)
      {
         /* we need trailing ENDIF's */
         nENDIF++;
         FORCE_COLON;
         FORCE_ENDIF;
      }
   }
   /* fixup trailing REMark command */
   if (bwb_strnicmp(Input, REM, REM_len) == 0)
   {
      /* REMark */
      /* 100 A=1 REMark */
      /* 100 A=1:REMark */
      /* 100 A=1'REMark */
      FORCE_COLON;
   }
   /* copy the comments */
   while (*Input != NULLCHAR)
   {
      COPYCHAR;
      /* cppcheck: (style) Variable 'LastChar' is assigned a value that is never used. */
   }
   OUTPUTCHAR(NULLCHAR);
   bwb_strcpy(InBuffer, OutBuffer);
}


/***************************************************************
  
        FUNCTION:       bwb_ladd()
  
        DESCRIPTION:    This function adds a new line (in the
                        buffer) to the program in memory.
  
***************************************************************/

int
bwb_ladd(char *buffer, LineType * p)
{
   LineType *l;
   LineType *previous;
   char           *newbuffer;

   char           *NextStatement;
   char           *ThisStatement;
   int             Replace = TRUE;
   char            BreakChar = BasicNulChar;


   bwx_DEBUG(__FUNCTION__);
   

   CleanLine(buffer);
   if ( buffer[0] == BasicNulChar )
   {
      return FALSE;
   }
   /* AUTO-FIX UNBALANCED QUOTES */
   FixQuotes(buffer);
   /*
   from here, the line WILL be added so the user can EDIT it,  
   we just complain and refuse to run if any error is detected.
   */

   My->rescan = TRUE;   /* program needs to be scanned again */

   if( IS_CHAR( *buffer, My->CurrentVersion->OptionStatementChar ) )
   {
      /* part of a multi-statement line */
   }
   else
   if( IS_CHAR( *buffer, My->CurrentVersion->OptionCommentChar ) )
   {
      /* part of a multi-statement line */
   }
   else
   {
      ImportClassicIfThenElse(buffer);
   }
   ThisStatement = buffer;
   NextStatement = NULL;
   BreakChar = BasicNulChar;

   do
   {
      if( BreakChar == BasicNulChar )
      {
          /* first pass thru the do{} while loop, do nothing */
      }
      else
      if( IS_CHAR( BreakChar, My->CurrentVersion->OptionCommentChar ) )
      {
          /* ThisStatment will turn out to be the last */
          *ThisStatement = My->CurrentVersion->OptionCommentChar;
      }
      else
      if( IS_CHAR( BreakChar, My->CurrentVersion->OptionStatementChar ) )
      {
          /* we are NOT the last statement, skip over the OptionStatementChar */
          ThisStatement++;
      }
      else
      {
         /* Internal Error */
      }
      
      if( BreakChar == BasicNulChar && IS_CHAR( *buffer, My->CurrentVersion->OptionStatementChar ) )
      {
         /* first pass thru and line begins with colon */
         /* part of a multi-statement line */
         NextStatement = NULL;
         if( My->NextValidLineNumber > 1 )
         {
            My->NextValidLineNumber--;
         }
         Replace = FALSE;
      }
      else
      if( BreakChar == BasicNulChar  && IS_CHAR( *buffer, My->CurrentVersion->OptionCommentChar ) )
      {
         /* first pass thru and line begins with apostrophe */
         /* part of a multi-statement line */
         NextStatement = NULL;
         if( My->NextValidLineNumber > 1 )
         {
            My->NextValidLineNumber--;
         }
         Replace = FALSE;
      }
      else
      {
         NextStatement = FindClassicStatementEnd(ThisStatement);
      }
      
      if (NextStatement == NULL)
      {
         /* we are the last statement */
      }
      else
      {
         /* another statement follows */
         BreakChar = *NextStatement;
         *NextStatement = BasicNulChar;
      }
      CleanLine(ThisStatement);
      if ( ThisStatement[0] != BasicNulChar )
      {

         /* get memory for this line */

         /* Revised to CALLOC pass-thru call by JBV */
         if ((l = (LineType *) CALLOC((size_t) 1, sizeof(LineType), "bwb_ladd")) == NULL)
         {
            WARN_OUT_OF_MEMORY;
            return FALSE;
         }
         /* this line has not been executed or numbered */
         l->LineFlags = 0;
         l->IncludeLevel = My->IncludeLevel; /* %INCLUDE */

         /* get the first element and test for a line number */
         l->position = 0;

         /* set line number in line structure */

         /* ALL lines will have a line number.  If a line
          * number is not provided, then the next available
          * line number is assigned.  */
         newbuffer = ThisStatement;
         l->number = My->NextValidLineNumber;

         if( buff_read_line_number(newbuffer, &(l->position), &l->number) )
         {
            if (l->number < My->NextValidLineNumber)
            {
               /* ERROR */
               sprintf(My->bwb_ebuf, "%d < %d - LINE OUT OF ORDER: %s\n", l->number, My->NextValidLineNumber, buffer);
               fputs( My->bwb_ebuf, My->SYSOUT->cfp );
               My->err_number = -1;  /* in bwb_ladd(), LINE OUT OF ORDER */
               l->number = My->NextValidLineNumber; /* sane default */
            }
            else
            if (l->number < BasicLineNumberMin || l->number > BasicLineNumberMax)
            {
               /* ERROR */
               sprintf(My->bwb_ebuf, "INVALID LINE NUMBER: %s\n", buffer);
               fputs( My->bwb_ebuf, My->SYSOUT->cfp );
               My->err_number = -1;  /* in bwb_ladd(), INVALID LINE NUMBER */
               l->number = My->NextValidLineNumber; /* sane default */
            }
            else
            {
               /* OK */
               My->NextValidLineNumber = l->number;
               l->LineFlags |= LINE_NUMBERED; /* line was manually numbered */
            }
            /* A SPACE IS REQUIRED AFTER THE LINE NUMBER
             * -- NO EXCEPTIONS */
            if (newbuffer[l->position] != ' ')
            {
               /* ERROR */
               sprintf(My->bwb_ebuf, "MISSING SPACE AFTER LINE NUMBER: %s\n", buffer);
               fputs( My->bwb_ebuf, My->SYSOUT->cfp );
               My->err_number = -1;  /* in bwb_ladd(), MISSING SPACE AFTER LINE NUMBER */
            }
            /* the buffer does NOT contain the line
             * number */
            newbuffer += l->position;
         }
         /* the next valid line number is this line number plus one */

         CleanLine(newbuffer);
         if (*newbuffer != BasicNulChar)
         {
            /* not an empty line, so it must start with a
             * BASIC COMMAND or VARIABLE */
            if( *newbuffer == My->CurrentVersion->OptionStatementChar )
            {
               /* this is a multi-statement line */
               newbuffer++;
               while( *newbuffer == ' ' )
               {
                  newbuffer++;
               }
            }
            if (bwb_isalpha(*newbuffer))
            {
               /* OK */
            }
            else
            if (*newbuffer == My->CurrentVersion->OptionCommentChar)
            {
               /* OK */
            }
            else
            if (*newbuffer == My->CurrentVersion->OptionPrintChar)
            {
               /* OK */
            }
            else
            if (*newbuffer == My->CurrentVersion->OptionImageChar)
            {
               /* OK */
            }
            else
            {
               /* ERROR */
               sprintf(My->bwb_ebuf, "ILLEGAL CHARACTER AFTER LINE NUMBER: %s\n", newbuffer);
               fputs( My->bwb_ebuf, My->SYSOUT->cfp );
               My->err_number = -1;  /* in bwb_ladd(), ILLEGAL CHARACTER AFTER LINE NUMBER */
            }
         }
         if (ln_asbuf(l, newbuffer) == FALSE)
         {
            /* ERROR */
            sprintf(My->bwb_ebuf, "INTERNAL ERROR, ln_asbuf() == FALSE\n");
            fputs( My->bwb_ebuf, My->SYSOUT->cfp );
            My->err_number = -1;  /* in bwb_ladd(), INTERNAL ERROR, ln_asbuf() == FALSE */
         }
         if (l->cmdnum > 0)
         {
            /* OK */
         }
         else
         {
            /* ERROR */
            sprintf(My->bwb_ebuf, "ILLEGAL COMMAND AFTER LINE NUMBER: %d %s\n", l->number, l->buffer);
            fputs( My->bwb_ebuf, My->SYSOUT->cfp );
            My->err_number = -1;  /* in bwb_ladd(), ILLEGAL COMMAND AFTER LINE NUMBER */
         }
         for (previous = p; previous != &My->bwb_end; previous = previous->next)
         {
            if (previous->number == l->number)
            {
               if (Replace == TRUE)
               {
                  /* REPLACE 'previous' */
                  while (previous->number == l->number)
                  {
                     LineType * z;
                     
                     z = previous;
                     previous = previous->next;
                     bwb_freeline( z );
                  }
                  l->next = previous;
                  p->next = l;
                  
               }
               else
               {
                  /* APPEND after 'previous' */
                  while (previous->next->number == l->number)
                  {
                     previous = previous->next;
                  }
                  l->next = previous->next;
                  previous->next = l;
               }
               break;
            }
            else
            if (previous->number < l->number && l->number < previous->next->number)
            {
               /* INSERT BETWEEN 'previous' AND
                * 'previous->next' */
               l->next = previous->next;
               previous->next = l;
               break;
            }
            p = previous;
         }

      }
      /* another statement may follow */
      ThisStatement = NextStatement;
      Replace = FALSE;

   }
   while (ThisStatement != NULL);

   My->NextValidLineNumber++;

   return TRUE;

}

/***************************************************************
  
        FUNCTION:       bwb_xtxtline()
  
        DESCRIPTION:    This function executes a text line, i.e.,
                        places it in memory and then relinquishes
                        control.
  
***************************************************************/

LineType *
bwb_xtxtline(char *buffer)
{
   bwx_DEBUG(__FUNCTION__);


   /* remove old program from memory */
   bwb_xnew(&My->user_line);

   /* advance past whitespace */
   while (*buffer == ' ')
   {
      buffer++;
   }
   if (*buffer == BasicNulChar)
   {
      return &My->bwb_end;
   }
   bwb_ladd(buffer, &My->user_line);


   /* execute the line as BASIC command line */
   if( bwb_incexec() )
   {
      My->stack_head->line = My->user_line.next; /* and set current line in it */
      My->stack_head->code = EXEC_NORM;   
      return My->user_line.next;
   }
   /* ERROR */
   return &My->bwb_end;
}

/***************************************************************
  
        FUNCTION:       bwb_incexec()
  
        DESCRIPTION:    This function increments the EXEC
         stack counter.
  
***************************************************************/

int
bwb_incexec(void)
{
   StackType * stack_item;
   bwx_DEBUG(__FUNCTION__);
   if( My->stack_level >= EXECLEVELS )
   {
      WARN_OUT_OF_MEMORY;
      return FALSE;
   }
   if ((stack_item = calloc(1, sizeof(StackType))) == NULL)
   {
      WARN_OUT_OF_MEMORY;
      return FALSE;
   }
   stack_item->line = My->ThisLine;
   stack_item->LoopTopLine = NULL;
   stack_item->local_variable = NULL;
   stack_item->OnErrorGoto = 0;
   stack_item->next = My->stack_head;
   My->stack_head = stack_item;
   My->stack_level++;
   return TRUE;
}

/***************************************************************
  
        FUNCTION:       bwb_decexec()
  
        DESCRIPTION:    This function decrements the EXEC
         stack counter.
  
***************************************************************/
void bwb_clrexec( void )
{
   bwx_DEBUG(__FUNCTION__);
   while(  My->stack_head != NULL )
   {
      bwb_decexec();
   }
}

void
bwb_decexec(void)
{
   StackType * stack_item;
   bwx_DEBUG(__FUNCTION__);

   if( My->stack_head == NULL )
   {
      WARN_RETURN_WITHOUT_GOSUB;
      return;
   }
   stack_item = My->stack_head;
   My->stack_head = stack_item->next;
   free( stack_item );
   My->stack_level--;
}

/***************************************************************
  
        FUNCTION:       bwb_mainloop()
  
        DESCRIPTION:    This C function performs one iteration
                        of the interpreter. In a non-preemptive
                        scheduler, this function should be called
                        by the scheduler, not by bwBASIC code.
  
***************************************************************/

void
bwb_mainloop(void)
{
   bwx_DEBUG(__FUNCTION__);

   if( My->stack_head != NULL )
   {
      /* BASIC program running */
      bwb_execline();   /* execute one line of program */
      return;
   }
   /* BASIC program completed */
   
   if( My->ExternalInputFile != NULL )
   {
      /* for automated testing, TAPE command */
      if( bwb_is_eof( My->ExternalInputFile ) == FALSE )
      {
         /* TAPE command is active */
         bwb_interact();   /* get user interaction */
         return;
      }
   }
   /* TAPE command inactive or completed */
   
   if (My->IsCommandLineFile == TRUE)
   {
      /* BASIC program was started from command line */
      bwx_terminate();
      return;
   }
   /* BASIC program was not started from command line */

   if (My->IsInteractive)
   {
      /* interactive */
      bwb_interact();   /* get user interaction */
      return;
   }
   /* non-interactive */

   bwx_terminate();
}

/***************************************************************
  
        FUNCTION:       bwb_execline()
  
        DESCRIPTION:    This function executes a single line of
                        a program in memory. This function is
         called by bwb_mainloop().
  
***************************************************************/

/*
ON statement (event trapping)
ON { COM(n) | KEY(n) | PEN | PLAY(n) | STRIG(n) | TIMER (x) } GOSUB line_number
ON ERROR GOTO line_number
  
*/
#define EVENT_ERROR 0x01
#define EVENT_COM   0X02
#define EVENT_KEY   0X04
#define EVENT_PEN   0X08
#define EVENT_PLAY  0X10
#define EVENT_STRIG 0X20
#define EVENT_TIMER 0X40
#define EVENT_USER  0X80

static void SetEvent(char EventType)
{
   bwx_DEBUG(__FUNCTION__);
   My->EventQueue |= EventType;
}
static void ClrEvent(char EventType)
{
   bwx_DEBUG(__FUNCTION__);
   My->EventQueue &= ~EventType;
}
static int HasEvent(char EventType)
{
   bwx_DEBUG(__FUNCTION__);
   return My->EventQueue & EventType;
}
void
bwb_Timer_On(void)
{
   bwx_DEBUG(__FUNCTION__);
   SetEvent(EVENT_TIMER);
}
void
bwb_Timer_Off(void)
{
   bwx_DEBUG(__FUNCTION__);
   ClrEvent(EVENT_TIMER);
}

void
bwb_Warning( int ErrorLevel, char *ErrorMessage )
{
   bwx_DEBUG(__FUNCTION__);
   if( ErrorLevel == 0 )
   {
      /* clear any existing error */
      My->err_number = 0;          /* ERR */
      My->err_line = NULL;         /* ERL */
      bwb_strcpy(My->ErrMsg, "");  /* ERROR$ */
      ClrEvent(EVENT_ERROR);
   }
   else
   {
      if( HasEvent(EVENT_ERROR) == 0 ) /* no errors pending */
      {
         /* only keep the first pending error to occur */
         if( ErrorMessage == NULL )
         {
            /* use the default error message */
            if( ErrorLevel > 0 && ErrorLevel < 80 )
            {
               ErrorMessage = DefaultErrorMessage[ ErrorLevel ];
            }
            else
            {
               ErrorMessage = DefaultErrorMessage[ 0 ];
            }
         }
         else
         {
            /* use a specified error message */
            if( bwb_strlen(ErrorMessage) > 255 )
            {
               ErrorMessage[ 255 ] = BasicNulChar;
            }
         }
         My->err_number = ErrorLevel;          /* ERR */
         if( My->stack_head != NULL )
         {
            My->err_line = My->stack_head->line;  /* ERL */
         }
         bwb_strcpy(My->ErrMsg, ErrorMessage); /* ERROR$ */
         SetEvent(EVENT_ERROR);
      }
   }
}
int
bwb_Warning_Pending(void)
{
   bwx_DEBUG(__FUNCTION__);
   return HasEvent(EVENT_ERROR);
}
void
bwb_Warning_Clear(void)
{
   bwx_DEBUG(__FUNCTION__);
   bwb_Warning(0, "");  /* clear */
}
int
bwb_Warning_Overflow(char *Message)
{
   /* Numeric overflow, String overflow, SPC() and TAB() */
   /* OVERFLOW is different.  A default value can be used. */
   /* If ON ERROR GOTO 0, then display message and continue (returns FALSE), otherwise ERROR 6 (returns TRUE) */
   bwx_DEBUG(__FUNCTION__);
   if (GetOnError() == 0)
   {
      /* user error handler NOT active */
#if TRUE
      fputs( Message, My->SYSOUT->cfp );
      fputs( "\n", My->SYSOUT->cfp );
#else
      sprintf( My->bwb_ebuf, "LINE %d: %s\n", My->ThisLine->number, Message );
      fputs( My->bwb_ebuf, My->SYSOUT->cfp );
#endif
      return FALSE;
   }
   /* user error handler IS active */
   bwb_Warning(6, Message);   /* Overflow */
   return TRUE;
}
void
bwb_execline(void)
{
   LineType *r, *l;

   bwx_DEBUG(__FUNCTION__);

   l = My->stack_head->line;

   /* if the line is &My->bwb_end, then break out of EXEC loops */
   if (l == &My->bwb_end || My->err_number < 0)
   {
      bwb_clrexec();
      return;
   }
   /* Check for wacko line numbers  */

   My->ThisLine = l;

   /* Print line number if trace is on */

   if (My->bwb_trace == TRUE)
   {
      if (l->number > 0)
      {
         sprintf(My->bwb_ebuf, "[ %d %s ]", l->number, l->buffer);
         prn_xprintf(My->bwb_ebuf);
      }
   }
   l->position = l->Startpos;

   /* if there is a BASIC command in the line, execute it here */


   if (l->cmdnum > 0)
   {
      /* OK */
   }
   else
   {
      WARN_ILLEGAL_DIRECT;
      l->cmdnum = C_REM;
   }
   /* l->cmdnum > 0 */
   
   if( l->LineFlags & LINE_BREAK )
   {
      /* BREAK line */
      l->LineFlags &= ~LINE_BREAK;
      My->ContinueLine = l;
      bwx_STOP();
      return;
   }


   /* execute the command vector */
   /* advance beyond whitespace */

   line_skip_spaces(l);

   if (My->CurrentVersion->OptionFlags & (OPTION_COVERAGE_ON) )
   {
      /* * We do this here * so "END" and "STOP" * are marked */
      if (l->cmdnum == C_DATA)
      {
         /* DATA lines are marked when they are READ */
      }
      else
      {
         /* this line was executed */
         l->LineFlags |= LINE_EXECUTED;
      }
   }

   r = bwb_vector(l);
   if( r == NULL )
   {
      WARN_INTERNAL_ERROR;
      return;
   }

   if (My->err_number < 0)  /* in bwb_execline, FATAL ERROR PENDING */
   {
      /* FATAL */
      bwb_clrexec();
      return;
   }
   if( bwb_Warning_Pending() /* Keep This */ )
   {
      /* we are probably not at the end-of-the-line */
   }
   else
   if (r == l)
   {
      /* we should be at the end-of-the-line */
      if ( line_is_eol(l) )
      {
         /* OK */
      }
      else
      {
         WARN_SYNTAX_ERROR;
         return;
      }
   }
   else
   {
      /* we are probably not at the end-of-the-line */
   }

   if (HasEvent(EVENT_ERROR))
   {
      /* a NON-FATAL ERROR has occurred. ERR, ERL, and ERROR$ were
       * already set using bwb_warning(ERR,ERROR$) */
      int             err_gotol;
      ClrEvent(EVENT_ERROR);
      err_gotol = GetOnError();
      if (l->number == 0)
      {
         /* BASIC PROMPT */
         /* For example: 10 ON ERROR GOTO 20 ERROR 1 */
         /* fall thru to the DEFAULT ERROR HANDLER */
      }
      else
      if (My->err_line == NULL)
      {
         /* BASIC PROMPT */
         /* For example: 10 ON ERROR GOTO 20 ERROR 1 */
         /* fall thru to the DEFAULT ERROR HANDLER */
      }
      else
      if (My->err_line->number == 0)
      {
         /* BASIC PROMPT */
         /* For example: 10 ON ERROR GOTO 20 ERROR 1 */
         /* fall thru to the DEFAULT ERROR HANDLER */
      }
      else
      if (err_gotol == -1)
      {
         /* ON ERROR RESUME NEXT */
         r->next->position = 0;
         My->stack_head->line = r->next;
         return;
      }
      else
      if (err_gotol == 0)
      {
         /* ON ERROR GOTO 0 */
         /* fall thru to the DEFAULT ERROR HANDLER */
      }
      else
      if (err_gotol == My->err_line->number)
      {
         /* RECURSION */
         /* For example: 10 ON ERROR GOTO 20 20 ERROR 1 */
         /* fall thru to the DEFAULT ERROR HANDLER */
      }
      else
      {
         /* USER ERROR HANDLER SPECIFIED */
         /* find the user-specified error handler and jump there */
         LineType *x;

         for (x = &My->bwb_start; x != &My->bwb_end; x = x->next)
         {
            if (x->number == err_gotol)
            {
               /* FOUND */
               if( My->CurrentVersion->OptionFlags & ( OPTION_ERROR_GOSUB ) )
               {
                   /* OPTION ERROR GOSUB */
                   if( bwb_incexec() )
                   {
                      x->position = 0;
                      My->stack_head->line = x;
                      My->stack_head->code = EXEC_GOSUB;
                   }
                   else
                   {
                      /* ERROR */
                      My->stack_head->line = &My->bwb_end;
                   }
               }
               else
               {
                   /* OPTION ERROR GOTO */
                   x->position = 0;  /* start of line */
                   My->stack_head->line = x;
               }
               return;
            }
         }
         /* NOT FOUND */
         /* fall thru to the DEFAULT ERROR HANDLER */
      }
      /* DEFAULT ERROR HANDLER */
      /* FATAL */
      bwx_DEBUG(My->ErrMsg); /* My->MaintainerDebugOn */
      prn_xprintf("\n");

      if( My->CurrentVersion->OptionVersionBitmask & ( C77 ) )
      {
         if( My->progfile[ 0 ] != BasicNulChar )
         {
            prn_xprintf("FILE:");
            prn_xprintf(My->progfile);
            prn_xprintf(", ");
         }
      }
      prn_xprintf("ERROR in line");
      if( My->ThisLine != NULL )
      {
         if ( BasicLineNumberMin <= My->ThisLine->number &&  My->ThisLine->number <= BasicLineNumberMax )
         {
            /* BASIC program line */
            char            tbuf[32];
            sprintf(tbuf, "%d", My->ThisLine->number);
            prn_xprintf(" ");
            prn_xprintf(tbuf);
         }
      }
      prn_xprintf(": ");
      prn_xprintf(My->ErrMsg);
      prn_xprintf("\n");

      if (My->CurrentVersion->OptionFlags & ( OPTION_TRACE_ON ) )
      {
         /* 
         ** Dump the BASIC stack trace when a FATAL error occurs.
         ** First line is the TOP of the stack.
         ** Last line is the BOTTOM of the stack.
         */
         StackType *stack_item;
         prn_xprintf("\nSTACK TRACE:\n");
         for( stack_item = My->stack_head; stack_item != NULL; stack_item = stack_item->next )
         {
            LineType *l;

            l = stack_item->line;
            if (l != NULL)
            {
               if ( BasicLineNumberMin <= l->number &&  l->number <= BasicLineNumberMax )
               {
                  /* BASIC program line */
                  char            LineNumber[32];
                  sprintf(LineNumber, "%d:", l->number);
                  prn_xprintf(LineNumber);
                  if (l->buffer != NULL)
                  {
                     prn_xprintf(l->buffer);
                  }
                  prn_xprintf("\n");
               }
            }
         }
      }

      My->AutomaticLineNumber = 0;
      My->AutomaticLineIncrement = 0;
   
      if (My->IsInteractive)
      {
         /* INTERACTIVE: terminate program */
   
         /* reset all stack counters */
         bwb_clrexec();
         SetOnError(0);
   
         My->err_number = -1; /* in break_handler() */
   
   
         /* reset the break handler */
         signal(SIGINT, break_mes);
   
   
         return;
      }
      /* NOT INTERACTIVE:  terminate immediately */
      bwx_terminate();
      return; /* never reached */
   }
   if (l->number > 0)
   {
      /* These events only occur in running programs */

      if (HasEvent(EVENT_TIMER))
      {
         /* TIMER ON */
         if (My->tmr_count > 0)
         {

            if (bwx_TIMER(0) > My->tmr_expires)
            {
               ClrEvent(EVENT_TIMER);
               if (My->tmr_line > 0)
               {
                  /* ON TIMER( My->tmr_count ) GOSUB My->tmr_line */
                  LineType *x;

                  for (x = &My->bwb_start; x != &My->bwb_end; x = x->next)
                  {
                     if (x->number == My->tmr_line)
                     {
                        /* FOUND */
                        /* save current stack level */
                        My->stack_head->line = r; 
                        /* increment exec stack */
                        if( bwb_incexec() )
                        {
                           /* set the new position to x and return x */
                           x->position = 0;
                           My->stack_head->line = x;
                           My->stack_head->code = EXEC_GOSUB;
                        }
                        else
                        {
                           /* ERROR */
                           My->stack_head->line = &My->bwb_end;
                        }
                        return;
                     }
                  }
                  /* NOT FOUND */
               }
            }
         }
      }
   }
   /* check for end of line: if so, advance to next line and return */
   if (r == l)
   {
      /* advance to the next line */
      l->next->position = 0;
      r = l->next;
   }
   else
   if ( line_is_eol( r ) )
   {
      /* we could be at the end-of-the-line, added for RETURN */
      /* advance to the next line */
      r->next->position = 0;
      r = r->next;
   }
   /* else reset with the value in r */
   My->stack_head->line = r;

}

/***************************************************************
  
        FUNCTION:       ln_asbuf()
  
        DESCRIPTION:    This function allocates memory and copies
         a null-terminated string to a line buffer.
  
***************************************************************/

int
ln_asbuf(LineType * l, char *s)
{
   bwx_DEBUG(__FUNCTION__);

   if (l->buffer != NULL)
   {
      /* Revised to FREE pass-thru call by JBV */
      FREE(l->buffer, "ln_asbuf");
      l->buffer = NULL; /* JBV */
   }
   /* Revised to CALLOC pass-thru call by JBV */
   if ((l->buffer = CALLOC(bwb_strlen(s) + 2, sizeof(char), "ln_asbuf")) == NULL)
   {
      WARN_OUT_OF_MEMORY;
      return FALSE;
   }
   /* copy the whole line to the line structure buffer */

   bwb_strcpy(l->buffer, s);


   /* strip CR from the buffer */

   CleanLine(l->buffer);


   /* determine command */
   line_start(l);

   return TRUE;

}


/***************************************************************
  
   FUNCTION:       is_ln()
  
   DESCRIPTION:    This function determines whether a program
         line (in buffer) begins with a line number.
  
***************************************************************/

int
is_ln(char *buffer)
{
   int             position;
   bwx_DEBUG(__FUNCTION__);

   position = 0;
   buff_skip_spaces(buffer, &position);
   if( bwb_isdigit(buffer[position]) )
   {
      return TRUE;
   }
   return FALSE;
}


/***************************************************************
  
   FUNCTION:       CALLOC()
  
   DESCRIPTION:    Pass-thru function to calloc() for debugging
         purposes.  Added by JBV 10/95
  
***************************************************************/

void           *
CALLOC(size_t nelem, size_t elsize, char *str)
{
   void           *ptr;

   bwx_DEBUG(__FUNCTION__);

   ptr = calloc(nelem, elsize);

   return ptr;
}

/***************************************************************
  
   FUNCTION:       FREE()
  
   DESCRIPTION:    Pass-thru function to free() for debugging
         purposes.  Added by JBV 10/95
  
***************************************************************/

void
FREE(void *ptr, char *str)
{
   bwx_DEBUG(__FUNCTION__);

   free(ptr);

}

/* SWITCH */
LineType *
bwb_vector( LineType *l )
{
   LineType *r;
   bwx_DEBUG(__FUNCTION__);
   bwx_DEBUG( l->buffer ); /* My->MaintainerDebugOn */
   switch( l->cmdnum )
   {
   case C_QUEST:
      r = bwb_QUEST( l );
      break;
   case C_APPEND:
      r = bwb_APPEND( l );
      break;
   case C_AS:
      r = bwb_AS( l );
      break;
   case C_AUTO:
      r = bwb_AUTO( l );
      break;
   case C_BACKSPACE:
      r = bwb_BACKSPACE( l );
      break;
   case C_BREAK:
      r = bwb_BREAK( l );
      break;
   case C_BYE:
      r = bwb_BYE( l );
      break;
   case C_CALL:
      r = bwb_CALL( l );
      break;
   case C_CASE:
      r = bwb_CASE( l );
      break;
   case C_CASE_ELSE:
      r = bwb_CASE_ELSE( l );
      break;
   case C_CHAIN:
      r = bwb_CHAIN( l );
      break;
   case C_CHANGE:
      r = bwb_CHANGE( l );
      break;
   case C_CLEAR:
      r = bwb_CLEAR( l );
      break;
   case C_CLOAD:
      r = bwb_CLOAD( l );
      break;
   case C_CLOAD8:
      r = bwb_CLOAD8( l );
      break;
   case C_CLOSE:
      r = bwb_CLOSE( l );
      break;
   case C_CLR:
      r = bwb_CLR( l );
      break;
   case C_CMDS:
      r = bwb_CMDS( l );
      break;
   case C_COMMON:
      r = bwb_COMMON( l );
      break;
   case C_CONSOLE:
      r = bwb_CONSOLE( l );
      break;
   case C_CONT:
      r = bwb_CONT( l );
      break;
   case C_CREATE:
      r = bwb_CREATE( l );
      break;
   case C_CSAVE:
      r = bwb_CSAVE( l );
      break;
   case C_CSAVE8:
      r = bwb_CSAVE8( l );
      break;
   case C_DATA:
      r = bwb_DATA( l );
      break;
   case C_DEF:
      r = bwb_DEF( l );
      break;
   case C_DEF_SUB:
      r = bwb_DEF_SUB( l );
      break;
   case C_DEFBYT:
      r = bwb_DEFBYT( l );
      break;
   case C_DEFCUR:
      r = bwb_DEFCUR( l );
      break;
   case C_DEFDBL:
      r = bwb_DEFDBL( l );
      break;
   case C_DEFINT:
      r = bwb_DEFINT( l );
      break;
   case C_DEFLNG:
      r = bwb_DEFLNG( l );
      break;
   case C_DEFSNG:
      r = bwb_DEFSNG( l );
      break;
   case C_DEFSTR:
      r = bwb_DEFSTR( l );
      break;
   case C_DELETE:
      r = bwb_DELETE( l );
      break;
   case C_DELIMIT:
      r = bwb_DELIMIT( l );
      break;
   case C_DIM:
      r = bwb_DIM( l );
      break;
   case C_DO:
      r = bwb_DO( l );
      break;
   case C_DSP:
      r = bwb_DSP( l );
      break;
   case C_EDIT:
      r = bwb_EDIT( l );
      break;
   case C_ELSE:
      r = bwb_ELSE( l );
      break;
   case C_ELSEIF:
      r = bwb_ELSEIF( l );
      break;
   case C_END:
      r = bwb_END( l );
      break;
   case C_END_FUNCTION:
      r = bwb_END_FUNCTION( l );
      break;
   case C_END_IF:
      r = bwb_END_IF( l );
      break;
   case C_END_SELECT:
      r = bwb_END_SELECT( l );
      break;
   case C_END_SUB:
      r = bwb_END_SUB( l );
      break;
   case C_ERASE:
      r = bwb_ERASE( l );
      break;
   case C_EXCHANGE:
      r = bwb_EXCHANGE( l );
      break;
   case C_EXIT:
      r = bwb_EXIT( l );
      break;
   case C_EXIT_DO:
      r = bwb_EXIT_DO( l );
      break;
   case C_EXIT_FOR:
      r = bwb_EXIT_FOR( l );
      break;
   case C_EXIT_FUNCTION:
      r = bwb_EXIT_FUNCTION( l );
      break;
   case C_EXIT_SUB:
      r = bwb_EXIT_SUB( l );
      break;
   case C_EXIT_UNTIL:
      r = bwb_EXIT_UNTIL( l );
      break;
   case C_EXIT_WHILE:
      r = bwb_EXIT_WHILE( l );
      break;
   case C_FEND:
      r = bwb_FEND( l );
      break;
   case C_FIELD:
      r = bwb_FIELD( l );
      break;
   case C_FILE:
      r = bwb_FILE( l );
      break;
   case C_FILES:
      r = bwb_FILES( l );
      break;
   case C_FNCS:
      r = bwb_FNCS( l );
      break;
   case C_FNEND:
      r = bwb_FNEND( l );
      break;
   case C_FOR:
      r = bwb_FOR( l );
      break;
   case C_FUNCTION:
      r = bwb_FUNCTION( l );
      break;
   case C_GET:
      r = bwb_GET( l );
      break;
   case C_GO:
      r = bwb_GO( l );
      break;
   case C_GO_SUB:
      r = bwb_GO_SUB( l );
      break;
   case C_GO_TO:
      r = bwb_GO_TO( l );
      break;
   case C_GOODBYE:
      r = bwb_GOODBYE( l );
      break;
   case C_GOSUB:
      r = bwb_GOSUB( l );
      break;
   case C_GOTO:
      r = bwb_GOTO( l );
      break;
   case C_HELP:
      r = bwb_HELP( l );
      break;
   case C_IF:
      r = bwb_IF( l );
      break;
   case C_IF_END:
      r = bwb_IF_END( l );
      break;
   case C_IF_MORE:
      r = bwb_IF_MORE( l );
      break;
   case C_IF_THEN:
      r = bwb_IF_THEN( l );
      break;
   case C_IMAGE:
      r = bwb_IMAGE( l );
      break;
   case C_INPUT:
      r = bwb_INPUT( l );
      break;
   case C_LET:
      r = bwb_LET( l );
      break;
   case C_LINE:
      r = bwb_LINE( l );
      break;
   case C_LIST:
      r = bwb_LIST( l );
      break;
   case C_LLIST:
      r = bwb_LLIST( l );
      break;
   case C_LOAD:
      r = bwb_LOAD( l );
      break;
   case C_LOOP:
      r = bwb_LOOP( l );
      break;
   case C_LPRINT:
      r = bwb_LPRINT( l );
      break;
   case C_LPRINTER:
      r = bwb_LPRINTER( l );
      break;
   case C_LSET:
      r = bwb_LSET( l );
      break;
   case C_MAINTAINER:
      r = bwb_MAINTAINER( l );
      break;
   case C_MARGIN:
      r = bwb_MARGIN( l );
      break;
   case C_MAT:
      r = bwb_MAT( l );
      break;
   case C_MAT_GET:
      r = bwb_MAT_GET( l );
      break;
   case C_MAT_INPUT:
      r = bwb_MAT_INPUT( l );
      break;
   case C_MAT_PRINT:
      r = bwb_MAT_PRINT( l );
      break;
   case C_MAT_PUT:
      r = bwb_MAT_PUT( l );
      break;
   case C_MAT_READ:
      r = bwb_MAT_READ( l );
      break;
   case C_MAT_WRITE:
      r = bwb_MAT_WRITE( l );
      break;
   case C_MERGE:
      r = bwb_MERGE( l );
      break;
   case C_MID4:
      r = bwb_MID4( l );
      break;
   case C_NAME:
      r = bwb_NAME( l );
      break;
   case C_NEW:
      r = bwb_NEW( l );
      break;
   case C_NEXT:
      r = bwb_NEXT( l );
      break;
   case C_OF:
      r = bwb_OF( l );
      break;
   case C_OLD:
      r = bwb_OLD( l );
      break;
   case C_ON:
      r = bwb_ON( l );
      break;
   case C_ON_ERROR:
      r = bwb_ON_ERROR( l );
      break;
   case C_ON_ERROR_GOSUB:
      r = bwb_ON_ERROR_GOSUB( l );
      break;
   case C_ON_ERROR_GOTO:
      r = bwb_ON_ERROR_GOTO( l );
      break;
   case C_ON_ERROR_RESUME:
      r = bwb_ON_ERROR_RESUME( l );
      break;
   case C_ON_ERROR_RESUME_NEXT:
      r = bwb_ON_ERROR_RESUME_NEXT( l );
      break;
   case C_ON_ERROR_RETURN:
      r = bwb_ON_ERROR_RETURN( l );
      break;
   case C_ON_ERROR_RETURN_NEXT:
      r = bwb_ON_ERROR_RETURN_NEXT( l );
      break;
   case C_ON_TIMER:
      r = bwb_ON_TIMER( l );
      break;
   case C_OPEN:
      r = bwb_OPEN( l );
      break;
   case C_OPTION:
      r = bwb_OPTION( l );
      break;
   case C_OPTION_ANGLE:
      r = bwb_OPTION_ANGLE( l );
      break;
   case C_OPTION_ANGLE_DEGREES:
      r = bwb_OPTION_ANGLE_DEGREES( l );
      break;
   case C_OPTION_ANGLE_GRADIANS:
      r = bwb_OPTION_ANGLE_GRADIANS( l );
      break;
   case C_OPTION_ANGLE_RADIANS:
      r = bwb_OPTION_ANGLE_RADIANS( l );
      break;
   case C_OPTION_ARITHMETIC:
      r = bwb_OPTION_ARITHMETIC( l );
      break;
   case C_OPTION_ARITHMETIC_DECIMAL:
      r = bwb_OPTION_ARITHMETIC_DECIMAL( l );
      break;
   case C_OPTION_ARITHMETIC_FIXED:
      r = bwb_OPTION_ARITHMETIC_FIXED( l );
      break;
   case C_OPTION_ARITHMETIC_NATIVE:
      r = bwb_OPTION_ARITHMETIC_NATIVE( l );
      break;
   case C_OPTION_BASE:
      r = bwb_OPTION_BASE( l );
      break;
   case C_OPTION_BUGS:
      r = bwb_OPTION_BUGS( l );
      break;
   case C_OPTION_BUGS_OFF:
      r = bwb_OPTION_BUGS_OFF( l );
      break;
   case C_OPTION_BUGS_ON:
      r = bwb_OPTION_BUGS_ON( l );
      break;
   case C_OPTION_COMMENT:
      r = bwb_OPTION_COMMENT( l );
      break;
   case C_OPTION_COMPARE:
      r = bwb_OPTION_COMPARE( l );
      break;
   case C_OPTION_COMPARE_BINARY:
      r = bwb_OPTION_COMPARE_BINARY( l );
      break;
   case C_OPTION_COMPARE_DATABASE:
      r = bwb_OPTION_COMPARE_DATABASE( l );
      break;
   case C_OPTION_COMPARE_TEXT:
      r = bwb_OPTION_COMPARE_TEXT( l );
      break;
   case C_OPTION_COVERAGE:
      r = bwb_OPTION_COVERAGE( l );
      break;
   case C_OPTION_COVERAGE_OFF:
      r = bwb_OPTION_COVERAGE_OFF( l );
      break;
   case C_OPTION_COVERAGE_ON:
      r = bwb_OPTION_COVERAGE_ON( l );
      break;
   case C_OPTION_DATE:
      r = bwb_OPTION_DATE( l );
      break;
   case C_OPTION_DISABLE:
      r = bwb_OPTION_DISABLE( l );
      break;
   case C_OPTION_DISABLE_COMMAND:
      r = bwb_OPTION_DISABLE_COMMAND( l );
      break;
   case C_OPTION_DISABLE_FUNCTION:
      r = bwb_OPTION_DISABLE_FUNCTION( l );
      break;
   case C_OPTION_DISABLE_OPERATOR:
      r = bwb_OPTION_DISABLE_OPERATOR( l );
      break;
   case C_OPTION_ENABLE:
      r = bwb_OPTION_ENABLE( l );
      break;
   case C_OPTION_ENABLE_COMMAND:
      r = bwb_OPTION_ENABLE_COMMAND( l );
      break;
   case C_OPTION_ENABLE_FUNCTION:
      r = bwb_OPTION_ENABLE_FUNCTION( l );
      break;
   case C_OPTION_ENABLE_OPERATOR:
      r = bwb_OPTION_ENABLE_OPERATOR( l );
      break;
   case C_OPTION_ERROR:
      r = bwb_OPTION_ERROR( l );
      break;
   case C_OPTION_ERROR_GOSUB:
      r = bwb_OPTION_ERROR_GOSUB( l );
      break;
   case C_OPTION_ERROR_GOTO:
      r = bwb_OPTION_ERROR_GOTO( l );
      break;
   case C_OPTION_EXPLICIT:
      r = bwb_OPTION_EXPLICIT( l );
      break;
   case C_OPTION_IMAGE:
      r = bwb_OPTION_IMAGE( l );
      break;
   case C_OPTION_IMPLICIT:
      r = bwb_OPTION_IMPLICIT( l );
      break;
   case C_OPTION_INDENT:
      r = bwb_OPTION_INDENT( l );
      break;
   case C_OPTION_LABELS:
      r = bwb_OPTION_LABELS( l );
      break;
   case C_OPTION_LABELS_OFF:
      r = bwb_OPTION_LABELS_OFF( l );
      break;
   case C_OPTION_LABELS_ON:
      r = bwb_OPTION_LABELS_ON( l );
      break;
   case C_OPTION_PRINT:
      r = bwb_OPTION_PRINT( l );
      break;
   case C_OPTION_ROUND:
      r = bwb_OPTION_ROUND( l );
      break;
   case C_OPTION_ROUND_BANK:
      r = bwb_OPTION_ROUND_BANK( l );
      break;
   case C_OPTION_ROUND_MATH:
      r = bwb_OPTION_ROUND_MATH( l );
      break;
   case C_OPTION_ROUND_TRUNCATE:
      r = bwb_OPTION_ROUND_TRUNCATE( l );
      break;
   case C_OPTION_SLEEP:
      r = bwb_OPTION_SLEEP( l );
      break;
   case C_OPTION_STATEMENT:
      r = bwb_OPTION_STATEMENT( l );
      break;
   case C_OPTION_STDERR:
      r = bwb_OPTION_STDERR( l );
      break;
   case C_OPTION_STDIN:
      r = bwb_OPTION_STDIN( l );
      break;
   case C_OPTION_STDOUT:
      r = bwb_OPTION_STDOUT( l );
      break;
   case C_OPTION_STRICT:
      r = bwb_OPTION_STRICT( l );
      break;
   case C_OPTION_STRICT_OFF:
      r = bwb_OPTION_STRICT_OFF( l );
      break;
   case C_OPTION_STRICT_ON:
      r = bwb_OPTION_STRICT_ON( l );
      break;
   case C_OPTION_TERMINAL:
      r = bwb_OPTION_TERMINAL( l );
      break;
   case C_OPTION_TERMINAL_ADM:
      r = bwb_OPTION_TERMINAL_ADM( l );
      break;
   case C_OPTION_TERMINAL_ANSI:
      r = bwb_OPTION_TERMINAL_ANSI( l );
      break;
   case C_OPTION_TERMINAL_NONE:
      r = bwb_OPTION_TERMINAL_NONE( l );
      break;
   case C_OPTION_TIME:
      r = bwb_OPTION_TIME( l );
      break;
   case C_OPTION_TRACE:
      r = bwb_OPTION_TRACE( l );
      break;
   case C_OPTION_TRACE_OFF:
      r = bwb_OPTION_TRACE_OFF( l );
      break;
   case C_OPTION_TRACE_ON:
      r = bwb_OPTION_TRACE_ON( l );
      break;
   case C_OPTION_USING:
      r = bwb_OPTION_USING( l );
      break;
   case C_OPTION_VERSION:
      r = bwb_OPTION_VERSION( l );
      break;
   case C_PAUSE:
      r = bwb_PAUSE( l );
      break;
   case C_POP:
      r = bwb_POP( l );
      break;
   case C_PRINT:
      r = bwb_PRINT( l );
      break;
   case C_PUT:
      r = bwb_PUT( l );
      break;
   case C_QUIT:
      r = bwb_QUIT( l );
      break;
   case C_READ:
      r = bwb_READ( l );
      break;
   case C_RECALL:
      r = bwb_RECALL( l );
      break;
   case C_REM:
      r = bwb_REM( l );
      break;
   case C_RENAME:
      r = bwb_RENAME( l );
      break;
   case C_RENUM:
      r = bwb_RENUM( l );
      break;
   case C_RENUMBER:
      r = bwb_RENUMBER( l );
      break;
   case C_RESET:
      r = bwb_RESET( l );
      break;
   case C_RESTORE:
      r = bwb_RESTORE( l );
      break;
   case C_RESUME:
      r = bwb_RESUME( l );
      break;
   case C_RETURN:
      r = bwb_RETURN( l );
      break;
   case C_RSET:
      r = bwb_RSET( l );
      break;
   case C_RUN:
      r = bwb_RUN( l );
      break;
   case C_SAVE:
      r = bwb_SAVE( l );
      break;
   case C_SCRATCH:
      r = bwb_SCRATCH( l );
      break;
   case C_SELECT:
      r = bwb_SELECT( l );
      break;
   case C_SELECT_CASE:
      r = bwb_SELECT_CASE( l );
      break;
   case C_STEP:
      r = bwb_STEP( l );
      break;
   case C_STOP:
      r = bwb_STOP( l );
      break;
   case C_STORE:
      r = bwb_STORE( l );
      break;
   case C_SUB:
      r = bwb_SUB( l );
      break;
   case C_SUBEND:
      r = bwb_SUBEND( l );
      break;
   case C_SWAP:
      r = bwb_SWAP( l );
      break;
   case C_SYSTEM:
      r = bwb_SYSTEM( l );
      break;
   case C_TEXT:
      r = bwb_TEXT( l );
      break;
   case C_THEN:
      r = bwb_THEN( l );
      break;
   case C_TIMER:
      r = bwb_TIMER( l );
      break;
   case C_TIMER_OFF:
      r = bwb_TIMER_OFF( l );
      break;
   case C_TIMER_ON:
      r = bwb_TIMER_ON( l );
      break;
   case C_TIMER_STOP:
      r = bwb_TIMER_STOP( l );
      break;
   case C_TLOAD:
      r = bwb_TLOAD( l );
      break;
   case C_TO:
      r = bwb_TO( l );
      break;
   case C_TRACE:
      r = bwb_TRACE( l );
      break;
   case C_TRACE_OFF:
      r = bwb_TRACE_OFF( l );
      break;
   case C_TRACE_ON:
      r = bwb_TRACE_ON( l );
      break;
   case C_TSAVE:
      r = bwb_TSAVE( l );
      break;
   case C_UEND:
      r = bwb_UEND( l );
      break;
   case C_UNTIL:
      r = bwb_UNTIL( l );
      break;
   case C_USE:
      r = bwb_USE( l );
      break;
   case C_USER_LBL:
      r = bwb_USER_LBL( l );
      break;
   case C_VARS:
      r = bwb_VARS( l );
      break;
   case C_WEND:
      r = bwb_WEND( l );
      break;
   case C_WHILE:
      r = bwb_WHILE( l );
      break;
   case C_WRITE:
      r = bwb_WRITE( l );
      break;
   default:
      WARN_INTERNAL_ERROR;
      r = l;
      break;
   }
   return r;
}

/* EOF */