glib.h

本文档详细介绍了在WINDOWS下用VC6.0编译ORTP的方法,还有要用到的4个头文件

								 gulong       n,
								 gchar const *format,
								 va_list      args);
gchar*  g_basename      (const gchar *file_name);
/* Check if a file name is an absolute path */
gboolean g_path_is_absolute (const gchar *file_name);
/* In case of absolute paths, skip the root part */
gchar*  g_path_skip_root    (gchar       *file_name);

/* strings are newly allocated with g_malloc() */
gchar*  g_dirname       (const gchar *file_name);
gchar*  g_get_current_dir   (void);
gchar*  g_getenv        (const gchar *variable);


/* we use a GLib function as a replacement for ATEXIT, so
 * the programmer is not required to check the return value
 * (if there is any in the implementation) and doesn't encounter
 * missing include files.
 */
void    g_atexit        (GVoidFunc    func);


/* Bit tests
 */
G_INLINE_FUNC gint  g_bit_nth_lsf (guint32 mask,
											 gint    nth_bit);
#ifdef  G_CAN_INLINE
G_INLINE_FUNC gint
g_bit_nth_lsf (guint32 mask,
					 gint    nth_bit)
{
	do
		{
			nth_bit++;
			if (mask & (1 << (guint) nth_bit))
		return nth_bit;
		}
	while (nth_bit < 32);
	return -1;
}
#endif  /* G_CAN_INLINE */

G_INLINE_FUNC gint  g_bit_nth_msf (guint32 mask,
											 gint    nth_bit);
#ifdef G_CAN_INLINE
G_INLINE_FUNC gint
g_bit_nth_msf (guint32 mask,
					 gint    nth_bit)
{
	if (nth_bit < 0)
		nth_bit = 32;
	do
		{
			nth_bit--;
			if (mask & (1 << (guint) nth_bit))
		return nth_bit;
		}
	while (nth_bit > 0);
	return -1;
}
#endif  /* G_CAN_INLINE */

G_INLINE_FUNC guint g_bit_storage (guint number);
#ifdef G_CAN_INLINE
G_INLINE_FUNC guint
g_bit_storage (guint number)
{
	register guint n_bits = 0;
	
	do
		{
			n_bits++;
			number >>= 1;
		}
	while (number);
	return n_bits;
}
#endif  /* G_CAN_INLINE */

/* String Chunks
 */
GStringChunk* g_string_chunk_new       (gint size);
void          g_string_chunk_free      (GStringChunk *chunk);
gchar*        g_string_chunk_insert    (GStringChunk *chunk,
												const gchar  *string);
gchar*        g_string_chunk_insert_const  (GStringChunk *chunk,
												const gchar  *string);


/* Strings
 */
GString* g_string_new       (const gchar *init);
GString* g_string_sized_new (guint    dfl_size);
void     g_string_free      (GString     *string,
								 gint     free_segment);
GString* g_string_assign    (GString     *lval,
								 const gchar *rval);
GString* g_string_truncate  (GString     *string,
								 gint     len);
GString* g_string_append    (GString     *string,
								 const gchar *val);
GString* g_string_append_c  (GString     *string,
								 gchar    c);
GString* g_string_prepend   (GString     *string,
								 const gchar *val);
GString* g_string_prepend_c (GString     *string,
								 gchar    c);
GString* g_string_insert    (GString     *string,
								 gint     pos,
								 const gchar *val);
GString* g_string_insert_c  (GString     *string,
								 gint     pos,
								 gchar    c);
GString* g_string_erase     (GString     *string,
								 gint     pos,
								 gint     len);
GString* g_string_down      (GString     *string);
GString* g_string_up        (GString     *string);
void     g_string_sprintf   (GString     *string,
								 const gchar *format,
								 ...) G_GNUC_PRINTF (2, 3);
void     g_string_sprintfa  (GString     *string,
								 const gchar *format,
								 ...) G_GNUC_PRINTF (2, 3);


/* Resizable arrays, remove fills any cleared spot and shortens the
 * array, while preserving the order. remove_fast will distort the
 * order by moving the last element to the position of the removed 
 */

#define g_array_append_val(a,v)   g_array_append_vals (a, &v, 1)
#define g_array_prepend_val(a,v)  g_array_prepend_vals (a, &v, 1)
#define g_array_insert_val(a,i,v) g_array_insert_vals (a, i, &v, 1)
#define g_array_index(a,t,i)      (((t*) (a)->data) [(i)])

GArray* g_array_new           (gboolean     zero_terminated,
									 gboolean     clear,
									 guint        element_size);
void    g_array_free              (GArray      *array,
									 gboolean     free_segment);
GArray* g_array_append_vals       (GArray      *array,
									 gconstpointer    data,
									 guint        len);
GArray* g_array_prepend_vals      (GArray      *array,
									 gconstpointer    data,
									 guint        len);
GArray* g_array_insert_vals       (GArray          *array,
									 guint            index,
									 gconstpointer    data,
									 guint            len);
GArray* g_array_set_size          (GArray      *array,
									 guint        length);
GArray* g_array_remove_index      (GArray      *array,
									 guint        index);
GArray* g_array_remove_index_fast (GArray      *array,
									 guint        index);

/* Resizable pointer array.  This interface is much less complicated
 * than the above.  Add appends appends a pointer.  Remove fills any
 * cleared spot and shortens the array. remove_fast will again distort
 * order.  
 */
#define     g_ptr_array_index(array,index) (array->pdata)[index]
GPtrArray*  g_ptr_array_new        (void);
void        g_ptr_array_free           (GPtrArray   *array,
												gboolean     free_seg);
void        g_ptr_array_set_size       (GPtrArray   *array,
												gint     length);
gpointer    g_ptr_array_remove_index       (GPtrArray   *array,
												guint    index);
gpointer    g_ptr_array_remove_index_fast  (GPtrArray   *array,
												guint    index);
gboolean    g_ptr_array_remove         (GPtrArray   *array,
												gpointer     data);
gboolean    g_ptr_array_remove_fast        (GPtrArray   *array,
												gpointer     data);
void        g_ptr_array_add        (GPtrArray   *array,
												gpointer     data);

/* Byte arrays, an array of guint8.  Implemented as a GArray,
 * but type-safe.
 */

GByteArray* g_byte_array_new               (void);
void        g_byte_array_free              (GByteArray   *array,
												gboolean      free_segment);
GByteArray* g_byte_array_append            (GByteArray   *array,
												const guint8 *data,
												guint     len);
GByteArray* g_byte_array_prepend           (GByteArray   *array,
												const guint8 *data,
												guint     len);
GByteArray* g_byte_array_set_size          (GByteArray   *array,
												guint     length);
GByteArray* g_byte_array_remove_index      (GByteArray   *array,
												guint     index);
GByteArray* g_byte_array_remove_index_fast (GByteArray   *array,
												guint     index);


/* Hash Functions
 */
gint  g_str_equal (gconstpointer   v,
					 gconstpointer   v2);
guint g_str_hash  (gconstpointer   v);

gint  g_int_equal (gconstpointer   v,
					 gconstpointer   v2);
guint g_int_hash  (gconstpointer   v);

/* This "hash" function will just return the key's adress as an
 * unsigned integer. Useful for hashing on plain adresses or
 * simple integer values.
 * passing NULL into g_hash_table_new() as GHashFunc has the
 * same effect as passing g_direct_hash().
 */
guint g_direct_hash  (gconstpointer v);
gint  g_direct_equal (gconstpointer v,
							gconstpointer v2);


/* Quarks (string<->id association)
 */
GQuark    g_quark_try_string        (const gchar    *string);
GQuark    g_quark_from_static_string    (const gchar    *string);
GQuark    g_quark_from_string       (const gchar    *string);
gchar*    g_quark_to_string     (GQuark      quark);


/* Keyed Data List
 * NOTE: these functions are scheduled for a rename in GLib 1.3
 */
void      g_datalist_init        (GData      **datalist);
void      g_datalist_clear       (GData      **datalist);
gpointer  g_datalist_id_get_data     (GData      **datalist,
											GQuark       key_id);
void      g_datalist_id_set_data_full    (GData      **datalist,
											GQuark       key_id,
											gpointer     data,
											GDestroyNotify   destroy_func);
void      g_datalist_id_remove_no_notify (GData      **datalist,
											GQuark       key_id);
void      g_datalist_foreach         (GData      **datalist,
											GDataForeachFunc func,
											gpointer     user_data);
#define   g_datalist_id_set_data(dl, q, d)  \
		 g_datalist_id_set_data_full ((dl), (q), (d), NULL)
#define   g_datalist_id_remove_data(dl, q)  \
		 g_datalist_id_set_data ((dl), (q), NULL)
#define   g_datalist_get_data(dl, k)        \
		 (g_datalist_id_get_data ((dl), g_quark_try_string (k)))
#define   g_datalist_set_data_full(dl, k, d, f) \
		 g_datalist_id_set_data_full ((dl), g_quark_from_string (k), (d), (f))
#define   g_datalist_remove_no_notify(dl, k)    \
		 g_datalist_id_remove_no_notify ((dl), g_quark_try_string (k))
#define   g_datalist_set_data(dl, k, d)     \
		 g_datalist_set_data_full ((dl), (k), (d), NULL)
#define   g_datalist_remove_data(dl, k)     \
		 g_datalist_id_set_data ((dl), g_quark_try_string (k), NULL)


/* Location Associated Keyed Data
 * NOTE: these functions are scheduled for a rename in GLib 1.3
 */
void      g_dataset_destroy     (gconstpointer    dataset_location);
gpointer  g_dataset_id_get_data     (gconstpointer    dataset_location,
										 GQuark       key_id);
void      g_dataset_id_set_data_full    (gconstpointer    dataset_location,
										 GQuark       key_id,
										 gpointer     data,
										 GDestroyNotify   destroy_func);
void      g_dataset_id_remove_no_notify (gconstpointer    dataset_location,
										 GQuark       key_id);
void      g_dataset_foreach     (gconstpointer    dataset_location,
										 GDataForeachFunc func,
										 gpointer     user_data);
#define   g_dataset_id_set_data(l, k, d)    \
		 g_dataset_id_set_data_full ((l), (k), (d), NULL)
#define   g_dataset_id_remove_data(l, k)    \
		 g_dataset_id_set_data ((l), (k), NULL)
#define   g_dataset_get_data(l, k)      \
		 (g_dataset_id_get_data ((l), g_quark_try_string (k)))
#define   g_dataset_set_data_full(l, k, d, f)   \
		 g_dataset_id_set_data_full ((l), g_quark_from_string (k), (d), (f))
#define   g_dataset_remove_no_notify(l, k)  \
		 g_dataset_id_remove_no_notify ((l), g_quark_try_string (k))
#define   g_dataset_set_data(l, k, d)       \
		 g_dataset_set_data_full ((l), (k), (d), NULL)
#define   g_dataset_remove_data(l, k)       \
		 g_dataset_id_set_data ((l), g_quark_try_string (k), NULL)


/* GScanner: Flexible lexical scanner for general purpose.
 */

/* Character sets */
#define G_CSET_A_2_Z    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
#define G_CSET_a_2_z    "abcdefghijklmnopqrstuvwxyz"
#define G_CSET_LATINC   "\300\301\302\303\304\305\306"\
						"\307\310\311\312\313\314\315\316\317\320"\
						"\321\322\323\324\325\326"\
						"\330\331\332\333\334\335\336"
#define G_CSET_LATINS   "\337\340\341\342\343\344\345\346"\
						"\347\350\351\352\353\354\355\356\357\360"\
						"\361\362\363\364\365\366"\
						"\370\371\372\373\374\375\376\377"

/* Error types */
typedef enum
{
	G_ERR_UNKNOWN,
	G_ERR_UNEXP_EOF,
	G_ERR_UNEXP_EOF_IN_STRING,
	G_ERR_UNEXP_EOF_IN_COMMENT,
	G_ERR_NON_DIGIT_IN_CONST,
	G_ERR_DIGIT_RADIX,
	G_ERR_FLOAT_RADIX,
	G_ERR_FLOAT_MALFORMED
} GErrorType;

/* Token types */
typedef enum
{
	G_TOKEN_EOF           =   0,
	
	G_TOKEN_LEFT_PAREN        = '(',
	G_TOKEN_RIGHT_PAREN       = ')',
	G_TOKEN_LEFT_CURLY        = '{',
	G_TOKEN_RIGHT_CURLY       = '}',
	G_TOKEN_LEFT_BRACE        = '[',
	G_TOKEN_RIGHT_BRACE       = ']',
	G_TOKEN_EQUAL_SIGN        = '=',
	G_TOKEN_COMMA         = ',',
	
	G_TOKEN_NONE          = 256,
	
	G_TOKEN_ERROR,
	
	G_TOKEN_CHAR,
	G_TOKEN_BINARY,
	G_TOKEN_OCTAL,
	G_TOKEN_INT,
	G_TOKEN_HEX,
	G_TOKEN_FLOAT,
	G_TOKEN_STRING,
	
	G_TOKEN_SYMBOL,
	G_TOKEN_IDENTIFIER,
	G_TOKEN_IDENTIFIER_NULL,
	
	G_TOKEN_COMMENT_SINGLE,
	G_TOKEN_COMMENT_MULTI,
	G_TOKEN_LAST
} GTokenType;

union   _GTokenValue
{
	gpointer  v_symbol;
	gchar     *v_identifier;
	gulong    v_binary;
	gulong    v_octal;
	gulong    v_int;
	gdouble   v_float;
	gulong    v_hex;
	gchar     *v_string;
	gchar     *v_comment;
	guchar    v_char;
	guint     v_error;
};

struct  _GScannerConfig
{
	/* Character sets
	 */
	gchar     *cset_skip_characters;      /* default: " \t\n" */
	gchar     *cset_identifier_first;
	gchar     *cset_identifier_nth;
	gchar     *cpair_comm