First pass at replacing deprecated APIs in Glib 3 with the new names.

Pretty sad, hopefully we are moving away from Glib soon

svn path=/trunk/mono/; revision=142513

diff --git a/mono/dis/declsec.c b/mono/dis/declsec.c
index ff5ca5a59411fb90f57cb52f60f04ec5a59c66d6..93300c2b991e109340f4f754f0fac8d4cfdd63d7 100644 (file)
--- a/mono/dis/declsec.c
+++ b/mono/dis/declsec.c
@@ -37,10 +37,10 @@ declsec_20_get_classname (const char* p, const char **rptr)
        while ((*a++ != ',') && (apos++ < len));
 
        if (apos - cpos > 1) {
-               g_string_sprintfa (res, "[%.*s]%.*s", apos - cpos, c, cpos, p);
+               g_string_append_printf (res, "[%.*s]%.*s", apos - cpos, c, cpos, p);
        } else {
                /* in-assembly type aren't fully qualified (no comma) */
-               g_string_sprintfa (res, "%.*s", cpos - 1, p);
+               g_string_append_printf (res, "%.*s", cpos - 1, p);
        }
 
        p += len;
@@ -80,34 +80,34 @@ declsec_20_write_value (GString *str, char type, const char *value)
 {
        switch (type) {
        case MONO_TYPE_U1:
-               g_string_sprintfa (str, "%d", (unsigned char)*value);
+               g_string_append_printf (str, "%d", (unsigned char)*value);
                return value + 1;
        case MONO_TYPE_I1:
-               g_string_sprintfa (str, "%d", *value);
+               g_string_append_printf (str, "%d", *value);
                return value + 1;
        case MONO_TYPE_BOOLEAN:
-               g_string_sprintfa (str, "%s", *value ? "true" : "false");
+               g_string_append_printf (str, "%s", *value ? "true" : "false");
                return value + 1;
        case MONO_TYPE_CHAR:
-               g_string_sprintfa (str, "0x%04X", read16 (value));
+               g_string_append_printf (str, "0x%04X", read16 (value));
                return value + 2;
        case MONO_TYPE_U2:
-               g_string_sprintfa (str, "%d", read16 (value));
+               g_string_append_printf (str, "%d", read16 (value));
                return value + 2;
        case MONO_TYPE_I2:
-               g_string_sprintfa (str, "%d", (gint16)read16 (value));
+               g_string_append_printf (str, "%d", (gint16)read16 (value));
                return value + 2;
        case MONO_TYPE_U4:
-               g_string_sprintfa (str, "%d", read32 (value));
+               g_string_append_printf (str, "%d", read32 (value));
                return value + 4;
        case MONO_TYPE_I4:
-               g_string_sprintfa (str, "%d", (gint32)read32 (value));
+               g_string_append_printf (str, "%d", (gint32)read32 (value));
                return value + 4;
        case MONO_TYPE_U8:
-               g_string_sprintfa (str, "%lld", (long long)read64 (value));
+               g_string_append_printf (str, "%lld", (long long)read64 (value));
                return value + 8;
        case MONO_TYPE_I8:
-               g_string_sprintfa (str, "%lld", (long long)read64 (value));
+               g_string_append_printf (str, "%lld", (long long)read64 (value));
                return value + 8;
        case MONO_TYPE_R4: {
                float val;
@@ -115,13 +115,13 @@ declsec_20_write_value (GString *str, char type, const char *value)
                readr4 (value, &val);
                inf = isinf (val);
                if (inf == -1) 
-                       g_string_sprintfa (str, "0xFF800000"); /* negative infinity */
+                       g_string_append_printf (str, "0xFF800000"); /* negative infinity */
                else if (inf == 1)
-                       g_string_sprintfa (str, "0x7F800000"); /* positive infinity */
+                       g_string_append_printf (str, "0x7F800000"); /* positive infinity */
                else if (isnan (val))
-                       g_string_sprintfa (str, "0xFFC00000"); /* NaN */
+                       g_string_append_printf (str, "0xFFC00000"); /* NaN */
                else
-                       g_string_sprintfa (str, "%.8g", val);
+                       g_string_append_printf (str, "%.8g", val);
                return value + 4;
        }
        case MONO_TYPE_R8: {
@@ -130,13 +130,13 @@ declsec_20_write_value (GString *str, char type, const char *value)
                readr8 (value, &val);
                inf = isinf (val);
                if (inf == -1) 
-                       g_string_sprintfa (str, "0xFFF00000000000000"); /* negative infinity */
+                       g_string_append_printf (str, "0xFFF00000000000000"); /* negative infinity */
                else if (inf == 1)
-                       g_string_sprintfa (str, "0x7FFF0000000000000"); /* positive infinity */
+                       g_string_append_printf (str, "0x7FFF0000000000000"); /* positive infinity */
                else if (isnan (val))
-                       g_string_sprintfa (str, "0xFFF80000000000000"); /* NaN */
+                       g_string_append_printf (str, "0xFFF80000000000000"); /* NaN */
                else
-                       g_string_sprintfa (str, "%.17g", val);
+                       g_string_append_printf (str, "%.17g", val);
                return value + 8;
        }
        case MONO_TYPE_STRING:
@@ -145,7 +145,7 @@ declsec_20_write_value (GString *str, char type, const char *value)
                        return value + 1;
                } else {
                        int len = mono_metadata_decode_value (value, &value);
-                       g_string_sprintfa (str, "'%.*s'", len, value);
+                       g_string_append_printf (str, "'%.*s'", len, value);
                        return value + len;
                }
        case MONO_TYPE_SYSTEM_TYPE: {
@@ -178,7 +178,7 @@ dump_declsec_entry20 (MonoImage *m, const char* p, const char *indent)
                int len, j, pos = 0, param_len;
                char *param_start;
                char *s = declsec_20_get_classname (p, &p);
-               g_string_sprintfa (res, "%s = {", s);
+               g_string_append_printf (res, "%s = {", s);
                g_free (s);
 
                /* optional parameters length */
@@ -209,13 +209,13 @@ dump_declsec_entry20 (MonoImage *m, const char* p, const char *indent)
                        if (type == MONO_DECLSEC_ENUM) {
                                s = declsec_20_get_classname (p, &p);
                                len = mono_metadata_decode_value (p, &p);
-                               g_string_sprintfa (res, "enum %s '%.*s' = ", s, len, p);
+                               g_string_append_printf (res, "enum %s '%.*s' = ", s, len, p);
                                g_free (s);
                                p += len;
                                /* TODO: we must detect the size of the enum element (from the type ? length ?)
                                 * note: ildasm v2 has some problem decoding them too and doesn't
                                 * seems to rely on the type (as the other assembly isn't loaded) */
-                               g_string_sprintfa (res, "int32(%d)", read32 (p));
+                               g_string_append_printf (res, "int32(%d)", read32 (p));
                                p += 4;
                        } else {
                                int arraytype = 0;
@@ -226,7 +226,7 @@ dump_declsec_entry20 (MonoImage *m, const char* p, const char *indent)
                                declsec_20_write_type (res, type);
 
                                len = mono_metadata_decode_value (p, &p);
-                               g_string_sprintfa (res, " '%.*s' = ", len, p);
+                               g_string_append_printf (res, " '%.*s' = ", len, p);
                                p += len;
 
                                if (type == MONO_TYPE_SZARRAY) {
@@ -234,7 +234,7 @@ dump_declsec_entry20 (MonoImage *m, const char* p, const char *indent)
                                        declsec_20_write_type (res, type);
                                        elem = read32 (p);
                                        p += 4;
-                                       g_string_sprintfa (res, "[%d]", elem);
+                                       g_string_append_printf (res, "[%d]", elem);
                                } else {
                                        declsec_20_write_type (res, type);
                                        elem = 1;
@@ -250,7 +250,7 @@ dump_declsec_entry20 (MonoImage *m, const char* p, const char *indent)
                                }
                                
                                if (j < pos - 1)
-                                       g_string_sprintfa (res, ")\n%s", indent);
+                                       g_string_append_printf (res, ")\n%s", indent);
                                else
                                        g_string_append (res, ")");
                        }
@@ -258,7 +258,7 @@ dump_declsec_entry20 (MonoImage *m, const char* p, const char *indent)
                }
 
                if (i < num - 1)
-                       g_string_sprintfa (res, "},\n%s", indent);
+                       g_string_append_printf (res, "},\n%s", indent);
                else
                        g_string_append (res, "}");
 

diff --git a/mono/dis/dump.c b/mono/dis/dump.c
index 1171949a3c949eeb3fab0aa1acb5de1f9305836b..88ec39a4118e9e6764695e66221e2901ee3751bc 100644 (file)
--- a/mono/dis/dump.c
+++ b/mono/dis/dump.c
@@ -820,43 +820,43 @@ custom_attr_params (MonoImage *m, MonoMethodSignature* sig, const char* value)
 handle_enum:
                switch (type) {
                case MONO_TYPE_U1:
-                       g_string_sprintfa (res, "%d", (unsigned int)*p);
+                       g_string_append_printf (res, "%d", (unsigned int)*p);
                        ++p;
                        break;
                case MONO_TYPE_I1:
-                       g_string_sprintfa (res, "%d", *p);
+                       g_string_append_printf (res, "%d", *p);
                        ++p;
                        break;
                case MONO_TYPE_BOOLEAN:
-                       g_string_sprintfa (res, "%s", *p?"true":"false");
+                       g_string_append_printf (res, "%s", *p?"true":"false");
                        ++p;
                        break;
                case MONO_TYPE_CHAR:
-                       g_string_sprintfa (res, "'%c'", read16 (p));
+                       g_string_append_printf (res, "'%c'", read16 (p));
                        p += 2;
                        break;
                case MONO_TYPE_U2:
-                       g_string_sprintfa (res, "%d", read16 (p));
+                       g_string_append_printf (res, "%d", read16 (p));
                        p += 2;
                        break;
                case MONO_TYPE_I2:
-                       g_string_sprintfa (res, "%d", (gint16)read16 (p));
+                       g_string_append_printf (res, "%d", (gint16)read16 (p));
                        p += 2;
                        break;
                case MONO_TYPE_U4:
-                       g_string_sprintfa (res, "%d", read32 (p));
+                       g_string_append_printf (res, "%d", read32 (p));
                        p += 4;
                        break;
                case MONO_TYPE_I4:
-                       g_string_sprintfa (res, "%d", (gint32)read32 (p));
+                       g_string_append_printf (res, "%d", (gint32)read32 (p));
                        p += 4;
                        break;
                case MONO_TYPE_U8:
-                       g_string_sprintfa (res, "%lld", (long long)read64 (p));
+                       g_string_append_printf (res, "%lld", (long long)read64 (p));
                        p += 8;
                        break;
                case MONO_TYPE_I8:
-                       g_string_sprintfa (res, "%lld", (long long)read64 (p));
+                       g_string_append_printf (res, "%lld", (long long)read64 (p));
                        p += 8;
                        break;
                case MONO_TYPE_R4: {
@@ -865,13 +865,13 @@ handle_enum:
                        readr4 (p, &val);
                        inf = isinf (val);
                        if (inf == -1) 
-                               g_string_sprintfa (res, "(00 00 80 ff)"); /* negative infinity */
+                               g_string_append_printf (res, "(00 00 80 ff)"); /* negative infinity */
                        else if (inf == 1)
-                               g_string_sprintfa (res, "(00 00 80 7f)"); /* positive infinity */
+                               g_string_append_printf (res, "(00 00 80 7f)"); /* positive infinity */
                        else if (isnan (val))
-                               g_string_sprintfa (res, "(00 00 c0 ff)"); /* NaN */
+                               g_string_append_printf (res, "(00 00 c0 ff)"); /* NaN */
                        else
-                               g_string_sprintfa (res, "%g", val);
+                               g_string_append_printf (res, "%g", val);
                        p += 4;
                        break;
                }
@@ -882,13 +882,13 @@ handle_enum:
                        readr8 (p, &val);
                        inf = isinf (val);
                        if (inf == -1) 
-                               g_string_sprintfa (res, "(00 00 00 00 00 00 f0 ff)"); /* negative infinity */
+                               g_string_append_printf (res, "(00 00 00 00 00 00 f0 ff)"); /* negative infinity */
                        else if (inf == 1)
-                               g_string_sprintfa (res, "(00 00 00 00 00 00 f0 7f)"); /* positive infinity */
+                               g_string_append_printf (res, "(00 00 00 00 00 00 f0 7f)"); /* positive infinity */
                        else if (isnan (val))
-                               g_string_sprintfa (res, "(00 00 00 00 00 00 f8 ff)"); /* NaN */
+                               g_string_append_printf (res, "(00 00 00 00 00 00 f8 ff)"); /* NaN */
                        else
-                               g_string_sprintfa (res, "%g", val);
+                               g_string_append_printf (res, "%g", val);
                        p += 8;
                        break;
                }
@@ -920,10 +920,10 @@ handle_enum:
        }
        slen = read16 (p);
        if (slen) {
-               g_string_sprintfa (res, " %d named args: (", slen);
+               g_string_append_printf (res, " %d named args: (", slen);
                slen = len - (p - value) + 1;
                for (i = 0; i < slen; ++i) {
-                       g_string_sprintfa (res, " %02X", (p [i] & 0xff));
+                       g_string_append_printf (res, " %02X", (p [i] & 0xff));
                }
                g_string_append_c (res, ')');
        }

diff --git a/mono/dis/get.c b/mono/dis/get.c
index 0651772fc3439adc100c5e2fb43cb68faee679f5..47da3ecda36579922de6c0174192907f9808232a 100644 (file)
--- a/mono/dis/get.c
+++ b/mono/dis/get.c
@@ -125,12 +125,12 @@ stringify_array (guint32 rank, guint32 num_sizes, guint32 num_lo_bounds, gint32
                if (i)
                        g_string_append_c (res, ',');
                if (i < num_lo_bounds)
-                       g_string_sprintfa (res, "%d...", lo_bounds [i]);
+                       g_string_append_printf (res, "%d...", lo_bounds [i]);
                if (i < num_sizes) {
                        if (i < num_lo_bounds)
-                               g_string_sprintfa (res, "%d", lo_bounds [i] + sizes [i] - 1);
+                               g_string_append_printf (res, "%d", lo_bounds [i] + sizes [i] - 1);
                        else
-                               g_string_sprintfa (res, "%d", sizes [i]);
+                               g_string_append_printf (res, "%d", sizes [i]);
                }
 
        }
@@ -511,8 +511,8 @@ dis_stringify_modifiers (MonoImage *m, int n, MonoCustomMod *mod)
        for (i = 0; i < n; ++i) {
                char *tok = dis_stringify_token (m, mod[i].token);
                if (i > 0)
-                       g_string_sprintfa (s, " ");
-               g_string_sprintfa (s, " %s (%s)", mod[i].required ? "modreq": "modopt", tok);
+                       g_string_append_printf (s, " ");
+               g_string_append_printf (s, " %s (%s)", mod[i].required ? "modreq": "modopt", tok);
                g_free (tok);
        }
        g_string_append_c (s, ' ');
@@ -968,11 +968,11 @@ dis_stringify_method_signature_full (MonoImage *m, MonoMethodSignature *method,
        if (method->hasthis)
                g_string_append (result_ret, "instance ");
        g_string_append (result_ret, map (method->call_convention, call_conv_type_map));
-       g_string_sprintfa (result_ret, " %s%s ", retval, ret_marshal_info ? ret_marshal_info :"");
+       g_string_append_printf (result_ret, " %s%s ", retval, ret_marshal_info ? ret_marshal_info :"");
        g_free (ret_marshal_info);
        if (type) {
                char *estype = get_escaped_name (type);
-               g_string_sprintfa (result_ret, "%s::", estype);
+               g_string_append_printf (result_ret, "%s::", estype);
                g_free (estype);
                g_free (type);
        }
@@ -1013,7 +1013,7 @@ dis_stringify_function_ptr (MonoImage *m, MonoMethodSignature *method)
        g_string_append (result, map (method->call_convention, call_conv_type_map));
 
        retval = dis_stringify_param (m, method->ret);
-       g_string_sprintfa (result, " %s ", retval);
+       g_string_append_printf (result, " %s ", retval);
        g_free (retval);
 
        g_string_append (result, " *(");
@@ -2527,7 +2527,7 @@ dis_get_custom_attrs (MonoImage *m, guint32 token)
                len = mono_metadata_decode_value (val, &val);
                attr = g_string_new (".custom ");
                dump = data_dump (val, len, "\t\t");
-               g_string_sprintfa (attr, "%s = %s", method, dump);
+               g_string_append_printf (attr, "%s = %s", method, dump);
                g_free (dump);
                list = g_list_append (list, attr->str);
                g_string_free (attr, FALSE);

diff --git a/mono/dis/main.c b/mono/dis/main.c
index 64af63db2dd8e8724ec3956a84f73102fab2ec1a..c45a40774f34e1f17ed06a8acf35616aa0a4cc67 100644 (file)
--- a/mono/dis/main.c
+++ b/mono/dis/main.c
@@ -1016,7 +1016,7 @@ dis_property_signature (MonoImage *m, guint32 prop_idx, MonoGenericContainer *co
        if (prop_flags & 0x0400)
                g_string_append (res, "rtspecialname ");
        qk = get_escaped_name (name);
-       g_string_sprintfa (res, "%s %s (", blurb, qk);
+       g_string_append_printf (res, "%s %s (", blurb, qk);
        g_free (qk);
        g_free (blurb);
        for (i = 0; i < pcount; i++) {
@@ -1068,7 +1068,7 @@ dis_event_signature (MonoImage *m, guint32 event_idx, MonoGenericContainer *cont
                g_string_append (res, "specialname ");
        if (event_flags & 0x0400)
                g_string_append (res, "rtspecialname ");
-       g_string_sprintfa (res, "%s %s", type, esname);
+       g_string_append_printf (res, "%s %s", type, esname);
 
        g_free (type);
        g_free (esname);

diff --git a/mono/dis/util.c b/mono/dis/util.c
index 9357ef994c291ac2876d0540aabefe2e668abfcc..e5e467d09ffcb6914bd6f6814784dacfbfaa1e6d 100644 (file)
--- a/mono/dis/util.c
+++ b/mono/dis/util.c
@@ -91,32 +91,32 @@ data_dump (const char *data, int len, const char* prefix) {
        str = g_string_new (" (");
        for (i = 0; i + 15 < len; i += 16) {
                if (i == 0)
-                       g_string_sprintfa (str, "\n");
-               g_string_sprintfa (str, "%s", prefix);
+                       g_string_append_printf (str, "\n");
+               g_string_append_printf (str, "%s", prefix);
                for (j = 0; j < 16; ++j)
-                       g_string_sprintfa (str, "%02X ", (unsigned char) (data [i + j]));
-               g_string_sprintfa (str, i == len - 16? ") // ": "  // ");
+                       g_string_append_printf (str, "%02X ", (unsigned char) (data [i + j]));
+               g_string_append_printf (str, i == len - 16? ") // ": "  // ");
                for (j = 0; j < 16; ++j)
-                       g_string_sprintfa (str, "%c", data [i + j] >= 32 && data [i + j] <= 126? data [i + j]: '.');
-               g_string_sprintfa (str, "\n");
+                       g_string_append_printf (str, "%c", data [i + j] >= 32 && data [i + j] <= 126? data [i + j]: '.');
+               g_string_append_printf (str, "\n");
        }
        if (i == len)
                return g_string_free (str, FALSE);
        if (len > 16)
-               g_string_sprintfa (str, "%s", prefix);
+               g_string_append_printf (str, "%s", prefix);
        j = i;
        for (; i < len; ++i)
-               g_string_sprintfa (str, "%02X ", (unsigned char) (data [i]));
+               g_string_append_printf (str, "%02X ", (unsigned char) (data [i]));
        if (len > 16) {
                /* align */
                int count = 16 - (len % 16);
                for (i = 0; i < count; ++i)
-                       g_string_sprintfa (str, "   ");
+                       g_string_append_printf (str, "   ");
        }
-       g_string_sprintfa (str, ") // ");
+       g_string_append_printf (str, ") // ");
        for (i = j; i < len; ++i)
-               g_string_sprintfa (str, "%c", data [i] >= 32 && data [i] <= 126? data [i]: '.');
-       g_string_sprintfa (str, "\n");
+               g_string_append_printf (str, "%c", data [i] >= 32 && data [i] <= 126? data [i]: '.');
+       g_string_append_printf (str, "\n");
        return g_string_free (str, FALSE);
 }
 

diff --git a/mono/interpreter/interp.c b/mono/interpreter/interp.c
index 2cc5b1598604e12f08004b5ab42c69b887d1dae0..fb437d0ccb9106f34cd89fbe4cc92fa84d5d1182 100644 (file)
--- a/mono/interpreter/interp.c
+++ b/mono/interpreter/interp.c
@@ -833,7 +833,7 @@ dump_stack (stackval *stack, stackval *sp)
                return g_string_free (str, FALSE);
        
        while (s < sp) {
-               g_string_sprintfa (str, "[%lld/0x%0llx] ", s->data.l, s->data.l);
+               g_string_append_printf (str, "[%lld/0x%0llx] ", s->data.l, s->data.l);
                ++s;
        }
        return g_string_free (str, FALSE);
@@ -851,7 +851,7 @@ dump_stackval (GString *str, stackval *s, MonoType *type)
        case MONO_TYPE_U4:
        case MONO_TYPE_CHAR:
        case MONO_TYPE_BOOLEAN:
-               g_string_sprintfa (str, "[%d] ", s->data.i);
+               g_string_append_printf (str, "[%d] ", s->data.i);
                break;
        case MONO_TYPE_STRING:
        case MONO_TYPE_SZARRAY:
@@ -861,22 +861,22 @@ dump_stackval (GString *str, stackval *s, MonoType *type)
        case MONO_TYPE_PTR:
        case MONO_TYPE_I:
        case MONO_TYPE_U:
-               g_string_sprintfa (str, "[%p] ", s->data.p);
+               g_string_append_printf (str, "[%p] ", s->data.p);
                break;
        case MONO_TYPE_VALUETYPE:
                if (type->data.klass->enumtype)
-                       g_string_sprintfa (str, "[%d] ", s->data.i);
+                       g_string_append_printf (str, "[%d] ", s->data.i);
                else
-                       g_string_sprintfa (str, "[vt:%p] ", s->data.p);
+                       g_string_append_printf (str, "[vt:%p] ", s->data.p);
                break;
        case MONO_TYPE_R4:
        case MONO_TYPE_R8:
-               g_string_sprintfa (str, "[%g] ", s->data.f);
+               g_string_append_printf (str, "[%g] ", s->data.f);
                break;
        case MONO_TYPE_I8:
        case MONO_TYPE_U8:
        default:
-               g_string_sprintfa (str, "[%lld/0x%0llx] ", s->data.l, s->data.l);
+               g_string_append_printf (str, "[%lld/0x%0llx] ", s->data.l, s->data.l);
                break;
        }
 }
@@ -892,7 +892,7 @@ dump_args (MonoInvocation *inv)
                return g_string_free (str, FALSE);
 
        if (signature->hasthis)
-               g_string_sprintfa (str, "%p ", inv->obj);
+               g_string_append_printf (str, "%p ", inv->obj);
 
        for (i = 0; i < signature->param_count; ++i)
                dump_stackval (str, inv->stack_args + i, signature->params [i]);
@@ -947,10 +947,10 @@ dump_frame (MonoInvocation *inv)
                        args = dump_args (inv);
                        name = mono_method_full_name (method, TRUE);
                        if (source)
-                               g_string_sprintfa (str, "#%d: 0x%05x %-10s in %s (%s) at %s\n", i, codep, opname,
+                               g_string_append_printf (str, "#%d: 0x%05x %-10s in %s (%s) at %s\n", i, codep, opname,
                                                   name, args, source);
                        else
-                               g_string_sprintfa (str, "#%d: 0x%05x %-10s in %s (%s)\n", i, codep, opname,
+                               g_string_append_printf (str, "#%d: 0x%05x %-10s in %s (%s)\n", i, codep, opname,
                                                   name, args);
                        g_free (name);
                        g_free (args);

diff --git a/mono/metadata/debug-helpers.c b/mono/metadata/debug-helpers.c
index a2a0a7af7f9493a87b687ae6325c7f678972fab4..61883ed13d01fcd9064d16a196fc6679028380b9 100644 (file)
--- a/mono/metadata/debug-helpers.c
+++ b/mono/metadata/debug-helpers.c
@@ -82,8 +82,8 @@ append_class_name (GString *res, MonoClass *class, gboolean include_namespace)
                g_string_append_c (res, '/');
        }
        if (include_namespace && *(class->name_space))
-               g_string_sprintfa (res, "%s.", class->name_space);
-       g_string_sprintfa (res, "%s", class->name);
+               g_string_append_printf (res, "%s.", class->name_space);
+       g_string_append_printf (res, "%s", class->name);
 }
 
 void
@@ -134,7 +134,7 @@ mono_type_get_desc (GString *res, MonoType *type, gboolean include_namespace)
                break;
        case MONO_TYPE_ARRAY:
                mono_type_get_desc (res, &type->data.array->eklass->byval_arg, include_namespace);
-               g_string_sprintfa (res, "[%d]", type->data.array->rank);
+               g_string_append_printf (res, "[%d]", type->data.array->rank);
                break;
        case MONO_TYPE_SZARRAY:
                mono_type_get_desc (res, &type->data.klass->byval_arg, include_namespace);
@@ -502,12 +502,12 @@ dis_one (GString *str, MonoDisHelper *dh, MonoMethod *method, const unsigned cha
                g_free (tmp);
        }
        if (dh->label_format)
-               g_string_sprintfa (str, dh->label_format, label);
+               g_string_append_printf (str, dh->label_format, label);
        
        i = mono_opcode_value (&ip, end);
        ip++;
        opcode = &mono_opcodes [i];
-       g_string_sprintfa (str, "%-10s", mono_opcode_name (i));
+       g_string_append_printf (str, "%-10s", mono_opcode_name (i));
 
        switch (opcode->argument) {
        case MonoInlineNone:
@@ -523,7 +523,7 @@ dis_one (GString *str, MonoDisHelper *dh, MonoMethod *method, const unsigned cha
                        g_string_append (str, tmp);
                        g_free (tmp);
                } else {
-                       g_string_sprintfa (str, "0x%08x", token);
+                       g_string_append_printf (str, "0x%08x", token);
                }
                ip += 4;
                break;
@@ -553,35 +553,35 @@ dis_one (GString *str, MonoDisHelper *dh, MonoMethod *method, const unsigned cha
                                s = g_utf16_to_utf8 ((gunichar2*)blob, len2, NULL, NULL, NULL);
 #endif
 
-                       g_string_sprintfa (str, "\"%s\"", s);
+                       g_string_append_printf (str, "\"%s\"", s);
                        g_free (s);
                }
                ip += 4;
                break;
        }
        case MonoInlineVar:
-               g_string_sprintfa (str, "%d", read16 (ip));
+               g_string_append_printf (str, "%d", read16 (ip));
                ip += 2;
                break;
        case MonoShortInlineVar:
-               g_string_sprintfa (str, "%d", (*ip));
+               g_string_append_printf (str, "%d", (*ip));
                ip ++;
                break;
        case MonoInlineBrTarget:
                sval = read32 (ip);
                ip += 4;
                if (dh->label_target)
-                       g_string_sprintfa (str, dh->label_target, ip + sval - il_code);
+                       g_string_append_printf (str, dh->label_target, ip + sval - il_code);
                else
-                       g_string_sprintfa (str, "%d", sval);
+                       g_string_append_printf (str, "%d", sval);
                break;
        case MonoShortInlineBrTarget:
                sval = *(const signed char*)ip;
                ip ++;
                if (dh->label_target)
-                       g_string_sprintfa (str, dh->label_target, ip + sval - il_code);
+                       g_string_append_printf (str, dh->label_target, ip + sval - il_code);
                else
-                       g_string_sprintfa (str, "%d", sval);
+                       g_string_append_printf (str, "%d", sval);
                break;
        case MonoInlineSwitch: {
                const unsigned char *end;
@@ -594,9 +594,9 @@ dis_one (GString *str, MonoDisHelper *dh, MonoMethod *method, const unsigned cha
                                g_string_append (str, ", ");
                        label = read32 (ip);
                        if (dh->label_target)
-                               g_string_sprintfa (str, dh->label_target, end + label - il_code);
+                               g_string_append_printf (str, dh->label_target, end + label - il_code);
                        else
-                               g_string_sprintfa (str, "%d", label);
+                               g_string_append_printf (str, "%d", label);
                        ip += 4;
                }
                g_string_append_c (str, ')');
@@ -605,23 +605,23 @@ dis_one (GString *str, MonoDisHelper *dh, MonoMethod *method, const unsigned cha
        case MonoInlineR: {
                double r;
                readr8 (ip, &r);
-               g_string_sprintfa (str, "%g", r);
+               g_string_append_printf (str, "%g", r);
                ip += 8;
                break;
        }
        case MonoShortInlineR: {
                float r;
                readr4 (ip, &r);
-               g_string_sprintfa (str, "%g", r);
+               g_string_append_printf (str, "%g", r);
                ip += 4;
                break;
        }
        case MonoInlineI:
-               g_string_sprintfa (str, "%d", (gint32)read32 (ip));
+               g_string_append_printf (str, "%d", (gint32)read32 (ip));
                ip += 4;
                break;
        case MonoShortInlineI:
-               g_string_sprintfa (str, "%d", *(const signed char*)ip);
+               g_string_append_printf (str, "%d", *(const signed char*)ip);
                ip ++;
                break;
        case MonoInlineI8:

diff --git a/mono/monograph/monograph.c b/mono/monograph/monograph.c
index 5451b8b54f33146c699460c7f89329d88f65fa5f..58e25335c61b31098f18e2a7f52136a2b864c65b 100644 (file)
--- a/mono/monograph/monograph.c
+++ b/mono/monograph/monograph.c
@@ -550,9 +550,9 @@ get_signature (MonoMethod *method) {
 
        res = g_string_new ("");
        if (include_namespace && *(method->klass->name_space))
-               g_string_sprintfa (res, "%s.", method->klass->name_space);
+               g_string_append_printf (res, "%s.", method->klass->name_space);
        result = mono_signature_get_desc (mono_method_signature (method), include_namespace);
-       g_string_sprintfa (res, "%s:%s(%s)", method->klass->name, method->name, result);
+       g_string_append_printf (res, "%s:%s(%s)", method->klass->name, method->name, result);
        g_free (result);
        g_hash_table_insert (hash, method, res->str);
 
@@ -1147,10 +1147,10 @@ main (int argc, char *argv[]) {
 
                if (outputfile) {
                        type = strrchr (outputfile, '.');
-                       g_string_sprintfa (command, " -o %s", outputfile);
+                       g_string_append_printf (command, " -o %s", outputfile);
                }
                if (type)
-                       g_string_sprintfa (command, " -T%s", type + 1);
+                       g_string_append_printf (command, " -T%s", type + 1);
                output = popen (command->str, "w");
                if (!output) {
                        g_print ("Cannot run neato: you may need to install the graphviz package.\n");