+/** \brief Search a type description from its name */
+gras_datadesc_type_t gras_datadesc_by_name(const char *name);
+
+
+/** @} */
+
+/** @fn gras_datadesc_type_t gras_datadesc_parse(const char *name, const char *C_statement)
+ * @ingroup GRAS_dd_implem
+ *
+ * Helper function doing the crude job of type parsing.
+ */
+
+/** @name b) Automatic parsing
+ * @ingroup GRAS_dd
+ *
+ * If you need to declare a new datatype, this is the simplest way to describe it to GRAS. Simply
+ * enclose its type definition into a \ref GRAS_DEFINE_TYPE macro call, and you're set. Here is
+ * an type declaration example: \verbatim GRAS_DEFINE_TYPE(mytype,struct mytype {
+ int myfirstfield;
+ char mysecondfield;
+ });\endverbatim
+ * The type is then both copied verbatim into your source file and stored for further parsing. This allows
+ * you to let GRAS parse the exact version you are actually using in your program.
+ * You can then retrieve the corresponding type description with \ref gras_datadesc_by_symbol.
+ * Don't worry too much for the performances, the type is only parsed once and a binary representation
+ * is stored and used in any subsequent calls.
+ *
+ * If your structure contains any pointer, you have to explain GRAS the size of the pointed array. This
+ * can be 1 in the case of simple references, or more in the case of regular arrays. For that, use the
+ * \ref GRAS_ANNOTE macro within the type declaration you are passing to \ref GRAS_DEFINE_TYPE. This macro
+ * rewrites itself to nothing in the declaration (so they won't pollute the type definition copied verbatim
+ * into your code), and give some information to GRAS about your pointer.
+
+ * GRAS_ANNOTE takes two arguments being the key name and the key value. For now, the only accepted key name
+ * is "size", to specify the length of the pointed array. It can either be the string "1" (without the quote)
+ * or the name of another field of the structure.
+ *
+ * Here is an example:\verbatim GRAS_DEFINE_TYPE(s_clause,
+ struct s_array {
+ int length;
+ int *data GRAS_ANNOTE(size,length);
+ struct s_array *father GRAS_ANNOTE(size,1);
+ }
+;)\endverbatim
+ * It specifies that the structure s_array contains two fields, and that the size of the array pointed
+ * by \a data is the \a length field, and that the \a father field is a simple reference.
+ *
+ * If you cannot express your datadescs with this mecanism, you'll have to use the more advanced
+ * (and somehow complex) one described below.
+ *
+ * \warning Since GRAS_DEFINE_TYPE is a macro, you shouldn't put any comma in your type definition
+ * (comma separates macro args).
+ *
+ * For example, change \verbatim int a, b;\endverbatim to \verbatim int a;
+ int b:\endverbatim
+ */
+/** @{ */
+
+
+/** @def GRAS_DEFINE_TYPE
+ * @hideinitializer
+ * @brief Automatically parse C code
+ */
+
+
+#define GRAS_DEFINE_TYPE(name,def) \
+ static const char * _gras_this_type_symbol_does_not_exist__##name=#def; def
+
+/** @brief Retrieve a datadesc which was previously parsed
+ * @hideinitializer
+ */
+#define gras_datadesc_by_symbol(name) \
+ (gras_datadesc_by_name(#name) ? \
+ gras_datadesc_by_name(#name) : \
+ gras_datadesc_parse(#name, \
+ _gras_this_type_symbol_does_not_exist__##name) \
+ )
+
+/** @def GRAS_ANNOTE
+ * @brief Add an annotation to a type to be automatically parsed
+ */
+#define GRAS_ANNOTE(key,val)
+
+/*@}*/
+
+gras_datadesc_type_t
+gras_datadesc_parse(const char *name, const char *C_statement);
+
+/** @name c) Simple manual definitions
+ * @ingroup GRAS_dd
+ *
+ * Here are the functions to use if you want to declare your description manually.
+ * The function names should be self-explanatory in most cases.
+ *
+ * You can add callbacks to the datatypes doing any kind of action you may want. Usually,
+ * pre-send callbacks are used to prepare the type expedition while post-receive callbacks
+ * are used to fix any issue after the receive.
+ *
+ * If your types are dynamic, you'll need to add some extra callback. For example, there is a
+ * specific callback for the string type which is in charge of computing the length of the char
+ * array. This is done with the cbps mecanism, explained in next section.
+ *
+ * If your types may contain pointer cycle, you must specify it to GRAS using the @ref gras_datadesc_cycle_set.
+ *
+ * Example:\verbatim
+ typedef struct {
+ unsigned char c1;
+ unsigned long int l1;
+ unsigned char c2;
+ unsigned long int l2;
+ } mystruct;
+ [...]
+ my_type=gras_datadesc_struct("mystruct");
+ gras_datadesc_struct_append(my_type,"c1", gras_datadesc_by_name("unsigned char"));
+ gras_datadesc_struct_append(my_type,"l1", gras_datadesc_by_name("unsigned long"));
+ gras_datadesc_struct_append(my_type,"c2", gras_datadesc_by_name("unsigned char"));
+ gras_datadesc_struct_append(my_type,"l2", gras_datadesc_by_name("unsigned long int"));
+ gras_datadesc_struct_close(my_type);
+
+ my_type=gras_datadesc_ref("mystruct*", gras_datadesc_by_name("mystruct"));
+
+ [Use my_type to send pointers to mystruct data]\endverbatim
+ */
+/*@{*/
+
+
+/** \brief Opaque type describing a type description callback persistant state. */
