CTPL_EOF

#define CTPL_EOF  0

End-Of-File constant.

Since 0.2

CTPL_BLANK_CHARS

#define CTPL_BLANK_CHARS  " \t\v\r\n"

Characters treated as blank, commonly used as separator.

ctpl_is_blank()

#define             ctpl_is_blank(c)

Checks whether a character is one from CTPL_BLANK_CHARS, but can be more optimized than a simple search in the string.

Since 0.2

CTPL_SYMBOL_CHARS

#define             CTPL_SYMBOL_CHARS

Characters that are valid for a symbol.

ctpl_is_symbol()

#define             ctpl_is_symbol(c)

Checks whether a character is one from CTPL_SYMBOL_CHARS, but can be more optimized than a simple search in the string.

Since 0.2

CTPL_ESCAPE_CHAR

#define CTPL_ESCAPE_CHAR  '\\'

Character used to escape a special character.

CTPL_STRING_DELIMITER_CHAR

#define CTPL_STRING_DELIMITER_CHAR '"'

Character surrounding string literals.

CtplInputStream

typedef struct {
} CtplInputStream;

An opaque object representing an input data stream.

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_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_double ()

gdouble             ctpl_input_stream_read_double       (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_long ()

glong               ctpl_input_stream_read_long         (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 0x, a decimal real with possible decimal exponent separated by a e or a hexadecimal real with possible decimal power separated by 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 CTPL_STRING_DELIMITER_CHAR, containing possible escaping sequences escaped by CTPL_ESCAPE_CHAR. A plain CTPL_ESCAPE_CHAR need to be escaped too, otherwise it will simply escape the next character.

For instance, a string might look like this, assuming the escape character is \ (backslash) and the quoting character is " (double quote): "a valid string with \"special\" characters such as \\ (backslash)"

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 */
}