ctpl_input_stream_new ()

CtplInputStream *
ctpl_input_stream_new (GInputStream *stream,
                       const gchar *name);

Creates a new CtplInputStream for a GInputStream. This function adds a reference to the GInputStream.

Since 0.2

ctpl_input_stream_new_for_gfile ()

CtplInputStream *
ctpl_input_stream_new_for_gfile (GFile *file,
                                 GError **error);

Creates a new CtplInputStream for a GFile. This is a wrapper around g_file_read() that also sets the name of the stream to the file's name. The errors this function can throw are those from the G_IO_ERROR domain. See ctpl_input_stream_new().

Since 0.2

ctpl_input_stream_new_for_memory ()

CtplInputStream *
ctpl_input_stream_new_for_memory (const gchar *data,
                                  gssize length,
                                  GDestroyNotify destroy,
                                  const gchar *name);

Creates a new CtplInputStream for in-memory data. This is a wrapper around GMemoryInputStream; see ctpl_input_stream_new().

Since 0.2

ctpl_input_stream_new_for_path ()

CtplInputStream *
ctpl_input_stream_new_for_path (const gchar *path,
                                GError **error);

Creates a new CtplInputStream for a path. This is a wrapper for ctpl_input_stream_new_for_gfile() that simply creates a GFile for the given path and call ctpl_input_stream_new_for_gfile() on it.

Since 0.2

ctpl_input_stream_new_for_uri ()

CtplInputStream *
ctpl_input_stream_new_for_uri (const gchar *uri,
                               GError **error);

Creates a new CtplInputStream for an URI. This is a wrapper for ctpl_input_stream_new_for_gfile() that simply creates a GFile for the given URI and call ctpl_input_stream_new_for_gfile() on it.

Since 0.2

ctpl_input_stream_ref ()

CtplInputStream *
ctpl_input_stream_ref (CtplInputStream *stream);

Adds a reference to a CtplInputStream.

Since 0.2

ctpl_input_stream_unref ()

void
ctpl_input_stream_unref (CtplInputStream *stream);

Removes a reference from a CtplInputStream. If the reference count drops to 0, frees the stream.

Since 0.2

ctpl_input_stream_get_stream ()

GInputStream *
ctpl_input_stream_get_stream (const CtplInputStream *stream);

Gets the underlying GInputStream associated with a CtplInputStream.

Since 0.3

ctpl_input_stream_get_name ()

const gchar *
ctpl_input_stream_get_name (const CtplInputStream *stream);

Gets the name associated with a CtplInputStream.

Since 0.3

ctpl_input_stream_get_line ()

guint
ctpl_input_stream_get_line (const CtplInputStream *stream);

Gets the current line number of a CtplInputStream.

Since 0.3

ctpl_input_stream_get_line_position ()

guint
ctpl_input_stream_get_line_position (const CtplInputStream *stream);

Gets the current offset position in the current line, in bytes, in a CtplInputStream.

Since 0.3

ctpl_input_stream_set_error ()

void
ctpl_input_stream_set_error (CtplInputStream *stream,
                             GError **error,
                             GQuark domain,
                             gint code,
                             const gchar *format,
                             ...);

This is a wrapper around g_set_error() that adds stream's position information to the reported error.

Since 0.2

ctpl_input_stream_read ()

gssize
ctpl_input_stream_read (CtplInputStream *stream,
                        void *buffer,
                        gsize count,
                        GError **error);

Reads data from a CtplInputStream.

Since 0.2

ctpl_input_stream_get_c ()

gchar
ctpl_input_stream_get_c (CtplInputStream *stream,
                         GError **error);

Reads a character from a CtplInputStream.

Since

ctpl_input_stream_read_float ()

gdouble
ctpl_input_stream_read_float (CtplInputStream *stream,
                              GError **error);

Reads a real form a CtplInputStream. See ctpl_input_stream_read_number() for details.

Since 0.2

ctpl_input_stream_read_int ()

glong
ctpl_input_stream_read_int (CtplInputStream *stream,
                            GError **error);

Reads an integer from a CtplInputStream. See ctpl_input_stream_read_number() for details.

Since 0.2

ctpl_input_stream_read_number ()

gboolean
ctpl_input_stream_read_number (CtplInputStream *stream,
                               CtplValue *value,
                               GError **error);

Reads a number from a CtplInputStream. A number can be a plain decimal integer, a binary integer prefixed with 0b, an octal integer prefixed with 0o, a hexadecimal integer prefixed with

a p; each possibly preceded by a plus or minus sign. The decimal point of real numbers is always a period (.).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

/* Decimal integers */
42
+512
/* Binary integers */
0b11
/* Octal integers */
0o755
/* Hexadecimal integers */
-0x7FFBE
0x8ff
/* Decimal reals */
+2.1
1.024e3
/* Hexadecimal reals */
0x71F.A0
-0x88fe.2p8

Since 0.2

ctpl_input_stream_read_string_literal ()

gchar *
ctpl_input_stream_read_string_literal (CtplInputStream *stream,
                                       GError **error);

Reads a string quoted with " (double quote), containing possible escaping sequences escaped by \ (backslash). A plain escaping character (backslash) need to be escaped too, otherwise it will simply escape the next character.

For instance, a string might look like this:

1

-->and \" (double quotes)" ]|

Since 0.2

ctpl_input_stream_read_symbol()

#define             ctpl_input_stream_read_symbol(stream, error)

Reads a symbol (a word composed of the characters from CTPL_SYMBOL_CHARS). See ctpl_input_stream_read_word() and ctpl_input_stream_read_symbol_full().

Since 0.2

ctpl_input_stream_read_symbol_full ()

gchar *
ctpl_input_stream_read_symbol_full (CtplInputStream *stream,
                                    gssize max_len,
                                    gsize *length,
                                    GError **error);

Reads a symbol from a CtplInputStream. A symbol is a word composed of the characters from CTPL_SYMBOL_CHARS. See ctpl_input_stream_read_word() and ctpl_input_stream_read_symbol().

Since 0.2

ctpl_input_stream_read_word ()

gchar *
ctpl_input_stream_read_word (CtplInputStream *stream,
                             const gchar *accept,
                             gssize accept_len,
                             gssize max_len,
                             gsize *length,
                             GError **error);

Reads a word from a CtplInputStream. A word is a sequence of characters referenced by accept . Note that the word might be empty if no characters matching accept are found before one that doesn't match.

For example, reading a word composed of any ASCII lowercase characters may be as the following:

1
2
3
4
5
6
7
8
9
10
11

gchar  *word;
GError *error = NULL;

word = ctpl_input_stream_read_word (stream, "abcdefghijklmnopqrstuvwxyz", -1,
                                    -1, NULL, &error);
if (! word) {
  /<!-- -->* deal with the error *<!-- -->/
} else {
  printf ("Read the word \"%s\"\n", word);
  g_free (word);
}

Since 0.2

ctpl_input_stream_peek ()

gssize
ctpl_input_stream_peek (CtplInputStream *stream,
                        void *buffer,
                        gsize count,
                        GError **error);

Peeks data from a CtplInputStream. Peeking data is like reading, but it doesn't removes the data from the stream.

Since 0.2

ctpl_input_stream_peek_c ()

gchar
ctpl_input_stream_peek_c (CtplInputStream *stream,
                          GError **error);

Peeks a character from a CtplInputStream. This may be implemented as a macro.

Since 0.2

ctpl_input_stream_peek_symbol()

#define             ctpl_input_stream_peek_symbol(stream, max_len, error)

Peeks a symbol from a CtplInputStream. See ctpl_input_stream_peek_word() and ctpl_input_stream_peek_symbol_full().

Since 0.2

ctpl_input_stream_peek_symbol_full ()

gchar *
ctpl_input_stream_peek_symbol_full (CtplInputStream *stream,
                                    gssize max_len,
                                    gsize *length,
                                    GError **error);

Peeks a symbol from a CtplInputStream. See ctpl_input_stream_peek_word() and ctpl_input_stream_peek_symbol().

Since 0.2

ctpl_input_stream_peek_word ()

gchar *
ctpl_input_stream_peek_word (CtplInputStream *stream,
                             const gchar *accept,
                             gssize accept_len,
                             gssize max_len,
                             gsize *length,
                             GError **error);

Peeks a word from a CtplInputStream. See ctpl_input_stream_peek() and ctpl_input_stream_read_word().

Since 0.2

ctpl_input_stream_skip ()

gssize
ctpl_input_stream_skip (CtplInputStream *stream,
                        gsize count,
                        GError **error);

Skips count bytes from a CtplInputStream.

Since

ctpl_input_stream_skip_blank ()

gssize
ctpl_input_stream_skip_blank (CtplInputStream *stream,
                              GError **error);

Skips blank characters (as reported by ctpl_is_blank()). See ctpl_input_stream_skip().

Since 0.2

ctpl_input_stream_skip_word ()

gssize
ctpl_input_stream_skip_word (CtplInputStream *stream,
                             const gchar *reject,
                             gssize reject_len,
                             GError **error);

Skips all the characters matching reject from a CtplInputStream until the first that doesn't match.

Since 0.2

ctpl_input_stream_eof ()

gboolean
ctpl_input_stream_eof (CtplInputStream *stream,
                       GError **error);

Reliably checks if the stream reached its end. The error this function can throw are from the G_IO_ERROR domain.

Since 0.2

ctpl_input_stream_eof_fast ()

gboolean
ctpl_input_stream_eof_fast (CtplInputStream *stream);

Checks if a CtplInputStream reached its end. See also ctpl_input_stream_eof().

1
2
3
4
5

ctpl_input_stream_peek_c (stream, &error);
/<!-- -->* deal with the possible error *<!-- -->/
if (ctpl_input_stream_eof_fast (stream)) {
  /<!-- -->* here EOF is reliable *<!-- -->/
}

CTPL_EOF

#define CTPL_EOF  0

End-Of-File constant.

Since 0.2

CtplInputStream

typedef struct _CtplInputStream CtplInputStream;

An opaque object representing an input data stream.