1 /* Copyright (C) 1995,1996,1998,2000,2001, 2004, 2006, 2008 Free Software Foundation, Inc.
3 * This library is free software; you can redistribute it and/or
4 * modify it under the terms of the GNU Lesser General Public
5 * License as published by the Free Software Foundation; either
6 * version 2.1 of the License, or (at your option) any later version.
8 * This library is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * Lesser General Public License for more details.
13 * You should have received a copy of the GNU Lesser General Public
14 * License along with this library; if not, write to the Free Software
15 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 #include "libguile/_scm.h"
28 #include "libguile/chars.h"
29 #include "libguile/root.h"
30 #include "libguile/strings.h"
31 #include "libguile/deprecation.h"
32 #include "libguile/validate.h"
33 #include "libguile/dynwind.h"
43 * XXX - keeping an accurate refcount during GC seems to be quite
44 * tricky, so we just keep score of whether a stringbuf might be
45 * shared, not wether it definitely is.
47 * The scheme I (mvo) tried to keep an accurate reference count would
48 * recount all strings that point to a stringbuf during the mark-phase
49 * of the GC. This was done since one cannot access the stringbuf of
50 * a string when that string is freed (in order to decrease the
51 * reference count). The memory of the stringbuf might have been
52 * reused already for something completely different.
54 * This recounted worked for a small number of threads beating on
55 * cow-strings, but it failed randomly with more than 10 threads, say.
56 * I couldn't figure out what went wrong, so I used the conservative
57 * approach implemented below.
59 * A stringbuf needs to know its length, but only so that it can be
60 * reported when the stringbuf is freed.
62 * Stringbufs (and strings) are not stored very compactly: a stringbuf
63 * has room for about 2*sizeof(scm_t_bits)-1 bytes additional
64 * information. As a compensation, the code below is made more
65 * complicated by storing small strings inline in the double cell of a
66 * stringbuf. So we have fixstrings and bigstrings...
69 #define STRINGBUF_F_SHARED 0x100
70 #define STRINGBUF_F_INLINE 0x200
72 #define STRINGBUF_TAG scm_tc7_stringbuf
73 #define STRINGBUF_SHARED(buf) (SCM_CELL_WORD_0(buf) & STRINGBUF_F_SHARED)
74 #define STRINGBUF_INLINE(buf) (SCM_CELL_WORD_0(buf) & STRINGBUF_F_INLINE)
76 #define STRINGBUF_OUTLINE_CHARS(buf) ((char *)SCM_CELL_WORD_1(buf))
77 #define STRINGBUF_OUTLINE_LENGTH(buf) (SCM_CELL_WORD_2(buf))
78 #define STRINGBUF_INLINE_CHARS(buf) ((char *)SCM_CELL_OBJECT_LOC(buf,1))
79 #define STRINGBUF_INLINE_LENGTH(buf) (((size_t)SCM_CELL_WORD_0(buf))>>16)
81 #define STRINGBUF_CHARS(buf) (STRINGBUF_INLINE (buf) \
82 ? STRINGBUF_INLINE_CHARS (buf) \
83 : STRINGBUF_OUTLINE_CHARS (buf))
84 #define STRINGBUF_LENGTH(buf) (STRINGBUF_INLINE (buf) \
85 ? STRINGBUF_INLINE_LENGTH (buf) \
86 : STRINGBUF_OUTLINE_LENGTH (buf))
88 #define STRINGBUF_MAX_INLINE_LEN (3*sizeof(scm_t_bits))
90 #define SET_STRINGBUF_SHARED(buf) \
91 (SCM_SET_CELL_WORD_0 ((buf), SCM_CELL_WORD_0 (buf) | STRINGBUF_F_SHARED))
94 static size_t lenhist
[1001];
98 make_stringbuf (size_t len
)
100 /* XXX - for the benefit of SCM_STRING_CHARS, SCM_SYMBOL_CHARS and
101 scm_i_symbol_chars, all stringbufs are null-terminated. Once
102 SCM_STRING_CHARS and SCM_SYMBOL_CHARS are removed and the code
103 has been changed for scm_i_symbol_chars, this null-termination
114 if (len
<= STRINGBUF_MAX_INLINE_LEN
-1)
116 return scm_double_cell (STRINGBUF_TAG
| STRINGBUF_F_INLINE
| (len
<< 16),
121 char *mem
= scm_gc_malloc (len
+1, "string");
123 return scm_double_cell (STRINGBUF_TAG
, (scm_t_bits
) mem
,
124 (scm_t_bits
) len
, (scm_t_bits
) 0);
128 /* Return a new stringbuf whose underlying storage consists of the LEN+1
129 octets pointed to by STR (the last octet is zero). */
131 scm_i_take_stringbufn (char *str
, size_t len
)
133 scm_gc_register_collectable_memory (str
, len
+ 1, "stringbuf");
135 return scm_double_cell (STRINGBUF_TAG
, (scm_t_bits
) str
,
136 (scm_t_bits
) len
, (scm_t_bits
) 0);
140 scm_i_stringbuf_mark (SCM buf
)
146 scm_i_stringbuf_free (SCM buf
)
148 if (!STRINGBUF_INLINE (buf
))
149 scm_gc_free (STRINGBUF_OUTLINE_CHARS (buf
),
150 STRINGBUF_OUTLINE_LENGTH (buf
) + 1, "string");
153 scm_i_pthread_mutex_t stringbuf_write_mutex
= SCM_I_PTHREAD_MUTEX_INITIALIZER
;
155 /* Copy-on-write strings.
158 #define STRING_TAG scm_tc7_string
160 #define STRING_STRINGBUF(str) (SCM_CELL_OBJECT_1(str))
161 #define STRING_START(str) ((size_t)SCM_CELL_WORD_2(str))
162 #define STRING_LENGTH(str) ((size_t)SCM_CELL_WORD_3(str))
164 #define SET_STRING_STRINGBUF(str,buf) (SCM_SET_CELL_OBJECT_1(str,buf))
165 #define SET_STRING_START(str,start) (SCM_SET_CELL_WORD_2(str,start))
167 #define IS_STRING(str) (SCM_NIMP(str) && SCM_TYP7(str) == STRING_TAG)
169 /* Read-only strings.
172 #define RO_STRING_TAG (scm_tc7_string + 0x200)
173 #define IS_RO_STRING(str) (SCM_CELL_TYPE(str)==RO_STRING_TAG)
175 /* Mutation-sharing substrings
178 #define SH_STRING_TAG (scm_tc7_string + 0x100)
180 #define SH_STRING_STRING(sh) (SCM_CELL_OBJECT_1(sh))
181 /* START and LENGTH as for STRINGs. */
183 #define IS_SH_STRING(str) (SCM_CELL_TYPE(str)==SH_STRING_TAG)
186 scm_i_make_string (size_t len
, char **charsp
)
188 SCM buf
= make_stringbuf (len
);
191 *charsp
= STRINGBUF_CHARS (buf
);
192 res
= scm_double_cell (STRING_TAG
, SCM_UNPACK(buf
),
193 (scm_t_bits
)0, (scm_t_bits
) len
);
198 validate_substring_args (SCM str
, size_t start
, size_t end
)
200 if (!IS_STRING (str
))
201 scm_wrong_type_arg_msg (NULL
, 0, str
, "string");
202 if (start
> STRING_LENGTH (str
))
203 scm_out_of_range (NULL
, scm_from_size_t (start
));
204 if (end
> STRING_LENGTH (str
) || end
< start
)
205 scm_out_of_range (NULL
, scm_from_size_t (end
));
209 get_str_buf_start (SCM
*str
, SCM
*buf
, size_t *start
)
211 *start
= STRING_START (*str
);
212 if (IS_SH_STRING (*str
))
214 *str
= SH_STRING_STRING (*str
);
215 *start
+= STRING_START (*str
);
217 *buf
= STRING_STRINGBUF (*str
);
221 scm_i_make_read_only_string (SCM str
)
223 return scm_i_substring_read_only (str
, 0, STRING_LENGTH (str
));
227 scm_i_substring (SCM str
, size_t start
, size_t end
)
231 get_str_buf_start (&str
, &buf
, &str_start
);
232 scm_i_pthread_mutex_lock (&stringbuf_write_mutex
);
233 SET_STRINGBUF_SHARED (buf
);
234 scm_i_pthread_mutex_unlock (&stringbuf_write_mutex
);
235 return scm_double_cell (STRING_TAG
, SCM_UNPACK(buf
),
236 (scm_t_bits
)str_start
+ start
,
237 (scm_t_bits
) end
- start
);
241 scm_i_substring_read_only (SCM str
, size_t start
, size_t end
)
245 if (SCM_UNLIKELY (STRING_LENGTH (str
) == 0))
246 /* We want the empty string to be `eq?' with the read-only empty
254 get_str_buf_start (&str
, &buf
, &str_start
);
255 scm_i_pthread_mutex_lock (&stringbuf_write_mutex
);
256 SET_STRINGBUF_SHARED (buf
);
257 scm_i_pthread_mutex_unlock (&stringbuf_write_mutex
);
259 result
= scm_double_cell (RO_STRING_TAG
, SCM_UNPACK (buf
),
260 (scm_t_bits
) str_start
+ start
,
261 (scm_t_bits
) end
- start
);
268 scm_i_substring_copy (SCM str
, size_t start
, size_t end
)
270 size_t len
= end
- start
;
273 get_str_buf_start (&str
, &buf
, &str_start
);
274 my_buf
= make_stringbuf (len
);
275 memcpy (STRINGBUF_CHARS (my_buf
),
276 STRINGBUF_CHARS (buf
) + str_start
+ start
, len
);
277 scm_remember_upto_here_1 (buf
);
278 return scm_double_cell (STRING_TAG
, SCM_UNPACK(my_buf
),
279 (scm_t_bits
)0, (scm_t_bits
) len
);
283 scm_i_substring_shared (SCM str
, size_t start
, size_t end
)
285 if (start
== 0 && end
== STRING_LENGTH (str
))
289 size_t len
= end
- start
;
290 if (IS_SH_STRING (str
))
292 start
+= STRING_START (str
);
293 str
= SH_STRING_STRING (str
);
295 return scm_double_cell (SH_STRING_TAG
, SCM_UNPACK(str
),
296 (scm_t_bits
)start
, (scm_t_bits
) len
);
301 scm_c_substring (SCM str
, size_t start
, size_t end
)
303 validate_substring_args (str
, start
, end
);
304 return scm_i_substring (str
, start
, end
);
308 scm_c_substring_read_only (SCM str
, size_t start
, size_t end
)
310 validate_substring_args (str
, start
, end
);
311 return scm_i_substring_read_only (str
, start
, end
);
315 scm_c_substring_copy (SCM str
, size_t start
, size_t end
)
317 validate_substring_args (str
, start
, end
);
318 return scm_i_substring_copy (str
, start
, end
);
322 scm_c_substring_shared (SCM str
, size_t start
, size_t end
)
324 validate_substring_args (str
, start
, end
);
325 return scm_i_substring_shared (str
, start
, end
);
329 scm_i_string_mark (SCM str
)
331 if (IS_SH_STRING (str
))
332 return SH_STRING_STRING (str
);
334 return STRING_STRINGBUF (str
);
338 scm_i_string_free (SCM str
)
342 /* Internal accessors
346 scm_i_string_length (SCM str
)
348 return STRING_LENGTH (str
);
352 scm_i_string_chars (SCM str
)
356 get_str_buf_start (&str
, &buf
, &start
);
357 return STRINGBUF_CHARS (buf
) + start
;
361 scm_i_string_writable_chars (SCM orig_str
)
363 SCM buf
, str
= orig_str
;
366 get_str_buf_start (&str
, &buf
, &start
);
367 if (IS_RO_STRING (str
))
368 scm_misc_error (NULL
, "string is read-only: ~s", scm_list_1 (orig_str
));
370 scm_i_pthread_mutex_lock (&stringbuf_write_mutex
);
371 if (STRINGBUF_SHARED (buf
))
373 /* Clone stringbuf. For this, we put all threads to sleep.
376 size_t len
= STRING_LENGTH (str
);
379 scm_i_pthread_mutex_unlock (&stringbuf_write_mutex
);
381 new_buf
= make_stringbuf (len
);
382 memcpy (STRINGBUF_CHARS (new_buf
),
383 STRINGBUF_CHARS (buf
) + STRING_START (str
), len
);
385 scm_i_thread_put_to_sleep ();
386 SET_STRING_STRINGBUF (str
, new_buf
);
387 start
-= STRING_START (str
);
388 SET_STRING_START (str
, 0);
389 scm_i_thread_wake_up ();
393 scm_i_pthread_mutex_lock (&stringbuf_write_mutex
);
396 return STRINGBUF_CHARS (buf
) + start
;
400 scm_i_string_stop_writing (void)
402 scm_i_pthread_mutex_unlock (&stringbuf_write_mutex
);
407 Basic symbol creation and accessing is done here, the rest is in
408 symbols.[hc]. This has been done to keep stringbufs and the
409 internals of strings and string-like objects confined to this file.
412 #define SYMBOL_STRINGBUF SCM_CELL_OBJECT_1
415 scm_i_make_symbol (SCM name
, scm_t_bits flags
,
416 unsigned long hash
, SCM props
)
419 size_t start
= STRING_START (name
);
420 size_t length
= STRING_LENGTH (name
);
422 if (IS_SH_STRING (name
))
424 name
= SH_STRING_STRING (name
);
425 start
+= STRING_START (name
);
427 buf
= SYMBOL_STRINGBUF (name
);
429 if (start
== 0 && length
== STRINGBUF_LENGTH (buf
))
432 scm_i_pthread_mutex_lock (&stringbuf_write_mutex
);
433 SET_STRINGBUF_SHARED (buf
);
434 scm_i_pthread_mutex_unlock (&stringbuf_write_mutex
);
439 SCM new_buf
= make_stringbuf (length
);
440 memcpy (STRINGBUF_CHARS (new_buf
),
441 STRINGBUF_CHARS (buf
) + start
, length
);
444 return scm_double_cell (scm_tc7_symbol
| flags
, SCM_UNPACK (buf
),
445 (scm_t_bits
) hash
, SCM_UNPACK (props
));
449 scm_i_c_make_symbol (const char *name
, size_t len
,
450 scm_t_bits flags
, unsigned long hash
, SCM props
)
452 SCM buf
= make_stringbuf (len
);
453 memcpy (STRINGBUF_CHARS (buf
), name
, len
);
455 return scm_double_cell (scm_tc7_symbol
| flags
, SCM_UNPACK (buf
),
456 (scm_t_bits
) hash
, SCM_UNPACK (props
));
459 /* Return a new symbol that uses the LEN bytes pointed to by NAME as its
460 underlying storage. */
462 scm_i_c_take_symbol (char *name
, size_t len
,
463 scm_t_bits flags
, unsigned long hash
, SCM props
)
465 SCM buf
= scm_i_take_stringbufn (name
, len
);
467 return scm_double_cell (scm_tc7_symbol
| flags
, SCM_UNPACK (buf
),
468 (scm_t_bits
) hash
, SCM_UNPACK (props
));
472 scm_i_symbol_length (SCM sym
)
474 return STRINGBUF_LENGTH (SYMBOL_STRINGBUF (sym
));
478 scm_c_symbol_length (SCM sym
)
479 #define FUNC_NAME "scm_c_symbol_length"
481 SCM_VALIDATE_SYMBOL (1, sym
);
483 return STRINGBUF_LENGTH (SYMBOL_STRINGBUF (sym
));
488 scm_i_symbol_chars (SCM sym
)
490 SCM buf
= SYMBOL_STRINGBUF (sym
);
491 return STRINGBUF_CHARS (buf
);
495 scm_i_symbol_mark (SCM sym
)
497 scm_gc_mark (SYMBOL_STRINGBUF (sym
));
498 return SCM_CELL_OBJECT_3 (sym
);
502 scm_i_symbol_free (SCM sym
)
507 scm_i_symbol_substring (SCM sym
, size_t start
, size_t end
)
509 SCM buf
= SYMBOL_STRINGBUF (sym
);
510 scm_i_pthread_mutex_lock (&stringbuf_write_mutex
);
511 SET_STRINGBUF_SHARED (buf
);
512 scm_i_pthread_mutex_unlock (&stringbuf_write_mutex
);
513 return scm_double_cell (RO_STRING_TAG
, SCM_UNPACK (buf
),
514 (scm_t_bits
)start
, (scm_t_bits
) end
- start
);
522 SCM
scm_sys_string_dump (SCM
);
523 SCM
scm_sys_symbol_dump (SCM
);
524 SCM
scm_sys_stringbuf_hist (void);
526 SCM_DEFINE (scm_sys_string_dump
, "%string-dump", 1, 0, 0,
529 #define FUNC_NAME s_scm_sys_string_dump
531 SCM_VALIDATE_STRING (1, str
);
532 fprintf (stderr
, "%p:\n", str
);
533 fprintf (stderr
, " start: %u\n", STRING_START (str
));
534 fprintf (stderr
, " len: %u\n", STRING_LENGTH (str
));
535 if (IS_SH_STRING (str
))
537 fprintf (stderr
, " string: %p\n", SH_STRING_STRING (str
));
538 fprintf (stderr
, "\n");
539 scm_sys_string_dump (SH_STRING_STRING (str
));
543 SCM buf
= STRING_STRINGBUF (str
);
544 fprintf (stderr
, " buf: %p\n", buf
);
545 fprintf (stderr
, " chars: %p\n", STRINGBUF_CHARS (buf
));
546 fprintf (stderr
, " length: %u\n", STRINGBUF_LENGTH (buf
));
547 fprintf (stderr
, " flags: %x\n", (SCM_CELL_WORD_0 (buf
) & 0x300));
549 return SCM_UNSPECIFIED
;
553 SCM_DEFINE (scm_sys_symbol_dump
, "%symbol-dump", 1, 0, 0,
556 #define FUNC_NAME s_scm_sys_symbol_dump
558 SCM_VALIDATE_SYMBOL (1, sym
);
559 fprintf (stderr
, "%p:\n", sym
);
560 fprintf (stderr
, " hash: %lu\n", scm_i_symbol_hash (sym
));
562 SCM buf
= SYMBOL_STRINGBUF (sym
);
563 fprintf (stderr
, " buf: %p\n", buf
);
564 fprintf (stderr
, " chars: %p\n", STRINGBUF_CHARS (buf
));
565 fprintf (stderr
, " length: %u\n", STRINGBUF_LENGTH (buf
));
566 fprintf (stderr
, " shared: %u\n", STRINGBUF_SHARED (buf
));
568 return SCM_UNSPECIFIED
;
572 SCM_DEFINE (scm_sys_stringbuf_hist
, "%stringbuf-hist", 0, 0, 0,
575 #define FUNC_NAME s_scm_sys_stringbuf_hist
578 for (i
= 0; i
< 1000; i
++)
580 fprintf (stderr
, " %3d: %u\n", i
, lenhist
[i
]);
581 fprintf (stderr
, ">999: %u\n", lenhist
[1000]);
582 return SCM_UNSPECIFIED
;
590 SCM_DEFINE (scm_string_p
, "string?", 1, 0, 0,
592 "Return @code{#t} if @var{obj} is a string, else @code{#f}.")
593 #define FUNC_NAME s_scm_string_p
595 return scm_from_bool (IS_STRING (obj
));
600 SCM_REGISTER_PROC (s_scm_list_to_string
, "list->string", 1, 0, 0, scm_string
);
602 SCM_DEFINE (scm_string
, "string", 0, 0, 1,
604 "@deffnx {Scheme Procedure} list->string chrs\n"
605 "Return a newly allocated string composed of the arguments,\n"
607 #define FUNC_NAME s_scm_string
614 long i
= scm_ilength (chrs
);
616 SCM_ASSERT (i
>= 0, chrs
, SCM_ARG1
, FUNC_NAME
);
620 result
= scm_i_make_string (len
, &data
);
621 while (len
> 0 && scm_is_pair (chrs
))
623 SCM elt
= SCM_CAR (chrs
);
625 SCM_VALIDATE_CHAR (SCM_ARGn
, elt
);
626 *data
++ = SCM_CHAR (elt
);
627 chrs
= SCM_CDR (chrs
);
631 scm_misc_error (NULL
, "list changed while constructing string", SCM_EOL
);
632 if (!scm_is_null (chrs
))
633 scm_wrong_type_arg_msg (NULL
, 0, chrs
, "proper list");
639 SCM_DEFINE (scm_make_string
, "make-string", 1, 1, 0,
641 "Return a newly allocated string of\n"
642 "length @var{k}. If @var{chr} is given, then all elements of\n"
643 "the string are initialized to @var{chr}, otherwise the contents\n"
644 "of the @var{string} are unspecified.")
645 #define FUNC_NAME s_scm_make_string
647 return scm_c_make_string (scm_to_size_t (k
), chr
);
652 scm_c_make_string (size_t len
, SCM chr
)
653 #define FUNC_NAME NULL
656 SCM res
= scm_i_make_string (len
, &dst
);
658 if (!SCM_UNBNDP (chr
))
660 SCM_VALIDATE_CHAR (0, chr
);
661 memset (dst
, SCM_CHAR (chr
), len
);
668 SCM_DEFINE (scm_string_length
, "string-length", 1, 0, 0,
670 "Return the number of characters in @var{string}.")
671 #define FUNC_NAME s_scm_string_length
673 SCM_VALIDATE_STRING (1, string
);
674 return scm_from_size_t (STRING_LENGTH (string
));
679 scm_c_string_length (SCM string
)
681 if (!IS_STRING (string
))
682 scm_wrong_type_arg_msg (NULL
, 0, string
, "string");
683 return STRING_LENGTH (string
);
686 SCM_DEFINE (scm_string_ref
, "string-ref", 2, 0, 0,
688 "Return character @var{k} of @var{str} using zero-origin\n"
689 "indexing. @var{k} must be a valid index of @var{str}.")
690 #define FUNC_NAME s_scm_string_ref
694 SCM_VALIDATE_STRING (1, str
);
695 idx
= scm_to_unsigned_integer (k
, 0, scm_i_string_length (str
)-1);
696 return SCM_MAKE_CHAR (scm_i_string_chars (str
)[idx
]);
701 scm_c_string_ref (SCM str
, size_t p
)
703 if (p
>= scm_i_string_length (str
))
704 scm_out_of_range (NULL
, scm_from_size_t (p
));
705 return SCM_MAKE_CHAR (scm_i_string_chars (str
)[p
]);
708 SCM_DEFINE (scm_string_set_x
, "string-set!", 3, 0, 0,
709 (SCM str
, SCM k
, SCM chr
),
710 "Store @var{chr} in element @var{k} of @var{str} and return\n"
711 "an unspecified value. @var{k} must be a valid index of\n"
713 #define FUNC_NAME s_scm_string_set_x
717 SCM_VALIDATE_STRING (1, str
);
718 idx
= scm_to_unsigned_integer (k
, 0, scm_i_string_length(str
)-1);
719 SCM_VALIDATE_CHAR (3, chr
);
721 char *dst
= scm_i_string_writable_chars (str
);
722 dst
[idx
] = SCM_CHAR (chr
);
723 scm_i_string_stop_writing ();
725 return SCM_UNSPECIFIED
;
730 scm_c_string_set_x (SCM str
, size_t p
, SCM chr
)
732 if (p
>= scm_i_string_length (str
))
733 scm_out_of_range (NULL
, scm_from_size_t (p
));
735 char *dst
= scm_i_string_writable_chars (str
);
736 dst
[p
] = SCM_CHAR (chr
);
737 scm_i_string_stop_writing ();
741 SCM_DEFINE (scm_substring
, "substring", 2, 1, 0,
742 (SCM str
, SCM start
, SCM end
),
743 "Return a newly allocated string formed from the characters\n"
744 "of @var{str} beginning with index @var{start} (inclusive) and\n"
745 "ending with index @var{end} (exclusive).\n"
746 "@var{str} must be a string, @var{start} and @var{end} must be\n"
747 "exact integers satisfying:\n\n"
748 "0 <= @var{start} <= @var{end} <= (string-length @var{str}).")
749 #define FUNC_NAME s_scm_substring
751 size_t len
, from
, to
;
753 SCM_VALIDATE_STRING (1, str
);
754 len
= scm_i_string_length (str
);
755 from
= scm_to_unsigned_integer (start
, 0, len
);
756 if (SCM_UNBNDP (end
))
759 to
= scm_to_unsigned_integer (end
, from
, len
);
760 return scm_i_substring (str
, from
, to
);
764 SCM_DEFINE (scm_substring_read_only
, "substring/read-only", 2, 1, 0,
765 (SCM str
, SCM start
, SCM end
),
766 "Return a newly allocated string formed from the characters\n"
767 "of @var{str} beginning with index @var{start} (inclusive) and\n"
768 "ending with index @var{end} (exclusive).\n"
769 "@var{str} must be a string, @var{start} and @var{end} must be\n"
770 "exact integers satisfying:\n"
772 "0 <= @var{start} <= @var{end} <= (string-length @var{str}).\n"
774 "The returned string is read-only.\n")
775 #define FUNC_NAME s_scm_substring_read_only
777 size_t len
, from
, to
;
779 SCM_VALIDATE_STRING (1, str
);
780 len
= scm_i_string_length (str
);
781 from
= scm_to_unsigned_integer (start
, 0, len
);
782 if (SCM_UNBNDP (end
))
785 to
= scm_to_unsigned_integer (end
, from
, len
);
786 return scm_i_substring_read_only (str
, from
, to
);
790 SCM_DEFINE (scm_substring_copy
, "substring/copy", 2, 1, 0,
791 (SCM str
, SCM start
, SCM end
),
792 "Return a newly allocated string formed from the characters\n"
793 "of @var{str} beginning with index @var{start} (inclusive) and\n"
794 "ending with index @var{end} (exclusive).\n"
795 "@var{str} must be a string, @var{start} and @var{end} must be\n"
796 "exact integers satisfying:\n\n"
797 "0 <= @var{start} <= @var{end} <= (string-length @var{str}).")
798 #define FUNC_NAME s_scm_substring_copy
800 /* For the Scheme version, START is mandatory, but for the C
801 version, it is optional. See scm_string_copy in srfi-13.c for a
807 SCM_VALIDATE_STRING (1, str
);
808 scm_i_get_substring_spec (scm_i_string_length (str
),
809 start
, &from
, end
, &to
);
810 return scm_i_substring_copy (str
, from
, to
);
814 SCM_DEFINE (scm_substring_shared
, "substring/shared", 2, 1, 0,
815 (SCM str
, SCM start
, SCM end
),
816 "Return string that indirectly refers to the characters\n"
817 "of @var{str} beginning with index @var{start} (inclusive) and\n"
818 "ending with index @var{end} (exclusive).\n"
819 "@var{str} must be a string, @var{start} and @var{end} must be\n"
820 "exact integers satisfying:\n\n"
821 "0 <= @var{start} <= @var{end} <= (string-length @var{str}).")
822 #define FUNC_NAME s_scm_substring_shared
824 size_t len
, from
, to
;
826 SCM_VALIDATE_STRING (1, str
);
827 len
= scm_i_string_length (str
);
828 from
= scm_to_unsigned_integer (start
, 0, len
);
829 if (SCM_UNBNDP (end
))
832 to
= scm_to_unsigned_integer (end
, from
, len
);
833 return scm_i_substring_shared (str
, from
, to
);
837 SCM_DEFINE (scm_string_append
, "string-append", 0, 0, 1,
839 "Return a newly allocated string whose characters form the\n"
840 "concatenation of the given strings, @var{args}.")
841 #define FUNC_NAME s_scm_string_append
848 SCM_VALIDATE_REST_ARGUMENT (args
);
849 for (l
= args
; !scm_is_null (l
); l
= SCM_CDR (l
))
852 SCM_VALIDATE_STRING (SCM_ARGn
, s
);
853 i
+= scm_i_string_length (s
);
855 res
= scm_i_make_string (i
, &data
);
856 for (l
= args
; !scm_is_null (l
); l
= SCM_CDR (l
))
860 SCM_VALIDATE_STRING (SCM_ARGn
, s
);
861 len
= scm_i_string_length (s
);
862 memcpy (data
, scm_i_string_chars (s
), len
);
864 scm_remember_upto_here_1 (s
);
871 scm_is_string (SCM obj
)
873 return IS_STRING (obj
);
877 scm_from_locale_stringn (const char *str
, size_t len
)
882 if (len
== (size_t)-1)
884 res
= scm_i_make_string (len
, &dst
);
885 memcpy (dst
, str
, len
);
890 scm_from_locale_string (const char *str
)
892 return scm_from_locale_stringn (str
, -1);
896 scm_take_locale_stringn (char *str
, size_t len
)
900 if (len
== (size_t)-1)
904 /* Ensure STR is null terminated. A realloc for 1 extra byte should
905 often be satisfied from the alignment padding after the block, with
906 no actual data movement. */
907 str
= scm_realloc (str
, len
+1);
911 buf
= scm_i_take_stringbufn (str
, len
);
912 res
= scm_double_cell (STRING_TAG
,
914 (scm_t_bits
) 0, (scm_t_bits
) len
);
919 scm_take_locale_string (char *str
)
921 return scm_take_locale_stringn (str
, -1);
925 scm_to_locale_stringn (SCM str
, size_t *lenp
)
930 if (!scm_is_string (str
))
931 scm_wrong_type_arg_msg (NULL
, 0, str
, "string");
932 len
= scm_i_string_length (str
);
933 res
= scm_malloc (len
+ ((lenp
==NULL
)? 1 : 0));
934 memcpy (res
, scm_i_string_chars (str
), len
);
938 if (strlen (res
) != len
)
941 scm_misc_error (NULL
,
942 "string contains #\\nul character: ~S",
949 scm_remember_upto_here_1 (str
);
954 scm_to_locale_string (SCM str
)
956 return scm_to_locale_stringn (str
, NULL
);
960 scm_to_locale_stringbuf (SCM str
, char *buf
, size_t max_len
)
964 if (!scm_is_string (str
))
965 scm_wrong_type_arg_msg (NULL
, 0, str
, "string");
966 len
= scm_i_string_length (str
);
967 memcpy (buf
, scm_i_string_chars (str
), (len
> max_len
)? max_len
: len
);
968 scm_remember_upto_here_1 (str
);
972 /* converts C scm_array of strings to SCM scm_list of strings. */
973 /* If argc < 0, a null terminated scm_array is assumed. */
975 scm_makfromstrs (int argc
, char **argv
)
980 for (i
= 0; argv
[i
]; i
++);
982 lst
= scm_cons (scm_from_locale_string (argv
[i
]), lst
);
986 /* Return a newly allocated array of char pointers to each of the strings
987 in args, with a terminating NULL pointer. */
990 scm_i_allocate_string_pointers (SCM list
)
993 int len
= scm_ilength (list
);
997 scm_wrong_type_arg_msg (NULL
, 0, list
, "proper list");
999 scm_dynwind_begin (0);
1001 result
= (char **) scm_malloc ((len
+ 1) * sizeof (char *));
1003 scm_dynwind_unwind_handler (free
, result
, 0);
1005 /* The list might be have been modified in another thread, so
1006 we check LIST before each access.
1008 for (i
= 0; i
< len
&& scm_is_pair (list
); i
++)
1010 result
[i
] = scm_to_locale_string (SCM_CAR (list
));
1011 list
= SCM_CDR (list
);
1019 scm_i_free_string_pointers (char **pointers
)
1023 for (i
= 0; pointers
[i
]; i
++)
1029 scm_i_get_substring_spec (size_t len
,
1030 SCM start
, size_t *cstart
,
1031 SCM end
, size_t *cend
)
1033 if (SCM_UNBNDP (start
))
1036 *cstart
= scm_to_unsigned_integer (start
, 0, len
);
1038 if (SCM_UNBNDP (end
))
1041 *cend
= scm_to_unsigned_integer (end
, *cstart
, len
);
1044 #if SCM_ENABLE_DEPRECATED
1046 /* When these definitions are removed, it becomes reasonable to use
1047 read-only strings for string literals. For that, change the reader
1048 to create string literals with scm_c_substring_read_only instead of
1049 with scm_c_substring_copy.
1053 scm_i_deprecated_stringp (SCM str
)
1055 scm_c_issue_deprecation_warning
1056 ("SCM_STRINGP is deprecated. Use scm_is_string instead.");
1058 return scm_is_string (str
);
1062 scm_i_deprecated_string_chars (SCM str
)
1066 scm_c_issue_deprecation_warning
1067 ("SCM_STRING_CHARS is deprecated. See the manual for alternatives.");
1069 /* We don't accept shared substrings here since they are not
1072 if (IS_SH_STRING (str
))
1073 scm_misc_error (NULL
,
1074 "SCM_STRING_CHARS does not work with shared substrings.",
1077 /* We explicitely test for read-only strings to produce a better
1081 if (IS_RO_STRING (str
))
1082 scm_misc_error (NULL
,
1083 "SCM_STRING_CHARS does not work with read-only strings.",
1086 /* The following is still wrong, of course...
1088 chars
= scm_i_string_writable_chars (str
);
1089 scm_i_string_stop_writing ();
1094 scm_i_deprecated_string_length (SCM str
)
1096 scm_c_issue_deprecation_warning
1097 ("SCM_STRING_LENGTH is deprecated. Use scm_c_string_length instead.");
1098 return scm_c_string_length (str
);
1106 scm_nullstr
= scm_i_make_string (0, NULL
);
1108 #include "libguile/strings.x"