886 lines
16 KiB
C
886 lines
16 KiB
C
/* misc - miscellaneous flex routines */
|
|
|
|
/*-
|
|
* Copyright (c) 1990 The Regents of the University of California.
|
|
* All rights reserved.
|
|
*
|
|
* This code is derived from software contributed to Berkeley by
|
|
* Vern Paxson.
|
|
*
|
|
* The United States Government has rights in this work pursuant
|
|
* to contract no. DE-AC03-76SF00098 between the United States
|
|
* Department of Energy and the University of California.
|
|
*
|
|
* Redistribution and use in source and binary forms with or without
|
|
* modification are permitted provided that: (1) source distributions retain
|
|
* this entire copyright notice and comment, and (2) distributions including
|
|
* binaries display the following acknowledgement: ``This product includes
|
|
* software developed by the University of California, Berkeley and its
|
|
* contributors'' in the documentation or other materials provided with the
|
|
* distribution and in all advertising materials mentioning features or use
|
|
* of this software. Neither the name of the University nor the names of
|
|
* its contributors may be used to endorse or promote products derived from
|
|
* this software without specific prior written permission.
|
|
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
|
|
* WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
|
*/
|
|
|
|
/* $Header$ */
|
|
|
|
#include "flexdef.h"
|
|
|
|
|
|
void action_define( defname, value )
|
|
char *defname;
|
|
int value;
|
|
{
|
|
char buf[MAXLINE];
|
|
|
|
if ( (int) strlen( defname ) > MAXLINE / 2 )
|
|
{
|
|
format_pinpoint_message( _( "name \"%s\" ridiculously long" ),
|
|
defname );
|
|
return;
|
|
}
|
|
|
|
sprintf( buf, "#define %s %d\n", defname, value );
|
|
add_action( buf );
|
|
}
|
|
|
|
|
|
void add_action( new_text )
|
|
char *new_text;
|
|
{
|
|
int len = strlen( new_text );
|
|
|
|
while ( len + action_index >= action_size - 10 /* slop */ )
|
|
{
|
|
int new_size = action_size * 2;
|
|
|
|
if ( new_size <= 0 )
|
|
/* Increase just a little, to try to avoid overflow
|
|
* on 16-bit machines.
|
|
*/
|
|
action_size += action_size / 8;
|
|
else
|
|
action_size = new_size;
|
|
|
|
action_array =
|
|
reallocate_character_array( action_array, action_size );
|
|
}
|
|
|
|
strcpy( &action_array[action_index], new_text );
|
|
|
|
action_index += len;
|
|
}
|
|
|
|
|
|
/* allocate_array - allocate memory for an integer array of the given size */
|
|
|
|
void *allocate_array( size, element_size )
|
|
int size;
|
|
size_t element_size;
|
|
{
|
|
register void *mem;
|
|
size_t num_bytes = element_size * size;
|
|
|
|
mem = flex_alloc( num_bytes );
|
|
if ( ! mem )
|
|
flexfatal(
|
|
_( "memory allocation failed in allocate_array()" ) );
|
|
|
|
return mem;
|
|
}
|
|
|
|
|
|
/* all_lower - true if a string is all lower-case */
|
|
|
|
int all_lower( str )
|
|
register char *str;
|
|
{
|
|
while ( *str )
|
|
{
|
|
if ( ! isascii( (Char) *str ) || ! islower( *str ) )
|
|
return 0;
|
|
++str;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
/* all_upper - true if a string is all upper-case */
|
|
|
|
int all_upper( str )
|
|
register char *str;
|
|
{
|
|
while ( *str )
|
|
{
|
|
if ( ! isascii( (Char) *str ) || ! isupper( *str ) )
|
|
return 0;
|
|
++str;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
/* bubble - bubble sort an integer array in increasing order
|
|
*
|
|
* synopsis
|
|
* int v[n], n;
|
|
* void bubble( v, n );
|
|
*
|
|
* description
|
|
* sorts the first n elements of array v and replaces them in
|
|
* increasing order.
|
|
*
|
|
* passed
|
|
* v - the array to be sorted
|
|
* n - the number of elements of 'v' to be sorted
|
|
*/
|
|
|
|
void bubble( v, n )
|
|
int v[], n;
|
|
{
|
|
register int i, j, k;
|
|
|
|
for ( i = n; i > 1; --i )
|
|
for ( j = 1; j < i; ++j )
|
|
if ( v[j] > v[j + 1] ) /* compare */
|
|
{
|
|
k = v[j]; /* exchange */
|
|
v[j] = v[j + 1];
|
|
v[j + 1] = k;
|
|
}
|
|
}
|
|
|
|
|
|
/* check_char - checks a character to make sure it's within the range
|
|
* we're expecting. If not, generates fatal error message
|
|
* and exits.
|
|
*/
|
|
|
|
void check_char( c )
|
|
int c;
|
|
{
|
|
if ( c >= CSIZE )
|
|
lerrsf( _( "bad character '%s' detected in check_char()" ),
|
|
readable_form( c ) );
|
|
|
|
if ( c >= csize )
|
|
lerrsf(
|
|
_( "scanner requires -8 flag to use the character %s" ),
|
|
readable_form( c ) );
|
|
}
|
|
|
|
|
|
|
|
/* clower - replace upper-case letter to lower-case */
|
|
|
|
Char clower( c )
|
|
register int c;
|
|
{
|
|
return (Char) ((isascii( c ) && isupper( c )) ? tolower( c ) : c);
|
|
}
|
|
|
|
|
|
/* copy_string - returns a dynamically allocated copy of a string */
|
|
|
|
char *copy_string( str )
|
|
register const char *str;
|
|
{
|
|
register const char *c1;
|
|
register char *c2;
|
|
char *copy;
|
|
unsigned int size;
|
|
|
|
/* find length */
|
|
for ( c1 = str; *c1; ++c1 )
|
|
;
|
|
|
|
size = (c1 - str + 1) * sizeof( char );
|
|
copy = (char *) flex_alloc( size );
|
|
|
|
if ( copy == NULL )
|
|
flexfatal( _( "dynamic memory failure in copy_string()" ) );
|
|
|
|
for ( c2 = copy; (*c2++ = *str++) != 0; )
|
|
;
|
|
|
|
return copy;
|
|
}
|
|
|
|
|
|
/* copy_unsigned_string -
|
|
* returns a dynamically allocated copy of a (potentially) unsigned string
|
|
*/
|
|
|
|
Char *copy_unsigned_string( str )
|
|
register Char *str;
|
|
{
|
|
register Char *c;
|
|
Char *copy;
|
|
|
|
/* find length */
|
|
for ( c = str; *c; ++c )
|
|
;
|
|
|
|
copy = allocate_Character_array( c - str + 1 );
|
|
|
|
for ( c = copy; (*c++ = *str++) != 0; )
|
|
;
|
|
|
|
return copy;
|
|
}
|
|
|
|
|
|
/* cshell - shell sort a character array in increasing order
|
|
*
|
|
* synopsis
|
|
*
|
|
* Char v[n];
|
|
* int n, special_case_0;
|
|
* cshell( v, n, special_case_0 );
|
|
*
|
|
* description
|
|
* Does a shell sort of the first n elements of array v.
|
|
* If special_case_0 is true, then any element equal to 0
|
|
* is instead assumed to have infinite weight.
|
|
*
|
|
* passed
|
|
* v - array to be sorted
|
|
* n - number of elements of v to be sorted
|
|
*/
|
|
|
|
void cshell( v, n, special_case_0 )
|
|
Char v[];
|
|
int n, special_case_0;
|
|
{
|
|
int gap, i, j, jg;
|
|
Char k;
|
|
|
|
for ( gap = n / 2; gap > 0; gap = gap / 2 )
|
|
for ( i = gap; i < n; ++i )
|
|
for ( j = i - gap; j >= 0; j = j - gap )
|
|
{
|
|
jg = j + gap;
|
|
|
|
if ( special_case_0 )
|
|
{
|
|
if ( v[jg] == 0 )
|
|
break;
|
|
|
|
else if ( v[j] != 0 && v[j] <= v[jg] )
|
|
break;
|
|
}
|
|
|
|
else if ( v[j] <= v[jg] )
|
|
break;
|
|
|
|
k = v[j];
|
|
v[j] = v[jg];
|
|
v[jg] = k;
|
|
}
|
|
}
|
|
|
|
|
|
/* dataend - finish up a block of data declarations */
|
|
|
|
void dataend()
|
|
{
|
|
if ( datapos > 0 )
|
|
dataflush();
|
|
|
|
/* add terminator for initialization; { for vi */
|
|
outn( " } ;\n" );
|
|
|
|
dataline = 0;
|
|
datapos = 0;
|
|
}
|
|
|
|
|
|
/* dataflush - flush generated data statements */
|
|
|
|
void dataflush()
|
|
{
|
|
outc( '\n' );
|
|
|
|
if ( ++dataline >= NUMDATALINES )
|
|
{
|
|
/* Put out a blank line so that the table is grouped into
|
|
* large blocks that enable the user to find elements easily.
|
|
*/
|
|
outc( '\n' );
|
|
dataline = 0;
|
|
}
|
|
|
|
/* Reset the number of characters written on the current line. */
|
|
datapos = 0;
|
|
}
|
|
|
|
|
|
/* flexerror - report an error message and terminate */
|
|
|
|
void flexerror( msg )
|
|
const char msg[];
|
|
{
|
|
fprintf( stderr, "%s: %s\n", program_name, msg );
|
|
flexend( 1 );
|
|
}
|
|
|
|
|
|
/* flexfatal - report a fatal error message and terminate */
|
|
|
|
void flexfatal( msg )
|
|
const char msg[];
|
|
{
|
|
fprintf( stderr, _( "%s: fatal internal error, %s\n" ),
|
|
program_name, msg );
|
|
exit( 1 );
|
|
}
|
|
|
|
|
|
/* htoi - convert a hexadecimal digit string to an integer value */
|
|
|
|
int htoi( str )
|
|
Char str[];
|
|
{
|
|
unsigned int result;
|
|
|
|
(void) sscanf( (char *) str, "%x", &result );
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
/* lerrif - report an error message formatted with one integer argument */
|
|
|
|
void lerrif( msg, arg )
|
|
const char msg[];
|
|
int arg;
|
|
{
|
|
char errmsg[MAXLINE];
|
|
(void) sprintf( errmsg, msg, arg );
|
|
flexerror( errmsg );
|
|
}
|
|
|
|
|
|
/* lerrsf - report an error message formatted with one string argument */
|
|
|
|
void lerrsf( msg, arg )
|
|
const char msg[], arg[];
|
|
{
|
|
char errmsg[MAXLINE];
|
|
|
|
(void) sprintf( errmsg, msg, arg );
|
|
flexerror( errmsg );
|
|
}
|
|
|
|
|
|
/* line_directive_out - spit out a "#line" statement */
|
|
|
|
void line_directive_out( output_file, do_infile )
|
|
FILE *output_file;
|
|
int do_infile;
|
|
{
|
|
char directive[MAXLINE], filename[MAXLINE];
|
|
char *s1, *s2, *s3;
|
|
static char line_fmt[] = "#line %d \"%s\"\n";
|
|
|
|
if ( ! gen_line_dirs )
|
|
return;
|
|
|
|
if ( (do_infile && ! infilename) || (! do_infile && ! outfilename) )
|
|
/* don't know the filename to use, skip */
|
|
return;
|
|
|
|
s1 = do_infile ? infilename : outfilename;
|
|
s2 = filename;
|
|
s3 = &filename[sizeof( filename ) - 2];
|
|
|
|
while ( s2 < s3 && *s1 )
|
|
{
|
|
if ( *s1 == '\\' )
|
|
/* Escape the '\' */
|
|
*s2++ = '\\';
|
|
|
|
*s2++ = *s1++;
|
|
}
|
|
|
|
*s2 = '\0';
|
|
|
|
if ( do_infile )
|
|
sprintf( directive, line_fmt, linenum, filename );
|
|
else
|
|
{
|
|
if ( output_file == stdout )
|
|
/* Account for the line directive itself. */
|
|
++out_linenum;
|
|
|
|
sprintf( directive, line_fmt, out_linenum, filename );
|
|
}
|
|
|
|
/* If output_file is nil then we should put the directive in
|
|
* the accumulated actions.
|
|
*/
|
|
if ( output_file )
|
|
{
|
|
fputs( directive, output_file );
|
|
}
|
|
else
|
|
add_action( directive );
|
|
}
|
|
|
|
|
|
/* mark_defs1 - mark the current position in the action array as
|
|
* representing where the user's section 1 definitions end
|
|
* and the prolog begins
|
|
*/
|
|
void mark_defs1()
|
|
{
|
|
defs1_offset = 0;
|
|
action_array[action_index++] = '\0';
|
|
action_offset = prolog_offset = action_index;
|
|
action_array[action_index] = '\0';
|
|
}
|
|
|
|
|
|
/* mark_prolog - mark the current position in the action array as
|
|
* representing the end of the action prolog
|
|
*/
|
|
void mark_prolog()
|
|
{
|
|
action_array[action_index++] = '\0';
|
|
action_offset = action_index;
|
|
action_array[action_index] = '\0';
|
|
}
|
|
|
|
|
|
/* mk2data - generate a data statement for a two-dimensional array
|
|
*
|
|
* Generates a data statement initializing the current 2-D array to "value".
|
|
*/
|
|
void mk2data( value )
|
|
int value;
|
|
{
|
|
if ( datapos >= NUMDATAITEMS )
|
|
{
|
|
outc( ',' );
|
|
dataflush();
|
|
}
|
|
|
|
if ( datapos == 0 )
|
|
/* Indent. */
|
|
out( " " );
|
|
|
|
else
|
|
outc( ',' );
|
|
|
|
++datapos;
|
|
|
|
out_dec( "%5d", value );
|
|
}
|
|
|
|
|
|
/* mkdata - generate a data statement
|
|
*
|
|
* Generates a data statement initializing the current array element to
|
|
* "value".
|
|
*/
|
|
void mkdata( value )
|
|
int value;
|
|
{
|
|
if ( datapos >= NUMDATAITEMS )
|
|
{
|
|
outc( ',' );
|
|
dataflush();
|
|
}
|
|
|
|
if ( datapos == 0 )
|
|
/* Indent. */
|
|
out( " " );
|
|
else
|
|
outc( ',' );
|
|
|
|
++datapos;
|
|
|
|
out_dec( "%5d", value );
|
|
}
|
|
|
|
|
|
/* myctoi - return the integer represented by a string of digits */
|
|
|
|
int myctoi( array )
|
|
char array[];
|
|
{
|
|
int val = 0;
|
|
|
|
(void) sscanf( array, "%d", &val );
|
|
|
|
return val;
|
|
}
|
|
|
|
|
|
/* myesc - return character corresponding to escape sequence */
|
|
|
|
Char myesc( array )
|
|
Char array[];
|
|
{
|
|
Char c, esc_char;
|
|
|
|
switch ( array[1] )
|
|
{
|
|
case 'b': return '\b';
|
|
case 'f': return '\f';
|
|
case 'n': return '\n';
|
|
case 'r': return '\r';
|
|
case 't': return '\t';
|
|
|
|
#if __STDC__
|
|
case 'a': return '\a';
|
|
case 'v': return '\v';
|
|
#else
|
|
case 'a': return '\007';
|
|
case 'v': return '\013';
|
|
#endif
|
|
|
|
case '0':
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
{ /* \<octal> */
|
|
int sptr = 1;
|
|
|
|
while ( isascii( array[sptr] ) &&
|
|
isdigit( array[sptr] ) )
|
|
/* Don't increment inside loop control
|
|
* because if isdigit() is a macro it might
|
|
* expand into multiple increments ...
|
|
*/
|
|
++sptr;
|
|
|
|
c = array[sptr];
|
|
array[sptr] = '\0';
|
|
|
|
esc_char = otoi( array + 1 );
|
|
|
|
array[sptr] = c;
|
|
|
|
return esc_char;
|
|
}
|
|
|
|
case 'x':
|
|
{ /* \x<hex> */
|
|
int sptr = 2;
|
|
|
|
while ( isascii( array[sptr] ) &&
|
|
isxdigit( (char) array[sptr] ) )
|
|
/* Don't increment inside loop control
|
|
* because if isdigit() is a macro it might
|
|
* expand into multiple increments ...
|
|
*/
|
|
++sptr;
|
|
|
|
c = array[sptr];
|
|
array[sptr] = '\0';
|
|
|
|
esc_char = htoi( array + 2 );
|
|
|
|
array[sptr] = c;
|
|
|
|
return esc_char;
|
|
}
|
|
|
|
default:
|
|
return array[1];
|
|
}
|
|
}
|
|
|
|
|
|
/* otoi - convert an octal digit string to an integer value */
|
|
|
|
int otoi( str )
|
|
Char str[];
|
|
{
|
|
unsigned int result;
|
|
|
|
(void) sscanf( (char *) str, "%o", &result );
|
|
return result;
|
|
}
|
|
|
|
|
|
/* out - various flavors of outputing a (possibly formatted) string for the
|
|
* generated scanner, keeping track of the line count.
|
|
*/
|
|
|
|
void out( str )
|
|
const char str[];
|
|
{
|
|
fputs( str, stdout );
|
|
out_line_count( str );
|
|
}
|
|
|
|
void out_dec( fmt, n )
|
|
const char fmt[];
|
|
int n;
|
|
{
|
|
printf( fmt, n );
|
|
out_line_count( fmt );
|
|
}
|
|
|
|
void out_dec2( fmt, n1, n2 )
|
|
const char fmt[];
|
|
int n1, n2;
|
|
{
|
|
printf( fmt, n1, n2 );
|
|
out_line_count( fmt );
|
|
}
|
|
|
|
void out_hex( fmt, x )
|
|
const char fmt[];
|
|
unsigned int x;
|
|
{
|
|
printf( fmt, x );
|
|
out_line_count( fmt );
|
|
}
|
|
|
|
void out_line_count( str )
|
|
const char str[];
|
|
{
|
|
register int i;
|
|
|
|
for ( i = 0; str[i]; ++i )
|
|
if ( str[i] == '\n' )
|
|
++out_linenum;
|
|
}
|
|
|
|
void out_str( fmt, str )
|
|
const char fmt[], str[];
|
|
{
|
|
printf( fmt, str );
|
|
out_line_count( fmt );
|
|
out_line_count( str );
|
|
}
|
|
|
|
void out_str3( fmt, s1, s2, s3 )
|
|
const char fmt[], s1[], s2[], s3[];
|
|
{
|
|
printf( fmt, s1, s2, s3 );
|
|
out_line_count( fmt );
|
|
out_line_count( s1 );
|
|
out_line_count( s2 );
|
|
out_line_count( s3 );
|
|
}
|
|
|
|
void out_str_dec( fmt, str, n )
|
|
const char fmt[], str[];
|
|
int n;
|
|
{
|
|
printf( fmt, str, n );
|
|
out_line_count( fmt );
|
|
out_line_count( str );
|
|
}
|
|
|
|
void outc( c )
|
|
int c;
|
|
{
|
|
putc( c, stdout );
|
|
|
|
if ( c == '\n' )
|
|
++out_linenum;
|
|
}
|
|
|
|
void outn( str )
|
|
const char str[];
|
|
{
|
|
puts( str );
|
|
out_line_count( str );
|
|
++out_linenum;
|
|
}
|
|
|
|
|
|
/* readable_form - return the the human-readable form of a character
|
|
*
|
|
* The returned string is in static storage.
|
|
*/
|
|
|
|
char *readable_form( c )
|
|
register int c;
|
|
{
|
|
static char rform[10];
|
|
|
|
if ( (c >= 0 && c < 32) || c >= 127 )
|
|
{
|
|
switch ( c )
|
|
{
|
|
case '\b': return "\\b";
|
|
case '\f': return "\\f";
|
|
case '\n': return "\\n";
|
|
case '\r': return "\\r";
|
|
case '\t': return "\\t";
|
|
|
|
#if __STDC__
|
|
case '\a': return "\\a";
|
|
case '\v': return "\\v";
|
|
#endif
|
|
|
|
default:
|
|
(void) sprintf( rform, "\\%.3o",
|
|
(unsigned int) c );
|
|
return rform;
|
|
}
|
|
}
|
|
|
|
else if ( c == ' ' )
|
|
return "' '";
|
|
|
|
else
|
|
{
|
|
rform[0] = c;
|
|
rform[1] = '\0';
|
|
|
|
return rform;
|
|
}
|
|
}
|
|
|
|
|
|
/* reallocate_array - increase the size of a dynamic array */
|
|
|
|
void *reallocate_array( array, size, element_size )
|
|
void *array;
|
|
int size;
|
|
size_t element_size;
|
|
{
|
|
register void *new_array;
|
|
size_t num_bytes = element_size * size;
|
|
|
|
new_array = flex_realloc( array, num_bytes );
|
|
if ( ! new_array )
|
|
flexfatal( _( "attempt to increase array size failed" ) );
|
|
|
|
return new_array;
|
|
}
|
|
|
|
|
|
/* skelout - write out one section of the skeleton file
|
|
*
|
|
* Description
|
|
* Copies skelfile or skel array to stdout until a line beginning with
|
|
* "%%" or EOF is found.
|
|
*/
|
|
void skelout()
|
|
{
|
|
char buf_storage[MAXLINE];
|
|
char *buf = buf_storage;
|
|
int do_copy = 1;
|
|
|
|
/* Loop pulling lines either from the skelfile, if we're using
|
|
* one, or from the skel[] array.
|
|
*/
|
|
while ( skelfile ?
|
|
(fgets( buf, MAXLINE, skelfile ) != NULL) :
|
|
((buf = (char *) skel[skel_ind++]) != 0) )
|
|
{ /* copy from skel array */
|
|
if ( buf[0] == '%' )
|
|
{ /* control line */
|
|
switch ( buf[1] )
|
|
{
|
|
case '%':
|
|
return;
|
|
|
|
case '+':
|
|
do_copy = C_plus_plus;
|
|
break;
|
|
|
|
case '-':
|
|
do_copy = ! C_plus_plus;
|
|
break;
|
|
|
|
case '*':
|
|
do_copy = 1;
|
|
break;
|
|
|
|
default:
|
|
flexfatal(
|
|
_( "bad line in skeleton file" ) );
|
|
}
|
|
}
|
|
|
|
else if ( do_copy )
|
|
{
|
|
if ( skelfile )
|
|
/* Skeleton file reads include final
|
|
* newline, skel[] array does not.
|
|
*/
|
|
out( buf );
|
|
else
|
|
outn( buf );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* transition_struct_out - output a yy_trans_info structure
|
|
*
|
|
* outputs the yy_trans_info structure with the two elements, element_v and
|
|
* element_n. Formats the output with spaces and carriage returns.
|
|
*/
|
|
|
|
void transition_struct_out( element_v, element_n )
|
|
int element_v, element_n;
|
|
{
|
|
out_dec2( " {%4d,%4d },", element_v, element_n );
|
|
|
|
datapos += TRANS_STRUCT_PRINT_LENGTH;
|
|
|
|
if ( datapos >= 79 - TRANS_STRUCT_PRINT_LENGTH )
|
|
{
|
|
outc( '\n' );
|
|
|
|
if ( ++dataline % 10 == 0 )
|
|
outc( '\n' );
|
|
|
|
datapos = 0;
|
|
}
|
|
}
|
|
|
|
|
|
/* The following is only needed when building flex's parser using certain
|
|
* broken versions of bison.
|
|
*/
|
|
void *yy_flex_xmalloc( size )
|
|
int size;
|
|
{
|
|
void *result = flex_alloc( (size_t) size );
|
|
|
|
if ( ! result )
|
|
flexfatal(
|
|
_( "memory allocation failed in yy_flex_xmalloc()" ) );
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
/* zero_out - set a region of memory to 0
|
|
*
|
|
* Sets region_ptr[0] through region_ptr[size_in_bytes - 1] to zero.
|
|
*/
|
|
|
|
void zero_out( region_ptr, size_in_bytes )
|
|
char *region_ptr;
|
|
size_t size_in_bytes;
|
|
{
|
|
register char *rp, *rp_end;
|
|
|
|
rp = region_ptr;
|
|
rp_end = region_ptr + size_in_bytes;
|
|
|
|
while ( rp < rp_end )
|
|
*rp++ = 0;
|
|
}
|