| /* GIO - GLib Input, Output and Streaming Library |
| * |
| * Copyright (C) 2006-2007 Red Hat, Inc. |
| * Copyright (C) 2007 Jürg Billeter |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2 of the License, or (at your option) any later version. |
| * |
| * This library 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 |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General |
| * Public License along with this library; if not, write to the |
| * Free Software Foundation, Inc., 59 Temple Place, Suite 330, |
| * Boston, MA 02111-1307, USA. |
| * |
| * Author: Alexander Larsson <alexl@redhat.com> |
| */ |
| |
| #include <config.h> |
| #include "gdatainputstream.h" |
| #include "gioenumtypes.h" |
| #include "glibintl.h" |
| |
| #include "gioalias.h" |
| |
| /** |
| * SECTION:gdatainputstream |
| * @short_description: Data Input Stream |
| * @include: gio.h |
| * @see_also: #GInputStream |
| * |
| * Data input stream implements #GInputStream and includes functions for |
| * reading structured data directly from a binary input stream. |
| * |
| **/ |
| |
| struct _GDataInputStreamPrivate { |
| GDataStreamByteOrder byte_order; |
| GDataStreamNewlineType newline_type; |
| }; |
| |
| enum { |
| PROP_0, |
| PROP_BYTE_ORDER, |
| PROP_NEWLINE_TYPE |
| }; |
| |
| static void g_data_input_stream_set_property (GObject *object, |
| guint prop_id, |
| const GValue *value, |
| GParamSpec *pspec); |
| static void g_data_input_stream_get_property (GObject *object, |
| guint prop_id, |
| GValue *value, |
| GParamSpec *pspec); |
| |
| G_DEFINE_TYPE (GDataInputStream, |
| g_data_input_stream, |
| G_TYPE_BUFFERED_INPUT_STREAM) |
| |
| |
| static void |
| g_data_input_stream_class_init (GDataInputStreamClass *klass) |
| { |
| GObjectClass *object_class; |
| |
| g_type_class_add_private (klass, sizeof (GDataInputStreamPrivate)); |
| |
| object_class = G_OBJECT_CLASS (klass); |
| object_class->get_property = g_data_input_stream_get_property; |
| object_class->set_property = g_data_input_stream_set_property; |
| |
| /** |
| * GDataStream:byte-order: |
| * |
| * The ::byte-order property determines the byte ordering that |
| * is used when reading multi-byte entities (such as integers) |
| * from the stream. |
| */ |
| g_object_class_install_property (object_class, |
| PROP_BYTE_ORDER, |
| g_param_spec_enum ("byte-order", |
| P_("Byte order"), |
| P_("The byte order"), |
| G_TYPE_DATA_STREAM_BYTE_ORDER, |
| G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN, |
| G_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_BLURB)); |
| |
| /** |
| * GDataStream:newline-type: |
| * |
| * The :newline-type property determines what is considered |
| * as a line ending when reading complete lines from the stream. |
| */ |
| g_object_class_install_property (object_class, |
| PROP_NEWLINE_TYPE, |
| g_param_spec_enum ("newline-type", |
| P_("Newline type"), |
| P_("The accepted types of line ending"), |
| G_TYPE_DATA_STREAM_NEWLINE_TYPE, |
| G_DATA_STREAM_NEWLINE_TYPE_LF, |
| G_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_BLURB)); |
| } |
| |
| static void |
| g_data_input_stream_set_property (GObject *object, |
| guint prop_id, |
| const GValue *value, |
| GParamSpec *pspec) |
| { |
| GDataInputStreamPrivate *priv; |
| GDataInputStream *dstream; |
| |
| dstream = G_DATA_INPUT_STREAM (object); |
| priv = dstream->priv; |
| |
| switch (prop_id) |
| { |
| case PROP_BYTE_ORDER: |
| g_data_input_stream_set_byte_order (dstream, g_value_get_enum (value)); |
| break; |
| |
| case PROP_NEWLINE_TYPE: |
| g_data_input_stream_set_newline_type (dstream, g_value_get_enum (value)); |
| break; |
| |
| default: |
| G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); |
| break; |
| } |
| |
| } |
| |
| static void |
| g_data_input_stream_get_property (GObject *object, |
| guint prop_id, |
| GValue *value, |
| GParamSpec *pspec) |
| { |
| GDataInputStreamPrivate *priv; |
| GDataInputStream *dstream; |
| |
| dstream = G_DATA_INPUT_STREAM (object); |
| priv = dstream->priv; |
| |
| switch (prop_id) |
| { |
| case PROP_BYTE_ORDER: |
| g_value_set_enum (value, priv->byte_order); |
| break; |
| |
| case PROP_NEWLINE_TYPE: |
| g_value_set_enum (value, priv->newline_type); |
| break; |
| |
| default: |
| G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); |
| break; |
| } |
| |
| } |
| static void |
| g_data_input_stream_init (GDataInputStream *stream) |
| { |
| stream->priv = G_TYPE_INSTANCE_GET_PRIVATE (stream, |
| G_TYPE_DATA_INPUT_STREAM, |
| GDataInputStreamPrivate); |
| |
| stream->priv->byte_order = G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN; |
| stream->priv->newline_type = G_DATA_STREAM_NEWLINE_TYPE_LF; |
| } |
| |
| /** |
| * g_data_input_stream_new: |
| * @base_stream: a #GInputStream. |
| * |
| * Creates a new data input stream for the @base_stream. |
| * |
| * Returns: a new #GDataInputStream. |
| **/ |
| GDataInputStream * |
| g_data_input_stream_new (GInputStream *base_stream) |
| { |
| GDataInputStream *stream; |
| |
| g_return_val_if_fail (G_IS_INPUT_STREAM (base_stream), NULL); |
| |
| stream = g_object_new (G_TYPE_DATA_INPUT_STREAM, |
| "base-stream", base_stream, |
| NULL); |
| |
| return stream; |
| } |
| |
| /** |
| * g_data_input_stream_set_byte_order: |
| * @stream: a given #GDataInputStream. |
| * @order: a #GDataStreamByteOrder to set. |
| * |
| * This function sets the byte order for the given @stream. All subsequent |
| * reads from the @stream will be read in the given @order. |
| * |
| **/ |
| void |
| g_data_input_stream_set_byte_order (GDataInputStream *stream, |
| GDataStreamByteOrder order) |
| { |
| GDataInputStreamPrivate *priv; |
| |
| g_return_if_fail (G_IS_DATA_INPUT_STREAM (stream)); |
| |
| priv = stream->priv; |
| |
| if (priv->byte_order != order) |
| { |
| priv->byte_order = order; |
| |
| g_object_notify (G_OBJECT (stream), "byte-order"); |
| } |
| } |
| |
| /** |
| * g_data_input_stream_get_byte_order: |
| * @stream: a given #GDataInputStream. |
| * |
| * Gets the byte order for the data input stream. |
| * |
| * Returns: the @stream's current #GDataStreamByteOrder. |
| **/ |
| GDataStreamByteOrder |
| g_data_input_stream_get_byte_order (GDataInputStream *stream) |
| { |
| g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream), G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN); |
| |
| return stream->priv->byte_order; |
| } |
| |
| /** |
| * g_data_input_stream_set_newline_type: |
| * @stream: a #GDataInputStream. |
| * @type: the type of new line return as #GDataStreamNewlineType. |
| * |
| * Sets the newline type for the @stream. |
| * |
| * Note that using G_DATA_STREAM_NEWLINE_TYPE_ANY is slightly unsafe. If a read |
| * chunk ends in "CR" we must read an additional byte to know if this is "CR" or |
| * "CR LF", and this might block if there is no more data availible. |
| * |
| **/ |
| void |
| g_data_input_stream_set_newline_type (GDataInputStream *stream, |
| GDataStreamNewlineType type) |
| { |
| GDataInputStreamPrivate *priv; |
| |
| g_return_if_fail (G_IS_DATA_INPUT_STREAM (stream)); |
| |
| priv = stream->priv; |
| |
| if (priv->newline_type != type) |
| { |
| priv->newline_type = type; |
| |
| g_object_notify (G_OBJECT (stream), "newline-type"); |
| } |
| } |
| |
| /** |
| * g_data_input_stream_get_newline_type: |
| * @stream: a given #GDataInputStream. |
| * |
| * Gets the current newline type for the @stream. |
| * |
| * Returns: #GDataStreamNewlineType for the given @stream. |
| **/ |
| GDataStreamNewlineType |
| g_data_input_stream_get_newline_type (GDataInputStream *stream) |
| { |
| g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream), G_DATA_STREAM_NEWLINE_TYPE_ANY); |
| |
| return stream->priv->newline_type; |
| } |
| |
| static gboolean |
| read_data (GDataInputStream *stream, |
| void *buffer, |
| gsize size, |
| GCancellable *cancellable, |
| GError **error) |
| { |
| gsize available; |
| gssize res; |
| |
| while ((available = g_buffered_input_stream_get_available (G_BUFFERED_INPUT_STREAM (stream))) < size) |
| { |
| res = g_buffered_input_stream_fill (G_BUFFERED_INPUT_STREAM (stream), |
| size - available, |
| cancellable, error); |
| if (res < 0) |
| return FALSE; |
| if (res == 0) |
| { |
| g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, |
| _("Unexpected early end-of-stream")); |
| return FALSE; |
| } |
| } |
| |
| /* This should always succeed, since its in the buffer */ |
| res = g_input_stream_read (G_INPUT_STREAM (stream), |
| buffer, size, |
| NULL, NULL); |
| g_warn_if_fail (res == size); |
| return TRUE; |
| } |
| |
| |
| /** |
| * g_data_input_stream_read_byte: |
| * @stream: a given #GDataInputStream. |
| * @cancellable: optional #GCancellable object, %NULL to ignore. |
| * @error: #GError for error reporting. |
| * |
| * Reads an unsigned 8-bit/1-byte value from @stream. |
| * |
| * Returns: an unsigned 8-bit/1-byte value read from the @stream or %0 |
| * if an error occurred. |
| **/ |
| guchar |
| g_data_input_stream_read_byte (GDataInputStream *stream, |
| GCancellable *cancellable, |
| GError **error) |
| { |
| guchar c; |
| |
| g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream), '\0'); |
| |
| if (read_data (stream, &c, 1, cancellable, error)) |
| return c; |
| |
| return 0; |
| } |
| |
| |
| /** |
| * g_data_input_stream_read_int16: |
| * @stream: a given #GDataInputStream. |
| * @cancellable: optional #GCancellable object, %NULL to ignore. |
| * @error: #GError for error reporting. |
| * |
| * Reads a 16-bit/2-byte value from @stream. |
| * |
| * In order to get the correct byte order for this read operation, |
| * see g_data_stream_get_byte_order() and g_data_stream_set_byte_order(). |
| * |
| * Returns: a signed 16-bit/2-byte value read from @stream or %0 if |
| * an error occurred. |
| **/ |
| gint16 |
| g_data_input_stream_read_int16 (GDataInputStream *stream, |
| GCancellable *cancellable, |
| GError **error) |
| { |
| gint16 v; |
| |
| g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream), 0); |
| |
| if (read_data (stream, &v, 2, cancellable, error)) |
| { |
| switch (stream->priv->byte_order) |
| { |
| case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN: |
| v = GINT16_FROM_BE (v); |
| break; |
| case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN: |
| v = GINT16_FROM_LE (v); |
| break; |
| case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN: |
| default: |
| break; |
| } |
| return v; |
| } |
| |
| return 0; |
| } |
| |
| |
| /** |
| * g_data_input_stream_read_uint16: |
| * @stream: a given #GDataInputStream. |
| * @cancellable: optional #GCancellable object, %NULL to ignore. |
| * @error: #GError for error reporting. |
| * |
| * Reads an unsigned 16-bit/2-byte value from @stream. |
| * |
| * In order to get the correct byte order for this read operation, |
| * see g_data_stream_get_byte_order() and g_data_stream_set_byte_order(). |
| * |
| * Returns: an unsigned 16-bit/2-byte value read from the @stream or %0 if |
| * an error occurred. |
| **/ |
| guint16 |
| g_data_input_stream_read_uint16 (GDataInputStream *stream, |
| GCancellable *cancellable, |
| GError **error) |
| { |
| guint16 v; |
| |
| g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream), 0); |
| |
| if (read_data (stream, &v, 2, cancellable, error)) |
| { |
| switch (stream->priv->byte_order) |
| { |
| case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN: |
| v = GUINT16_FROM_BE (v); |
| break; |
| case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN: |
| v = GUINT16_FROM_LE (v); |
| break; |
| case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN: |
| default: |
| break; |
| } |
| return v; |
| } |
| |
| return 0; |
| } |
| |
| |
| /** |
| * g_data_input_stream_read_int32: |
| * @stream: a given #GDataInputStream. |
| * @cancellable: optional #GCancellable object, %NULL to ignore. |
| * @error: #GError for error reporting. |
| * |
| * Reads a signed 32-bit/4-byte value from @stream. |
| * |
| * In order to get the correct byte order for this read operation, |
| * see g_data_stream_get_byte_order() and g_data_stream_set_byte_order(). |
| * |
| * If @cancellable is not %NULL, then the operation can be cancelled by |
| * triggering the cancellable object from another thread. If the operation |
| * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. |
| * |
| * Returns: a signed 32-bit/4-byte value read from the @stream or %0 if |
| * an error occurred. |
| **/ |
| gint32 |
| g_data_input_stream_read_int32 (GDataInputStream *stream, |
| GCancellable *cancellable, |
| GError **error) |
| { |
| gint32 v; |
| |
| g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream), 0); |
| |
| if (read_data (stream, &v, 4, cancellable, error)) |
| { |
| switch (stream->priv->byte_order) |
| { |
| case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN: |
| v = GINT32_FROM_BE (v); |
| break; |
| case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN: |
| v = GINT32_FROM_LE (v); |
| break; |
| case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN: |
| default: |
| break; |
| } |
| return v; |
| } |
| |
| return 0; |
| } |
| |
| |
| /** |
| * g_data_input_stream_read_uint32: |
| * @stream: a given #GDataInputStream. |
| * @cancellable: optional #GCancellable object, %NULL to ignore. |
| * @error: #GError for error reporting. |
| * |
| * Reads an unsigned 32-bit/4-byte value from @stream. |
| * |
| * In order to get the correct byte order for this read operation, |
| * see g_data_stream_get_byte_order() and g_data_stream_set_byte_order(). |
| * |
| * If @cancellable is not %NULL, then the operation can be cancelled by |
| * triggering the cancellable object from another thread. If the operation |
| * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. |
| * |
| * Returns: an unsigned 32-bit/4-byte value read from the @stream or %0 if |
| * an error occurred. |
| **/ |
| guint32 |
| g_data_input_stream_read_uint32 (GDataInputStream *stream, |
| GCancellable *cancellable, |
| GError **error) |
| { |
| guint32 v; |
| |
| g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream), 0); |
| |
| if (read_data (stream, &v, 4, cancellable, error)) |
| { |
| switch (stream->priv->byte_order) |
| { |
| case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN: |
| v = GUINT32_FROM_BE (v); |
| break; |
| case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN: |
| v = GUINT32_FROM_LE (v); |
| break; |
| case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN: |
| default: |
| break; |
| } |
| return v; |
| } |
| |
| return 0; |
| } |
| |
| |
| /** |
| * g_data_input_stream_read_int64: |
| * @stream: a given #GDataInputStream. |
| * @cancellable: optional #GCancellable object, %NULL to ignore. |
| * @error: #GError for error reporting. |
| * |
| * Reads a 64-bit/8-byte value from @stream. |
| * |
| * In order to get the correct byte order for this read operation, |
| * see g_data_stream_get_byte_order() and g_data_stream_set_byte_order(). |
| * |
| * If @cancellable is not %NULL, then the operation can be cancelled by |
| * triggering the cancellable object from another thread. If the operation |
| * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. |
| * |
| * Returns: a signed 64-bit/8-byte value read from @stream or %0 if |
| * an error occurred. |
| **/ |
| gint64 |
| g_data_input_stream_read_int64 (GDataInputStream *stream, |
| GCancellable *cancellable, |
| GError **error) |
| { |
| gint64 v; |
| |
| g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream), 0); |
| |
| if (read_data (stream, &v, 8, cancellable, error)) |
| { |
| switch (stream->priv->byte_order) |
| { |
| case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN: |
| v = GINT64_FROM_BE (v); |
| break; |
| case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN: |
| v = GINT64_FROM_LE (v); |
| break; |
| case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN: |
| default: |
| break; |
| } |
| return v; |
| } |
| |
| return 0; |
| } |
| |
| |
| /** |
| * g_data_input_stream_read_uint64: |
| * @stream: a given #GDataInputStream. |
| * @cancellable: optional #GCancellable object, %NULL to ignore. |
| * @error: #GError for error reporting. |
| * |
| * Reads an unsigned 64-bit/8-byte value from @stream. |
| * |
| * In order to get the correct byte order for this read operation, |
| * see g_data_stream_get_byte_order(). |
| * |
| * If @cancellable is not %NULL, then the operation can be cancelled by |
| * triggering the cancellable object from another thread. If the operation |
| * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. |
| * |
| * Returns: an unsigned 64-bit/8-byte read from @stream or %0 if |
| * an error occurred. |
| **/ |
| guint64 |
| g_data_input_stream_read_uint64 (GDataInputStream *stream, |
| GCancellable *cancellable, |
| GError **error) |
| { |
| guint64 v; |
| |
| g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream), 0); |
| |
| if (read_data (stream, &v, 8, cancellable, error)) |
| { |
| switch (stream->priv->byte_order) |
| { |
| case G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN: |
| v = GUINT64_FROM_BE (v); |
| break; |
| case G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN: |
| v = GUINT64_FROM_LE (v); |
| break; |
| case G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN: |
| default: |
| break; |
| } |
| return v; |
| } |
| |
| return 0; |
| } |
| |
| static gssize |
| scan_for_newline (GDataInputStream *stream, |
| gsize *checked_out, |
| gboolean *last_saw_cr_out, |
| int *newline_len_out) |
| { |
| GBufferedInputStream *bstream; |
| GDataInputStreamPrivate *priv; |
| const char *buffer; |
| gsize start, end, peeked; |
| int i; |
| gssize found_pos; |
| int newline_len; |
| gsize available, checked; |
| gboolean last_saw_cr; |
| |
| priv = stream->priv; |
| |
| bstream = G_BUFFERED_INPUT_STREAM (stream); |
| |
| checked = *checked_out; |
| last_saw_cr = *last_saw_cr_out; |
| found_pos = -1; |
| newline_len = 0; |
| |
| start = checked; |
| buffer = (const char*)g_buffered_input_stream_peek_buffer (bstream, &available) + start; |
| end = available; |
| peeked = end - start; |
| |
| for (i = 0; checked < available && i < peeked; i++) |
| { |
| switch (priv->newline_type) |
| { |
| case G_DATA_STREAM_NEWLINE_TYPE_LF: |
| if (buffer[i] == 10) |
| { |
| found_pos = start + i; |
| newline_len = 1; |
| } |
| break; |
| case G_DATA_STREAM_NEWLINE_TYPE_CR: |
| if (buffer[i] == 13) |
| { |
| found_pos = start + i; |
| newline_len = 1; |
| } |
| break; |
| case G_DATA_STREAM_NEWLINE_TYPE_CR_LF: |
| if (last_saw_cr && buffer[i] == 10) |
| { |
| found_pos = start + i - 1; |
| newline_len = 2; |
| } |
| break; |
| default: |
| case G_DATA_STREAM_NEWLINE_TYPE_ANY: |
| if (buffer[i] == 10) /* LF */ |
| { |
| if (last_saw_cr) |
| { |
| /* CR LF */ |
| found_pos = start + i - 1; |
| newline_len = 2; |
| } |
| else |
| { |
| /* LF */ |
| found_pos = start + i; |
| newline_len = 1; |
| } |
| } |
| else if (last_saw_cr) |
| { |
| /* Last was cr, this is not LF, end is CR */ |
| found_pos = start + i - 1; |
| newline_len = 1; |
| } |
| /* Don't check for CR here, instead look at last_saw_cr on next byte */ |
| break; |
| } |
| |
| last_saw_cr = (buffer[i] == 13); |
| |
| if (found_pos != -1) |
| { |
| *newline_len_out = newline_len; |
| return found_pos; |
| } |
| } |
| |
| checked = end; |
| |
| *checked_out = checked; |
| *last_saw_cr_out = last_saw_cr; |
| return -1; |
| } |
| |
| |
| /** |
| * g_data_input_stream_read_line: |
| * @stream: a given #GDataInputStream. |
| * @length: a #gsize to get the length of the data read in. |
| * @cancellable: optional #GCancellable object, %NULL to ignore. |
| * @error: #GError for error reporting. |
| * |
| * Reads a line from the data input stream. |
| * |
| * If @cancellable is not %NULL, then the operation can be cancelled by |
| * triggering the cancellable object from another thread. If the operation |
| * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. |
| * |
| * Returns: a string with the line that was read in (including the newlines). |
| * Set @length to a #gsize to get the length of the read line. Returns %NULL on an error. |
| **/ |
| char * |
| g_data_input_stream_read_line (GDataInputStream *stream, |
| gsize *length, |
| GCancellable *cancellable, |
| GError **error) |
| { |
| GBufferedInputStream *bstream; |
| gsize checked; |
| gboolean last_saw_cr; |
| gssize found_pos; |
| gssize res; |
| int newline_len; |
| char *line; |
| |
| g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream), NULL); |
| |
| bstream = G_BUFFERED_INPUT_STREAM (stream); |
| |
| newline_len = 0; |
| checked = 0; |
| last_saw_cr = FALSE; |
| |
| while ((found_pos = scan_for_newline (stream, &checked, &last_saw_cr, &newline_len)) == -1) |
| { |
| if (g_buffered_input_stream_get_available (bstream) == |
| g_buffered_input_stream_get_buffer_size (bstream)) |
| g_buffered_input_stream_set_buffer_size (bstream, |
| 2 * g_buffered_input_stream_get_buffer_size (bstream)); |
| |
| res = g_buffered_input_stream_fill (bstream, -1, cancellable, error); |
| if (res < 0) |
| return NULL; |
| if (res == 0) |
| { |
| /* End of stream */ |
| if (g_buffered_input_stream_get_available (bstream) == 0) |
| { |
| if (length) |
| *length = 0; |
| return NULL; |
| } |
| else |
| { |
| found_pos = checked; |
| newline_len = 0; |
| break; |
| } |
| } |
| } |
| |
| line = g_malloc (found_pos + newline_len + 1); |
| |
| res = g_input_stream_read (G_INPUT_STREAM (stream), |
| line, |
| found_pos + newline_len, |
| NULL, NULL); |
| if (length) |
| *length = (gsize)found_pos; |
| g_warn_if_fail (res == found_pos + newline_len); |
| line[found_pos] = 0; |
| |
| return line; |
| } |
| |
| |
| static gssize |
| scan_for_chars (GDataInputStream *stream, |
| gsize *checked_out, |
| const char *stop_chars) |
| { |
| GBufferedInputStream *bstream; |
| GDataInputStreamPrivate *priv; |
| const char *buffer; |
| gsize start, end, peeked; |
| int i; |
| gssize found_pos; |
| gsize available, checked; |
| const char *stop_char; |
| |
| priv = stream->priv; |
| |
| bstream = G_BUFFERED_INPUT_STREAM (stream); |
| |
| checked = *checked_out; |
| found_pos = -1; |
| |
| start = checked; |
| buffer = (const char *)g_buffered_input_stream_peek_buffer (bstream, &available) + start; |
| end = available; |
| peeked = end - start; |
| |
| for (i = 0; checked < available && i < peeked; i++) |
| { |
| for (stop_char = stop_chars; *stop_char != '\0'; stop_char++) |
| { |
| if (buffer[i] == *stop_char) |
| return (start + i); |
| } |
| } |
| |
| checked = end; |
| |
| *checked_out = checked; |
| return -1; |
| } |
| |
| /** |
| * g_data_input_stream_read_until: |
| * @stream: a given #GDataInputStream. |
| * @stop_chars: characters to terminate the read. |
| * @length: a #gsize to get the length of the data read in. |
| * @cancellable: optional #GCancellable object, %NULL to ignore. |
| * @error: #GError for error reporting. |
| * |
| * Reads a string from the data input stream, up to the first |
| * occurrance of any of the stop characters. |
| * |
| * Returns: a string with the data that was read before encountering |
| * any of the stop characters. Set @length to a #gsize to get the length |
| * of the string. This function will return %NULL on an error. |
| **/ |
| char * |
| g_data_input_stream_read_until (GDataInputStream *stream, |
| const gchar *stop_chars, |
| gsize *length, |
| GCancellable *cancellable, |
| GError **error) |
| { |
| GBufferedInputStream *bstream; |
| gsize checked; |
| gssize found_pos; |
| gssize res; |
| int stop_char_len; |
| char *data_until; |
| |
| g_return_val_if_fail (G_IS_DATA_INPUT_STREAM (stream), NULL); |
| |
| bstream = G_BUFFERED_INPUT_STREAM (stream); |
| |
| stop_char_len = 1; |
| checked = 0; |
| |
| while ((found_pos = scan_for_chars (stream, &checked, stop_chars)) == -1) |
| { |
| if (g_buffered_input_stream_get_available (bstream) == |
| g_buffered_input_stream_get_buffer_size (bstream)) |
| g_buffered_input_stream_set_buffer_size (bstream, |
| 2 * g_buffered_input_stream_get_buffer_size (bstream)); |
| |
| res = g_buffered_input_stream_fill (bstream, -1, cancellable, error); |
| if (res < 0) |
| return NULL; |
| if (res == 0) |
| { |
| /* End of stream */ |
| if (g_buffered_input_stream_get_available (bstream) == 0) |
| { |
| if (length) |
| *length = 0; |
| return NULL; |
| } |
| else |
| { |
| found_pos = checked; |
| stop_char_len = 0; |
| break; |
| } |
| } |
| } |
| |
| data_until = g_malloc (found_pos + stop_char_len + 1); |
| |
| res = g_input_stream_read (G_INPUT_STREAM (stream), |
| data_until, |
| found_pos + stop_char_len, |
| NULL, NULL); |
| if (length) |
| *length = (gsize)found_pos; |
| g_warn_if_fail (res == found_pos + stop_char_len); |
| data_until[found_pos] = 0; |
| |
| return data_until; |
| } |
| |
| #define __G_DATA_INPUT_STREAM_C__ |
| #include "gioaliasdef.c" |