1 /* Copyright (C) 1995,1996,1998,1999,2000,2001,2002, 2003, 2005, 2006, 2009, 2010, 2011 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 License
5 * as published by the Free Software Foundation; either version 3 of
6 * the License, or (at your option) any later version.
8 * This library is distributed in the hope that it will be useful, but
9 * 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
26 #include "libguile/_scm.h"
33 #include "libguile/bytevectors.h"
34 #include "libguile/eval.h"
35 #include "libguile/ports.h"
36 #include "libguile/read.h"
37 #include "libguile/root.h"
38 #include "libguile/strings.h"
39 #include "libguile/modules.h"
40 #include "libguile/validate.h"
41 #include "libguile/deprecation.h"
42 #include "libguile/srfi-4.h"
44 #include "libguile/strports.h"
52 /* {Ports - string ports}
58 write_buf/write_end point to the ends of the allocated bytevector.
59 read_buf/read_end in principle point to the part of the bytevector which
60 has been written to, but this is only updated after a flush.
61 read_pos and write_pos in principle should be equal, but this is only true
62 when rw_active is SCM_PORT_NEITHER.
64 ENHANCE-ME - output blocks:
66 The current code keeps an output string as a single block. That means
67 when the size is increased the entire old contents must be copied. It'd
68 be more efficient to begin a new block when the old one is full, so
69 there's no re-copying of previous data.
71 To make seeking efficient, keeping the pieces in a vector might be best,
72 though appending is probably the most common operation. The size of each
73 block could be progressively increased, so the bigger the string the
76 When `get-output-string' is called the blocks have to be coalesced into a
77 string, the result could be kept as a single big block. If blocks were
78 strings then `get-output-string' could notice when there's just one and
79 return that with a copy-on-write (though repeated calls to
80 `get-output-string' are probably unlikely).
82 Another possibility would be to extend the port mechanism to let SCM
83 strings come through directly from `display' and friends. That way if a
84 big string is written it can be kept as a copy-on-write, saving time
85 copying and maybe saving some space. */
88 scm_t_bits scm_tc16_strport
;
92 stfill_buffer (SCM port
)
94 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
96 if (pt
->read_pos
>= pt
->read_end
)
99 return scm_return_first_int (*pt
->read_pos
, port
);
102 /* Change the size of a port's bytevector to NEW_SIZE. This doesn't
103 change `read_buf_size'. */
105 st_resize_port (scm_t_port
*pt
, scm_t_off new_size
)
107 SCM old_stream
= SCM_PACK (pt
->stream
);
108 const signed char *src
= SCM_BYTEVECTOR_CONTENTS (old_stream
);
109 SCM new_stream
= scm_c_make_bytevector (new_size
);
110 signed char *dst
= SCM_BYTEVECTOR_CONTENTS (new_stream
);
111 unsigned long int old_size
= SCM_BYTEVECTOR_LENGTH (old_stream
);
112 unsigned long int min_size
= min (old_size
, new_size
);
114 scm_t_off index
= pt
->write_pos
- pt
->write_buf
;
116 pt
->write_buf_size
= new_size
;
118 memcpy (dst
, src
, min_size
);
120 scm_remember_upto_here_1 (old_stream
);
124 pt
->stream
= SCM_UNPACK (new_stream
);
125 pt
->read_buf
= pt
->write_buf
= (unsigned char *)dst
;
126 pt
->read_pos
= pt
->write_pos
= pt
->write_buf
+ index
;
127 pt
->write_end
= pt
->write_buf
+ pt
->write_buf_size
;
128 pt
->read_end
= pt
->read_buf
+ pt
->read_buf_size
;
132 /* amount by which write_buf is expanded. */
133 #define SCM_WRITE_BLOCK 80
135 /* ensure that write_pos < write_end by enlarging the buffer when
136 necessary. update read_buf to account for written chars.
138 The buffer is enlarged by 1.5 times, plus SCM_WRITE_BLOCK. Adding just a
139 fixed amount is no good, because there's a block copy for each increment,
140 and that copying would take quadratic time. In the past it was found to
141 be very slow just adding 80 bytes each time (eg. about 10 seconds for
142 writing a 100kbyte string). */
147 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
149 if (pt
->write_pos
== pt
->write_end
)
151 st_resize_port (pt
, pt
->write_buf_size
* 3 / 2 + SCM_WRITE_BLOCK
);
153 pt
->read_pos
= pt
->write_pos
;
154 if (pt
->read_pos
> pt
->read_end
)
156 pt
->read_end
= (unsigned char *) pt
->read_pos
;
157 pt
->read_buf_size
= pt
->read_end
- pt
->read_buf
;
159 pt
->rw_active
= SCM_PORT_NEITHER
;
163 st_write (SCM port
, const void *data
, size_t size
)
165 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
166 const char *input
= (char *) data
;
170 int space
= pt
->write_end
- pt
->write_pos
;
171 int write_len
= (size
> space
) ? space
: size
;
173 memcpy ((char *) pt
->write_pos
, input
, write_len
);
174 pt
->write_pos
+= write_len
;
177 if (write_len
== space
)
183 st_end_input (SCM port
, int offset
)
185 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
187 if (pt
->read_pos
- pt
->read_buf
< offset
)
188 scm_misc_error ("st_end_input", "negative position", SCM_EOL
);
190 pt
->write_pos
= (unsigned char *) (pt
->read_pos
= pt
->read_pos
- offset
);
191 pt
->rw_active
= SCM_PORT_NEITHER
;
195 st_seek (SCM port
, scm_t_off offset
, int whence
)
197 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
200 if (pt
->rw_active
== SCM_PORT_READ
&& offset
== 0 && whence
== SEEK_CUR
)
201 /* special case to avoid disturbing the unread-char buffer. */
203 if (pt
->read_buf
== pt
->putback_buf
)
205 target
= pt
->saved_read_pos
- pt
->saved_read_buf
206 - (pt
->read_end
- pt
->read_pos
);
210 target
= pt
->read_pos
- pt
->read_buf
;
214 /* all other cases. */
216 if (pt
->rw_active
== SCM_PORT_WRITE
)
219 if (pt
->rw_active
== SCM_PORT_READ
)
220 scm_end_input (port
);
225 target
= pt
->read_pos
- pt
->read_buf
+ offset
;
228 target
= pt
->read_end
- pt
->read_buf
+ offset
;
230 default: /* SEEK_SET */
236 scm_misc_error ("st_seek", "negative offset", SCM_EOL
);
238 if (target
>= pt
->write_buf_size
)
240 if (!(SCM_CELL_WORD_0 (port
) & SCM_WRTNG
))
242 if (target
> pt
->write_buf_size
)
244 scm_misc_error ("st_seek",
245 "seek past end of read-only strport",
251 st_resize_port (pt
, target
+ (target
== pt
->write_buf_size
256 pt
->read_pos
= pt
->write_pos
= pt
->read_buf
+ target
;
257 if (pt
->read_pos
> pt
->read_end
)
259 pt
->read_end
= (unsigned char *) pt
->read_pos
;
260 pt
->read_buf_size
= pt
->read_end
- pt
->read_buf
;
267 st_truncate (SCM port
, scm_t_off length
)
269 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
271 if (length
> pt
->write_buf_size
)
272 st_resize_port (pt
, length
);
274 pt
->read_buf_size
= length
;
275 pt
->read_end
= pt
->read_buf
+ length
;
276 if (pt
->read_pos
> pt
->read_end
)
277 pt
->read_pos
= pt
->read_end
;
279 if (pt
->write_pos
> pt
->read_end
)
280 pt
->write_pos
= pt
->read_end
;
284 scm_mkstrport (SCM pos
, SCM str
, long modes
, const char *caller
)
288 size_t str_len
, c_pos
;
291 if (!((modes
& SCM_WRTNG
) || (modes
& SCM_RDNG
)))
292 scm_misc_error ("scm_mkstrport", "port must read or write", SCM_EOL
);
294 scm_dynwind_begin (0);
295 scm_i_dynwind_pthread_mutex_lock (&scm_i_port_table_mutex
);
297 z
= scm_new_port_table_entry (scm_tc16_strport
);
298 pt
= SCM_PTAB_ENTRY(z
);
301 /* STR is a string. */
304 SCM_ASSERT (scm_is_string (str
), str
, SCM_ARG1
, caller
);
306 /* Create a copy of STR in the encoding of PT. */
307 copy
= scm_to_stringn (str
, &str_len
, pt
->encoding
,
308 SCM_FAILED_CONVERSION_ERROR
);
309 buf
= scm_c_make_bytevector (str_len
);
310 c_buf
= (char *) SCM_BYTEVECTOR_CONTENTS (buf
);
311 memcpy (c_buf
, copy
, str_len
);
314 c_pos
= scm_to_unsigned_integer (pos
, 0, str_len
);
315 pt
->read_buf_size
= str_len
;
318 SCM_SETSTREAM (z
, SCM_UNPACK (buf
));
319 SCM_SET_CELL_TYPE (z
, scm_tc16_strport
| modes
);
321 pt
->write_buf
= pt
->read_buf
= (unsigned char *) c_buf
;
322 pt
->read_pos
= pt
->write_pos
= pt
->read_buf
+ c_pos
;
323 pt
->write_buf_size
= str_len
;
324 pt
->write_end
= pt
->read_end
= pt
->read_buf
+ pt
->read_buf_size
;
330 /* Ensure WRITE_POS is writable. */
331 if ((modes
& SCM_WRTNG
) && pt
->write_pos
== pt
->write_end
)
334 scm_i_set_conversion_strategy_x (z
, SCM_FAILED_CONVERSION_ERROR
);
338 /* Create a new string from the buffer of PORT, a string port, converting from
339 PORT's encoding to the standard string representation. */
341 scm_strport_to_string (SCM port
)
344 scm_t_port
*pt
= SCM_PTAB_ENTRY (port
);
346 if (pt
->rw_active
== SCM_PORT_WRITE
)
349 if (pt
->read_buf_size
== 0)
352 if (pt
->encoding
== NULL
)
355 str
= scm_i_make_string (pt
->read_buf_size
, &buf
);
356 memcpy (buf
, pt
->read_buf
, pt
->read_buf_size
);
359 str
= scm_from_stringn ((char *)pt
->read_buf
, pt
->read_buf_size
,
360 pt
->encoding
, pt
->ilseq_handler
);
361 scm_remember_upto_here_1 (port
);
365 SCM_DEFINE (scm_object_to_string
, "object->string", 1, 1, 0,
366 (SCM obj
, SCM printer
),
367 "Return a Scheme string obtained by printing @var{obj}.\n"
368 "Printing function can be specified by the optional second\n"
369 "argument @var{printer} (default: @code{write}).")
370 #define FUNC_NAME s_scm_object_to_string
374 if (!SCM_UNBNDP (printer
))
375 SCM_VALIDATE_PROC (2, printer
);
377 str
= scm_c_make_string (0, SCM_UNDEFINED
);
378 port
= scm_mkstrport (SCM_INUM0
, str
, SCM_OPN
| SCM_WRTNG
, FUNC_NAME
);
380 if (SCM_UNBNDP (printer
))
381 scm_write (obj
, port
);
383 scm_call_2 (printer
, obj
, port
);
385 return scm_strport_to_string (port
);
389 SCM_DEFINE (scm_call_with_output_string
, "call-with-output-string", 1, 0, 0,
391 "Calls the one-argument procedure @var{proc} with a newly created output\n"
392 "port. When the function returns, the string composed of the characters\n"
393 "written into the port is returned.")
394 #define FUNC_NAME s_scm_call_with_output_string
398 p
= scm_mkstrport (SCM_INUM0
,
399 scm_make_string (SCM_INUM0
, SCM_UNDEFINED
),
402 scm_call_1 (proc
, p
);
404 return scm_get_output_string (p
);
408 SCM_DEFINE (scm_call_with_input_string
, "call-with-input-string", 2, 0, 0,
409 (SCM string
, SCM proc
),
410 "Calls the one-argument procedure @var{proc} with a newly\n"
411 "created input port from which @var{string}'s contents may be\n"
412 "read. The value yielded by the @var{proc} is returned.")
413 #define FUNC_NAME s_scm_call_with_input_string
415 SCM p
= scm_mkstrport(SCM_INUM0
, string
, SCM_OPN
| SCM_RDNG
, FUNC_NAME
);
416 return scm_call_1 (proc
, p
);
420 SCM_DEFINE (scm_open_input_string
, "open-input-string", 1, 0, 0,
422 "Take a string and return an input port that delivers characters\n"
423 "from the string. The port can be closed by\n"
424 "@code{close-input-port}, though its storage will be reclaimed\n"
425 "by the garbage collector if it becomes inaccessible.")
426 #define FUNC_NAME s_scm_open_input_string
428 SCM p
= scm_mkstrport(SCM_INUM0
, str
, SCM_OPN
| SCM_RDNG
, FUNC_NAME
);
433 SCM_DEFINE (scm_open_output_string
, "open-output-string", 0, 0, 0,
435 "Return an output port that will accumulate characters for\n"
436 "retrieval by @code{get-output-string}. The port can be closed\n"
437 "by the procedure @code{close-output-port}, though its storage\n"
438 "will be reclaimed by the garbage collector if it becomes\n"
440 #define FUNC_NAME s_scm_open_output_string
444 p
= scm_mkstrport (SCM_INUM0
,
445 scm_make_string (SCM_INUM0
, SCM_UNDEFINED
),
452 SCM_DEFINE (scm_get_output_string
, "get-output-string", 1, 0, 0,
454 "Given an output port created by @code{open-output-string},\n"
455 "return a string consisting of the characters that have been\n"
456 "output to the port so far.")
457 #define FUNC_NAME s_scm_get_output_string
459 SCM_VALIDATE_OPOUTSTRPORT (1, port
);
460 return scm_strport_to_string (port
);
465 /* Given a null-terminated string EXPR containing a Scheme expression
466 read it, and return it as an SCM value. */
468 scm_c_read_string (const char *expr
)
470 /* FIXME: the c string gets packed into a string, only to get
471 immediately unpacked in scm_mkstrport. */
472 SCM port
= scm_mkstrport (SCM_INUM0
,
473 scm_from_locale_string (expr
),
475 "scm_c_read_string");
478 form
= scm_read (port
);
480 scm_close_port (port
);
484 /* Given a null-terminated string EXPR containing Scheme program text,
485 evaluate it, and return the result of the last expression evaluated. */
487 scm_c_eval_string (const char *expr
)
489 return scm_eval_string (scm_from_locale_string (expr
));
493 scm_c_eval_string_in_module (const char *expr
, SCM module
)
495 return scm_eval_string_in_module (scm_from_locale_string (expr
), module
);
500 inner_eval_string (void *data
)
502 SCM port
= (SCM
)data
;
504 SCM ans
= SCM_UNSPECIFIED
;
506 /* Read expressions from that port; ignore the values. */
507 while (!SCM_EOF_OBJECT_P (form
= scm_read (port
)))
508 ans
= scm_primitive_eval_x (form
);
510 /* Don't close the port here; if we re-enter this function via a
511 continuation, then the next time we enter it, we'll get an error.
512 It's a string port anyway, so there's no advantage to closing it
518 SCM_DEFINE (scm_eval_string_in_module
, "eval-string", 1, 1, 0,
519 (SCM string
, SCM module
),
520 "Evaluate @var{string} as the text representation of a Scheme\n"
521 "form or forms, and return whatever value they produce.\n"
522 "Evaluation takes place in the given module, or the current\n"
523 "module when no module is given.\n"
524 "While the code is evaluated, the given module is made the\n"
525 "current one. The current module is restored when this\n"
526 "procedure returns.")
527 #define FUNC_NAME s_scm_eval_string_in_module
529 SCM port
= scm_mkstrport (SCM_INUM0
, string
, SCM_OPN
| SCM_RDNG
,
531 if (SCM_UNBNDP (module
))
532 module
= scm_current_module ();
534 SCM_VALIDATE_MODULE (2, module
);
535 return scm_c_call_with_current_module (module
,
536 inner_eval_string
, (void *)port
);
541 scm_eval_string (SCM string
)
543 return scm_eval_string_in_module (string
, SCM_UNDEFINED
);
549 scm_t_bits tc
= scm_make_port_type ("string", stfill_buffer
, st_write
);
551 scm_set_port_end_input (tc
, st_end_input
);
552 scm_set_port_flush (tc
, st_flush
);
553 scm_set_port_seek (tc
, st_seek
);
554 scm_set_port_truncate (tc
, st_truncate
);
562 scm_tc16_strport
= scm_make_stptob ();
564 #include "libguile/strports.x"