* Eliminated some potential gc problems.
* Eliminated some signedness problems.
* Minor changes.
scm_tc_dblc - replaced by scm_tc16_complex.
scm_list_star - replaced by scm_cons_star.
+** Deprecated: scm_makfromstr
+
+Use scm_mem2string instead.
+
** Deprecated: scm_make_shared_substring
Explicit shared substrings will disappear from Guile.
load.c: scm_read_and_eval_x
smob.c: scm_make_smob_type_mfpe, scm_set_smob_mfpe
gc.c: scm_remember
- string.c: scm_makstr
+ string.c: scm_makstr, scm_makfromstr
- remove deprecated procedures:
boot-9.scm: eval-in-module, id, -1+, return-it, string-character-length,
flags
+2001-06-26 Dirk Herrmann <D.Herrmann@tu-bs.de>
+
+ * oldfmt.c (scm_oldfmt): Use scm_mem2string instead of
+ scm_makfromstr.
+
2001-06-25 Neil Jerram <neil@ossau.uklinux.net>
* gh.texi (GH deprecation): Remove paragraph about portability.
-/* Copyright (C) 2000 Free Software Foundation, Inc.
+/* Copyright (C) 2000,2001 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
int n;
SCM_ASSERT (SCM_NIMP (s) && SCM_STRINGP (s), s, 1, s_oldfmt);
n = SCM_LENGTH (s);
- return scm_return_first (scm_makfromstr (scm_c_oldfmt (SCM_ROCHARS (s), n),
- n,
- 0),
+ return scm_return_first (scm_mem2string (scm_c_oldfmt (SCM_ROCHARS (s), n),
+ n),
s);
#endif
}
+2001-06-26 Dirk Herrmann <D.Herrmann@tu-bs.de>
+
+ * filesys.c (scm_close), ports.c (scm_close_port,
+ scm_port_closed_p), strop.c (scm_string_null_p): Use SCM_BOOL
+ instead of SCM_NEGATE_BOOL.
+
+ * filesys.c (scm_stat): Clean up type dispatch.
+
+ * filesys.c (scm_stat), ports.c (scm_input_port_p,
+ scm_output_port_p): Get rid of redundant IM type check.
+
+ * filesys.c (scm_readdir, scm_getcwd, scm_readlink), gh_data.c
+ (gh_str2scm), load.c (scm_primitive_load, scm_internal_parse_path,
+ scm_search_path), net_db.c (scm_gethost, scm_getnet, scm_getproto,
+ scm_return_entry), numbers.c (scm_number_to_string), objects.c
+ (scm_make_subclass_object), ports.c (scm_port_mode), read.c
+ (scm_lreadr), simpos.c (scm_getenv), socket.c (scm_inet_ntoa,
+ scm_addr_vector), stime.c (scm_strftime), strings.c
+ (scm_makfromstrs, scm_makfrom0str, scm_substring), strings.h
+ (SCM_STRING_COERCE_0TERMINATION_X), strop.c (string_copy,
+ scm_string_split), strports.c (scm_strport_to_string), symbols.c
+ (scm_symbol_to_string), vports.c (sf_write): Use scm_mem2string
+ instead of scm_makfromstr.
+
+ * net_db.c (scm_sethost, scm_setnet, scm_setproto, scm_setserv),
+ ports.c (scm_close_all_ports_except), read.c (scm_lreadr,
+ scm_read_hash_extend), stime.c (scm_strftime), strings.c
+ (scm_string_append, scm_string), strings.h (SCM_STRINGP,
+ SCM_STRING_COERCE_0TERMINATION_X, SCM_RWSTRINGP), strop.c
+ (string_capitalize_x): Prefer explicit type check over SCM_N?IMP,
+ !SCM_<pred> over SCM_N<pred>.
+
+ * strings.[ch] (scm_makfromstr): Deprecated.
+
+ (scm_mem2string): New function, replaces scm_makfromstr.
+
+ * strings.c (scm_substring), strop.c (string_copy,
+ scm_string_split), strports.c (scm_strport_to_string), symbols.c
+ (scm_symbol_to_string): Fix gc problem.
+
+ * strings.h (STRINGSH, SCM_STRINGS_H): Rename <foo>H to
+ SCM_<foo>_H.
+
+ * validate.h (SCM_VALIDATE_SUBSTRING_SPEC_COPY): Eliminate
+ warning about comparing signed and unsigned values. This fix is
+ not optimal, since it won't work reliably if sizeof (c_start) >
+ sizeof (size_t) or sizeof (c_end) > sizeof (size_t). A better
+ solution is to define this macro as an inline function, thus
+ allowing to specifiy the types of c_start and c_end.
+
2001-06-25 Dirk Herrmann <D.Herrmann@tu-bs.de>
* debug.h (SCM_DEBUGOBJ_FRAME): Deliver result as a
not an error. */
if (rv < 0 && errno != EBADF)
SCM_SYSERROR;
- return SCM_NEGATE_BOOL(rv < 0);
+ return SCM_BOOL (rv >= 0);
}
#undef FUNC_NAME
struct stat stat_temp;
if (SCM_INUMP (object))
- SCM_SYSCALL (rv = fstat (SCM_INUM (object), &stat_temp));
+ {
+ SCM_SYSCALL (rv = fstat (SCM_INUM (object), &stat_temp));
+ }
+ else if (SCM_STRINGP (object))
+ {
+ SCM_STRING_COERCE_0TERMINATION_X (object);
+ SCM_SYSCALL (rv = stat (SCM_STRING_CHARS (object), &stat_temp));
+ }
else
{
- SCM_VALIDATE_NIM (1,object);
- if (SCM_STRINGP (object))
- {
- SCM_STRING_COERCE_0TERMINATION_X (object);
- SCM_SYSCALL (rv = stat (SCM_STRING_CHARS (object), &stat_temp));
- }
- else
- {
- object = SCM_COERCE_OUTPORT (object);
- SCM_VALIDATE_OPFPORT(1,object);
- fdes = SCM_FPORT_FDES (object);
- SCM_SYSCALL (rv = fstat (fdes, &stat_temp));
- }
+ object = SCM_COERCE_OUTPORT (object);
+ SCM_VALIDATE_OPFPORT (1, object);
+ fdes = SCM_FPORT_FDES (object);
+ SCM_SYSCALL (rv = fstat (fdes, &stat_temp));
}
+
if (rv == -1)
{
int en = errno;
if (errno != 0)
SCM_SYSERROR;
- return (rdent ? scm_makfromstr (rdent->d_name, NAMLEN (rdent), 0)
+ return (rdent ? scm_mem2string (rdent->d_name, NAMLEN (rdent))
: SCM_EOF_VAL);
}
#undef FUNC_NAME
}
if (rv == 0)
SCM_SYSERROR;
- result = scm_makfromstr (wd, strlen (wd), 0);
+ result = scm_mem2string (wd, strlen (wd));
scm_must_free (wd);
return result;
}
}
if (rv == -1)
SCM_SYSERROR;
- result = scm_makfromstr (buf, rv, 0);
+ result = scm_mem2string (buf, rv);
scm_must_free (buf);
return result;
}
SCM
gh_str2scm (const char *s, size_t len)
{
- return scm_makfromstr (s, len, 0);
+ return scm_mem2string (s, len);
}
SCM
gh_str02scm (const char *s)
{ /* scope */
SCM port, save_port;
- port = scm_open_file (filename,
- scm_makfromstr ("r", (size_t) sizeof (char), 0));
+ port = scm_open_file (filename, scm_mem2string ("r", sizeof (char)));
save_port = port;
scm_internal_dynamic_wind (swap_port,
load,
/* Scan back to the beginning of the current element. */
do scan--;
while (scan >= path && *scan != ':');
- tail = scm_cons (scm_makfromstr (scan + 1, elt_end - (scan + 1), 0),
+ tail = scm_cons (scm_mem2string (scan + 1, elt_end - (scan + 1)),
tail);
elt_end = scan;
} while (scan >= path);
if (stat (buf, &mode) == 0
&& ! (mode.st_mode & S_IFDIR))
{
- result = scm_makfromstr (buf, len + ext_len, 0);
+ result = scm_mem2string (buf, len + ext_len);
goto end;
}
}
if (!entry)
scm_resolv_error (FUNC_NAME, host);
- ve[0] = scm_makfromstr (entry->h_name,
- (size_t) strlen (entry->h_name), 0);
+ ve[0] = scm_mem2string (entry->h_name, strlen (entry->h_name));
ve[1] = scm_makfromstrs (-1, entry->h_aliases);
ve[2] = SCM_MAKINUM (entry->h_addrtype + 0L);
ve[3] = SCM_MAKINUM (entry->h_length + 0L);
}
if (!entry)
SCM_SYSERROR_MSG ("no such network ~A", SCM_LIST1 (net), errno);
- ve[0] = scm_makfromstr (entry->n_name, (size_t) strlen (entry->n_name), 0);
+ ve[0] = scm_mem2string (entry->n_name, strlen (entry->n_name));
ve[1] = scm_makfromstrs (-1, entry->n_aliases);
ve[2] = SCM_MAKINUM (entry->n_addrtype + 0L);
ve[3] = scm_ulong2num (entry->n_net + 0L);
}
if (!entry)
SCM_SYSERROR_MSG ("no such protocol ~A", SCM_LIST1 (protocol), errno);
- ve[0] = scm_makfromstr (entry->p_name, (size_t) strlen (entry->p_name), 0);
+ ve[0] = scm_mem2string (entry->p_name, strlen (entry->p_name));
ve[1] = scm_makfromstrs (-1, entry->p_aliases);
ve[2] = SCM_MAKINUM (entry->p_proto + 0L);
return ans;
ans = scm_c_make_vector (4, SCM_UNSPECIFIED);
ve = SCM_VELTS (ans);
- ve[0] = scm_makfromstr (entry->s_name, (size_t) strlen (entry->s_name), 0);
+ ve[0] = scm_mem2string (entry->s_name, strlen (entry->s_name));
ve[1] = scm_makfromstrs (-1, entry->s_aliases);
ve[2] = SCM_MAKINUM (ntohs (entry->s_port) + 0L);
- ve[3] = scm_makfromstr (entry->s_proto, (size_t) strlen (entry->s_proto), 0);
+ ve[3] = scm_mem2string (entry->s_proto, strlen (entry->s_proto));
return ans;
}
if (SCM_UNBNDP (stayopen))
endhostent ();
else
- sethostent (SCM_NFALSEP (stayopen));
+ sethostent (!SCM_FALSEP (stayopen));
return SCM_UNSPECIFIED;
}
#undef FUNC_NAME
if (SCM_UNBNDP (stayopen))
endnetent ();
else
- setnetent (SCM_NFALSEP (stayopen));
+ setnetent (!SCM_FALSEP (stayopen));
return SCM_UNSPECIFIED;
}
#undef FUNC_NAME
if (SCM_UNBNDP (stayopen))
endprotoent ();
else
- setprotoent (SCM_NFALSEP (stayopen));
+ setprotoent (!SCM_FALSEP (stayopen));
return SCM_UNSPECIFIED;
}
#undef FUNC_NAME
if (SCM_UNBNDP (stayopen))
endservent ();
else
- setservent (SCM_NFALSEP (stayopen));
+ setservent (!SCM_FALSEP (stayopen));
return SCM_UNSPECIFIED;
}
#undef FUNC_NAME
if (SCM_INUMP (n)) {
char num_buf [SCM_INTBUFLEN];
size_t length = scm_iint2str (SCM_INUM (n), base, num_buf);
- return scm_makfromstr (num_buf, length, 0);
+ return scm_mem2string (num_buf, length);
} else if (SCM_BIGP (n)) {
return big2str (n, (unsigned int) base);
} else if (SCM_INEXACTP (n)) {
char num_buf [FLOBUFLEN];
- return scm_makfromstr (num_buf, iflo2str (n, num_buf), 0);
+ return scm_mem2string (num_buf, iflo2str (n, num_buf));
} else {
SCM_WRONG_TYPE_ARG (1, n);
}
SCM_VALIDATE_STRING (2,layout);
pl = SCM_PACK (SCM_STRUCT_DATA (class) [scm_vtable_index_layout]);
/* Convert symbol->string */
- pl = scm_makfromstr (SCM_SYMBOL_CHARS (pl), SCM_SYMBOL_LENGTH (pl), 0);
+ pl = scm_mem2string (SCM_SYMBOL_CHARS (pl), SCM_SYMBOL_LENGTH (pl));
return scm_i_make_class_object (SCM_STRUCT_VTABLE (class),
scm_string_append (SCM_LIST2 (pl, layout)),
SCM_CLASS_FLAGS (class));
strcpy (modes, "w");
if (SCM_CELL_WORD_0 (port) & SCM_BUF0)
strcat (modes, "0");
- return scm_makfromstr (modes, strlen (modes), 0);
+ return scm_mem2string (modes, strlen (modes));
}
#undef FUNC_NAME
rv = 0;
scm_remove_from_port_table (port);
SCM_CLR_PORT_OPEN_FLAG (port);
- return SCM_NEGATE_BOOL (rv < 0);
+ return SCM_BOOL (rv >= 0);
}
#undef FUNC_NAME
int found = 0;
SCM ports_ptr = ports;
- while (SCM_NNULLP (ports_ptr))
+ while (!SCM_NULLP (ports_ptr))
{
SCM port = SCM_COERCE_OUTPORT (SCM_CAR (ports_ptr));
if (i == 0)
"@code{port?}.")
#define FUNC_NAME s_scm_input_port_p
{
- if (SCM_IMP (x))
- return SCM_BOOL_F;
- return SCM_BOOL(SCM_INPUT_PORT_P (x));
+ return SCM_BOOL (SCM_INPUT_PORT_P (x));
}
#undef FUNC_NAME
"@code{port?}.")
#define FUNC_NAME s_scm_output_port_p
{
- if (SCM_IMP (x))
- return SCM_BOOL_F;
- if (SCM_PORT_WITH_PS_P (x))
- x = SCM_PORT_WITH_PS_PORT (x);
- return SCM_BOOL(SCM_OUTPUT_PORT_P (x));
+ SCM_COERCE_OUTPORT (x);
+ return SCM_BOOL (SCM_OUTPUT_PORT_P (x));
}
#undef FUNC_NAME
#define FUNC_NAME s_scm_port_closed_p
{
SCM_VALIDATE_PORT (1,port);
- return SCM_NEGATE_BOOL(SCM_OPPORTP (port));
+ return SCM_BOOL (!SCM_OPPORTP (port));
}
#undef FUNC_NAME
case '*':
j = scm_read_token (c, tok_buf, port, 0);
p = scm_istr2bve (SCM_STRING_CHARS (*tok_buf) + 1, (long) (j - 1));
- if (SCM_NFALSEP (p))
+ if (!SCM_FALSEP (p))
return p;
else
goto unkshrp;
if (c >= '0' && c < '8')
{
p = scm_istr2int (SCM_STRING_CHARS (*tok_buf), (long) j, 8);
- if (SCM_NFALSEP (p))
+ if (!SCM_FALSEP (p))
return SCM_MAKE_CHAR (SCM_INUM (p));
}
for (c = 0; c < scm_n_charnames; c++)
{
SCM sharp = scm_get_hash_procedure (c);
- if (SCM_NIMP (sharp))
+ if (!SCM_FALSEP (sharp))
{
int line = SCM_LINUM (port);
int column = SCM_COL (port) - 2;
if (j == 0)
return scm_nullstr;
SCM_STRING_CHARS (*tok_buf)[j] = 0;
- {
- SCM str;
- str = scm_makfromstr (SCM_STRING_CHARS (*tok_buf), j, 0);
- return str;
- }
+ return scm_mem2string (SCM_STRING_CHARS (*tok_buf), j);
case'0':case '1':case '2':case '3':case '4':
case '5':case '6':case '7':case '8':case '9':
num:
j = scm_read_token (c, tok_buf, port, 0);
p = scm_istring2number (SCM_STRING_CHARS (*tok_buf), (long) j, 10L);
- if (SCM_NFALSEP (p))
+ if (!SCM_FALSEP (p))
return p;
if (c == '#')
{
SCM this;
SCM prev;
- SCM_VALIDATE_CHAR (1,chr);
- SCM_ASSERT (SCM_FALSEP (proc) || SCM_NIMP(proc), proc, SCM_ARG2,
- FUNC_NAME);
+ SCM_VALIDATE_CHAR (1, chr);
+ SCM_ASSERT (SCM_FALSEP (proc)
+ || SCM_EQ_P (scm_procedure_p (proc), SCM_BOOL_T),
+ proc, SCM_ARG2, FUNC_NAME);
/* Check if chr is already in the alist. */
this = *scm_read_hash_procedures;
if (SCM_NULLP (this))
{
/* not found, so add it to the beginning. */
- if (SCM_NFALSEP (proc))
+ if (!SCM_FALSEP (proc))
{
*scm_read_hash_procedures =
scm_cons (scm_cons (chr, proc), *scm_read_hash_procedures);
-/* Copyright (C) 1995,1996,1997,1998, 2000, 2001 Free Software Foundation, Inc.
+/* Copyright (C) 1995,1996,1997,1998,2000,2001 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
SCM_VALIDATE_STRING (1, nam);
SCM_STRING_COERCE_0TERMINATION_X (nam);
val = getenv (SCM_STRING_CHARS (nam));
- return (val) ? scm_makfromstr(val, (size_t)strlen(val), 0) : SCM_BOOL_F;
+ return val ? scm_mem2string (val, strlen (val)) : SCM_BOOL_F;
}
#undef FUNC_NAME
SCM answer;
addr.s_addr = htonl (SCM_NUM2ULONG (1, inetid));
s = inet_ntoa (addr);
- answer = scm_makfromstr (s, strlen (s), 0);
+ answer = scm_mem2string (s, strlen (s));
return answer;
}
#undef FUNC_NAME
result = scm_c_make_vector (2, SCM_UNSPECIFIED);
ve = SCM_VELTS (result);
ve[0] = scm_ulong2num ((unsigned long) fam);
- ve[1] = scm_makfromstr (nad->sun_path,
- (size_t) strlen (nad->sun_path), 0);
+ ve[1] = scm_mem2string (nad->sun_path, strlen (nad->sun_path));
}
break;
#endif
SCM *velts = SCM_VELTS (stime);
int have_zone = 0;
- if (SCM_NFALSEP (velts[10]) && *SCM_STRING_CHARS (velts[10]) != 0)
+ if (!SCM_FALSEP (velts[10]) && *SCM_STRING_CHARS (velts[10]) != 0)
{
/* it's not required that the TZ setting be correct, just that
it has the right name. so try something like TZ=EST0.
#endif
}
- result = scm_makfromstr (tbuf+1, len-1, 0);
+ result = scm_mem2string (tbuf + 1, len - 1);
scm_must_free (tbuf);
scm_must_free(myfmt);
return result;
{
unsigned char *data = SCM_STRING_UCHARS (result);
- while (SCM_NNULLP (chrs))
+ while (!SCM_NULLP (chrs))
{
SCM elt = SCM_CAR (chrs);
if (0 > i)
for (i = 0; argv[i]; i++);
while (i--)
- lst = scm_cons (scm_makfromstr (argv[i], (size_t) strlen (argv[i]), 0), lst);
+ lst = scm_cons (scm_mem2string (argv[i], strlen (argv[i])), lst);
return lst;
}
return scm_take_str (s, strlen (s));
}
+#if (SCM_DEBUG_DEPRECATED == 0)
+
SCM
scm_makfromstr (const char *src, size_t len, int dummy SCM_UNUSED)
+{
+ scm_c_issue_deprecation_warning ("`scm_makfromstr' is deprecated. "
+ "Use `scm_mem2string' instead.");
+
+ return scm_mem2string (src, len);
+}
+
+#endif
+
+SCM
+scm_mem2string (const char *src, size_t len)
{
SCM s = scm_allocate_string (len);
char *dst = SCM_STRING_CHARS (s);
scm_makfrom0str (const char *src)
{
if (!src) return SCM_BOOL_F;
- return scm_makfromstr (src, (size_t) strlen (src), 0);
+ return scm_mem2string (src, strlen (src));
}
{
long int from;
long int to;
+ SCM substr;
SCM_VALIDATE_STRING (1, str);
SCM_VALIDATE_INUM (2, start);
to = SCM_INUM (end);
SCM_ASSERT_RANGE (3, end, from <= to && to <= SCM_STRING_LENGTH (str));
- return scm_makfromstr (&SCM_STRING_CHARS (str)[from], (size_t) (to - from), 0);
+ substr = scm_mem2string (&SCM_STRING_CHARS (str)[from], to - from);
+ scm_remember_upto_here_1 (str);
+ return substr;
}
#undef FUNC_NAME
}
res = scm_allocate_string (i);
data = SCM_STRING_UCHARS (res);
- for (l = args;SCM_NIMP (l);l = SCM_CDR (l)) {
+ for (l = args; !SCM_NULLP (l);l = SCM_CDR (l)) {
s = SCM_CAR (l);
for (i = 0;i<SCM_STRING_LENGTH (s);i++) *data++ = SCM_STRING_UCHARS (s)[i];
}
/* classes: h_files */
-#ifndef STRINGSH
-#define STRINGSH
-/* Copyright (C) 1995,1996,1997,1998, 2000 Free Software Foundation, Inc.
+#ifndef SCM_STRINGS_H
+#define SCM_STRINGS_H
+/* Copyright (C) 1995,1996,1997,1998,2000,2001 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
\f
-#define SCM_STRINGP(x) (SCM_NIMP (x) && (SCM_TYP7S (x) == scm_tc7_string))
+#define SCM_STRINGP(x) (!SCM_IMP (x) && (SCM_TYP7S (x) == scm_tc7_string))
#if (SCM_DEBUG_DEPRECATED == 1)
#define SCM_STRING_UCHARS(x) ((unsigned char *) (SCM_CELL_WORD_1 (x)))
#define SCM_STRING_CHARS(x) ((char *) (SCM_CELL_WORD_1 (x)))
#define SCM_SET_STRING_LENGTH(s, l) (SCM_SET_CELL_WORD_0 ((s), ((l) << 8) + scm_tc7_string))
#define SCM_STRING_COERCE_0TERMINATION_X(x) \
- { if (SCM_NIMP (x) && (SCM_TYP7 (x) == scm_tc7_substring)) \
- x = scm_makfromstr (SCM_STRING_CHARS (x), SCM_STRING_LENGTH (x), 0); }
+ { if (!SCM_IMP (x) && (SCM_TYP7 (x) == scm_tc7_substring)) \
+ x = scm_mem2string (SCM_STRING_CHARS (x), SCM_STRING_LENGTH (x)); }
\f
extern SCM scm_makfromstrs (int argc, char **argv);
extern SCM scm_take_str (char *s, size_t len);
extern SCM scm_take0str (char *s);
-extern SCM scm_makfromstr (const char *src, size_t len, int);
+extern SCM scm_mem2string (const char *src, size_t len);
extern SCM scm_makfrom0str (const char *src);
extern SCM scm_makfrom0str_opt (const char *src);
extern SCM scm_allocate_string (size_t len);
#if (SCM_DEBUG_DEPRECATED == 0)
#define SCM_SLOPPY_STRINGP(x) (SCM_STRINGP(x))
-#define SCM_RWSTRINGP(x) (SCM_NIMP (x) && (SCM_TYP7 (x) == scm_tc7_string))
+#define SCM_RWSTRINGP(x) (!SCM_IMP (x) && (SCM_TYP7 (x) == scm_tc7_string))
#define SCM_STRING_UCHARS(x) \
((SCM_TYP7 (x) == scm_tc7_substring) \
? (unsigned char *) SCM_CELL_WORD_1 (SCM_CDDR (x)) + SCM_INUM (SCM_CADR (x)) \
: (char *) SCM_CELL_WORD_1 (x))
extern SCM scm_make_shared_substring (SCM str, SCM frm, SCM to);
extern SCM scm_makstr (size_t len, int);
+extern SCM scm_makfromstr (const char *src, size_t len, int);
#endif /* SCM_DEBUG_DEPRECATED == 0 */
-#endif /* STRINGSH */
+#endif /* SCM_STRINGS_H */
/*
Local Variables:
/* classes: src_files */
-/* Copyright (C) 1994, 1996, 1997, 1999, 2000, 2001 Free Software Foundation, Inc.
+/* Copyright (C) 1994,1996,1997,1999,2000,2001 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
#define FUNC_NAME s_scm_string_null_p
{
SCM_VALIDATE_STRING (1,str);
- return SCM_NEGATE_BOOL (SCM_STRING_LENGTH (str));
+ return SCM_BOOL (SCM_STRING_LENGTH (str) == 0);
}
#undef FUNC_NAME
static SCM
string_copy (SCM str)
{
- return scm_makfromstr (SCM_STRING_CHARS (str), SCM_STRING_LENGTH (str), 0);
+ const char* chars = SCM_STRING_CHARS (str);
+ size_t length = SCM_STRING_LENGTH (str);
+ SCM new_string = scm_mem2string (chars, length);
+ scm_remember_upto_here_1 (str);
+ return new_string;
}
len = SCM_STRING_LENGTH(str);
sz = SCM_STRING_CHARS (str);
for(i=0; i<len; i++) {
- if(SCM_NFALSEP(scm_char_alphabetic_p(SCM_MAKE_CHAR(sz[i])))) {
+ if (!SCM_FALSEP (scm_char_alphabetic_p (SCM_MAKE_CHAR (sz[i])))) {
if(!in_word) {
sz[i] = scm_upcase(sz[i]);
in_word = 1;
idx--;
if (idx >= 0)
{
- res = scm_cons (scm_makfromstr (p + idx, last_idx - idx, 0), res);
+ res = scm_cons (scm_mem2string (p + idx, last_idx - idx), res);
idx--;
}
}
+ scm_remember_upto_here_1 (str);
return res;
}
#undef FUNC_NAME
SCM scm_strport_to_string (SCM port)
{
scm_t_port *pt = SCM_PTAB_ENTRY (port);
+ SCM str;
if (pt->rw_active == SCM_PORT_WRITE)
st_flush (port);
- return scm_makfromstr ((char *) pt->read_buf, pt->read_buf_size, 0);
+
+ str = scm_mem2string ((char *) pt->read_buf, pt->read_buf_size);
+ scm_remember_upto_here_1 (port);
+ return str;
}
SCM_DEFINE (scm_object_to_string, "object->string", 1, 1, 0,
"@end lisp")
#define FUNC_NAME s_scm_symbol_to_string
{
+ SCM str;
SCM_VALIDATE_SYMBOL (1, s);
- return scm_makfromstr (SCM_SYMBOL_CHARS (s), SCM_SYMBOL_LENGTH (s), 0);
+ str = scm_mem2string (SCM_SYMBOL_CHARS (s), SCM_SYMBOL_LENGTH (s));
+ scm_remember_upto_here_1 (s);
+ return str;
}
#undef FUNC_NAME
-/* $Id: validate.h,v 1.33 2001-05-26 20:51:22 cmm Exp $ */
+/* $Id: validate.h,v 1.34 2001-06-26 10:59:34 dirk Exp $ */
/* Copyright (C) 1999,2000,2001 Free Software Foundation, Inc.
*
* This program is free software; you can redistribute it and/or modify
SCM_VALIDATE_INUM_DEF_COPY (pos_start, start, 0, c_start);\
SCM_VALIDATE_INUM_DEF_COPY (pos_end, end, SCM_STRING_LENGTH (str), c_end);\
SCM_ASSERT_RANGE (pos_start, start,\
- 0 <= c_start && c_start <= SCM_STRING_LENGTH (str));\
+ 0 <= c_start \
+ && (size_t) c_start <= SCM_STRING_LENGTH (str));\
SCM_ASSERT_RANGE (pos_end, end,\
- c_start <= c_end && c_end <= SCM_STRING_LENGTH (str));\
+ c_start <= c_end \
+ && (size_t) c_end <= SCM_STRING_LENGTH (str));\
} while (0)
#define SCM_VALIDATE_REAL(pos, z) SCM_MAKE_VALIDATE (pos, z, REALP)
-/* Copyright (C) 1995,1996,1998,1999, 2000, 2001 Free Software Foundation, Inc.
+/* Copyright (C) 1995,1996,1998,1999,2000,2001 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
SCM p = SCM_PACK (SCM_STREAM (port));
scm_apply (SCM_VELTS (p)[1],
- scm_cons (scm_makfromstr ((char *) data, size, 0), SCM_EOL),
+ scm_cons (scm_mem2string ((char *) data, size), SCM_EOL),
SCM_EOL);
}
+2001-06-26 Dirk Herrmann <D.Herrmann@tu-bs.de>
+
+ * srfi-13.c (scm_string_copyS, scm_string_take, scm_string_drop,
+ scm_string_take_right, scm_string_drop_right, scm_string_trim,
+ scm_string_trim_right, scm_string_trim_both, scm_string_tokenize):
+ Use scm_mem2string instead of scm_makfromstr.
+
+ (scm_reverse_list_to_string, string_titlecase_x): Prefer
+ !SCM_<pred> over SCM_N<pred>.
+
2001-06-25 Marius Vollmer <mvo@zagadka.ping.de>
* srfi-8.scm: Use `re-export-syntax' to correctly re-export
/* srfi-13.c --- SRFI-13 procedures for Guile
*
- * Copyright (C) 2001 Free Software Foundation, Inc.
+ * Copyright (C) 2001 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
{
unsigned char *data = SCM_STRING_UCHARS (result) + i;
- while (SCM_NNULLP (chrs))
+ while (!SCM_NULLP (chrs))
{
SCM elt = SCM_CAR (chrs);
SCM_VALIDATE_SUBSTRING_SPEC_COPY (1, str, cstr,
2, start, cstart,
3, end, cend);
- return scm_makfromstr (cstr + cstart, cend - cstart, 0);
+ return scm_mem2string (cstr + cstart, cend - cstart);
}
#undef FUNC_NAME
SCM_VALIDATE_INUM_COPY (2, n, cn);
SCM_ASSERT_RANGE (2, n, cn >= 0 && cn <= SCM_STRING_LENGTH (s));
- return scm_makfromstr (cstr, cn, 0);
+ return scm_mem2string (cstr, cn);
}
#undef FUNC_NAME
SCM_VALIDATE_INUM_COPY (2, n, cn);
SCM_ASSERT_RANGE (2, n, cn >= 0 && cn <= SCM_STRING_LENGTH (s));
- return scm_makfromstr (cstr + cn, SCM_STRING_LENGTH (s) - cn, 0);
+ return scm_mem2string (cstr + cn, SCM_STRING_LENGTH (s) - cn);
}
#undef FUNC_NAME
SCM_VALIDATE_INUM_COPY (2, n, cn);
SCM_ASSERT_RANGE (2, n, cn >= 0 && cn <= SCM_STRING_LENGTH (s));
- return scm_makfromstr (cstr + SCM_STRING_LENGTH (s) - cn, cn, 0);
+ return scm_mem2string (cstr + SCM_STRING_LENGTH (s) - cn, cn);
}
#undef FUNC_NAME
SCM_VALIDATE_INUM_COPY (2, n, cn);
SCM_ASSERT_RANGE (2, n, cn >= 0 && cn <= SCM_STRING_LENGTH (s));
- return scm_makfromstr (cstr, SCM_STRING_LENGTH (s) - cn, 0);
+ return scm_mem2string (cstr, SCM_STRING_LENGTH (s) - cn);
}
#undef FUNC_NAME
cstart++;
}
}
- return scm_makfromstr (cstr + cstart, cend - cstart, 0);
+ return scm_mem2string (cstr + cstart, cend - cstart);
}
#undef FUNC_NAME
cend--;
}
}
- return scm_makfromstr (cstr + cstart, cend - cstart, 0);
+ return scm_mem2string (cstr + cstart, cend - cstart);
}
#undef FUNC_NAME
cend--;
}
}
- return scm_makfromstr (cstr + cstart, cend - cstart, 0);
+ return scm_mem2string (cstr + cstart, cend - cstart);
}
#undef FUNC_NAME
sz = SCM_STRING_CHARS (str);
for(i = start; i < end; i++)
{
- if(SCM_NFALSEP(scm_char_alphabetic_p(SCM_MAKE_CHAR(sz[i]))))
+ if (!SCM_FALSEP (scm_char_alphabetic_p (SCM_MAKE_CHAR (sz[i]))))
{
if (!in_word)
{
break;
cend--;
}
- result = scm_cons (scm_makfromstr (cstr + cend, idx - cend,
- 0), result);
+ result = scm_cons (scm_mem2string (cstr + cend, idx - cend), result);
}
}
else if (SCM_CHARSETP (token_char))
break;
cend--;
}
- result = scm_cons (scm_makfromstr (cstr + cend, idx - cend,
- 0), result);
+ result = scm_cons (scm_mem2string (cstr + cend, idx - cend), result);
}
}
else
break;
cend--;
}
- result = scm_cons (scm_makfromstr (cstr + cend, idx - cend,
- 0), result);
+ result = scm_cons (scm_mem2string (cstr + cend, idx - cend), result);
}
}
return result;
HCoop / bpt / guile.git / commitdiff