209 lines
5.1 KiB
C
209 lines
5.1 KiB
C
/*
|
||
* implement string functions for dc
|
||
*
|
||
* Copyright (C) 1994, 1997 Free Software Foundation, Inc.
|
||
*
|
||
* This program is free software; you can redistribute it and/or modify
|
||
* it under the terms of the GNU General Public License as published by
|
||
* the Free Software Foundation; either version 2, or (at your option)
|
||
* any later version.
|
||
*
|
||
* This program is distributed in the hope that it will be useful,
|
||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
* GNU General Public License for more details.
|
||
*
|
||
* You should have received a copy of the GNU General Public License
|
||
* along with this program; if not, you can either send email to this
|
||
* program's author (see below) or write to: The Free Software Foundation,
|
||
* Inc.; 675 Mass Ave. Cambridge, MA 02139, USA.
|
||
*/
|
||
|
||
/* This should be the only module that knows the internals of type dc_string */
|
||
|
||
#include "config.h"
|
||
|
||
#include <stdio.h>
|
||
#ifdef HAVE_STDDEF_H
|
||
# include <stddef.h> /* ptrdiff_t */
|
||
#else
|
||
# define ptrdiff_t size_t
|
||
#endif
|
||
#ifdef HAVE_STDLIB_H
|
||
# include <stdlib.h>
|
||
#endif
|
||
#ifdef HAVE_STRING_H
|
||
# include <string.h> /* memcpy */
|
||
#else
|
||
# ifdef HAVE_MEMORY_H
|
||
# include <memory.h> /* memcpy, maybe */
|
||
# else
|
||
# ifdef HAVE_STRINGS_H
|
||
# include <strings.h> /* memcpy, maybe */
|
||
# endif
|
||
# endif
|
||
#endif
|
||
#include "dc.h"
|
||
#include "dc-proto.h"
|
||
|
||
/* here is the completion of the dc_string type: */
|
||
struct dc_string {
|
||
char *s_ptr; /* pointer to base of string */
|
||
size_t s_len; /* length of counted string */
|
||
int s_refs; /* reference count to cut down on memory use by duplicates */
|
||
};
|
||
|
||
|
||
/* return a duplicate of the string in the passed value */
|
||
/* The mismatched data types forces the caller to deal with
|
||
* bad dc_type'd dc_data values, and makes it more convenient
|
||
* for the caller to not have to do the grunge work of setting
|
||
* up a dc_type result.
|
||
*/
|
||
dc_data
|
||
dc_dup_str DC_DECLARG((value))
|
||
dc_str value DC_DECLEND
|
||
{
|
||
dc_data result;
|
||
|
||
++value->s_refs;
|
||
result.v.string = value;
|
||
result.dc_type = DC_STRING;
|
||
return result;
|
||
}
|
||
|
||
/* free an instance of a dc_str value */
|
||
void
|
||
dc_free_str DC_DECLARG((value))
|
||
dc_str *value DC_DECLEND
|
||
{
|
||
struct dc_string *string = *value;
|
||
|
||
if (--string->s_refs < 1){
|
||
free(string->s_ptr);
|
||
free(string);
|
||
}
|
||
}
|
||
|
||
/* Output a dc_str value.
|
||
* Add a trailing newline if "newline" is set.
|
||
* Free the value after use if discard_flag is set.
|
||
*/
|
||
void
|
||
dc_out_str DC_DECLARG((value, newline, discard_flag))
|
||
dc_str value DC_DECLSEP
|
||
dc_boolean newline DC_DECLSEP
|
||
dc_boolean discard_flag DC_DECLEND
|
||
{
|
||
fwrite(value->s_ptr, value->s_len, sizeof *value->s_ptr, stdout);
|
||
if (newline == DC_TRUE)
|
||
printf("\n");
|
||
if (discard_flag == DC_TRUE)
|
||
dc_free_str(&value);
|
||
}
|
||
|
||
/* make a copy of a string (base s, length len)
|
||
* into a dc_str value; return a dc_data result
|
||
* with this value
|
||
*/
|
||
dc_data
|
||
dc_makestring DC_DECLARG((s, len))
|
||
const char *s DC_DECLSEP
|
||
size_t len DC_DECLEND
|
||
{
|
||
dc_data result;
|
||
struct dc_string *string;
|
||
|
||
string = dc_malloc(sizeof *string);
|
||
string->s_ptr = dc_malloc(len+1);
|
||
memcpy(string->s_ptr, s, len);
|
||
string->s_ptr[len] = '\0'; /* nul terminated for those who need it */
|
||
string->s_len = len;
|
||
string->s_refs = 1;
|
||
result.v.string = string;
|
||
result.dc_type = DC_STRING;
|
||
return result;
|
||
}
|
||
|
||
/* read a dc_str value from FILE *fp;
|
||
* if ldelim == rdelim, then read until a ldelim char or EOF is reached;
|
||
* if ldelim != rdelim, then read until a matching rdelim for the
|
||
* (already eaten) first ldelim is read.
|
||
* Return a dc_data result with the dc_str value as its contents.
|
||
*/
|
||
dc_data
|
||
dc_readstring DC_DECLARG((fp, ldelim, rdelim))
|
||
FILE *fp DC_DECLSEP
|
||
int ldelim DC_DECLSEP
|
||
int rdelim DC_DECLEND
|
||
{
|
||
static char *line_buf = NULL; /* a buffer to build the string in */
|
||
static size_t buflen = 0; /* the current size of line_buf */
|
||
int depth=1;
|
||
int c;
|
||
char *p;
|
||
const char *end;
|
||
|
||
if (!line_buf){
|
||
/* initial buflen should be large enough to handle most cases */
|
||
buflen = 2016;
|
||
line_buf = dc_malloc(buflen);
|
||
}
|
||
p = line_buf;
|
||
end = line_buf + buflen;
|
||
for (;;){
|
||
c = getc(fp);
|
||
if (c == EOF)
|
||
break;
|
||
else if (c == rdelim && --depth < 1)
|
||
break;
|
||
else if (c == ldelim)
|
||
++depth;
|
||
if (p >= end){
|
||
ptrdiff_t offset = p - line_buf;
|
||
/* buflen increment should be big enough
|
||
* to avoid execessive reallocs:
|
||
*/
|
||
buflen += 2048;
|
||
line_buf = realloc(line_buf, buflen);
|
||
if (!line_buf)
|
||
dc_memfail();
|
||
p = line_buf + offset;
|
||
end = line_buf + buflen;
|
||
}
|
||
*p++ = c;
|
||
}
|
||
return dc_makestring(line_buf, (size_t)(p-line_buf));
|
||
}
|
||
|
||
/* return the base pointer of the dc_str value;
|
||
* This function is needed because no one else knows what dc_str
|
||
* looks like.
|
||
*/
|
||
const char *
|
||
dc_str2charp DC_DECLARG((value))
|
||
dc_str value DC_DECLEND
|
||
{
|
||
return value->s_ptr;
|
||
}
|
||
|
||
/* return the length of the dc_str value;
|
||
* This function is needed because no one else knows what dc_str
|
||
* looks like, and strlen(dc_str2charp(value)) won't work
|
||
* if there's an embedded '\0'.
|
||
*/
|
||
size_t
|
||
dc_strlen DC_DECLARG((value))
|
||
dc_str value DC_DECLEND
|
||
{
|
||
return value->s_len;
|
||
}
|
||
|
||
|
||
/* initialize the strings subsystem */
|
||
void
|
||
dc_string_init DC_DECLVOID()
|
||
{
|
||
/* nothing to do for this implementation */
|
||
}
|