home *** CD-ROM | disk | FTP | other *** search
/ HyperLib 1997 Winter - Disc 1 / HYPERLIB-1997-Winter-CD1.ISO.7z / HYPERLIB-1997-Winter-CD1.ISO / オンラインウェア / PRG / bwbasic-2.10.sit / bwbasic-2.10 / bwb_str.c < prev    next >
Text File  |  1996-10-09  |  7KB  |  355 lines
  1. /***************************************************************
  2.  
  3.     bwb_str.c       String-Management Routines
  4.                         for Bywater BASIC Interpreter
  5.  
  6.                         Copyright (c) 1993, Ted A. Campbell
  7.                         Bywater Software
  8.  
  9.                         email: tcamp@delphi.com
  10.  
  11.         Copyright and Permissions Information:
  12.  
  13.         All U.S. and international rights are claimed by the author,
  14.         Ted A. Campbell.
  15.  
  16.     This software is released under the terms of the GNU General
  17.     Public License (GPL), which is distributed with this software
  18.     in the file "COPYING".  The GPL specifies the terms under
  19.     which users may copy and use the software in this distribution.
  20.  
  21.     A separate license is available for commercial distribution,
  22.     for information on which you should contact the author.
  23.  
  24. ***************************************************************/
  25.  
  26. #include <stdio.h>
  27.  
  28. #include "bwbasic.h"
  29. #include "bwb_mes.h"
  30.  
  31. #if INTENSIVE_DEBUG || TEST_BSTRING
  32. static char tbuf[ MAXSTRINGSIZE + 1 ];
  33. #endif
  34.  
  35. /***************************************************************
  36.  
  37.         FUNCTION:       str_btob()
  38.  
  39.         DESCRIPTION:    This C function assigns a bwBASIC string
  40.             structure to another bwBASIC string
  41.             structure.
  42.  
  43. ***************************************************************/
  44.  
  45. #if ANSI_C
  46. int
  47. str_btob( bstring *d, bstring *s )
  48. #else
  49. int
  50. str_btob( d, s )
  51.    bstring *d;
  52.    bstring *s;
  53. #endif
  54.    {
  55.    char *t;
  56.    register int i;
  57.  
  58. #if TEST_BSTRING
  59.    sprintf( tbuf, "in str_btob(): entry, source b string name is <%s>", s->name );
  60.    bwb_debug( tbuf );
  61.    sprintf( tbuf, "in str_btob(): entry, destination b string name is <%s>", d->name );
  62.    bwb_debug( tbuf );
  63. #endif
  64.  
  65.    /* get memory for new buffer */
  66.  
  67.    if ( ( t = (char *) calloc( s->length + 1, 1 )) == NULL )
  68.       {
  69. #if PROG_ERRORS
  70.       bwb_error( "in str_btob(): failed to get memory for new buffer" );
  71. #else
  72.       bwb_error( err_getmem );
  73. #endif
  74.       return FALSE;
  75.       }
  76.  
  77.    /* write the c string to the b string */
  78.  
  79.    t[ 0 ] = '¥0';
  80.    for ( i = 0; i < (int) s->length; ++i )
  81.       {
  82.       t[ i ] = s->sbuffer[ i ];
  83. #if INTENSIVE_DEBUG
  84.       tbuf[ i ] = s->sbuffer[ i ];
  85.       tbuf[ i + 1 ] = '¥0';
  86. #endif
  87.       }
  88.  
  89.    /* deallocate old memory */
  90.  
  91. #if INTENSIVE_DEBUG
  92.    if ( d->rab == TRUE )
  93.       {
  94.       sprintf( bwb_ebuf, "in str_btob(): reallocating RAB" );
  95.       bwb_debug( bwb_ebuf );
  96.       }
  97. #endif
  98.  
  99.    if (( d->rab != TRUE ) && ( d->sbuffer != NULL ))
  100.       {
  101. #if INTENSIVE_DEBUG
  102.       sprintf( tbuf, "in str_btob(): deallocating string memory" );
  103.       bwb_debug ( tbuf );
  104. #endif
  105.       free( d->sbuffer );
  106.       }
  107.    else
  108.       {
  109.       d->rab = (char) FALSE;
  110.       }
  111.  
  112.    /* reassign buffer */
  113.  
  114.    d->sbuffer = t;
  115.  
  116.    /* reassign length */
  117.  
  118.    d->length = s->length;
  119.  
  120. #if INTENSIVE_DEBUG
  121.    sprintf( bwb_ebuf, "in str_btob(): exit length <%d> string <%s>",
  122.       d->length, tbuf );
  123.    bwb_debug( bwb_ebuf );
  124. #endif
  125.  
  126.    /* return */
  127.  
  128.    return TRUE;
  129.  
  130.    }
  131.  
  132. /***************************************************************
  133.  
  134.         FUNCTION:       str_ctob()
  135.  
  136.         DESCRIPTION:    This C function assigns a null-terminated
  137.             C string to a bwBASIC string structure.
  138.  
  139. ***************************************************************/
  140.  
  141. #if ANSI_C
  142. int
  143. str_ctob( bstring *s, char *buffer )
  144. #else
  145. int
  146. str_ctob( s, buffer )
  147.    bstring *s;
  148.    char *buffer;
  149. #endif
  150.    {
  151.    char *t;
  152.    register int i;
  153.  
  154. #if INTENSIVE_DEBUG
  155.    sprintf( tbuf, "in str_ctob(): entry, c string is <%s>", buffer );
  156.    bwb_debug( tbuf );
  157. #endif
  158. #if TEST_BSTRING
  159.    sprintf( tbuf, "in str_ctob(): entry, b string name is <%s>", s->name );
  160.    bwb_debug( tbuf );
  161. #endif
  162.  
  163.    /* get memory for new buffer */
  164.  
  165.    if ( ( t = (char *) calloc( strlen( buffer ) + 1, 1 )) == NULL )
  166.       {
  167. #if PROG_ERRORS
  168.       bwb_error( "in str_ctob(): failed to get memory for new buffer" );
  169. #else
  170.       bwb_error( err_getmem );
  171. #endif
  172.       return FALSE;
  173.       }
  174.  
  175.    /* write the c string to the b string */
  176.  
  177.    t[ 0 ] = '¥0';
  178.    for ( i = 0; i < (int) strlen( buffer ); ++i )
  179.       {
  180.       t[ i ] = buffer[ i ];
  181. #if INTENSIVE_DEBUG
  182.       tbuf[ i ] = buffer[ i ];
  183.       tbuf[ i + 1 ] = '¥0';
  184. #endif
  185.       }
  186.  
  187.    /* deallocate old memory */
  188.  
  189. #if INTENSIVE_DEBUG
  190.    if ( s->rab == TRUE )
  191.       {
  192.       sprintf( bwb_ebuf, "in str_ctob(): reallocating RAB" );
  193.       bwb_debug( bwb_ebuf );
  194.       }
  195. #endif
  196.  
  197.    if (( s->rab != TRUE ) && ( s->sbuffer != NULL ))
  198.       {
  199.       free( s->sbuffer );
  200.       }
  201.    else
  202.       {
  203.       s->rab = (char) FALSE;
  204.       }
  205.  
  206.    /* reassign buffer */
  207.  
  208.    s->sbuffer = t;
  209.  
  210.    /* reassign length */
  211.  
  212.    s->length = (unsigned char) strlen( buffer );
  213.  
  214. #if INTENSIVE_DEBUG
  215.    sprintf( bwb_ebuf, "in str_ctob(): exit length <%d> string <%s>",
  216.       s->length, tbuf );
  217.    bwb_debug( bwb_ebuf );
  218. #endif
  219.  
  220.    /* return */
  221.  
  222.    return TRUE;
  223.  
  224.    }
  225.  
  226. /***************************************************************
  227.  
  228.         FUNCTION:       str_btoc()
  229.  
  230.         DESCRIPTION:    This C function assigns a null-terminated
  231.             C string to a bwBASIC string structure.
  232.  
  233. ***************************************************************/
  234.  
  235. #if ANSI_C
  236. int
  237. str_btoc( char *buffer, bstring *s )
  238. #else
  239. int
  240. str_btoc( buffer, s )
  241.    char *buffer;
  242.    bstring *s;
  243. #endif
  244.    {
  245.    register int i;
  246.  
  247. #if INTENSIVE_DEBUG
  248.    sprintf( tbuf, "in str_btoc(): entry, b string length is <%d>",
  249.       s->length );
  250.    bwb_debug( tbuf );
  251. #endif
  252. #if TEST_BSTRING
  253.    sprintf( tbuf, "in str_btoc(): entry, b string name is <%s>", s->name );
  254.    bwb_debug( tbuf );
  255. #endif
  256.  
  257.    /* write the b string to the c string */
  258.  
  259.    buffer[ 0 ] = '¥0';
  260.    for ( i = 0; i < (int) s->length; ++i )
  261.       {
  262.       buffer[ i ] = s->sbuffer[ i ];
  263.       buffer[ i + 1 ] = '¥0';
  264.       if ( i >= MAXSTRINGSIZE )
  265.          {
  266.          i = s->length + 1;
  267.          }
  268.       }
  269.  
  270. #if INTENSIVE_DEBUG
  271.    sprintf( tbuf, "in str_btoc(): exit, c string is <%s>", buffer );
  272.    bwb_debug( tbuf );
  273. #endif
  274.  
  275.    /* return */
  276.  
  277.    return TRUE;
  278.  
  279.    }
  280.  
  281. /***************************************************************
  282.  
  283.         FUNCTION:       str_cat()
  284.  
  285.         DESCRIPTION:    This C function performs the equivalent
  286.             of the C strcat() function, using BASIC
  287.             strings.
  288.  
  289. ***************************************************************/
  290.  
  291. #if ANSI_C
  292. char *
  293. str_cat( bstring *a, bstring *b )
  294. #else
  295. char *
  296. str_cat( a, b )
  297.    bstring *a;
  298.    bstring *b;
  299. #endif
  300.    {
  301.    char abuf[ MAXSTRINGSIZE + 1 ];
  302.    char bbuf[ MAXSTRINGSIZE + 1 ];
  303.    char *r;
  304.  
  305.    str_btoc( abuf, a );
  306.    str_btoc( bbuf, b );
  307.  
  308. #if INTENSIVE_DEBUG
  309.    sprintf( bwb_ebuf, "in str_cat(): a <%s> b <%s>", abuf, bbuf );
  310.    bwb_debug( bwb_ebuf );
  311. #endif
  312.  
  313.    strcat( abuf, bbuf );
  314.    str_ctob( a, abuf );
  315.  
  316. #if INTENSIVE_DEBUG
  317.    sprintf( bwb_ebuf, "in str_cat(): returns <%s>", abuf );
  318.    bwb_debug( bwb_ebuf );
  319. #endif
  320.     r= abuf;
  321.    return r;
  322.    }
  323.  
  324. /***************************************************************
  325.  
  326.         FUNCTION:       str_cmp()
  327.  
  328.     DESCRIPTION:    This C function performs the equivalent
  329.             of the C strcmp() function, using BASIC
  330.             strings.
  331.  
  332. ***************************************************************/
  333.  
  334. #if ANSI_C
  335. int
  336. str_cmp( bstring *a, bstring *b )
  337. #else
  338. int
  339. str_cmp( a, b )
  340.    bstring *a;
  341.    bstring *b;
  342. #endif
  343.    {
  344.    char abuf[ MAXSTRINGSIZE + 1 ];
  345.    char bbuf[ MAXSTRINGSIZE + 1 ];
  346.  
  347.    str_btoc( abuf, a );
  348.    str_btoc( bbuf, b );
  349.  
  350.    return strcmp( abuf, bbuf );
  351.    }
  352.  
  353.  
  354.  
  355.