~ubuntu-branches/ubuntu/precise/gccgo-4.7/precise

« back to all changes in this revision

Viewing changes to debian/patches/fix-warnings.diff

  • Committer: Package Import Robot
  • Author(s): Matthias Klose
  • Date: 2012-03-11 19:37:32 UTC
  • Revision ID: package-import@ubuntu.com-20120311193732-ty08ntcphseuouao
Tags: 4.7.0~rc1-0ubuntu1
* Build standalone gccgo-4.7 packages.
* libgo: Work around parse error of struct timex_ on ARM.

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# DP: Fix warnings with -D_FORTIFY_SOURCE and -Wformat-security.
 
2
 
 
3
libcpp/
 
4
 
 
5
        * macro.c (create_iso_definition): Avoid warnings with
 
6
        -Wformat-security.
 
7
        * lex.c (cpp_output_token): Avoid warnings with -D_FORTIFY_SOURCE.
 
8
 
 
9
gcc/
 
10
 
 
11
        * toplev.c (print_to_asm_out_file, print_to_stderr): Avoid warnings with
 
12
        -Wformat-security, (pch_option_mismatch) avoid warnings with
 
13
        -D_FORTIFY_SOURCE.
 
14
 
 
15
        * c-convert.c (convert): Avoid warnings with -Wformat-security.
 
16
        * c-typeck.c (convert_arguments, build_unary_op, build_binary_op): Likewise.
 
17
        * c-common.c (c_parse_error): Likewise.
 
18
        * cfg.c (dump_cfg_bb_info): Likewise.
 
19
        * fold-const.c (fold_overflow_warning): Likewise.
 
20
        * ira-conflicts.c (print_hard_reg_set): Likewise.
 
21
        * opts.c (print_filtered_help): Likewise.
 
22
        * tree-switch-conversion.c (do_switchconv): Likewise.
 
23
        * collect2.c (collect_execute, scan_prog_file): Likewise.
 
24
 
 
25
        * c-ppoutput.c (print_lines_directives_only,scan_translation_unit_trad):
 
26
        Avoid warnings with -D_FORTIFY_SOURCE.
 
27
        * dbxout.c (dbxout_finish_complex_stabs): Likewise.
 
28
        * diagnostic.c (build_message_string): Likewise.
 
29
        * final.c (output_operand_lossage): Likewise.
 
30
        * tree-data-ref.c (dot_rdg): Likewise.
 
31
        * tree-ssa-structalias.c (create_function_info_for,
 
32
        create_variable_info_for): Likewise.
 
33
 
 
34
gcc/cp/
 
35
 
 
36
        * pt.c (tsubst_copy_and_build): Avoid warnings with -Wformat-security.
 
37
        * parser.c (cp_parser_check_type_definition,
 
38
        cp_parser_non_integral_constant_expression): Likewise.
 
39
        * typeck.c (cp_build_binary_op, cp_build_unary_op): Likewise.
 
40
        * cvt.c (ocp_convert): Likewise.
 
41
 
 
42
gcc/fortran/
 
43
 
 
44
        * cpp.c (scan_translation_unit_trad): Avoid warnings with -D_FORTIFY_SOURCE.
 
45
        * trans.c (gfc_trans_runtime_error_vararg): Likewise.
 
46
        * trans-array.c (gfc_trans_array_bound_check, gfc_conv_array_ref,
 
47
        gfc_conv_ss_startstride, gfc_trans_dummy_array_bias,
 
48
        gfc_conv_array_parameter): Likewise.
 
49
        * trans-io.c (gfc_trans_io_runtime_check, set_string): Likewise.
 
50
        * trans-expr.c (gfc_conv_substring): Likewise.
 
51
 
 
52
        * decl.c (gfc_match_kind_spec, match_char_kind): Avoid warnings with
 
53
        -Wformat-security.
 
54
        * intrinsic.c (add_sym, find_sym, make_alias): Likewise.
 
55
        * match.c (gfc_match_small_int, gfc_match_small_int_expr): Likewise.
 
56
        * matchexp.c (match_primary, match_level_2, match_level_3,
 
57
        match_level_4, match_or_operand, match_equiv_operand, match_level_5,
 
58
        gfc_match_expr): Likewise.
 
59
        * module.c (find_true_name, mio_pool_string, mio_symtree_ref, mio_expr,
 
60
        load_generic_interfaces, load_needed, read_module, write_symbol0,
 
61
        write_generic, import_iso_c_binding_module, create_int_parameter,
 
62
        use_iso_fortran_env_module, gfc_use_module): Likewise.
 
63
        * openmp.c (gfc_match_omp_clauses): Likewise.
 
64
        * primary.c (match_hollerith_constant, match_string_constant,
 
65
        match_keyword_arg): Likewise.
 
66
        * symbol.c (gfc_add_component, gfc_new_symtree, gfc_delete_symtree,
 
67
        gfc_get_uop, gfc_new_symbol, gfc_get_gsymbol, gen_special_c_interop_ptr,
 
68
        gen_cptr_param, gen_fptr_param, gen_shape_param,
 
69
        generate_isocbinding_symbol, get_iso_c_sym): Likewise.
 
70
        * trans-decl.c (gfc_find_module): Likewise.
 
71
 
 
72
gcc/objc/
 
73
 
 
74
        * objc-act.c (objc_lookup_protocol): Avoid warnings with
 
75
        -Wformat-security.
 
76
 
 
77
---
 
78
 gcc/c-common.c               |    4 +-
 
79
 gcc/c-convert.c              |    2 +-
 
80
 gcc/c-ppoutput.c             |    6 ++-
 
81
 gcc/c-typeck.c               |    6 +-
 
82
 gcc/cfg.c                    |    2 +-
 
83
 gcc/collect2.c               |    8 ++--
 
84
 gcc/cp/cvt.c                 |    2 +-
 
85
 gcc/cp/parser.c              |    4 +-
 
86
 gcc/cp/pt.c                  |    2 +-
 
87
 gcc/cp/typeck.c              |    4 +-
 
88
 gcc/dbxout.c                 |    5 +-
 
89
 gcc/diagnostic.c             |    3 +-
 
90
 gcc/final.c                  |    5 +-
 
91
 gcc/fold-const.c             |    2 +-
 
92
 gcc/fortran/cpp.c            |    3 +-
 
93
 gcc/fortran/decl.c           |    4 +-
 
94
 gcc/fortran/intrinsic.c      |    8 ++--
 
95
 gcc/fortran/match.c          |    4 +-
 
96
 gcc/fortran/matchexp.c       |   18 ++++----
 
97
 gcc/fortran/module.c         |   30 +++++++-------
 
98
 gcc/fortran/openmp.c         |    2 +-
 
99
 gcc/fortran/primary.c        |    6 +-
 
100
 gcc/fortran/symbol.c         |   24 +++++-----
 
101
 gcc/fortran/trans-array.c    |   94 +++++++++++++++++++++++++----------------
 
102
 gcc/fortran/trans-decl.c     |    2 +-
 
103
 gcc/fortran/trans-expr.c     |   22 ++++++----
 
104
 gcc/fortran/trans-io.c       |    9 +++-
 
105
 gcc/fortran/trans.c          |   11 +++--
 
106
 gcc/ira-conflicts.c          |    2 +-
 
107
 gcc/objc/objc-act.c          |    2 +-
 
108
 gcc/opts.c                   |    2 +-
 
109
 gcc/toplev.c                 |    9 +++-
 
110
 gcc/tree-data-ref.c          |    3 +-
 
111
 gcc/tree-ssa-structalias.c   |   13 ++++--
 
112
 gcc/tree-switch-conversion.c |    2 +-
 
113
 libcpp/lex.c                 |    6 ++-
 
114
 libcpp/macro.c               |    4 +-
 
115
 37 files changed, 190 insertions(+), 145 deletions(-)
 
116
 
 
117
--- a/src/gcc/c-common.c
 
118
+++ b/src/gcc/c-common.c
 
119
@@ -7493,11 +7493,11 @@ c_parse_error (const char *gmsgid, enum cpp_ttype token, tree value)
 
120
       message = NULL;
 
121
     }
 
122
   else
 
123
-    error (gmsgid);
 
124
+    error ("%s", gmsgid);
 
125
 
 
126
   if (message)
 
127
     {
 
128
-      error (message);
 
129
+      error ("%s", message);
 
130
       free (message);
 
131
     }
 
132
 #undef catenate_messages
 
133
--- a/src/gcc/c-convert.c
 
134
+++ b/src/gcc/c-convert.c
 
135
@@ -79,7 +79,7 @@ convert (tree type, tree expr)
 
136
   if ((invalid_conv_diag
 
137
        = targetm.invalid_conversion (TREE_TYPE (expr), type)))
 
138
     {
 
139
-      error (invalid_conv_diag);
 
140
+      error ("%s", invalid_conv_diag);
 
141
       return error_mark_node;
 
142
     }
 
143
 
 
144
--- a/src/gcc/c-ppoutput.c
 
145
+++ b/src/gcc/c-ppoutput.c
 
146
@@ -223,8 +223,9 @@ scan_translation_unit (cpp_reader *pfile)
 
147
 static void
 
148
 print_lines_directives_only (int lines, const void *buf, size_t size)
 
149
 {
 
150
+  size_t rv_neverused ATTRIBUTE_UNUSED;
 
151
   print.src_line += lines;
 
152
-  fwrite (buf, 1, size, print.outf);
 
153
+  rv_neverused = fwrite (buf, 1, size, print.outf);
 
154
 }
 
155
 
 
156
 /* Writes out the preprocessed file, handling spacing and paste
 
157
@@ -256,8 +257,9 @@ scan_translation_unit_trad (cpp_reader *pfile)
 
158
   while (_cpp_read_logical_line_trad (pfile))
 
159
     {
 
160
       size_t len = pfile->out.cur - pfile->out.base;
 
161
+      size_t rv_neverused ATTRIBUTE_UNUSED;
 
162
       maybe_print_line (pfile->out.first_line);
 
163
-      fwrite (pfile->out.base, 1, len, print.outf);
 
164
+      rv_neverused = fwrite (pfile->out.base, 1, len, print.outf);
 
165
       print.printed = 1;
 
166
       if (!CPP_OPTION (pfile, discard_comments))
 
167
        account_for_newlines (pfile->out.base, len);
 
168
--- a/src/gcc/c-typeck.c
 
169
+++ b/src/gcc/c-typeck.c
 
170
@@ -2730,7 +2730,7 @@ convert_arguments (int nargs, tree *argarray,
 
171
       else if ((invalid_func_diag =
 
172
                targetm.calls.invalid_arg_for_unprototyped_fn (typelist, fundecl, val)))
 
173
        {
 
174
-         error (invalid_func_diag);
 
175
+         error ("%s", invalid_func_diag);
 
176
          return -1;
 
177
        }
 
178
       else
 
179
@@ -2947,7 +2947,7 @@ build_unary_op (location_t location,
 
180
   if ((invalid_op_diag
 
181
        = targetm.invalid_unary_op (code, TREE_TYPE (xarg))))
 
182
     {
 
183
-      error_at (location, invalid_op_diag);
 
184
+      error_at (location, "%s", invalid_op_diag);
 
185
       return error_mark_node;
 
186
     }
 
187
 
 
188
@@ -8095,7 +8095,7 @@ build_binary_op (location_t location, enum tree_code code,
 
189
   if ((invalid_op_diag
 
190
        = targetm.invalid_binary_op (code, type0, type1)))
 
191
     {
 
192
-      error_at (location, invalid_op_diag);
 
193
+      error_at (location, "%s", invalid_op_diag);
 
194
       return error_mark_node;
 
195
     }
 
196
 
 
197
--- a/src/gcc/cfg.c
 
198
+++ b/src/gcc/cfg.c
 
199
@@ -908,7 +908,7 @@ dump_cfg_bb_info (FILE *file, basic_block bb)
 
200
        else
 
201
          fprintf (file, ", ");
 
202
        first = false;
 
203
-       fprintf (file, bb_bitnames[i]);
 
204
+       fprintf (file, "%s", bb_bitnames[i]);
 
205
       }
 
206
   if (!first)
 
207
     fprintf (file, ")");
 
208
--- a/src/gcc/collect2.c
 
209
+++ b/src/gcc/collect2.c
 
210
@@ -1647,10 +1647,10 @@ collect_execute (const char *prog, char **argv, const char *outname,
 
211
       if (err != 0)
 
212
        {
 
213
          errno = err;
 
214
-         fatal_perror (errmsg);
 
215
+         fatal_perror ("%s", errmsg);
 
216
        }
 
217
       else
 
218
-       fatal (errmsg);
 
219
+       fatal ("%s", errmsg);
 
220
     }
 
221
 
 
222
   if (response_arg)
 
223
@@ -2137,10 +2137,10 @@ scan_prog_file (const char *prog_name, enum pass which_pass)
 
224
       if (err != 0)
 
225
        {
 
226
          errno = err;
 
227
-         fatal_perror (errmsg);
 
228
+         fatal_perror ("%s", errmsg);
 
229
        }
 
230
       else
 
231
-       fatal (errmsg);
 
232
+       fatal ("%s", errmsg);
 
233
     }
 
234
 
 
235
   int_handler  = (void (*) (int)) signal (SIGINT,  SIG_IGN);
 
236
--- a/src/gcc/cp/cvt.c
 
237
+++ b/src/gcc/cp/cvt.c
 
238
@@ -591,7 +591,7 @@ ocp_convert (tree type, tree expr, int convtype, int flags)
 
239
   if ((invalid_conv_diag
 
240
        = targetm.invalid_conversion (TREE_TYPE (expr), type)))
 
241
     {
 
242
-      error (invalid_conv_diag);
 
243
+      error ("%s", invalid_conv_diag);
 
244
       return error_mark_node;
 
245
     }
 
246
 
 
247
--- a/src/gcc/cp/parser.c
 
248
+++ b/src/gcc/cp/parser.c
 
249
@@ -2204,7 +2204,7 @@ cp_parser_check_type_definition (cp_parser* parser)
 
250
     {
 
251
       /* Don't use `%s' to print the string, because quotations (`%<', `%>')
 
252
         in the message need to be interpreted.  */
 
253
-      error (parser->type_definition_forbidden_message);
 
254
+      error ("%s", parser->type_definition_forbidden_message);
 
255
       return false;
 
256
     }
 
257
   return true;
 
258
@@ -2291,7 +2291,7 @@ cp_parser_non_integral_constant_expression (cp_parser  *parser,
 
259
          char *message = concat (thing,
 
260
                                  " cannot appear in a constant-expression",
 
261
                                  NULL);
 
262
-         error (message);
 
263
+         error ("%s", message);
 
264
          free (message);
 
265
          return true;
 
266
        }
 
267
--- a/src/gcc/cp/pt.c
 
268
+++ b/src/gcc/cp/pt.c
 
269
@@ -11060,7 +11060,7 @@ tsubst_copy_and_build (tree t,
 
270
                                     &error_msg,
 
271
                                     input_location);
 
272
        if (error_msg)
 
273
-         error (error_msg);
 
274
+         error ("%s", error_msg);
 
275
        if (!function_p && TREE_CODE (decl) == IDENTIFIER_NODE)
 
276
          decl = unqualified_name_lookup_error (decl);
 
277
        return decl;
 
278
--- a/src/gcc/cp/typeck.c
 
279
+++ b/src/gcc/cp/typeck.c
 
280
@@ -3373,7 +3373,7 @@ cp_build_binary_op (location_t location,
 
281
   if ((invalid_op_diag
 
282
        = targetm.invalid_binary_op (code, type0, type1)))
 
283
     {
 
284
-      error (invalid_op_diag);
 
285
+      error ("%s", invalid_op_diag);
 
286
       return error_mark_node;
 
287
     }
 
288
 
 
289
@@ -4254,7 +4254,7 @@ cp_build_unary_op (enum tree_code code, tree xarg, int noconvert,
 
290
                                    : code),
 
291
                                   TREE_TYPE (xarg))))
 
292
     {
 
293
-      error (invalid_op_diag);
 
294
+      error ("%s", invalid_op_diag);
 
295
       return error_mark_node;
 
296
     }
 
297
 
 
298
--- a/src/gcc/dbxout.c
 
299
+++ b/src/gcc/dbxout.c
 
300
@@ -847,6 +847,7 @@ dbxout_finish_complex_stabs (tree sym, STAB_CODE_TYPE code,
 
301
   int line ATTRIBUTE_UNUSED;
 
302
   char *str;
 
303
   size_t len;
 
304
+  size_t rv_neverused ATTRIBUTE_UNUSED;
 
305
 
 
306
   line = sym ? DECL_SOURCE_LINE (sym) : 0;
 
307
   if (DBX_CONTIN_LENGTH > 0)
 
308
@@ -867,7 +868,7 @@ dbxout_finish_complex_stabs (tree sym, STAB_CODE_TYPE code,
 
309
       for (;;)
 
310
        {
 
311
          chunklen = strlen (chunk);
 
312
-         fwrite (chunk, 1, chunklen, asm_out_file);
 
313
+         rv_neverused = fwrite (chunk, 1, chunklen, asm_out_file);
 
314
          fputs ("\",", asm_out_file);
 
315
 
 
316
          /* Must add an extra byte to account for the NUL separator.  */
 
317
@@ -894,7 +895,7 @@ dbxout_finish_complex_stabs (tree sym, STAB_CODE_TYPE code,
 
318
       len = obstack_object_size (&stabstr_ob);
 
319
       str = XOBFINISH (&stabstr_ob, char *);
 
320
       
 
321
-      fwrite (str, 1, len, asm_out_file);
 
322
+      rv_neverused = fwrite (str, 1, len, asm_out_file);
 
323
       DBX_FINISH_STABS (sym, code, line, addr, label, number);
 
324
     }
 
325
   obstack_free (&stabstr_ob, str);
 
326
--- a/src/gcc/diagnostic.c
 
327
+++ b/src/gcc/diagnostic.c
 
328
@@ -70,9 +70,10 @@ build_message_string (const char *msg, ...)
 
329
 {
 
330
   char *str;
 
331
   va_list ap;
 
332
+  size_t rv_neverused ATTRIBUTE_UNUSED;
 
333
 
 
334
   va_start (ap, msg);
 
335
-  vasprintf (&str, msg, ap);
 
336
+  rv_neverused = vasprintf (&str, msg, ap);
 
337
   va_end (ap);
 
338
 
 
339
   return str;
 
340
--- a/src/gcc/final.c
 
341
+++ b/src/gcc/final.c
 
342
@@ -2989,12 +2989,13 @@ output_operand_lossage (const char *cmsgid, ...)
 
343
   char *new_message;
 
344
   const char *pfx_str;
 
345
   va_list ap;
 
346
+  int rv_neverused ATTRIBUTE_UNUSED;
 
347
 
 
348
   va_start (ap, cmsgid);
 
349
 
 
350
   pfx_str = this_is_asm_operands ? _("invalid 'asm': ") : "output_operand: ";
 
351
-  asprintf (&fmt_string, "%s%s", pfx_str, _(cmsgid));
 
352
-  vasprintf (&new_message, fmt_string, ap);
 
353
+  rv_neverused = asprintf (&fmt_string, "%s%s", pfx_str, _(cmsgid));
 
354
+  rv_neverused = vasprintf (&new_message, fmt_string, ap);
 
355
 
 
356
   if (this_is_asm_operands)
 
357
     error_for_asm (this_is_asm_operands, "%s", new_message);
 
358
--- a/src/gcc/fold-const.c
 
359
+++ b/src/gcc/fold-const.c
 
360
@@ -1025,7 +1025,7 @@ fold_overflow_warning (const char* gmsgid, enum warn_strict_overflow_code wc)
 
361
        }
 
362
     }
 
363
   else if (issue_strict_overflow_warning (wc))
 
364
-    warning (OPT_Wstrict_overflow, gmsgid);
 
365
+    warning (OPT_Wstrict_overflow, "%s", gmsgid);
 
366
 }
 
367
 
 
368
 /* Return true if the built-in mathematical function specified by CODE
 
369
--- a/src/gcc/fortran/cpp.c
 
370
+++ b/src/gcc/fortran/cpp.c
 
371
@@ -729,8 +729,9 @@ scan_translation_unit_trad (cpp_reader *pfile)
 
372
   while (_cpp_read_logical_line_trad (pfile))
 
373
     {
 
374
       size_t len = pfile->out.cur - pfile->out.base;
 
375
+      size_t rv_neverused ATTRIBUTE_UNUSED;
 
376
       maybe_print_line (pfile->out.first_line);
 
377
-      fwrite (pfile->out.base, 1, len, print.outf);
 
378
+      rv_neverused = fwrite (pfile->out.base, 1, len, print.outf);
 
379
       print.printed = 1;
 
380
       if (!CPP_OPTION (pfile, discard_comments))
 
381
        account_for_newlines (pfile->out.base, len);
 
382
--- a/src/gcc/fortran/decl.c
 
383
+++ b/src/gcc/fortran/decl.c
 
384
@@ -1954,7 +1954,7 @@ kind_expr:
 
385
 
 
386
   if (msg != NULL)
 
387
     {
 
388
-      gfc_error (msg);
 
389
+      gfc_error ("%s", msg);
 
390
       m = MATCH_ERROR;
 
391
       goto no_match;
 
392
     }
 
393
@@ -2060,7 +2060,7 @@ match_char_kind (int * kind, int * is_iso_c)
 
394
   *is_iso_c = e->ts.is_iso_c;
 
395
   if (msg != NULL)
 
396
     {
 
397
-      gfc_error (msg);
 
398
+      gfc_error ("%s", msg);
 
399
       m = MATCH_ERROR;
 
400
       goto no_match;
 
401
     }
 
402
--- a/src/gcc/fortran/intrinsic.c
 
403
+++ b/src/gcc/fortran/intrinsic.c
 
404
@@ -262,11 +262,11 @@ add_sym (const char *name, gfc_isym_id id, enum klass cl, int actual_ok, bt type
 
405
       break;
 
406
 
 
407
     case SZ_NOTHING:
 
408
-      next_sym->name = gfc_get_string (name);
 
409
+      next_sym->name = gfc_get_string ("%s", name);
 
410
 
 
411
       strcpy (buf, "_gfortran_");
 
412
       strcat (buf, name);
 
413
-      next_sym->lib_name = gfc_get_string (buf);
 
414
+      next_sym->lib_name = gfc_get_string ("%s", buf);
 
415
 
 
416
       next_sym->elemental = (cl == CLASS_ELEMENTAL);
 
417
       next_sym->inquiry = (cl == CLASS_INQUIRY);
 
418
@@ -722,7 +722,7 @@ find_sym (gfc_intrinsic_sym *start, int n, const char *name)
 
419
   /* name may be a user-supplied string, so we must first make sure
 
420
      that we're comparing against a pointer into the global string
 
421
      table.  */
 
422
-  const char *p = gfc_get_string (name);
 
423
+  const char *p = gfc_get_string ("%s", name);
 
424
 
 
425
   while (n > 0)
 
426
     {
 
427
@@ -918,7 +918,7 @@ make_alias (const char *name, int standard)
 
428
 
 
429
     case SZ_NOTHING:
 
430
       next_sym[0] = next_sym[-1];
 
431
-      next_sym->name = gfc_get_string (name);
 
432
+      next_sym->name = gfc_get_string ("%s", name);
 
433
       next_sym->standard = standard;
 
434
       next_sym++;
 
435
       break;
 
436
--- a/src/gcc/fortran/match.c
 
437
+++ b/src/gcc/fortran/match.c
 
438
@@ -391,7 +391,7 @@ gfc_match_small_int (int *value)
 
439
 
 
440
   if (p != NULL)
 
441
     {
 
442
-      gfc_error (p);
 
443
+      gfc_error ("%s", p);
 
444
       m = MATCH_ERROR;
 
445
     }
 
446
 
 
447
@@ -423,7 +423,7 @@ gfc_match_small_int_expr (int *value, gfc_expr **expr)
 
448
 
 
449
   if (p != NULL)
 
450
     {
 
451
-      gfc_error (p);
 
452
+      gfc_error ("%s", p);
 
453
       m = MATCH_ERROR;
 
454
     }
 
455
 
 
456
--- a/src/gcc/fortran/matchexp.c
 
457
+++ b/src/gcc/fortran/matchexp.c
 
458
@@ -193,7 +193,7 @@ match_primary (gfc_expr **result)
 
459
   return MATCH_YES;
 
460
 
 
461
 syntax:
 
462
-  gfc_error (expression_syntax);
 
463
+  gfc_error ("%s", expression_syntax);
 
464
   return MATCH_ERROR;
 
465
 }
 
466
 
 
467
@@ -496,7 +496,7 @@ match_level_2 (gfc_expr **result)
 
468
       m = match_ext_add_operand (&e);
 
469
       if (m == MATCH_NO)
 
470
        {
 
471
-         gfc_error (expression_syntax);
 
472
+         gfc_error ("%s", expression_syntax);
 
473
          m = MATCH_ERROR;
 
474
        }
 
475
     }
 
476
@@ -535,7 +535,7 @@ match_level_2 (gfc_expr **result)
 
477
 
 
478
       m = match_ext_add_operand (&e);
 
479
       if (m == MATCH_NO)
 
480
-       gfc_error (expression_syntax);
 
481
+       gfc_error ("%s", expression_syntax);
 
482
       if (m != MATCH_YES)
 
483
        {
 
484
          gfc_free_expr (all);
 
485
@@ -586,7 +586,7 @@ match_level_3 (gfc_expr **result)
 
486
       m = match_level_2 (&e);
 
487
       if (m == MATCH_NO)
 
488
        {
 
489
-         gfc_error (expression_syntax);
 
490
+         gfc_error ("%s", expression_syntax);
 
491
          gfc_free_expr (all);
 
492
        }
 
493
       if (m != MATCH_YES)
 
494
@@ -646,7 +646,7 @@ match_level_4 (gfc_expr **result)
 
495
 
 
496
   m = match_level_3 (&right);
 
497
   if (m == MATCH_NO)
 
498
-    gfc_error (expression_syntax);
 
499
+    gfc_error ("%s", expression_syntax);
 
500
   if (m != MATCH_YES)
 
501
     {
 
502
       gfc_free_expr (left);
 
503
@@ -755,7 +755,7 @@ match_or_operand (gfc_expr **result)
 
504
 
 
505
       m = match_and_operand (&e);
 
506
       if (m == MATCH_NO)
 
507
-       gfc_error (expression_syntax);
 
508
+       gfc_error ("%s", expression_syntax);
 
509
       if (m != MATCH_YES)
 
510
        {
 
511
          gfc_free_expr (all);
 
512
@@ -798,7 +798,7 @@ match_equiv_operand (gfc_expr **result)
 
513
 
 
514
       m = match_or_operand (&e);
 
515
       if (m == MATCH_NO)
 
516
-       gfc_error (expression_syntax);
 
517
+       gfc_error ("%s", expression_syntax);
 
518
       if (m != MATCH_YES)
 
519
        {
 
520
          gfc_free_expr (all);
 
521
@@ -852,7 +852,7 @@ match_level_5 (gfc_expr **result)
 
522
 
 
523
       m = match_equiv_operand (&e);
 
524
       if (m == MATCH_NO)
 
525
-       gfc_error (expression_syntax);
 
526
+       gfc_error ("%s", expression_syntax);
 
527
       if (m != MATCH_YES)
 
528
        {
 
529
          gfc_free_expr (all);
 
530
@@ -911,7 +911,7 @@ gfc_match_expr (gfc_expr **result)
 
531
 
 
532
       m = match_level_5 (&e);
 
533
       if (m == MATCH_NO)
 
534
-       gfc_error (expression_syntax);
 
535
+       gfc_error ("%s", expression_syntax);
 
536
       if (m != MATCH_YES)
 
537
        {
 
538
          gfc_free_expr (all);
 
539
--- a/src/gcc/fortran/module.c
 
540
+++ b/src/gcc/fortran/module.c
 
541
@@ -805,9 +805,9 @@ find_true_name (const char *name, const char *module)
 
542
   gfc_symbol sym;
 
543
   int c;
 
544
 
 
545
-  sym.name = gfc_get_string (name);
 
546
+  sym.name = gfc_get_string ("%s", name);
 
547
   if (module != NULL)
 
548
-    sym.module = gfc_get_string (module);
 
549
+    sym.module = gfc_get_string ("%s", module);
 
550
   else
 
551
     sym.module = NULL;
 
552
   t.sym = &sym;
 
553
@@ -1612,7 +1612,7 @@ mio_pool_string (const char **stringp)
 
554
   else
 
555
     {
 
556
       require_atom (ATOM_STRING);
 
557
-      *stringp = atom_string[0] == '\0' ? NULL : gfc_get_string (atom_string);
 
558
+      *stringp = atom_string[0] == '\0' ? NULL : gfc_get_string ("%s", atom_string);
 
559
       gfc_free (atom_string);
 
560
     }
 
561
 }
 
562
@@ -2460,7 +2460,7 @@ mio_symtree_ref (gfc_symtree **stp)
 
563
            {
 
564
              p->u.rsym.sym = gfc_new_symbol (p->u.rsym.true_name,
 
565
                                              gfc_current_ns);
 
566
-             p->u.rsym.sym->module = gfc_get_string (p->u.rsym.module);
 
567
+             p->u.rsym.sym->module = gfc_get_string ("%s", p->u.rsym.module);
 
568
            }
 
569
 
 
570
          p->u.rsym.symtree->n.sym = p->u.rsym.sym;
 
571
@@ -2967,7 +2967,7 @@ mio_expr (gfc_expr **ep)
 
572
       else
 
573
        {
 
574
          require_atom (ATOM_STRING);
 
575
-         e->value.function.name = gfc_get_string (atom_string);
 
576
+         e->value.function.name = gfc_get_string ("%s", atom_string);
 
577
          gfc_free (atom_string);
 
578
 
 
579
          mio_integer (&flag);
 
580
@@ -3695,8 +3695,8 @@ load_generic_interfaces (void)
 
581
              if (!sym)
 
582
                {
 
583
                  gfc_get_symbol (p, NULL, &sym);
 
584
-                 sym->name = gfc_get_string (name);
 
585
-                 sym->module = gfc_get_string (module_name);
 
586
+                 sym->name = gfc_get_string ("%s", name);
 
587
+                 sym->module = gfc_get_string ("%s", module_name);
 
588
                  sym->attr.flavor = FL_PROCEDURE;
 
589
                  sym->attr.generic = 1;
 
590
                  sym->attr.use_assoc = 1;
 
591
@@ -3901,7 +3901,7 @@ load_needed (pointer_info *p)
 
592
                                 1, &ns->proc_name);
 
593
 
 
594
       sym = gfc_new_symbol (p->u.rsym.true_name, ns);
 
595
-      sym->module = gfc_get_string (p->u.rsym.module);
 
596
+      sym->module = gfc_get_string ("%s", p->u.rsym.module);
 
597
       strcpy (sym->binding_label, p->u.rsym.binding_label);
 
598
 
 
599
       associate_integer_pointer (p, sym);
 
600
@@ -4162,7 +4162,7 @@ read_module (void)
 
601
                  info->u.rsym.sym = gfc_new_symbol (info->u.rsym.true_name,
 
602
                                                     gfc_current_ns);
 
603
                  sym = info->u.rsym.sym;
 
604
-                 sym->module = gfc_get_string (info->u.rsym.module);
 
605
+                 sym->module = gfc_get_string ("%s", info->u.rsym.module);
 
606
 
 
607
                  /* TODO: hmm, can we test this?  Do we know it will be
 
608
                     initialized to zeros?  */
 
609
@@ -4521,7 +4521,7 @@ write_symbol0 (gfc_symtree *st)
 
610
 
 
611
   sym = st->n.sym;
 
612
   if (sym->module == NULL)
 
613
-    sym->module = gfc_get_string (module_name);
 
614
+    sym->module = gfc_get_string ("%s", module_name);
 
615
 
 
616
   if (sym->attr.flavor == FL_PROCEDURE && sym->attr.generic
 
617
       && !sym->attr.subroutine && !sym->attr.function)
 
618
@@ -4614,7 +4614,7 @@ write_generic (gfc_symtree *st)
 
619
     return;
 
620
 
 
621
   if (sym->module == NULL)
 
622
-    sym->module = gfc_get_string (module_name);
 
623
+    sym->module = gfc_get_string ("%s", module_name);
 
624
 
 
625
   mio_symbol_interface (&st->name, &sym->module, &sym->generic);
 
626
 }
 
627
@@ -4962,7 +4962,7 @@ import_iso_c_binding_module (void)
 
628
 
 
629
       mod_sym->attr.flavor = FL_MODULE;
 
630
       mod_sym->attr.intrinsic = 1;
 
631
-      mod_sym->module = gfc_get_string (iso_c_module_name);
 
632
+      mod_sym->module = gfc_get_string ("%s", iso_c_module_name);
 
633
       mod_sym->from_intmod = INTMOD_ISO_C_BINDING;
 
634
     }
 
635
 
 
636
@@ -5039,7 +5039,7 @@ create_int_parameter (const char *name, int value, const char *modname,
 
637
   gfc_get_sym_tree (name, gfc_current_ns, &tmp_symtree);
 
638
   sym = tmp_symtree->n.sym;
 
639
 
 
640
-  sym->module = gfc_get_string (modname);
 
641
+  sym->module = gfc_get_string ("%s", modname);
 
642
   sym->attr.flavor = FL_PARAMETER;
 
643
   sym->ts.type = BT_INTEGER;
 
644
   sym->ts.kind = gfc_default_integer_kind;
 
645
@@ -5083,7 +5083,7 @@ use_iso_fortran_env_module (void)
 
646
 
 
647
       mod_sym->attr.flavor = FL_MODULE;
 
648
       mod_sym->attr.intrinsic = 1;
 
649
-      mod_sym->module = gfc_get_string (mod);
 
650
+      mod_sym->module = gfc_get_string ("%s", mod);
 
651
       mod_sym->from_intmod = INTMOD_ISO_FORTRAN_ENV;
 
652
     }
 
653
   else
 
654
@@ -5279,7 +5279,7 @@ gfc_use_module (void)
 
655
   fclose (module_fp);
 
656
 
 
657
   use_stmt = gfc_get_use_list ();
 
658
-  use_stmt->module_name = gfc_get_string (module_name);
 
659
+  use_stmt->module_name = gfc_get_string ("%s", module_name);
 
660
   use_stmt->only_flag = only_flag;
 
661
   use_stmt->rename = gfc_rename_list;
 
662
   use_stmt->where = use_locus;
 
663
--- a/src/gcc/fortran/openmp.c
 
664
+++ b/src/gcc/fortran/openmp.c
 
665
@@ -396,7 +396,7 @@ gfc_match_omp_clauses (gfc_omp_clauses **cp, int mask)
 
666
              const char *p = gfc_extract_int (cexpr, &collapse);
 
667
              if (p)
 
668
                {
 
669
-                 gfc_error (p);
 
670
+                 gfc_error ("%s", p);
 
671
                  collapse = 1;
 
672
                }
 
673
              else if (collapse <= 0)
 
674
--- a/src/gcc/fortran/primary.c
 
675
+++ b/src/gcc/fortran/primary.c
 
676
@@ -255,7 +255,7 @@ match_hollerith_constant (gfc_expr **result)
 
677
       msg = gfc_extract_int (e, &num);
 
678
       if (msg != NULL)
 
679
        {
 
680
-         gfc_error (msg);
 
681
+         gfc_error ("%s", msg);
 
682
          goto cleanup;
 
683
        }
 
684
       if (num == 0)
 
685
@@ -924,7 +924,7 @@ match_string_constant (gfc_expr **result)
 
686
       q = gfc_extract_int (sym->value, &kind);
 
687
       if (q != NULL)
 
688
        {
 
689
-         gfc_error (q);
 
690
+         gfc_error ("%s", q);
 
691
          return MATCH_ERROR;
 
692
        }
 
693
       gfc_set_sym_referenced (sym);
 
694
@@ -1479,7 +1479,7 @@ match_keyword_arg (gfc_actual_arglist *actual, gfc_actual_arglist *base)
 
695
          }
 
696
     }
 
697
 
 
698
-  actual->name = gfc_get_string (name);
 
699
+  actual->name = gfc_get_string ("%s", name);
 
700
   return MATCH_YES;
 
701
 
 
702
 cleanup:
 
703
--- a/src/gcc/fortran/symbol.c
 
704
+++ b/src/gcc/fortran/symbol.c
 
705
@@ -1759,7 +1759,7 @@ gfc_add_component (gfc_symbol *sym, const char *name,
 
706
   else
 
707
     tail->next = p;
 
708
 
 
709
-  p->name = gfc_get_string (name);
 
710
+  p->name = gfc_get_string ("%s", name);
 
711
   p->loc = gfc_current_locus;
 
712
 
 
713
   *component = p;
 
714
@@ -2251,7 +2251,7 @@ gfc_new_symtree (gfc_symtree **root, const char *name)
 
715
   gfc_symtree *st;
 
716
 
 
717
   st = XCNEW (gfc_symtree);
 
718
-  st->name = gfc_get_string (name);
 
719
+  st->name = gfc_get_string ("%s", name);
 
720
   st->typebound = NULL;
 
721
 
 
722
   gfc_insert_bbt (root, st, compare_symtree);
 
723
@@ -2268,7 +2268,7 @@ gfc_delete_symtree (gfc_symtree **root, const char *name)
 
724
 
 
725
   st0 = gfc_find_symtree (*root, name);
 
726
 
 
727
-  st.name = gfc_get_string (name);
 
728
+  st.name = gfc_get_string ("%s", name);
 
729
   gfc_delete_bbt (root, &st, compare_symtree);
 
730
 
 
731
   gfc_free (st0);
 
732
@@ -2327,7 +2327,7 @@ gfc_get_uop (const char *name)
 
733
   st = gfc_new_symtree (&gfc_current_ns->uop_root, name);
 
734
 
 
735
   uop = st->n.uop = XCNEW (gfc_user_op);
 
736
-  uop->name = gfc_get_string (name);
 
737
+  uop->name = gfc_get_string ("%s", name);
 
738
   uop->access = ACCESS_UNKNOWN;
 
739
   uop->ns = gfc_current_ns;
 
740
 
 
741
@@ -2399,7 +2399,7 @@ gfc_new_symbol (const char *name, gfc_namespace *ns)
 
742
   if (strlen (name) > GFC_MAX_SYMBOL_LEN)
 
743
     gfc_internal_error ("new_symbol(): Symbol name too long");
 
744
 
 
745
-  p->name = gfc_get_string (name);
 
746
+  p->name = gfc_get_string ("%s", name);
 
747
 
 
748
   /* Make sure flags for symbol being C bound are clear initially.  */
 
749
   p->attr.is_bind_c = 0;
 
750
@@ -3280,7 +3280,7 @@ gfc_get_gsymbol (const char *name)
 
751
 
 
752
   s = XCNEW (gfc_gsymbol);
 
753
   s->type = GSYM_UNKNOWN;
 
754
-  s->name = gfc_get_string (name);
 
755
+  s->name = gfc_get_string ("%s", name);
 
756
 
 
757
   gfc_insert_bbt (&gfc_gsym_root, s, gsym_compare);
 
758
 
 
759
@@ -3517,7 +3517,7 @@ gen_special_c_interop_ptr (int ptr_id, const char *ptr_name,
 
760
     }
 
761
 
 
762
   /* Module name is some mangled version of iso_c_binding.  */
 
763
-  tmp_sym->module = gfc_get_string (module_name);
 
764
+  tmp_sym->module = gfc_get_string ("%s", module_name);
 
765
   
 
766
   /* Say it's from the iso_c_binding module.  */
 
767
   tmp_sym->attr.is_iso_c = 1;
 
768
@@ -3637,7 +3637,7 @@ gen_cptr_param (gfc_formal_arglist **head,
 
769
     }
 
770
 
 
771
   param_sym->ts.derived = c_ptr_sym;
 
772
-  param_sym->module = gfc_get_string (module_name);
 
773
+  param_sym->module = gfc_get_string ("%s", module_name);
 
774
 
 
775
   /* Make new formal arg.  */
 
776
   formal_arg = gfc_get_formal_arglist ();
 
777
@@ -3682,7 +3682,7 @@ gen_fptr_param (gfc_formal_arglist **head,
 
778
 
 
779
   /* ISO C Binding type to allow any pointer type as actual param.  */
 
780
   param_sym->ts.type = BT_VOID;
 
781
-  param_sym->module = gfc_get_string (module_name);
 
782
+  param_sym->module = gfc_get_string ("%s", module_name);
 
783
    
 
784
   /* Make the arg.  */
 
785
   formal_arg = gfc_get_formal_arglist ();
 
786
@@ -3753,7 +3753,7 @@ gen_shape_param (gfc_formal_arglist **head,
 
787
   param_sym->attr.optional = 1;
 
788
   param_sym->attr.intent = INTENT_IN;
 
789
   param_sym->attr.dimension = 1;
 
790
-  param_sym->module = gfc_get_string (module_name);
 
791
+  param_sym->module = gfc_get_string ("%s", module_name);
 
792
    
 
793
   /* Make the arg.  */
 
794
   formal_arg = gfc_get_formal_arglist ();
 
795
@@ -3957,7 +3957,7 @@ generate_isocbinding_symbol (const char *mod_name, iso_c_binding_symbol s,
 
796
                        "create symbol");
 
797
 
 
798
   /* Say what module this symbol belongs to.  */
 
799
-  tmp_sym->module = gfc_get_string (mod_name);
 
800
+  tmp_sym->module = gfc_get_string ("%s", mod_name);
 
801
   tmp_sym->from_intmod = INTMOD_ISO_C_BINDING;
 
802
   tmp_sym->intmod_sym_id = s;
 
803
 
 
804
@@ -4234,7 +4234,7 @@ get_iso_c_sym (gfc_symbol *old_sym, char *new_name,
 
805
   strcpy (new_symtree->n.sym->binding_label, new_binding_label);
 
806
   new_symtree->n.sym->attr = old_sym->attr;
 
807
   new_symtree->n.sym->ts = old_sym->ts;
 
808
-  new_symtree->n.sym->module = gfc_get_string (old_sym->module);
 
809
+  new_symtree->n.sym->module = gfc_get_string ("%s", old_sym->module);
 
810
   new_symtree->n.sym->from_intmod = old_sym->from_intmod;
 
811
   new_symtree->n.sym->intmod_sym_id = old_sym->intmod_sym_id;
 
812
   /* Build the formal arg list.  */
 
813
--- a/src/gcc/fortran/trans-array.c
 
814
+++ b/src/gcc/fortran/trans-array.c
 
815
@@ -2232,6 +2232,7 @@ gfc_trans_array_bound_check (gfc_se * se, tree descriptor, tree index, int n,
 
816
   tree tmp;
 
817
   char *msg;
 
818
   const char * name = NULL;
 
819
+  int rv_neverused ATTRIBUTE_UNUSED;
 
820
 
 
821
   if (!flag_bounds_check)
 
822
     return index;
 
823
@@ -2270,11 +2271,13 @@ gfc_trans_array_bound_check (gfc_se * se, tree descriptor, tree index, int n,
 
824
   tmp = gfc_conv_array_lbound (descriptor, n);
 
825
   fault = fold_build2 (LT_EXPR, boolean_type_node, index, tmp);
 
826
   if (name)
 
827
-    asprintf (&msg, "%s for array '%s', lower bound of dimension %d exceeded"
 
828
-             "(%%ld < %%ld)", gfc_msg_fault, name, n+1);
 
829
+    rv_neverused =
 
830
+      asprintf (&msg, "%s for array '%s', lower bound of dimension %d exceeded"
 
831
+               "(%%ld < %%ld)", gfc_msg_fault, name, n+1);
 
832
   else
 
833
-    asprintf (&msg, "%s, lower bound of dimension %d exceeded (%%ld < %%ld)",
 
834
-             gfc_msg_fault, n+1);
 
835
+    rv_neverused =
 
836
+      asprintf (&msg, "%s, lower bound of dimension %d exceeded (%%ld < %%ld)",
 
837
+               gfc_msg_fault, n+1);
 
838
   gfc_trans_runtime_check (true, false, fault, &se->pre, where, msg,
 
839
                           fold_convert (long_integer_type_node, index),
 
840
                           fold_convert (long_integer_type_node, tmp));
 
841
@@ -2286,11 +2289,14 @@ gfc_trans_array_bound_check (gfc_se * se, tree descriptor, tree index, int n,
 
842
       tmp = gfc_conv_array_ubound (descriptor, n);
 
843
       fault = fold_build2 (GT_EXPR, boolean_type_node, index, tmp);
 
844
       if (name)
 
845
-       asprintf (&msg, "%s for array '%s', upper bound of dimension %d "
 
846
-                       " exceeded (%%ld > %%ld)", gfc_msg_fault, name, n+1);
 
847
+       rv_neverused =
 
848
+         asprintf (&msg, "%s for array '%s', upper bound of dimension %d "
 
849
+                   " exceeded (%%ld > %%ld)", gfc_msg_fault, name, n+1);
 
850
       else
 
851
-       asprintf (&msg, "%s, upper bound of dimension %d exceeded (%%ld > %%ld)",
 
852
-                 gfc_msg_fault, n+1);
 
853
+       rv_neverused =
 
854
+         asprintf (&msg,
 
855
+                   "%s, upper bound of dimension %d exceeded (%%ld > %%ld)",
 
856
+                   gfc_msg_fault, n+1);
 
857
       gfc_trans_runtime_check (true, false, fault, &se->pre, where, msg,
 
858
                               fold_convert (long_integer_type_node, index),
 
859
                               fold_convert (long_integer_type_node, tmp));
 
860
@@ -2474,6 +2480,7 @@ gfc_conv_array_ref (gfc_se * se, gfc_array_ref * ar, gfc_symbol * sym,
 
861
          /* Check array bounds.  */
 
862
          tree cond;
 
863
          char *msg;
 
864
+         int rv_neverused ATTRIBUTE_UNUSED;
 
865
 
 
866
          /* Evaluate the indexse.expr only once.  */
 
867
          indexse.expr = save_expr (indexse.expr);
 
868
@@ -2482,9 +2489,10 @@ gfc_conv_array_ref (gfc_se * se, gfc_array_ref * ar, gfc_symbol * sym,
 
869
          tmp = gfc_conv_array_lbound (se->expr, n);
 
870
          cond = fold_build2 (LT_EXPR, boolean_type_node, 
 
871
                              indexse.expr, tmp);
 
872
-         asprintf (&msg, "%s for array '%s', "
 
873
-                   "lower bound of dimension %d exceeded (%%ld < %%ld)",
 
874
-                   gfc_msg_fault, sym->name, n+1);
 
875
+         rv_neverused =
 
876
+           asprintf (&msg, "%s for array '%s', "
 
877
+                     "lower bound of dimension %d exceeded (%%ld < %%ld)",
 
878
+                     gfc_msg_fault, sym->name, n+1);
 
879
          gfc_trans_runtime_check (true, false, cond, &se->pre, where, msg,
 
880
                                   fold_convert (long_integer_type_node,
 
881
                                                 indexse.expr),
 
882
@@ -2499,9 +2507,10 @@ gfc_conv_array_ref (gfc_se * se, gfc_array_ref * ar, gfc_symbol * sym,
 
883
              tmp = gfc_conv_array_ubound (se->expr, n);
 
884
              cond = fold_build2 (GT_EXPR, boolean_type_node, 
 
885
                                  indexse.expr, tmp);
 
886
-             asprintf (&msg, "%s for array '%s', "
 
887
-                       "upper bound of dimension %d exceeded (%%ld > %%ld)",
 
888
-                       gfc_msg_fault, sym->name, n+1);
 
889
+             rv_neverused =
 
890
+               asprintf (&msg, "%s for array '%s', "
 
891
+                         "upper bound of dimension %d exceeded (%%ld > %%ld)",
 
892
+                         gfc_msg_fault, sym->name, n+1);
 
893
              gfc_trans_runtime_check (true, false, cond, &se->pre, where, msg,
 
894
                                   fold_convert (long_integer_type_node,
 
895
                                                 indexse.expr),
 
896
@@ -3048,6 +3057,7 @@ gfc_conv_ss_startstride (gfc_loopinfo * loop)
 
897
          for (n = 0; n < loop->dimen; n++)
 
898
            {
 
899
              bool check_upper;
 
900
+             int rv_neverused ATTRIBUTE_UNUSED;
 
901
 
 
902
              dim = info->dim[n];
 
903
              if (info->ref->u.ar.dimen_type[dim] != DIMEN_RANGE)
 
904
@@ -3063,9 +3073,10 @@ gfc_conv_ss_startstride (gfc_loopinfo * loop)
 
905
              /* Zero stride is not allowed.  */
 
906
              tmp = fold_build2 (EQ_EXPR, boolean_type_node, info->stride[n],
 
907
                                 gfc_index_zero_node);
 
908
-             asprintf (&msg, "Zero stride is not allowed, for dimension %d "
 
909
-                       "of array '%s'", info->dim[n]+1,
 
910
-                       ss->expr->symtree->name);
 
911
+             rv_neverused = 
 
912
+               asprintf (&msg, "Zero stride is not allowed, for dimension %d "
 
913
+                         "of array '%s'", info->dim[n]+1,
 
914
+                         ss->expr->symtree->name);
 
915
              gfc_trans_runtime_check (true, false, tmp, &inner,
 
916
                                       &ss->expr->where, msg);
 
917
              gfc_free (msg);
 
918
@@ -3106,9 +3117,10 @@ gfc_conv_ss_startstride (gfc_loopinfo * loop)
 
919
                                 lbound);
 
920
              tmp = fold_build2 (TRUTH_AND_EXPR, boolean_type_node,
 
921
                                 non_zerosized, tmp);
 
922
-             asprintf (&msg, "%s, lower bound of dimension %d of array '%s'"
 
923
-                       " exceeded (%%ld < %%ld)", gfc_msg_fault,
 
924
-                       info->dim[n]+1, ss->expr->symtree->name);
 
925
+             rv_neverused =
 
926
+               asprintf (&msg, "%s, lower bound of dimension %d of array '%s'"
 
927
+                         " exceeded (%%ld < %%ld)", gfc_msg_fault,
 
928
+                         info->dim[n]+1, ss->expr->symtree->name);
 
929
              gfc_trans_runtime_check (true, false, tmp, &inner,
 
930
                                       &ss->expr->where, msg,
 
931
                                       fold_convert (long_integer_type_node,
 
932
@@ -3123,9 +3135,10 @@ gfc_conv_ss_startstride (gfc_loopinfo * loop)
 
933
                                     info->start[n], ubound);
 
934
                  tmp = fold_build2 (TRUTH_AND_EXPR, boolean_type_node,
 
935
                                     non_zerosized, tmp);
 
936
-                 asprintf (&msg, "%s, upper bound of dimension %d of array "
 
937
-                           "'%s' exceeded (%%ld > %%ld)", gfc_msg_fault,
 
938
-                           info->dim[n]+1, ss->expr->symtree->name);
 
939
+                 rv_neverused =
 
940
+                   asprintf (&msg, "%s, upper bound of dimension %d of array "
 
941
+                             "'%s' exceeded (%%ld > %%ld)", gfc_msg_fault,
 
942
+                             info->dim[n]+1, ss->expr->symtree->name);
 
943
                  gfc_trans_runtime_check (true, false, tmp, &inner,
 
944
                        &ss->expr->where, msg,
 
945
                        fold_convert (long_integer_type_node, info->start[n]),
 
946
@@ -3146,9 +3159,10 @@ gfc_conv_ss_startstride (gfc_loopinfo * loop)
 
947
              tmp = fold_build2 (LT_EXPR, boolean_type_node, tmp2, lbound);
 
948
              tmp = fold_build2 (TRUTH_AND_EXPR, boolean_type_node,
 
949
                                 non_zerosized, tmp);
 
950
-             asprintf (&msg, "%s, lower bound of dimension %d of array '%s'"
 
951
-                       " exceeded (%%ld < %%ld)", gfc_msg_fault,
 
952
-                       info->dim[n]+1, ss->expr->symtree->name);
 
953
+             rv_neverused =
 
954
+               asprintf (&msg, "%s, lower bound of dimension %d of array '%s'"
 
955
+                         " exceeded (%%ld < %%ld)", gfc_msg_fault,
 
956
+                         info->dim[n]+1, ss->expr->symtree->name);
 
957
              gfc_trans_runtime_check (true, false, tmp, &inner,
 
958
                                       &ss->expr->where, msg,
 
959
                                       fold_convert (long_integer_type_node,
 
960
@@ -3162,9 +3176,10 @@ gfc_conv_ss_startstride (gfc_loopinfo * loop)
 
961
                  tmp = fold_build2 (GT_EXPR, boolean_type_node, tmp2, ubound);
 
962
                  tmp = fold_build2 (TRUTH_AND_EXPR, boolean_type_node,
 
963
                                     non_zerosized, tmp);
 
964
-                 asprintf (&msg, "%s, upper bound of dimension %d of array "
 
965
-                           "'%s' exceeded (%%ld > %%ld)", gfc_msg_fault,
 
966
-                           info->dim[n]+1, ss->expr->symtree->name);
 
967
+                 rv_neverused =
 
968
+                   asprintf (&msg, "%s, upper bound of dimension %d of array "
 
969
+                             "'%s' exceeded (%%ld > %%ld)", gfc_msg_fault,
 
970
+                             info->dim[n]+1, ss->expr->symtree->name);
 
971
                  gfc_trans_runtime_check (true, false, tmp, &inner,
 
972
                        &ss->expr->where, msg,
 
973
                        fold_convert (long_integer_type_node, tmp2),
 
974
@@ -3186,9 +3201,10 @@ gfc_conv_ss_startstride (gfc_loopinfo * loop)
 
975
                  tree tmp3;
 
976
 
 
977
                  tmp3 = fold_build2 (NE_EXPR, boolean_type_node, tmp, size[n]);
 
978
-                 asprintf (&msg, "%s, size mismatch for dimension %d "
 
979
-                           "of array '%s' (%%ld/%%ld)", gfc_msg_bounds,
 
980
-                           info->dim[n]+1, ss->expr->symtree->name);
 
981
+                 rv_neverused =
 
982
+                   asprintf (&msg, "%s, size mismatch for dimension %d "
 
983
+                             "of array '%s' (%%ld/%%ld)", gfc_msg_bounds,
 
984
+                             info->dim[n]+1, ss->expr->symtree->name);
 
985
                  gfc_trans_runtime_check (true, false, tmp3, &inner,
 
986
                                           &ss->expr->where, msg,
 
987
                        fold_convert (long_integer_type_node, tmp),
 
988
@@ -4449,14 +4465,16 @@ gfc_trans_dummy_array_bias (gfc_symbol * sym, tree tmpdesc, tree body)
 
989
            {
 
990
              /* Check (ubound(a) - lbound(a) == ubound(b) - lbound(b)).  */
 
991
              char * msg;
 
992
+             int rv_neverused ATTRIBUTE_UNUSED;
 
993
 
 
994
              tmp = fold_build2 (MINUS_EXPR, gfc_array_index_type,
 
995
                                 ubound, lbound);
 
996
               stride2 = fold_build2 (MINUS_EXPR, gfc_array_index_type,
 
997
                                     dubound, dlbound);
 
998
               tmp = fold_build2 (NE_EXPR, gfc_array_index_type, tmp, stride2);
 
999
-             asprintf (&msg, "%s for dimension %d of array '%s'",
 
1000
-                       gfc_msg_bounds, n+1, sym->name);
 
1001
+             rv_neverused =
 
1002
+               asprintf (&msg, "%s for dimension %d of array '%s'",
 
1003
+                         gfc_msg_bounds, n+1, sym->name);
 
1004
              gfc_trans_runtime_check (true, false, tmp, &block, &loc, msg);
 
1005
              gfc_free (msg);
 
1006
            }
 
1007
@@ -5332,12 +5350,14 @@ gfc_conv_array_parameter (gfc_se * se, gfc_expr * expr, gfc_ss * ss, int g77,
 
1008
       if (gfc_option.flag_check_array_temporaries)
 
1009
        {
 
1010
          char * msg;
 
1011
+         int rv_neverused ATTRIBUTE_UNUSED;
 
1012
 
 
1013
          if (fsym && proc_name)
 
1014
-           asprintf (&msg, "An array temporary was created for argument "
 
1015
-                     "'%s' of procedure '%s'", fsym->name, proc_name);
 
1016
+           rv_neverused =
 
1017
+             asprintf (&msg, "An array temporary was created for argument "
 
1018
+                       "'%s' of procedure '%s'", fsym->name, proc_name);
 
1019
          else
 
1020
-           asprintf (&msg, "An array temporary was created");
 
1021
+           rv_neverused = asprintf (&msg, "An array temporary was created");
 
1022
 
 
1023
          tmp = build_fold_indirect_ref (desc);
 
1024
          tmp = gfc_conv_array_data (tmp);
 
1025
--- a/src/gcc/fortran/trans-decl.c
 
1026
+++ b/src/gcc/fortran/trans-decl.c
 
1027
@@ -3071,7 +3071,7 @@ gfc_find_module (const char *name)
 
1028
     {
 
1029
       struct module_htab_entry *entry = GGC_CNEW (struct module_htab_entry);
 
1030
 
 
1031
-      entry->name = gfc_get_string (name);
 
1032
+      entry->name = gfc_get_string ("%s", name);
 
1033
       entry->decls = htab_create_ggc (10, module_htab_decls_hash,
 
1034
                                      module_htab_decls_eq, NULL);
 
1035
       *slot = (void *) entry;
 
1036
--- a/src/gcc/fortran/trans-expr.c
 
1037
+++ b/src/gcc/fortran/trans-expr.c
 
1038
@@ -400,6 +400,8 @@ gfc_conv_substring (gfc_se * se, gfc_ref * ref, int kind,
 
1039
 
 
1040
   if (flag_bounds_check)
 
1041
     {
 
1042
+      int rv_neverused ATTRIBUTE_UNUSED;
 
1043
+
 
1044
       tree nonempty = fold_build2 (LE_EXPR, boolean_type_node,
 
1045
                                   start.expr, end.expr);
 
1046
 
 
1047
@@ -409,11 +411,13 @@ gfc_conv_substring (gfc_se * se, gfc_ref * ref, int kind,
 
1048
       fault = fold_build2 (TRUTH_ANDIF_EXPR, boolean_type_node,
 
1049
                           nonempty, fault);
 
1050
       if (name)
 
1051
-       asprintf (&msg, "Substring out of bounds: lower bound (%%ld) of '%s' "
 
1052
-                 "is less than one", name);
 
1053
+       rv_neverused =
 
1054
+         asprintf (&msg, "Substring out of bounds: lower bound (%%ld) of '%s' "
 
1055
+                   "is less than one", name);
 
1056
       else
 
1057
-       asprintf (&msg, "Substring out of bounds: lower bound (%%ld)"
 
1058
-                 "is less than one");
 
1059
+       rv_neverused =
 
1060
+         asprintf (&msg, "Substring out of bounds: lower bound (%%ld)"
 
1061
+                   "is less than one");
 
1062
       gfc_trans_runtime_check (true, false, fault, &se->pre, where, msg,
 
1063
                               fold_convert (long_integer_type_node,
 
1064
                                             start.expr));
 
1065
@@ -425,11 +429,13 @@ gfc_conv_substring (gfc_se * se, gfc_ref * ref, int kind,
 
1066
       fault = fold_build2 (TRUTH_ANDIF_EXPR, boolean_type_node,
 
1067
                           nonempty, fault);
 
1068
       if (name)
 
1069
-       asprintf (&msg, "Substring out of bounds: upper bound (%%ld) of '%s' "
 
1070
-                 "exceeds string length (%%ld)", name);
 
1071
+       rv_neverused =
 
1072
+         asprintf (&msg, "Substring out of bounds: upper bound (%%ld) of '%s' "
 
1073
+                   "exceeds string length (%%ld)", name);
 
1074
       else
 
1075
-       asprintf (&msg, "Substring out of bounds: upper bound (%%ld) "
 
1076
-                 "exceeds string length (%%ld)");
 
1077
+       rv_neverused =
 
1078
+         asprintf (&msg, "Substring out of bounds: upper bound (%%ld) "
 
1079
+                   "exceeds string length (%%ld)");
 
1080
       gfc_trans_runtime_check (true, false, fault, &se->pre, where, msg,
 
1081
                               fold_convert (long_integer_type_node, end.expr),
 
1082
                               fold_convert (long_integer_type_node,
 
1083
--- a/src/gcc/fortran/trans-io.c
 
1084
+++ b/src/gcc/fortran/trans-io.c
 
1085
@@ -232,6 +232,7 @@ gfc_trans_io_runtime_check (tree cond, tree var, int error_code,
 
1086
   tree tmp;
 
1087
   tree arg1, arg2, arg3;
 
1088
   char *message;
 
1089
+  int rv_neverused ATTRIBUTE_UNUSED;
 
1090
 
 
1091
   if (integer_zerop (cond))
 
1092
     return;
 
1093
@@ -243,7 +244,7 @@ gfc_trans_io_runtime_check (tree cond, tree var, int error_code,
 
1094
   
 
1095
   arg2 = build_int_cst (integer_type_node, error_code),
 
1096
   
 
1097
-  asprintf (&message, "%s", _(msgid));
 
1098
+  rv_neverused = asprintf (&message, "%s", _(msgid));
 
1099
   arg3 = gfc_build_addr_expr (pchar_type_node,
 
1100
                              gfc_build_localized_cstring_const (message));
 
1101
   gfc_free(message);
 
1102
@@ -660,14 +661,16 @@ set_string (stmtblock_t * block, stmtblock_t * postblock, tree var,
 
1103
     {
 
1104
       char * msg;
 
1105
       tree cond;
 
1106
+      int rv_neverused ATTRIBUTE_UNUSED;
 
1107
 
 
1108
       gfc_conv_label_variable (&se, e);
 
1109
       tmp = GFC_DECL_STRING_LEN (se.expr);
 
1110
       cond = fold_build2 (LT_EXPR, boolean_type_node,
 
1111
                          tmp, build_int_cst (TREE_TYPE (tmp), 0));
 
1112
 
 
1113
-      asprintf(&msg, "Label assigned to variable '%s' (%%ld) is not a format "
 
1114
-              "label", e->symtree->name);
 
1115
+      rv_neverused =
 
1116
+       asprintf(&msg, "Label assigned to variable '%s' (%%ld) is not a format "
 
1117
+                "label", e->symtree->name);
 
1118
       gfc_trans_runtime_check (true, false, cond, &se.pre, &e->where, msg,
 
1119
                               fold_convert (long_integer_type_node, tmp));
 
1120
       gfc_free (msg);
 
1121
--- a/src/gcc/fortran/trans.c
 
1122
+++ b/src/gcc/fortran/trans.c
 
1123
@@ -371,6 +371,7 @@ gfc_trans_runtime_error_vararg (bool error, locus* where, const char* msgid,
 
1124
   char *message;
 
1125
   const char *p;
 
1126
   int line, nargs, i;
 
1127
+  int rv_neverused ATTRIBUTE_UNUSED;
 
1128
 
 
1129
   /* Compute the number of extra arguments from the format string.  */
 
1130
   for (p = msgid, nargs = 0; *p; p++)
 
1131
@@ -387,18 +388,18 @@ gfc_trans_runtime_error_vararg (bool error, locus* where, const char* msgid,
 
1132
   if (where)
 
1133
     {
 
1134
       line = LOCATION_LINE (where->lb->location);
 
1135
-      asprintf (&message, "At line %d of file %s",  line,
 
1136
-               where->lb->file->filename);
 
1137
+      rv_neverused = asprintf (&message, "At line %d of file %s",  line,
 
1138
+                              where->lb->file->filename);
 
1139
     }
 
1140
   else
 
1141
-    asprintf (&message, "In file '%s', around line %d",
 
1142
-             gfc_source_file, input_line + 1);
 
1143
+    rv_neverused = asprintf (&message, "In file '%s', around line %d",
 
1144
+                            gfc_source_file, input_line + 1);
 
1145
 
 
1146
   arg = gfc_build_addr_expr (pchar_type_node,
 
1147
                             gfc_build_localized_cstring_const (message));
 
1148
   gfc_free(message);
 
1149
   
 
1150
-  asprintf (&message, "%s", _(msgid));
 
1151
+  rv_neverused = asprintf (&message, "%s", _(msgid));
 
1152
   arg2 = gfc_build_addr_expr (pchar_type_node,
 
1153
                              gfc_build_localized_cstring_const (message));
 
1154
   gfc_free(message);
 
1155
--- a/src/gcc/ira-conflicts.c
 
1156
+++ b/src/gcc/ira-conflicts.c
 
1157
@@ -664,7 +664,7 @@ print_hard_reg_set (FILE *file, const char *title, HARD_REG_SET set)
 
1158
 {
 
1159
   int i, start;
 
1160
 
 
1161
-  fprintf (file, title);
 
1162
+  fputs (title, file);
 
1163
   for (start = -1, i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 
1164
     {
 
1165
       if (TEST_HARD_REG_BIT (set, i))
 
1166
--- a/src/gcc/objc/objc-act.c
 
1167
+++ b/src/gcc/objc/objc-act.c
 
1168
@@ -988,7 +988,7 @@ objc_lookup_protocol (tree proto, tree cls, tree typ, bool warn)
 
1169
       strcat (errbuf, " the \'");
 
1170
       strcat (errbuf, IDENTIFIER_POINTER (PROTOCOL_NAME (proto)));
 
1171
       strcat (errbuf, "\' protocol");
 
1172
-      warning (0, errbuf);
 
1173
+      warning (0, "%s", errbuf);
 
1174
     }
 
1175
 
 
1176
   return false;
 
1177
--- a/src/gcc/opts.c
 
1178
+++ b/src/gcc/opts.c
 
1179
@@ -1287,7 +1287,7 @@ print_filtered_help (unsigned int include_flags,
 
1180
                      if (* (const char **) option->flag_var != NULL)
 
1181
                        snprintf (new_help + strlen (new_help),
 
1182
                                  sizeof (new_help) - strlen (new_help),
 
1183
-                                 * (const char **) option->flag_var);
 
1184
+                                 "%s", * (const char **) option->flag_var);
 
1185
                    }
 
1186
                  else
 
1187
                    sprintf (new_help + strlen (new_help),
 
1188
--- a/src/gcc/toplev.c
 
1189
+++ b/src/gcc/toplev.c
 
1190
@@ -1182,7 +1182,7 @@ print_to_asm_out_file (print_switch_type type, const char * text)
 
1191
     case SWITCH_TYPE_ENABLED:
 
1192
       if (prepend_sep)
 
1193
        fputc (' ', asm_out_file);
 
1194
-      fprintf (asm_out_file, text);
 
1195
+      fputs (text, asm_out_file);
 
1196
       /* No need to return the length here as
 
1197
         print_single_switch has already done it.  */
 
1198
       return 0;
 
1199
@@ -1211,7 +1211,7 @@ print_to_stderr (print_switch_type type, const char * text)
 
1200
       /* Drop through.  */
 
1201
 
 
1202
     case SWITCH_TYPE_DESCRIPTIVE:
 
1203
-      fprintf (stderr, text);
 
1204
+      fputs (text, stderr);
 
1205
       /* No need to return the length here as
 
1206
         print_single_switch has already done it.  */
 
1207
       return 0;
 
1208
@@ -1437,8 +1437,11 @@ static const char *
 
1209
 pch_option_mismatch (const char *option)
 
1210
 {
 
1211
   char *r;
 
1212
+  int rv_neverused ATTRIBUTE_UNUSED;
 
1213
 
 
1214
-  asprintf (&r, _("created and used with differing settings of '%s'"), option);
 
1215
+  rv_neverused = asprintf (&r,
 
1216
+                          _("created and used with differing settings of '%s'"),
 
1217
+                          option);
 
1218
   if (r == NULL)
 
1219
     return _("out of memory");
 
1220
   return r;
 
1221
--- a/src/gcc/tree-data-ref.c
 
1222
+++ b/src/gcc/tree-data-ref.c
 
1223
@@ -4607,13 +4607,14 @@ dot_rdg_1 (FILE *file, struct graph *rdg)
 
1224
 void
 
1225
 dot_rdg (struct graph *rdg)
 
1226
 {
 
1227
+  int rv_neverused ATTRIBUTE_UNUSED;
 
1228
   FILE *file = fopen ("/tmp/rdg.dot", "w");
 
1229
   gcc_assert (file != NULL);
 
1230
 
 
1231
   dot_rdg_1 (file, rdg);
 
1232
   fclose (file);
 
1233
 
 
1234
-  system ("dotty /tmp/rdg.dot");
 
1235
+  rv_neverused = system ("dotty /tmp/rdg.dot");
 
1236
 }
 
1237
 
 
1238
 
 
1239
--- a/src/gcc/tree-ssa-structalias.c
 
1240
+++ b/src/gcc/tree-ssa-structalias.c
 
1241
@@ -4240,6 +4240,7 @@ create_function_info_for (tree decl, const char *name)
 
1242
   tree arg;
 
1243
   unsigned int i;
 
1244
   bool is_varargs = false;
 
1245
+  int rv_neverused ATTRIBUTE_UNUSED;
 
1246
 
 
1247
   /* Create the variable info.  */
 
1248
 
 
1249
@@ -4279,7 +4280,7 @@ create_function_info_for (tree decl, const char *name)
 
1250
        argdecl = arg;
 
1251
 
 
1252
       newindex = VEC_length (varinfo_t, varmap);
 
1253
-      asprintf (&tempname, "%s.arg%d", name, i-1);
 
1254
+      rv_neverused = asprintf (&tempname, "%s.arg%d", name, i-1);
 
1255
       newname = ggc_strdup (tempname);
 
1256
       free (tempname);
 
1257
 
 
1258
@@ -4315,7 +4316,7 @@ create_function_info_for (tree decl, const char *name)
 
1259
        resultdecl = DECL_RESULT (decl);
 
1260
 
 
1261
       newindex = VEC_length (varinfo_t, varmap);
 
1262
-      asprintf (&tempname, "%s.result", name);
 
1263
+      rv_neverused = asprintf (&tempname, "%s.result", name);
 
1264
       newname = ggc_strdup (tempname);
 
1265
       free (tempname);
 
1266
 
 
1267
@@ -4474,9 +4475,11 @@ create_variable_info_for (tree decl, const char *name)
 
1268
          newindex = VEC_length (varinfo_t, varmap);
 
1269
          if (dump_file)
 
1270
            {
 
1271
-             asprintf (&tempname, "%s." HOST_WIDE_INT_PRINT_DEC
 
1272
-                       "+" HOST_WIDE_INT_PRINT_DEC,
 
1273
-                       vi->name, fo->offset, fo->size);
 
1274
+             int rv_neverused ATTRIBUTE_UNUSED;
 
1275
+
 
1276
+             rv_neverused = asprintf (&tempname, "%s." HOST_WIDE_INT_PRINT_DEC
 
1277
+                                      "+" HOST_WIDE_INT_PRINT_DEC,
 
1278
+                                      vi->name, fo->offset, fo->size);
 
1279
              newname = ggc_strdup (tempname);
 
1280
              free (tempname);
 
1281
            }
 
1282
--- a/src/gcc/tree-switch-conversion.c
 
1283
+++ b/src/gcc/tree-switch-conversion.c
 
1284
@@ -858,7 +858,7 @@ do_switchconv (void)
 
1285
              {
 
1286
                gcc_assert (info.reason);
 
1287
                fprintf (dump_file, "Bailing out - ");
 
1288
-               fprintf (dump_file, info.reason);
 
1289
+               fprintf (dump_file, "%s", info.reason);
 
1290
                fprintf (dump_file, "--------------------------------\n");
 
1291
              }
 
1292
          }
 
1293
--- a/src/libcpp/lex.c
 
1294
+++ b/src/libcpp/lex.c
 
1295
@@ -1512,6 +1512,8 @@ cpp_type2name (enum cpp_ttype type)
 
1296
 void
 
1297
 cpp_output_token (const cpp_token *token, FILE *fp)
 
1298
 {
 
1299
+  size_t rv_neverused ATTRIBUTE_UNUSED;
 
1300
+
 
1301
   switch (TOKEN_SPELL (token))
 
1302
     {
 
1303
     case SPELL_OPERATOR:
 
1304
@@ -1545,7 +1547,7 @@ cpp_output_token (const cpp_token *token, FILE *fp)
 
1305
            {
 
1306
              unsigned char buffer[10];
 
1307
              i += utf8_to_ucn (buffer, name + i) - 1;
 
1308
-             fwrite (buffer, 1, 10, fp);
 
1309
+             rv_neverused = fwrite (buffer, 1, 10, fp);
 
1310
            }
 
1311
          else
 
1312
            fputc (NODE_NAME (token->val.node)[i], fp);
 
1313
@@ -1553,7 +1555,7 @@ cpp_output_token (const cpp_token *token, FILE *fp)
 
1314
       break;
 
1315
 
 
1316
     case SPELL_LITERAL:
 
1317
-      fwrite (token->val.str.text, 1, token->val.str.len, fp);
 
1318
+      rv_neverused = fwrite (token->val.str.text, 1, token->val.str.len, fp);
 
1319
       break;
 
1320
 
 
1321
     case SPELL_NONE:
 
1322
--- a/src/libcpp/macro.c
 
1323
+++ b/src/libcpp/macro.c
 
1324
@@ -1701,7 +1701,7 @@ create_iso_definition (cpp_reader *pfile, cpp_macro *macro)
 
1325
             function-like macros, but not at the end.  */
 
1326
          if (following_paste_op)
 
1327
            {
 
1328
-             cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
 
1329
+             cpp_error (pfile, CPP_DL_ERROR, "%s", paste_op_error_msg);
 
1330
              return false;
 
1331
            }
 
1332
          break;
 
1333
@@ -1714,7 +1714,7 @@ create_iso_definition (cpp_reader *pfile, cpp_macro *macro)
 
1334
             function-like macros, but not at the beginning.  */
 
1335
          if (macro->count == 1)
 
1336
            {
 
1337
-             cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
 
1338
+             cpp_error (pfile, CPP_DL_ERROR, "%s", paste_op_error_msg);
 
1339
              return false;
 
1340
            }
 
1341