<MACRO>
<NAME>CTPL_ENVIRON_ERROR</NAME>
#define CTPL_ENVIRON_ERROR  (ctpl_environ_error_quark ())
</MACRO>
<ENUM>
<NAME>CtplEnvironError</NAME>
typedef enum _CtplEnvironError
{
  CTPL_ENVIRON_ERROR_LOADER_MISSING_SYMBOL,
  CTPL_ENVIRON_ERROR_LOADER_MISSING_VALUE,
  CTPL_ENVIRON_ERROR_LOADER_MISSING_SEPARATOR,
  CTPL_ENVIRON_ERROR_FAILED
} CtplEnvironError;
</ENUM>
<STRUCT>
<NAME>CtplEnviron</NAME>
</STRUCT>
<USER_FUNCTION>
<NAME>CtplEnvironForeachFunc</NAME>
<RETURNS>gboolean </RETURNS>
CtplEnviron     *env,
                                             const gchar     *symbol,
                                             const CtplValue *value,
                                             gpointer         user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>ctpl_environ_error_quark</NAME>
<RETURNS>GQuark            </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ctpl_environ_new</NAME>
<RETURNS>CtplEnviron      *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ctpl_environ_ref</NAME>
<RETURNS>CtplEnviron      *</RETURNS>
CtplEnviron *env
</FUNCTION>
<FUNCTION>
<NAME>ctpl_environ_unref</NAME>
<RETURNS>void              </RETURNS>
CtplEnviron *env
</FUNCTION>
<FUNCTION>
<NAME>ctpl_environ_lookup</NAME>
<RETURNS>const CtplValue  *</RETURNS>
const CtplEnviron *env,const gchar       *symbol
</FUNCTION>
<FUNCTION>
<NAME>ctpl_environ_push</NAME>
<RETURNS>void              </RETURNS>
CtplEnviron     *env,const gchar     *symbol,const CtplValue *value
</FUNCTION>
<FUNCTION>
<NAME>ctpl_environ_push_int</NAME>
<RETURNS>void              </RETURNS>
CtplEnviron     *env,const gchar     *symbol,glong            value
</FUNCTION>
<FUNCTION>
<NAME>ctpl_environ_push_float</NAME>
<RETURNS>void              </RETURNS>
CtplEnviron     *env,const gchar      *symbol,gdouble           value
</FUNCTION>
<FUNCTION>
<NAME>ctpl_environ_push_string</NAME>
<RETURNS>void              </RETURNS>
CtplEnviron     *env,const gchar     *symbol,const gchar     *value
</FUNCTION>
<FUNCTION>
<NAME>ctpl_environ_pop</NAME>
<RETURNS>gboolean          </RETURNS>
CtplEnviron *env,const gchar *symbol,CtplValue  **poped_value
</FUNCTION>
<FUNCTION>
<NAME>ctpl_environ_foreach</NAME>
<RETURNS>void              </RETURNS>
CtplEnviron           *env,CtplEnvironForeachFunc func,gpointer               user_data
</FUNCTION>
<FUNCTION>
<NAME>ctpl_environ_merge</NAME>
<RETURNS>void              </RETURNS>
CtplEnviron        *env,const CtplEnviron  *source,gboolean            merge_symbols
</FUNCTION>
<FUNCTION>
<NAME>ctpl_environ_add_from_stream</NAME>
<RETURNS>gboolean          </RETURNS>
CtplEnviron     *env,CtplInputStream *stream,GError         **error
</FUNCTION>
<FUNCTION>
<NAME>ctpl_environ_add_from_string</NAME>
<RETURNS>gboolean          </RETURNS>
CtplEnviron  *env,const gchar  *string,GError      **error
</FUNCTION>
<FUNCTION>
<NAME>ctpl_environ_add_from_path</NAME>
<RETURNS>gboolean          </RETURNS>
CtplEnviron *env,const gchar *path,GError     **error
</FUNCTION>
<STRUCT>
<NAME>CtplInputStream</NAME>
</STRUCT>
<MACRO>
<NAME>CTPL_EOF</NAME>
#define CTPL_EOF  0
</MACRO>
<FUNCTION>
<NAME>ctpl_input_stream_new</NAME>
<RETURNS>CtplInputStream  *</RETURNS>
GInputStream  *stream,const gchar   *name
</FUNCTION>
<FUNCTION>
<NAME>ctpl_input_stream_new_for_memory</NAME>
<RETURNS>CtplInputStream  *</RETURNS>
const gchar   *data,gssize         length,GDestroyNotify destroy,const gchar   *name
</FUNCTION>
<FUNCTION>
<NAME>ctpl_input_stream_new_for_gfile</NAME>
<RETURNS>CtplInputStream  *</RETURNS>
GFile    *file,GError  **error
</FUNCTION>
<FUNCTION>
<NAME>ctpl_input_stream_new_for_path</NAME>
<RETURNS>CtplInputStream  *</RETURNS>
const gchar   *path,GError       **error
</FUNCTION>
<FUNCTION>
<NAME>ctpl_input_stream_new_for_uri</NAME>
<RETURNS>CtplInputStream  *</RETURNS>
const gchar   *uri,GError       **error
</FUNCTION>
<FUNCTION>
<NAME>ctpl_input_stream_ref</NAME>
<RETURNS>CtplInputStream  *</RETURNS>
CtplInputStream *stream
</FUNCTION>
<FUNCTION>
<NAME>ctpl_input_stream_unref</NAME>
<RETURNS>void              </RETURNS>
CtplInputStream *stream
</FUNCTION>
<FUNCTION>
<NAME>ctpl_input_stream_get_stream</NAME>
<RETURNS>GInputStream     *</RETURNS>
const CtplInputStream *stream
</FUNCTION>
<FUNCTION>
<NAME>ctpl_input_stream_get_name</NAME>
<RETURNS>const gchar      *</RETURNS>
const CtplInputStream *stream
</FUNCTION>
<FUNCTION>
<NAME>ctpl_input_stream_get_line</NAME>
<RETURNS>guint             </RETURNS>
const CtplInputStream *stream
</FUNCTION>
<FUNCTION>
<NAME>ctpl_input_stream_get_line_position</NAME>
<RETURNS>guint             </RETURNS>
const CtplInputStream *stream
</FUNCTION>
<FUNCTION>
<NAME>ctpl_input_stream_set_error</NAME>
<RETURNS>void              </RETURNS>
CtplInputStream  *stream,GError          **error,GQuark            domain,gint              code,const gchar      *format,...
</FUNCTION>
<FUNCTION>
<NAME>ctpl_input_stream_eof</NAME>
<RETURNS>gboolean          </RETURNS>
CtplInputStream *stream,GError         **error
</FUNCTION>
<FUNCTION>
<NAME>ctpl_input_stream_eof_fast</NAME>
<RETURNS>gboolean          </RETURNS>
CtplInputStream *stream
</FUNCTION>
<FUNCTION>
<NAME>ctpl_input_stream_read</NAME>
<RETURNS>gssize            </RETURNS>
CtplInputStream *stream,void            *buffer,gsize            count,GError         **error
</FUNCTION>
<FUNCTION>
<NAME>ctpl_input_stream_peek</NAME>
<RETURNS>gssize            </RETURNS>
CtplInputStream *stream,void            *buffer,gsize            count,GError         **error
</FUNCTION>
<FUNCTION>
<NAME>ctpl_input_stream_get_c</NAME>
<RETURNS>gchar             </RETURNS>
CtplInputStream *stream,GError         **error
</FUNCTION>
<FUNCTION>
<NAME>ctpl_input_stream_peek_c</NAME>
<RETURNS>gchar             </RETURNS>
CtplInputStream *stream,GError         **error
</FUNCTION>
<FUNCTION>
<NAME>ctpl_input_stream_read_word</NAME>
<RETURNS>gchar            *</RETURNS>
CtplInputStream *stream,const gchar     *accept,gssize           accept_len,gssize           max_len,gsize           *length,GError         **error
</FUNCTION>
<FUNCTION>
<NAME>ctpl_input_stream_read_symbol_full</NAME>
<RETURNS>gchar            *</RETURNS>
CtplInputStream *stream,gssize           max_len,gsize           *length,GError         **error
</FUNCTION>
<FUNCTION>
<NAME>ctpl_input_stream_peek_word</NAME>
<RETURNS>gchar            *</RETURNS>
CtplInputStream *stream,const gchar     *accept,gssize           accept_len,gssize           max_len,gsize           *length,GError         **error
</FUNCTION>
<FUNCTION>
<NAME>ctpl_input_stream_peek_symbol_full</NAME>
<RETURNS>gchar            *</RETURNS>
CtplInputStream *stream,gssize           max_len,gsize           *length,GError         **error
</FUNCTION>
<FUNCTION>
<NAME>ctpl_input_stream_skip</NAME>
<RETURNS>gssize            </RETURNS>
CtplInputStream *stream,gsize            count,GError         **error
</FUNCTION>
<FUNCTION>
<NAME>ctpl_input_stream_skip_word</NAME>
<RETURNS>gssize            </RETURNS>
CtplInputStream *stream,const gchar     *reject,gssize           reject_len,GError         **error
</FUNCTION>
<FUNCTION>
<NAME>ctpl_input_stream_skip_blank</NAME>
<RETURNS>gssize            </RETURNS>
CtplInputStream  *stream,GError          **error
</FUNCTION>
<FUNCTION>
<NAME>ctpl_input_stream_read_string_literal</NAME>
<RETURNS>gchar            *</RETURNS>
CtplInputStream *stream,GError         **error
</FUNCTION>
<FUNCTION>
<NAME>ctpl_input_stream_read_number</NAME>
<RETURNS>gboolean          </RETURNS>
CtplInputStream *stream,CtplValue       *value,GError         **error
</FUNCTION>
<FUNCTION>
<NAME>ctpl_input_stream_read_float</NAME>
<RETURNS>gdouble           </RETURNS>
CtplInputStream *stream,GError         **error
</FUNCTION>
<FUNCTION>
<NAME>ctpl_input_stream_read_int</NAME>
<RETURNS>glong             </RETURNS>
CtplInputStream *stream,GError         **error
</FUNCTION>
<MACRO>
<NAME>ctpl_input_stream_get_c</NAME>
#define ctpl_input_stream_get_c ctpl_input_stream_get_c_inline
</MACRO>
<MACRO>
<NAME>ctpl_input_stream_read_symbol</NAME>
#define ctpl_input_stream_read_symbol(stream, error)                           \
  (ctpl_input_stream_read_symbol_full ((stream), -1, NULL, (error)))
</MACRO>
<MACRO>
<NAME>ctpl_input_stream_peek_symbol</NAME>
#define ctpl_input_stream_peek_symbol(stream, max_len, error)                  \
  (ctpl_input_stream_peek_symbol_full ((stream), max_len, NULL, (error)))
</MACRO>
<MACRO>
<NAME>CTPL_LEXER_EXPR_ERROR</NAME>
#define CTPL_LEXER_EXPR_ERROR (ctpl_lexer_expr_error_quark ())
</MACRO>
<ENUM>
<NAME>CtplLexerExprError</NAME>
typedef enum _CtplLexerExprError
{
  CTPL_LEXER_EXPR_ERROR_MISSING_OPERAND,
  CTPL_LEXER_EXPR_ERROR_MISSING_OPERATOR,
  CTPL_LEXER_EXPR_ERROR_SYNTAX_ERROR,
  CTPL_LEXER_EXPR_ERROR_FAILED
} CtplLexerExprError;
</ENUM>
<FUNCTION>
<NAME>ctpl_lexer_expr_error_quark</NAME>
<RETURNS>GQuark          </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ctpl_lexer_expr_lex</NAME>
<RETURNS>CtplTokenExpr  *</RETURNS>
CtplInputStream *stream,GError         **error
</FUNCTION>
<FUNCTION>
<NAME>ctpl_lexer_expr_lex_full</NAME>
<RETURNS>CtplTokenExpr  *</RETURNS>
CtplInputStream *stream,gboolean         lex_all,GError         **error
</FUNCTION>
<FUNCTION>
<NAME>ctpl_lexer_expr_lex_string</NAME>
<RETURNS>CtplTokenExpr  *</RETURNS>
const gchar *expr,gssize       len,GError     **error
</FUNCTION>
<MACRO>
<NAME>CTPL_MATH_FLOAT_EQ</NAME>
# define CTPL_MATH_FLOAT_EQ(a, b) (fpclassify ((a) - (b)) == FP_ZERO)
</MACRO>
<MACRO>
<NAME>CTPL_MATH_FLOAT_EQ</NAME>
# define CTPL_MATH_FLOAT_EQ(a, b) (fabs ((a) - (b)) < 0.000001)
</MACRO>
<FUNCTION>
<NAME>ctpl_math_string_to_float</NAME>
<RETURNS>gboolean    </RETURNS>
const gchar *string,gdouble     *value
</FUNCTION>
<FUNCTION>
<NAME>ctpl_math_string_to_int</NAME>
<RETURNS>gboolean    </RETURNS>
const gchar *string,glong       *value
</FUNCTION>
<MACRO>
<NAME>ctpl_math_dtostr</NAME>
#define ctpl_math_dtostr(buf, buf_len, f) \
  (g_ascii_formatd ((buf), (buf_len), "%.15g", (f)))
</MACRO>
<MACRO>
<NAME>ctpl_math_float_to_string</NAME>
#define ctpl_math_float_to_string(f) \
  (ctpl_math_dtostr (g_malloc (G_ASCII_DTOSTR_BUF_SIZE), \
                     G_ASCII_DTOSTR_BUF_SIZE, \
                     (f)))
</MACRO>
<MACRO>
<NAME>ctpl_math_int_to_string</NAME>
#define ctpl_math_int_to_string(i) \
  (g_strdup_printf ("%ld", (i)))
</MACRO>
<ENUM>
<NAME>CtplValueType</NAME>
typedef enum _CtplValueType
{
  CTPL_VTYPE_INT,
  CTPL_VTYPE_FLOAT,
  CTPL_VTYPE_STRING,
  CTPL_VTYPE_ARRAY
} CtplValueType;
</ENUM>
<STRUCT>
<NAME>CtplValue</NAME>
</STRUCT>
<STRUCT>
<NAME>CtplValue</NAME>
struct _CtplValue
{
  /*<private>*/
  gint type; /* held type */
  union {
    glong     v_int;
    gdouble   v_float;
    gchar    *v_string;
    GSList   *v_array;
  } value;
};
</STRUCT>
<MACRO>
<NAME>CTPL_VALUE_HOLDS</NAME>
#define CTPL_VALUE_HOLDS(value, vtype) \
  (ctpl_value_get_held_type (value) == (vtype))
</MACRO>
<MACRO>
<NAME>CTPL_VALUE_HOLDS_INT</NAME>
#define CTPL_VALUE_HOLDS_INT(value) \
  (CTPL_VALUE_HOLDS (value, CTPL_VTYPE_INT))
</MACRO>
<MACRO>
<NAME>CTPL_VALUE_HOLDS_FLOAT</NAME>
#define CTPL_VALUE_HOLDS_FLOAT(value) \
  (CTPL_VALUE_HOLDS (value, CTPL_VTYPE_FLOAT))
</MACRO>
<MACRO>
<NAME>CTPL_VALUE_HOLDS_STRING</NAME>
#define CTPL_VALUE_HOLDS_STRING(value) \
  (CTPL_VALUE_HOLDS (value, CTPL_VTYPE_STRING))
</MACRO>
<MACRO>
<NAME>CTPL_VALUE_HOLDS_ARRAY</NAME>
#define CTPL_VALUE_HOLDS_ARRAY(value) \
  (CTPL_VALUE_HOLDS (value, CTPL_VTYPE_ARRAY))
</MACRO>
<FUNCTION>
<NAME>ctpl_value_init</NAME>
<RETURNS>void          </RETURNS>
CtplValue *value
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_new</NAME>
<RETURNS>CtplValue    *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_copy</NAME>
<RETURNS>void          </RETURNS>
const CtplValue *src_value,CtplValue       *dst_value
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_dup</NAME>
<RETURNS>CtplValue    *</RETURNS>
const CtplValue *value
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_free_value</NAME>
<RETURNS>void          </RETURNS>
CtplValue *value
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_free</NAME>
<RETURNS>void          </RETURNS>
CtplValue *value
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_new_int</NAME>
<RETURNS>CtplValue    *</RETURNS>
glong val
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_new_float</NAME>
<RETURNS>CtplValue    *</RETURNS>
gdouble val
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_new_string</NAME>
<RETURNS>CtplValue    *</RETURNS>
const gchar *val
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_new_arrayv</NAME>
<RETURNS>CtplValue    *</RETURNS>
CtplValueType type,gsize         count,va_list       ap
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_new_array</NAME>
<RETURNS>CtplValue    *</RETURNS>
CtplValueType  type,gsize          count,...
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_set_int</NAME>
<RETURNS>void          </RETURNS>
CtplValue *value,glong      val
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_set_float</NAME>
<RETURNS>void          </RETURNS>
CtplValue *value,gdouble    val
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_set_string</NAME>
<RETURNS>void          </RETURNS>
CtplValue   *value,const gchar *val
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_set_arrayv</NAME>
<RETURNS>void          </RETURNS>
CtplValue     *value,CtplValueType  type,gsize          count,va_list        ap
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_set_array</NAME>
<RETURNS>void          </RETURNS>
CtplValue     *value,CtplValueType  type,gsize          count,...
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_set_array_intv</NAME>
<RETURNS>void          </RETURNS>
CtplValue     *value,gsize          count,va_list        ap
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_set_array_int</NAME>
<RETURNS>void          </RETURNS>
CtplValue     *value,gsize          count,...
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_set_array_floatv</NAME>
<RETURNS>void          </RETURNS>
CtplValue     *value,gsize          count,va_list        ap
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_set_array_float</NAME>
<RETURNS>void          </RETURNS>
CtplValue     *value,gsize          count,...
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_set_array_stringv</NAME>
<RETURNS>void          </RETURNS>
CtplValue     *value,gsize          count,va_list        ap
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_set_array_string</NAME>
<RETURNS>void          </RETURNS>
CtplValue     *value,gsize          count,...
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_array_append</NAME>
<RETURNS>void          </RETURNS>
CtplValue       *value,const CtplValue *val
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_array_prepend</NAME>
<RETURNS>void          </RETURNS>
CtplValue       *value,const CtplValue *val
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_array_append_int</NAME>
<RETURNS>void          </RETURNS>
CtplValue       *value,glong            val
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_array_prepend_int</NAME>
<RETURNS>void          </RETURNS>
CtplValue       *value,glong            val
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_array_append_float</NAME>
<RETURNS>void          </RETURNS>
CtplValue       *value,gdouble          val
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_array_prepend_float</NAME>
<RETURNS>void          </RETURNS>
CtplValue       *value,gdouble          val
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_array_append_string</NAME>
<RETURNS>void          </RETURNS>
CtplValue       *value,const gchar     *val
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_array_prepend_string</NAME>
<RETURNS>void          </RETURNS>
CtplValue       *value,const gchar     *val
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_array_length</NAME>
<RETURNS>gsize         </RETURNS>
const CtplValue *value
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_array_index</NAME>
<RETURNS>CtplValue *</RETURNS>
const CtplValue *value,gsize            idx
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_get_held_type</NAME>
<RETURNS>CtplValueType </RETURNS>
const CtplValue *value
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_get_int</NAME>
<RETURNS>glong         </RETURNS>
const CtplValue *value
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_get_float</NAME>
<RETURNS>gdouble       </RETURNS>
const CtplValue *value
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_get_string</NAME>
<RETURNS>const gchar  *</RETURNS>
const CtplValue *value
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_get_array</NAME>
<RETURNS>const GSList *</RETURNS>
const CtplValue *value
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_get_array_int</NAME>
<RETURNS>glong        *</RETURNS>
const CtplValue *value,gsize           *length
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_get_array_float</NAME>
<RETURNS>gdouble      *</RETURNS>
const CtplValue *value,gsize           *length
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_get_array_string</NAME>
<RETURNS>gchar       **</RETURNS>
const CtplValue *value,gsize           *length
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_to_string</NAME>
<RETURNS>gchar        *</RETURNS>
const CtplValue *value
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_convert</NAME>
<RETURNS>gboolean      </RETURNS>
CtplValue     *value,CtplValueType  vtype
</FUNCTION>
<FUNCTION>
<NAME>ctpl_value_type_get_name</NAME>
<RETURNS>const gchar  *</RETURNS>
CtplValueType type
</FUNCTION>
<MACRO>
<NAME>ctpl_value_get_held_type_name</NAME>
#define ctpl_value_get_held_type_name(v) \
  (ctpl_value_type_get_name (ctpl_value_get_held_type ((v))))
</MACRO>
<MACRO>
<NAME>CTPL_PARSER_ERROR</NAME>
#define CTPL_PARSER_ERROR  (ctpl_parser_error_quark ())
</MACRO>
<ENUM>
<NAME>CtplParserError</NAME>
typedef enum _CtplParserError
{
  CTPL_PARSER_ERROR_INCOMPATIBLE_SYMBOL,
  CTPL_PARSER_ERROR_SYMBOL_NOT_FOUND,
  CTPL_PARSER_ERROR_FAILED
} CtplParserError;
</ENUM>
<FUNCTION>
<NAME>ctpl_parser_error_quark</NAME>
<RETURNS>GQuark    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ctpl_parser_parse</NAME>
<RETURNS>gboolean  </RETURNS>
const CtplToken   *tree,CtplEnviron       *env,CtplOutputStream  *output,GError           **error
</FUNCTION>
<MACRO>
<NAME>CTPL_LEXER_ERROR</NAME>
#define CTPL_LEXER_ERROR  (ctpl_lexer_error_quark ())
</MACRO>
<ENUM>
<NAME>CtplLexerError</NAME>
typedef enum _CtplLexerError
{
  CTPL_LEXER_ERROR_SYNTAX_ERROR,
  CTPL_LEXER_ERROR_FAILED
} CtplLexerError;
</ENUM>
<FUNCTION>
<NAME>ctpl_lexer_error_quark</NAME>
<RETURNS>GQuark      </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ctpl_lexer_lex</NAME>
<RETURNS>CtplToken  *</RETURNS>
CtplInputStream *stream,GError         **error
</FUNCTION>
<FUNCTION>
<NAME>ctpl_lexer_lex_string</NAME>
<RETURNS>CtplToken  *</RETURNS>
const gchar *template,GError     **error
</FUNCTION>
<FUNCTION>
<NAME>ctpl_lexer_lex_path</NAME>
<RETURNS>CtplToken  *</RETURNS>
const gchar *path,GError     **error
</FUNCTION>
<STRUCT>
<NAME>CtplToken</NAME>
</STRUCT>
<STRUCT>
<NAME>CtplTokenExpr</NAME>
</STRUCT>
<FUNCTION>
<NAME>ctpl_token_free</NAME>
<RETURNS>void          </RETURNS>
CtplToken *token
</FUNCTION>
<FUNCTION>
<NAME>ctpl_token_expr_free</NAME>
<RETURNS>void          </RETURNS>
CtplTokenExpr *token
</FUNCTION>
<ENUM>
<NAME>CtplIOError</NAME>
typedef enum _CtplIOError
{
  CTPL_IO_ERROR_EOF,
  CTPL_IO_ERROR_INVALID_NUMBER,
  CTPL_IO_ERROR_INVALID_STRING,
  CTPL_IO_ERROR_RANGE,
  CTPL_IO_ERROR_FAILED
} CtplIOError;
</ENUM>
<MACRO>
<NAME>CTPL_IO_ERROR</NAME>
#define CTPL_IO_ERROR   (ctpl_io_error_quark ())
</MACRO>
<FUNCTION>
<NAME>ctpl_io_error_quark</NAME>
<RETURNS>GQuark            </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>CTPL_MAJOR_VERSION</NAME>
#define CTPL_MAJOR_VERSION 0
</MACRO>
<MACRO>
<NAME>CTPL_MINOR_VERSION</NAME>
#define CTPL_MINOR_VERSION 3
</MACRO>
<MACRO>
<NAME>CTPL_MICRO_VERSION</NAME>
#define CTPL_MICRO_VERSION 2
</MACRO>
<MACRO>
<NAME>CTPL_CHECK_VERSION</NAME>
#define CTPL_CHECK_VERSION(major, minor, micro) \
  ((CTPL_MAJOR_VERSION > (major)) || \
   ((CTPL_MAJOR_VERSION == (major)) && \
    ((CTPL_MINOR_VERSION > (minor)) || \
     ((CTPL_MINOR_VERSION == (minor)) && CTPL_MICRO_VERSION >= (micro)))))
</MACRO>
<VARIABLE>
<NAME>ctpl_major_version</NAME>
extern const guint ctpl_major_version;
</VARIABLE>
<VARIABLE>
<NAME>ctpl_minor_version</NAME>
extern const guint ctpl_minor_version;
</VARIABLE>
<VARIABLE>
<NAME>ctpl_micro_version</NAME>
extern const guint ctpl_micro_version;
</VARIABLE>
<FUNCTION>
<NAME>ctpl_check_version</NAME>
<RETURNS>gboolean            </RETURNS>
guint major,guint minor,guint micro
</FUNCTION>
<STRUCT>
<NAME>CtplOutputStream</NAME>
</STRUCT>
<FUNCTION>
<NAME>ctpl_output_stream_new</NAME>
<RETURNS>CtplOutputStream *</RETURNS>
GOutputStream *stream
</FUNCTION>
<FUNCTION>
<NAME>ctpl_output_stream_ref</NAME>
<RETURNS>CtplOutputStream *</RETURNS>
CtplOutputStream *stream
</FUNCTION>
<FUNCTION>
<NAME>ctpl_output_stream_unref</NAME>
<RETURNS>void              </RETURNS>
CtplOutputStream *stream
</FUNCTION>
<FUNCTION>
<NAME>ctpl_output_stream_get_stream</NAME>
<RETURNS>GOutputStream    *</RETURNS>
CtplOutputStream *stream
</FUNCTION>
<FUNCTION>
<NAME>ctpl_output_stream_write</NAME>
<RETURNS>gboolean          </RETURNS>
CtplOutputStream  *stream,const gchar       *data,gssize             length,GError           **error
</FUNCTION>
<FUNCTION>
<NAME>ctpl_output_stream_put_c</NAME>
<RETURNS>gboolean          </RETURNS>
CtplOutputStream  *stream,gchar              c,GError           **error
</FUNCTION>
<FUNCTION>
<NAME>ctpl_output_stream_write</NAME>
<RETURNS>return </RETURNS>
stream, &c, 1, error
</FUNCTION>
<MACRO>
<NAME>ctpl_output_stream_put_c</NAME>
#define ctpl_output_stream_put_c ctpl_output_stream_put_c_inline
</MACRO>
<MACRO>
<NAME>CTPL_EVAL_ERROR</NAME>
#define CTPL_EVAL_ERROR  (ctpl_eval_error_quark ())
</MACRO>
<ENUM>
<NAME>CtplEvalError</NAME>
typedef enum _CtplEvalError
{
  CTPL_EVAL_ERROR_INVALID_OPERAND,
  CTPL_EVAL_ERROR_SYMBOL_NOT_FOUND,
  CTPL_EVAL_ERROR_FAILED
} CtplEvalError;
</ENUM>
<FUNCTION>
<NAME>ctpl_eval_error_quark</NAME>
<RETURNS>GQuark      </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ctpl_eval_value</NAME>
<RETURNS>gboolean    </RETURNS>
const CtplTokenExpr  *expr,CtplEnviron          *env,CtplValue            *value,GError              **error
</FUNCTION>
<FUNCTION>
<NAME>ctpl_eval_bool</NAME>
<RETURNS>gboolean    </RETURNS>
const CtplTokenExpr *expr,CtplEnviron         *env,gboolean            *result,GError             **error
</FUNCTION>
<STRUCT>
<NAME>CtplStack</NAME>
</STRUCT>
<FUNCTION>
<NAME>ctpl_stack_new</NAME>
<RETURNS>CtplStack  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ctpl_stack_free</NAME>
<RETURNS>void        </RETURNS>
CtplStack *stack,GFreeFunc  free_func
</FUNCTION>
<FUNCTION>
<NAME>ctpl_stack_push</NAME>
<RETURNS>void        </RETURNS>
CtplStack *stack,gpointer   data
</FUNCTION>
<FUNCTION>
<NAME>ctpl_stack_pop</NAME>
<RETURNS>gpointer    </RETURNS>
CtplStack *stack
</FUNCTION>
<FUNCTION>
<NAME>ctpl_stack_peek</NAME>
<RETURNS>gpointer    </RETURNS>
const CtplStack *stack
</FUNCTION>
<FUNCTION>
<NAME>ctpl_stack_is_empty</NAME>
<RETURNS>gboolean    </RETURNS>
const CtplStack *stack
</FUNCTION>
