home *** CD-ROM | disk | FTP | other *** search
/ EuroCD 3 / EuroCD 3.iso / Programming / PPCbwb111 / source / bwb_int.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-06-24  |  17.0 KB  |  728 lines
  1. /***************************************************************f
  2.  
  3.         bwb_int.c       Line Interpretation Routines
  4.                         for Bywater BASIC Interpreter
  5.  
  6.                         Copyright (c) 1992, Ted A. Campbell
  7.  
  8.                         Bywater Software
  9.                         P. O. Box 4023
  10.                         Duke Station
  11.                         Durham, NC  27706
  12.  
  13.                         email: tcamp@acpub.duke.edu
  14.  
  15.         Copyright and Permissions Information:
  16.  
  17.         All U.S. and international copyrights are claimed by the
  18.         author. The author grants permission to use this code
  19.         and software based on it under the following conditions:
  20.         (a) in general, the code and software based upon it may be
  21.         used by individuals and by non-profit organizations; (b) it
  22.         may also be utilized by governmental agencies in any country,
  23.         with the exception of military agencies; (c) the code and/or
  24.         software based upon it may not be sold for a profit without
  25.         an explicit and specific permission from the author, except
  26.         that a minimal fee may be charged for media on which it is
  27.         copied, and for copying and handling; (d) the code must be
  28.         distributed in the form in which it has been released by the
  29.         author; and (e) the code and software based upon it may not
  30.         be used for illegal activities.
  31.  
  32. ***************************************************************/
  33.  
  34. #include <stdio.h>
  35. #include <stdlib.h>
  36. #include <ctype.h>
  37. #include <string.h>
  38.  
  39. #include "bwbasic.h"
  40. #include "bwb_mes.h"
  41.  
  42. /***************************************************************
  43.  
  44.         FUNCTION:       adv_element()
  45.  
  46.         DESCRIPTION:    This function reads characters in <buffer>
  47.                         beginning at <pos> and advances past a
  48.                         line element, incrementing <pos> appropri-
  49.                         ately and returning the line element in
  50.                         <element>.
  51.  
  52. ***************************************************************/
  53.  
  54. int
  55. adv_element( char *buffer, int *pos, char *element )
  56.    {
  57.    int loop;                                    /* control loop */
  58.    int e_pos;                                   /* position in element buffer */
  59.    int str_const;                               /* boolean: building a string constant */
  60.  
  61.    /* advance beyond any initial whitespace */
  62.  
  63.    adv_ws( buffer, pos );
  64.  
  65. #if INTENSIVE_DEBUG
  66.    sprintf( bwb_ebuf, "in adv_element(): receieved <%s>.", &( buffer[ *pos ] ));
  67.    bwb_debug( bwb_ebuf );
  68. #endif
  69.  
  70.    /* now loop while building an element and looking for an
  71.       element terminator */
  72.  
  73.    loop = TRUE;
  74.    e_pos = 0;
  75.    element[ e_pos ] = '\0';
  76.    str_const = FALSE;
  77.  
  78.    while ( loop == TRUE )
  79.       {
  80.       switch( buffer[ *pos ] )
  81.          {
  82.          case ',':                      /* element terminators */
  83.          case ';':
  84.          case ':':
  85.          case '=':
  86.          case ' ':
  87.          case '\t':
  88.          case '\0':
  89.          case '\n':
  90.          case '\r':
  91.             if ( str_const == TRUE )
  92.                {
  93.                element[ e_pos ] = buffer[ *pos ];
  94.                ++e_pos;
  95.                ++( *pos );
  96.                element[ e_pos ] = '\0';
  97.                }
  98.             else
  99.                {
  100.                return TRUE;
  101.                }
  102.             break;
  103.  
  104.          case '\"':                     /* string constant */
  105.             element[ e_pos ] = buffer[ *pos ];
  106.             ++e_pos;
  107.             ++( *pos );
  108.             element[ e_pos ] = '\0';
  109.             if ( str_const == TRUE )    /* termination of string constant */
  110.                {
  111.                return TRUE;
  112.                }
  113.             else                        /* beginning of string constant */
  114.                {
  115.                str_const = TRUE;
  116.                }
  117.             break;
  118.  
  119.          default:
  120.             element[ e_pos ] = buffer[ *pos ];
  121.             ++e_pos;
  122.             ++( *pos );
  123.             element[ e_pos ] = '\0';
  124.             break;
  125.          }
  126.       }
  127.  
  128.    /* This should not happen */
  129.  
  130.    return FALSE;
  131.  
  132.    }
  133.  
  134. /***************************************************************
  135.  
  136.         FUNCTION:       adv_ws()
  137.  
  138.         DESCRIPTION:    This function reads characters in <buffer>
  139.                         beginning at <pos> and advances past any
  140.                         whitespace, incrementing <pos> appropri-
  141.                         ately.
  142.  
  143. ***************************************************************/
  144.  
  145. int
  146. adv_ws( char *buffer, int *pos )
  147.    {
  148.    int loop;
  149.  
  150.    loop = TRUE;
  151.    while ( loop == TRUE )
  152.       {
  153.       switch( buffer[ *pos ] )
  154.          {
  155.          case ' ':
  156.          case '\t':
  157.             ++( *pos );
  158.             break;
  159.          default:
  160.             return TRUE;
  161.          }
  162.       }
  163.  
  164.    /* This should not happen */
  165.  
  166.    return FALSE;
  167.  
  168.    }
  169.  
  170. /***************************************************************
  171.  
  172.         FUNCTION:       bwb_strtoupper()
  173.  
  174.         DESCRIPTION:    This function converts the string in
  175.                         <buffer> to upper-case characters.
  176.  
  177. ***************************************************************/
  178.  
  179. int
  180. bwb_strtoupper( char *buffer )
  181.    {
  182.    char *p;
  183.  
  184.    p = buffer;
  185.    while ( *p != '\0' )
  186.       {
  187.       if ( islower( *p ) != FALSE )
  188.          {
  189.          *p = toupper( *p );
  190.          }
  191.       ++p;
  192.       }
  193.  
  194.    return TRUE;
  195.  
  196.    }
  197.  
  198. /***************************************************************
  199.  
  200.         FUNCTION:       line_start()
  201.  
  202.         DESCRIPTION:    This function reads a line buffer in
  203.                         <buffer> beginning at the position
  204.                         <pos> and attempts to determine (a)
  205.                         the position of the line number in the
  206.                         buffer (returned in <lnpos>), (b) the
  207.                         line number at this position (returned
  208.                         in <lnum>), (c) the position of the
  209.                         BASIC command in the buffer (returned
  210.                         in <cmdpos>), (d) the position of this
  211.                         BASIC command in the command table
  212.                         (returned in <cmdnum>), and (e) the
  213.                         position of the beginning of the rest
  214.                         of the line (returned in <startpos>).
  215.                         Although <startpos> must be returned
  216.                         as a positive integer, the other
  217.                         searches may fail, in which case FALSE
  218.                         will be returned in their positions.
  219.                         <pos> is not incremented.
  220.  
  221. ***************************************************************/
  222.  
  223. int
  224. line_start( char *buffer, int *pos, int *lnpos, int *lnum, int *cmdpos,
  225.    int *cmdnum, int *startpos )
  226.    {
  227.    static int position;
  228.    register int n;
  229.    static char *tbuf;
  230.    static int init = FALSE;
  231.  
  232.    /* get memory for temporary buffer if necessary */
  233.  
  234.    if ( init == FALSE )
  235.       {
  236.       init = TRUE;
  237.       if ( ( tbuf = calloc( MAXSTRINGSIZE + 1, sizeof( char ) )) == NULL )
  238.          {
  239.          bwb_error( err_getmem );
  240.          }
  241.       }
  242.  
  243. #if INTENSIVE_DEBUG
  244.    sprintf( bwb_ebuf, "in line_start(): pos <%d> buffer <%s>", *pos,
  245.       buffer );
  246.    bwb_debug( bwb_ebuf );
  247. #endif
  248.  
  249.    /* set initial values */
  250.  
  251.    *startpos = position = *pos;
  252.    *cmdpos = *lnpos = *pos;
  253.    *cmdnum = *lnum = -1;
  254.  
  255.    /* check for null line */
  256.  
  257.    adv_ws( buffer, &position );
  258.    if ( buffer[ position ] == '\0' )
  259.       {
  260. #if INTENSIVE_DEBUG
  261.       bwb_debug( "in line_start(): found NULL line" );
  262. #endif
  263.       *cmdnum = getcmdnum( "REM" );
  264.       return TRUE;
  265.       }
  266.  
  267.    /* advance beyond the first element */
  268.  
  269.    *lnpos = position;
  270.    adv_element( buffer, &position, tbuf );
  271.    adv_ws( buffer, &position );
  272.  
  273.    /* test for a line number in the first element */
  274.  
  275.    if ( is_numconst( tbuf ) == TRUE )               /* a line number */
  276.       {
  277.  
  278.       *lnum = atoi( tbuf );
  279.       *startpos = position;                             /* temp */
  280.       *cmdpos = position;
  281.  
  282.       adv_element( buffer, &position, tbuf );       /* advance past next element */
  283.  
  284. #if INTENSIVE_DEBUG
  285.       sprintf( bwb_ebuf, "in line_start(): new element is <%s>", tbuf );
  286.       bwb_debug( bwb_ebuf );
  287. #endif
  288.  
  289.       if ( is_cmd( tbuf, cmdnum ) == TRUE )
  290.          {
  291.          adv_ws( buffer, &position );
  292.          *startpos = position;
  293.          }
  294.       else if ( is_let( &( buffer[ *cmdpos ] ), cmdnum ) == TRUE )
  295.          {
  296.          *cmdpos = -1;
  297.          }
  298.       else
  299.          {
  300.          *cmdpos = *cmdnum = -1;
  301.          }
  302.       }
  303.  
  304.    /* not a line number */
  305.  
  306.    else
  307.       {
  308.       *lnum = -1;
  309.       *lnpos = -1;
  310.  
  311. #if INTENSIVE_DEBUG
  312.       sprintf( bwb_ebuf, "in line_start(): no line number, element <%s>.",
  313.          tbuf );
  314.       bwb_debug( bwb_ebuf );
  315. #endif
  316.  
  317.       if ( is_cmd( tbuf, cmdnum ) == TRUE )
  318.          {
  319.          adv_ws( buffer, &position );
  320.          *startpos = position;
  321.          }
  322.       else if ( is_let( &( buffer[ position ] ), cmdnum ) == TRUE )
  323.          {
  324.          adv_ws( buffer, &position );
  325.          *cmdpos = -1;
  326.          }
  327.       else
  328.          {
  329.          *cmdpos = *cmdnum = -1;
  330.          }
  331.       }
  332.  
  333. #if INTENSIVE_DEBUG
  334.    sprintf( bwb_ebuf, "in line_start(): lnpos <%d> lnum <%d>",
  335.       *lnpos, *lnum );
  336.    bwb_debug( bwb_ebuf );
  337.    sprintf( bwb_ebuf, "in line_start(): cmdpos <%d> cmdnum <%d> startpos <%d>",
  338.       *cmdpos, *cmdnum, *startpos );
  339.    bwb_debug( bwb_ebuf );
  340. #endif
  341.  
  342.    /* return */
  343.  
  344.    return TRUE;
  345.  
  346.    }
  347.  
  348. /***************************************************************
  349.  
  350.         FUNCTION:       is_cmd()
  351.  
  352.         DESCRIPTION:
  353.  
  354. ***************************************************************/
  355.  
  356. int
  357. is_cmd( char *buffer, int *cmdnum )
  358.    {
  359.    register int n;
  360.  
  361.    /* Convert the command name to upper case */
  362.  
  363.    bwb_strtoupper( buffer );
  364.  
  365.    /* Go through the command table and search for a match. */
  366.  
  367.    for ( n = 0; n < COMMANDS; ++n )
  368.       {
  369.       if ( strncmp( bwb_cmdtable[ n ].name, buffer,
  370.          strlen( bwb_cmdtable[ n ].name )) == 0 )
  371.          {
  372.          *cmdnum = n;
  373. #if INTENSIVE_DEBUG
  374.          bwb_debug( "in is_cmd(): command found" );
  375. #endif
  376.          return TRUE;
  377.          }
  378.       }
  379.  
  380.    /* No command name was found */
  381.  
  382. #if INTENSIVE_DEBUG
  383.    bwb_debug( "in is_cmd(): command not found" );
  384. #endif
  385.  
  386.    *cmdnum = -1;
  387.    return FALSE;
  388.  
  389.    }
  390.  
  391. /***************************************************************
  392.  
  393.         FUNCTION:       is_let()
  394.  
  395.         DESCRIPTION:    This function tries to determine if the
  396.                         expression in <buffer> is a LET statement
  397.                         without the LET command specified.
  398.  
  399. ***************************************************************/
  400.  
  401. int
  402. is_let( char *buffer, int *cmdnum )
  403.    {
  404.    register int n, i;
  405.  
  406. #if INTENSIVE_DEBUG
  407.    sprintf( bwb_ebuf, "in is_let(): buffer <%s>", buffer );
  408.    bwb_debug( bwb_ebuf );
  409. #endif
  410.  
  411.    /* Go through the expression and search for an assignment operator. */
  412.  
  413.    for ( n = 0; buffer[ n ] != '\0'; ++n )
  414.       {
  415.       switch( buffer[ n ] )
  416.          {
  417.          case '\"':                     /* string constant */
  418.             ++n;
  419.             while( buffer[ n ] != '\"' )
  420.                {
  421.                ++n;
  422.                if ( buffer[ n ] == '\0' )
  423.                   {
  424. #if PROG_ERRORS
  425.                   sprintf( bwb_ebuf, "Incomplete string constant" );
  426.                   bwb_error( bwb_ebuf );
  427. #else
  428.                   bwb_error( err_syntax );
  429. #endif
  430.                   *cmdnum = -1;
  431.                   return FALSE;
  432.                   }
  433.                }
  434.             ++n;
  435.             break;
  436.          case '=':
  437.  
  438. #if INTENSIVE_DEBUG
  439.             sprintf( bwb_ebuf, "in is_let(): implied LET found." );
  440.             bwb_debug( bwb_ebuf );
  441. #endif
  442.  
  443.             for ( i = 0; i < COMMANDS; ++i )
  444.                {
  445.                if ( strncmp( bwb_cmdtable[ i ].name, "LET", (size_t) 3 ) == 0 )
  446.                   {
  447.                   *cmdnum = i;
  448.                   }
  449.                }
  450.             return TRUE;
  451.          }
  452.       }
  453.  
  454.    /* No command name was found */
  455.  
  456.    *cmdnum = -1;
  457.    return FALSE;
  458.  
  459.    }
  460.  
  461. /***************************************************************
  462.  
  463.         FUNCTION:       bwb_stripcr()
  464.  
  465.         DESCRIPTION:
  466.  
  467.  
  468. ***************************************************************/
  469.  
  470. int
  471. bwb_stripcr( char *s )
  472.    {
  473.    char *p;
  474.  
  475.    p = s;
  476.    while ( *p != 0 )
  477.       {
  478.       switch( *p )
  479.          {
  480.  
  481.  
  482.          case '\r':
  483.          case '\n':
  484.             *p = 0;
  485.             return TRUE;
  486.          }
  487.       ++p;
  488.       }
  489.    *p = 0;
  490.    return TRUE;
  491.    }
  492.  
  493. /***************************************************************
  494.  
  495.         FUNCTION:       is_numconst()
  496.  
  497.         DESCRIPTION:    This function reads the string in <buffer>
  498.                         and returns TRUE if it is a numerical
  499.                         constant and FALSE if it is not. At
  500.                         this point, only decimal (base 10)
  501.                         constants are detected.
  502.  
  503. ***************************************************************/
  504.  
  505. int
  506. is_numconst( char *buffer )
  507.    {
  508.    char *p;
  509.  
  510. #if INTENSIVE_DEBUG
  511.    sprintf( bwb_ebuf, "in is_numconst(): received string <%s>.", buffer );
  512.    bwb_debug( bwb_ebuf );
  513. #endif
  514.  
  515.    /* Return FALSE for empty buffer */
  516.  
  517.    if ( buffer[ 0 ] == '\0' )
  518.       {
  519.       return FALSE;
  520.       }
  521.  
  522.    /* else check digits */
  523.  
  524.    p = buffer;
  525.    while( *p != '\0' )
  526.       {
  527.       switch( *p )
  528.          {
  529.          case '0':
  530.          case '1':
  531.          case '2':
  532.          case '3':
  533.          case '4':
  534.          case '5':
  535.          case '6':
  536.          case '7':
  537.          case '8':
  538.          case '9':
  539.             break;
  540.          default:
  541.             return FALSE;
  542.          }
  543.       ++p;
  544.       }
  545.  
  546.    /* only numerical characters detected */
  547.  
  548.    return TRUE;
  549.  
  550.    }
  551.  
  552. /***************************************************************
  553.  
  554.         FUNCTION:       bwb_numseq()
  555.  
  556.         DESCRIPTION:
  557.  
  558. ***************************************************************/
  559.  
  560. int
  561. bwb_numseq( char *buffer, int *start, int *end )
  562.    {
  563.    register int b, n;
  564.    int numbers;
  565.    static char *tbuf;
  566.    static int init = FALSE;
  567.  
  568.    /* get memory for temporary buffer if necessary */
  569.  
  570.    if ( init == FALSE )
  571.       {
  572.       init = TRUE;
  573.       if ( ( tbuf = calloc( MAXSTRINGSIZE + 1, sizeof( char ) )) == NULL )
  574.          {
  575.          bwb_error( err_getmem );
  576.          }
  577.       }
  578.  
  579.    if ( buffer[ 0 ] == 0 )
  580.       {
  581.       *start = *end = 0;
  582.       return FALSE;
  583.       }
  584.  
  585.    numbers = n = b = 0;
  586.    tbuf[ 0 ] = 0;
  587.    while( TRUE )
  588.       {
  589.       switch( buffer[ b ] )
  590.          {
  591.          case 0:                           /* end of string */
  592.          case '\n':
  593.          case '\r':
  594.             if ( n > 0 )
  595.                {
  596.                if ( numbers == 0 )
  597.                   {
  598.                   *end = 0;
  599.                   *start = atoi( tbuf );
  600.                   ++numbers;
  601.                   }
  602.                else
  603.                   {
  604.  
  605.                   *end = atoi( tbuf );
  606.                   return TRUE;
  607.                   }
  608.                }
  609.             else
  610.                {
  611.                if ( numbers == 0 )
  612.                   {
  613.                   *start = *end = 0;
  614.                   }
  615.                else if ( numbers == 1 )
  616.                   {
  617.                   *end = 0;
  618.                   }
  619.                else if ( ( numbers == 2 ) && ( tbuf[ 0 ] == 0 ))
  620.                   {
  621.                   *end = 0;
  622.                   }
  623.                }
  624.             return TRUE;
  625.  
  626. #ifdef ALLOWWHITESPACE
  627.          case ' ':                         /* whitespace */
  628.          case '\t':
  629. #endif
  630.  
  631.          case '-':                         /* or skip to next number */
  632.             if ( n > 0 )
  633.                {
  634.                if ( numbers == 0 )
  635.                   {
  636.                   *start = atoi( tbuf );
  637.                   ++numbers;
  638.                   }
  639.                else
  640.                   {
  641.                   *end = atoi( tbuf );
  642.                   return TRUE;
  643.                   }
  644.                }
  645.             ++b;
  646.             n = 0;
  647.             break;
  648.          case '0':
  649.          case '1':
  650.          case '2':
  651.          case '3':
  652.          case '4':
  653.          case '5':
  654.          case '6':
  655.          case '7':
  656.          case '8':
  657.          case '9':
  658.             tbuf[ n ] = buffer[ b ];
  659.             ++n;
  660.             tbuf[ n ] = 0;
  661.             ++b;
  662.             break;
  663.          default:
  664. #if PROG_ERRORS
  665.             sprintf( bwb_ebuf,
  666.                "ERROR: character <%c> unexpected in numerical sequence",
  667.                buffer[ b ] );
  668.             ++b;
  669.             bwb_error( bwb_ebuf );
  670. #else
  671.             bwb_error( err_syntax );
  672. #endif
  673.             break;
  674.          }
  675.       }
  676.  
  677.    }
  678.  
  679. /***************************************************************
  680.  
  681.         FUNCTION:       bwb_freeline()
  682.  
  683.         DESCRIPTION:
  684.  
  685. ***************************************************************/
  686.  
  687. int
  688. bwb_freeline( struct bwb_line *l )
  689.    {
  690.    register int n;
  691.  
  692.    /* free arguments if there are any */
  693.    
  694.    free( l );
  695.  
  696.    return TRUE;
  697.    }
  698.    
  699. /***************************************************************
  700.  
  701.         FUNCTION:       int_qmdstr()
  702.  
  703.         DESCRIPTION:    This function finds a quotation-mark
  704.             delimited string.
  705.  
  706. ***************************************************************/
  707.  
  708. int
  709. int_qmdstr( char *buffer_a, char *buffer_b )
  710.    {
  711.    char *a, *b;
  712.    
  713.    a = buffer_a;
  714.    ++a;                         /* advance beyond quotation mark */
  715.    b = buffer_b;
  716.  
  717.    while( *a != '\"' )
  718.       {
  719.       *b = *a;
  720.       ++a;
  721.       ++b;
  722.       *b = '\0';
  723.       }
  724.  
  725.    return TRUE;
  726.  
  727.    }
  728.