pidgin3: comparison libpurple/protocols/myspace/message.c

-:d11321258152
+:b3b072dd8478
 * @param not_empty FALSE if message is empty, TRUE if variadic arguments follow.
 * @param ... A sequence of gchar* key/type/value triplets, terminated with NULL.
 *
 * See msim_msg_append() documentation for details on types.
 */
-MsimMessage *msim_msg_new(gboolean not_empty, ...)
+MsimMessage *
+msim_msg_new(gboolean not_empty, ...)
 {
 	va_list argp;
 	va_start(argp, not_empty);
 * @param argp A va_list of variadic arguments, already started with va_start(). Will be va_end()'d.
 * @return New MsimMessage *, must be freed with msim_msg_free().
 *
 * For internal use - users probably want msim_msg_new() or msim_send().
 */
-static MsimMessage *msim_msg_new_v(va_list argp)
+static MsimMessage *
+msim_msg_new_v(va_list argp)
 {
 	gchar *key, *value;
 	MsimMessageType type;
 	GString *gs;
 	MsimMessage *msg;
 /** Clone an individual element.
 *
 * @param data MsimMessageElement * to clone.
 * @param user_data Pointer to MsimMessage * to add cloned element to.
 */
-static void msim_msg_clone_element(gpointer data, gpointer user_data)
+static void
+msim_msg_clone_element(gpointer data, gpointer user_data)
 {
 	MsimMessageElement *elem;
 	MsimMessage **new;
 	gpointer new_data;
 /** Clone an existing MsimMessage.
 *
 * @return Cloned message; caller should free with msim_msg_free().
 */
-MsimMessage *msim_msg_clone(MsimMessage *old)
+MsimMessage *
+msim_msg_clone(MsimMessage *old)
 {
 	MsimMessage *new;
 	if (old == NULL)
 		return NULL;
 /** Free an individual message element.
 *
 * @param data MsimMessageElement * to free.
 * @param user_data Not used; required to match g_list_foreach() callback prototype.
 */
-static void msim_msg_free_element(gpointer data, gpointer user_data)
+static void
+msim_msg_free_element(gpointer data, gpointer user_data)
 {
 	MsimMessageElement *elem;
 	elem = (MsimMessageElement *)data;
 	g_free(elem);
 }
 /** Free a complete message. */
-void msim_msg_free(MsimMessage *msg)
+void
+msim_msg_free(MsimMessage *msg)
 {
 	if (!msg)
 	{
 		/* already free as can be */
 		return;
 	g_list_foreach(msg, msim_msg_free_element, NULL);
 	g_list_free(msg);
 }
 /** Send an existing MsimMessage. */
-gboolean msim_msg_send(MsimSession *session, MsimMessage *msg)
+gboolean
+msim_msg_send(MsimSession *session, MsimMessage *msg)
 {
 	gchar *raw;
 	gboolean success;
 	raw = msim_msg_pack(msg);
 * and sent in one line of code. Internally it calls msim_msg_send().
 *
 * IMPORTANT: See msim_msg_append() documentation for details on element types.
 *
 */
-gboolean msim_send(MsimSession *session, ...)
+gboolean
+msim_send(MsimSession *session, ...)
 {
 	gboolean success;
 	MsimMessage *msg;
 	va_list argp;
 /** Create a new MsimMessageElement * - must be g_free()'d.
 *
 * For internal use; users probably want msim_msg_append() or msim_msg_insert_before().
 */
-static MsimMessageElement *msim_msg_element_new(const gchar *name, MsimMessageType type, gpointer data)
+static MsimMessageElement *
+msim_msg_element_new(const gchar *name, MsimMessageType type, gpointer data)
 {
 	MsimMessageElement *elem;
 	elem = g_new0(MsimMessageElement, 1);
 * * MSIM_TYPE_DICTIONARY: TODO
 *
 * * MSIM_TYPE_LIST: TODO
 *
 * */
-MsimMessage *msim_msg_append(MsimMessage *msg, const gchar *name, MsimMessageType type, gpointer data)
+MsimMessage *
+msim_msg_append(MsimMessage *msg, const gchar *name,
+		MsimMessageType type, gpointer data)
 {
 	return g_list_append(msg, msim_msg_element_new(name, type, data));
 }
 /** Insert a new element into a message, before the given element name.
 * @param name_before Name of the element to insert the new element before. If
 * 					  could not be found or NULL, new element will be inserted at end.
 *
 * See msim_msg_append() for usage of other parameters, and an important note about return value.
 */
-MsimMessage *msim_msg_insert_before(MsimMessage *msg, const gchar *name_before, const gchar *name, MsimMessageType type, gpointer data)
+MsimMessage *
+msim_msg_insert_before(MsimMessage *msg, const gchar *name_before,
+		const gchar *name, MsimMessageType type, gpointer data)
 {
 	MsimMessageElement *new_elem;
 	GList *node_before;
 	new_elem = msim_msg_element_new(name, type, data);
 }
 /** Pack a string using the given GFunc and seperator.
 * Used by msim_msg_dump() and msim_msg_pack().
 */
-gchar *msim_msg_pack_using(MsimMessage *msg, GFunc gf, const gchar *sep, const gchar *begin, const gchar *end)
+gchar *
+msim_msg_pack_using(MsimMessage *msg, GFunc gf, const gchar *sep,
+		const gchar *begin, const gchar *end)
 {
 	gchar **strings;
 	gchar **strings_tmp;
 	gchar *joined;
 	gchar *final;
 /** Store a human-readable string describing the element.
 *
 * @param data Pointer to an MsimMessageElement.
 * @param user_data
 */
-static void msim_msg_debug_string_element(gpointer data, gpointer user_data)
+static void
+msim_msg_debug_string_element(gpointer data, gpointer user_data)
 {
 	MsimMessageElement *elem;
 	gchar *string;
 	GString *gs;
 	gchar *binary;
 /** Print a human-readable string of the message to Purple's debug log.
 *
 * @param fmt_string A static string, in which '%s' will be replaced.
 */
-void msim_msg_dump(const gchar *fmt_string, MsimMessage *msg)
+void
+msim_msg_dump(const gchar *fmt_string, MsimMessage *msg)
 {
 	gchar *debug_str;
 	if (!msg)
 	{
 *
 * Returns a string suitable for inclusion in a raw protocol message, not necessarily
 * optimal for human consumption. For example, strings are escaped. Use
 * msim_msg_get_string() if you want a string, which in some cases is same as this.
 */
-static gchar *msim_msg_pack_element_data(MsimMessageElement *elem)
+static gchar *
+msim_msg_pack_element_data(MsimMessageElement *elem)
 {
 	switch (elem->type)
 	{
 		case MSIM_TYPE_INTEGER:
 			return g_strdup_printf("%d", GPOINTER_TO_UINT(elem->data));
 * Called by msim_msg_pack(). Will pack the MsimMessageElement into
 * a part of the protocol string and append it to the array. Caller
 * is responsible for creating array to correct dimensions, and
 * freeing each string element of the array added by this function.
 */
-static void msim_msg_pack_element(gpointer data, gpointer user_data)
+static void
+msim_msg_pack_element(gpointer data, gpointer user_data)
 {
 	MsimMessageElement *elem;
 	gchar *string, *data_string;
 	gchar ***items;
 /** Return a packed string suitable for sending over the wire.
 *
 * @return A string. Caller must g_free().
 */
-gchar *msim_msg_pack(MsimMessage *msg)
+gchar *
+msim_msg_pack(MsimMessage *msg)
 {
 	g_return_val_if_fail(msg != NULL, NULL);
 	return msim_msg_pack_using(msg, msim_msg_pack_element, "\\", "\\", "\\final\\");
 }
 *
 * @param raw The raw message string to parse, will be g_free()'d.
 *
 * @return MsimMessage *. Caller should msim_msg_free() when done.
 */
-MsimMessage *msim_parse(gchar *raw)
+MsimMessage *
+msim_parse(gchar *raw)
 {
 	MsimMessage *msg;
 gchar *token;
 gchar **tokens;
 gchar *key;
 * @param body_str The text of the dictionary to parse. Often the
 *                  value for the 'body' field.
 *
 * @return Hash table of the keys and values. Must g_hash_table_destroy() when done.
 */
-GHashTable *msim_parse_body(const gchar *body_str)
+GHashTable *
+msim_parse_body(const gchar *body_str)
 {
 GHashTable *table;
 gchar *item;
 gchar **items;
 gchar **elements;
 *
 * For internal use - users probably want to use msim_msg_get() to
 * access the MsimMessageElement *, instead of the GList * container.
 *
 */
-static GList *msim_msg_get_node(MsimMessage *msg, const gchar *name)
+static GList *
+msim_msg_get_node(MsimMessage *msg, const gchar *name)
 {
 	GList *i;
 	if (!name)
 	{
 		if (strcmp(elem->name, name) == 0)
 			return i;
 	}
 	return NULL;
 }
 /** Return the first MsimMessageElement * with given name in the MsimMessage *.
 *
 * @param name Name to search for.
 *
 *
 * Note: useful fields of MsimMessageElement are 'data' and 'type', which
 * you can access directly. But it is often more convenient to use
 * another msim_msg_get_* that converts the data to what type you want.
 */
-MsimMessageElement *msim_msg_get(MsimMessage *msg, const gchar *name)
+MsimMessageElement *
+msim_msg_get(MsimMessage *msg, const gchar *name)
 {
 	GList *node;
 	node = msim_msg_get_node(msg, name);
 	if (node)
 *
 * Note that msim_msg_pack_element_data() is similar, but returns a string
 * for inclusion into a raw protocol string (escaped and everything).
 * This function unescapes the string for you, if needed.
 */
-gchar *msim_msg_get_string(MsimMessage *msg, const gchar *name)
+gchar *
+msim_msg_get_string(MsimMessage *msg, const gchar *name)
 {
 	MsimMessageElement *elem;
 	elem = msim_msg_get(msg, name);
 	if (!elem)
 *
 * Useful to obtain an element's data if you know it should be an integer,
 * even if it is not stored as an MSIM_TYPE_INTEGER. MSIM_TYPE_STRING will
 * be converted handled correctly, for example.
 */
-guint msim_msg_get_integer(MsimMessage *msg, const gchar *name)
+guint
+msim_msg_get_integer(MsimMessage *msg, const gchar *name)
 {
 	MsimMessageElement *elem;
 	elem = msim_msg_get(msg, name);
 *
 * @param binary_length A pointer to an integer, which will be set to the binary data length.
 *
 * @return TRUE if successful, FALSE if not.
 */
-gboolean msim_msg_get_binary(MsimMessage *msg, const gchar *name, gchar **binary_data, gsize *binary_length)
+gboolean
+msim_msg_get_binary(MsimMessage *msg, const gchar *name,
+		gchar **binary_data, gsize *binary_length)
 {
 	MsimMessageElement *elem;
 	elem = msim_msg_get(msg, name);

Mercurial > pidgin3 / file comparison

comparison: libpurple/protocols/myspace/message.c

libpurple/protocols/myspace/message.c