1. Consolite option/flag mutually exslusive messages.

   %s= and %s= are mutually exclusive
   %s= and %s= are mutually exclusive. %s= will be ignored.
   %s= and %s=/%s= are mutually exclusive
   %s=, %s=, %s= and %s= are mutually exclusive.
   %s=, %s= and %s= are mutually exclusive
   -%c and %s= are mutually exclusive
   -%c and -%c are mutually exclusive
   -%c, -%c, %s=, %s= and %s= are mutually exclusive
   -%c/-%c and %s= are mutually exclusive
   -%c/-%c and %s=%s are mutually exclusive
   -%c/-%c and -%c are mutually exclusive

2. Option(s) <opt>, ... => opt=, ...
3. Flag(s) -f, ... => -f, ...



git-svn-id: https://svn.osgeo.org/grass/grass/trunk@60703 15284696-431f-4ddb-bdfa-cd5b030d7da7

display/d.vect/shape.c

@@ -195,8 +195,8 @@ int display_shape(struct Map_info *Map, int type, struct cat_list *Clist, const
 	    z_style = NULL;
 	}
         else if (rgb_column) {
-            G_warning(_("Options <%s> and <%s> are mutually exclusive. "
-                        "Option <%s> will be ignored."), "zcolor", "rgb_column", "zcolor");
+            G_warning(_("%s= and %s= are mutually exclusive. "
+                        "%s= will be ignored."), "zcolor", "rgb_column", "zcolor");
 	    z_style = NULL;
         }
 	else {

general/g.gisenv/main.c

@@ -94,7 +94,8 @@ int main(int argc, char *argv[])
 	exit(EXIT_FAILURE);
 
     if (flag_s->answer && flag_n->answer)
-	G_fatal_error(_("Flags -%c and -%c are mutually exclusive"), flag_s->key, flag_n->key);
+	G_fatal_error(_("-%c and -%c are mutually exclusive"),
+			flag_s->key, flag_n->key);
 
     nopts = 0;
     if (get_opt->answer)
@@ -128,7 +129,7 @@ int main(int argc, char *argv[])
     }
     
     if (nopts != 1)
-	G_fatal_error(_("Options <%s>, <%s>, and <%s> are mutually exclusive"),
+	G_fatal_error(_("%s=, %s= and %s= are mutually exclusive"),
 		      get_opt->key, set_opt->key, unset_opt->key);
     
     store = G_VAR_GISRC;

gui/wxpython/animation/g.gui.animation.py

@@ -84,7 +84,8 @@ def main():
         
 
     if numInputs > 1:
-        grass.fatal(_("Options 'rast', 'vect', 'strds' and 'stvds' are mutually exclusive."))
+        grass.fatal(_("%s=, %s=, %s= and %s= are mutually exclusive.") %
+                ("rast", "vect", "strds", "stvds"))
         
     if numInputs > 0:
         # We need to initialize the temporal framework in case

lib/python/temporal/register.py

@@ -74,20 +74,16 @@ def register_maps_in_space_time_dataset(
         increment = str(increment)
 
     if maps and file:
-        msgr.fatal(_("%(m)s= and %(f)s= are mutually exclusive") % {'m': "maps",
-                                                                    'f': "file"})
+        msgr.fatal(_("%s= and %s= are mutually exclusive") % ("maps", "file"))
 
     if end and increment:
-        msgr.fatal(_("%(e)s= and %(i)s= are mutually exclusive") % {'e': "end",
-                   'i': "increment"})
+        msgr.fatal(_("%s= and %s= are mutually exclusive") % ("end", "increment"))
 
     if end and not start:
-        msgr.fatal(_("Please specify %(st)s= and %(e)s=") % {'st': "start_time",
-                                                             'e': "end_time"})
+        msgr.fatal(_("Please specify %s= and %s=") % ("start_time", "end_time"))
 
     if not maps and not file:
-        msgr.fatal(_("Please specify %(m)s= or %(f)s=") % {'m': "maps",
-                                                           'f': "file"})
+        msgr.fatal(_("Please specify %s= or %s=") % ("maps", "file"))
     # We may need the mapset
     mapset = get_current_mapset()
     dbif, connected = init_dbif(None)

raster/r.colors/edit_colors.c

@@ -162,15 +162,15 @@ int edit_colors(int argc, char **argv, int type, const char *maptype,
     file = opt.file->answer;
 
     if (opt.maps->answer && opt.file->answer)
-        G_fatal_error(_("Options <%s> and <%s> are mutually exclusive"),
+        G_fatal_error(_("%s= and %s= are mutually exclusive"),
 		      opt.maps->key, opt.file->key);
 
     if (!opt.maps->answer && !opt.file->answer)
-        G_fatal_error(_("Option <%s> or <%s> must be specified"),
+        G_fatal_error(_("%s= or %s= must be specified"),
 		      opt.maps->key, opt.file->key);
 
     if (opt.rast->answer && opt.volume->answer)
-        G_fatal_error(_("Options <%s> and <%s> are mutually exclusive"),
+        G_fatal_error(_("%s= and %s= are mutually exclusive"),
 		      opt.rast->key, opt.volume->key);
 
     if (opt.rast->answer)
@@ -179,17 +179,16 @@ int edit_colors(int argc, char **argv, int type, const char *maptype,
         cmap = opt.volume->answer;
 
     if (!cmap && !style && !rules && !remove)
-        G_fatal_error(_("One of -%c or options <%s>, <%s> or <%s> "
-			"must be specified"), flag.r->key, opt.colr->key,
-			opt.rast->key, opt.rules->key);
+        G_fatal_error(_("One of -%c, %s=, %s= or %s= must be specified"),
+			flag.r->key, opt.colr->key, opt.rast->key,
+			opt.rules->key);
     
     if (!!style + !!cmap + !!rules > 1)
-        G_fatal_error(_("Options <%s>, <%s>, and <%s> are mutually "
-			"exclusive"), opt.colr->key, opt.rules->key,
-		      opt.rast->key);
+        G_fatal_error(_("%s=, %s= and %s= are mutually exclusive"),
+			opt.colr->key, opt.rules->key, opt.rast->key);
     
     if (flag.g->answer && flag.a->answer)
-        G_fatal_error(_("Flags -%c and -%c are mutually exclusive"),
+        G_fatal_error(_("-%c and -%c are mutually exclusive"),
 		      flag.g->key, flag.a->key);
 
     is_from_stdin = rules && strcmp(rules, "-") == 0;

raster/r.external/main.c

@@ -140,11 +140,11 @@ int main(int argc, char *argv[])
 	title = NULL;
 
     if (!input && !source)
-	G_fatal_error(_("One of options <%s> or <%s> must be given"),
+	G_fatal_error(_("%s= or %s= must be given"),
 		      parm.input->key, parm.source->key);
 
     if (input && source)
-	G_fatal_error(_("Option <%s> and <%s> are mutually exclusive"),
+	G_fatal_error(_("%s= and %s= are mutually exclusive"),
 		      parm.input->key, parm.source->key);
     
     if (input && !G_is_absolute_path(input)) {

raster/r.in.bin/main.c

@@ -363,7 +363,8 @@ int main(int argc, char *argv[])
 
     if (flag.swap->answer) {
 	if (strcmp(parm.order->answer, "native") != 0)
-	    G_fatal_error(_("order= and -b are mutually exclusive"));
+	    G_fatal_error(_("-%c and %s= are mutually exclusive"),
+			    flag.swap->key, parm.order->key);
 	order = G_is_little_endian() ? 0 : 1;
     }
 
@@ -378,11 +379,13 @@ int main(int argc, char *argv[])
 	bytes = atoi(parm.bytes->answer);
 
     if (flag.float_in->answer && flag.double_in->answer)
-	G_fatal_error(_("-f and -d are mutually exclusive"));
+	G_fatal_error(_("-%c and -%c are mutually exclusive"),
+			flag.float_in->key, flag.double_in->key);
 
     if (flag.float_in->answer) {
 	if (bytes && bytes < 4)
-	    G_fatal_error(_("-f incompatible with bytes=%d; must be 4 or 8"), bytes);
+	    G_fatal_error(_("-%c incompatible with %s=%d; must be 4 or 8"),
+			    flag.float_in->key, parm.bytes->key, bytes);
 	if (!bytes)
 	    bytes = 4;
 	is_fp = 1;
@@ -390,22 +393,24 @@ int main(int argc, char *argv[])
 
     if (flag.double_in->answer) {
 	if (bytes && bytes != 8)
-	    G_fatal_error(_("-d incompatible with bytes=%d; must be 8"), bytes);
+	    G_fatal_error(_("-%c incompatible with %s=%d; must be 8"),
+			    flag.double_in->key, parm.bytes->key, bytes);
 	if (!bytes)
 	    bytes = 8;
 	is_fp = 1;
     }
 
     if (!is_fp && !bytes)
-	G_fatal_error(_("bytes= required for integer data"));
+	G_fatal_error(_("%s= required for integer data"), parm.bytes->key);
 
 #ifndef HAVE_LONG_LONG_INT
     if (!is_fp && bytes > 4)
-	G_fatal_error(_("Integer input doesn't support size=8 in this build"));
+	G_fatal_error(_("Integer input doesn't support %s=8 in this build"),
+			parm.bytes->key);
 #endif
 
     if (bytes != 1 && bytes != 2 && bytes != 4 && bytes != 8)
-	G_fatal_error(_("bytes= must be 1, 2, 4 or 8"));
+	G_fatal_error(_("%s= must be 1, 2, 4 or 8"), parm.bytes->key);
 
     if (parm.null->answer)
 	null_val = atof(parm.null->answer);
@@ -418,12 +423,15 @@ int main(int argc, char *argv[])
 	int num_bounds;
 
 	if (!parm.rows->answer || !parm.cols->answer)
-	    G_fatal_error(_("Either -h or rows= and cols= must be given"));
+	    G_fatal_error(_("Either -%c or %s= and %s= must be given"),
+			    flag.gmt_hd->key, parm.rows->key, parm.cols->key);
 
 	num_bounds = !!parm.north->answer + !!parm.south->answer +
 	    !!parm.east->answer + !!parm.west->answer;
 	if (num_bounds != 0 && num_bounds != 4)
-	    G_fatal_error(_("Either all or none of north=, south=, east= and west= must be given"));
+	    G_fatal_error(_("Either all or none of %s=, %s=, %s= and %s= must be given"),
+			    parm.north->key, parm.south->key,
+			    parm.east->key, parm.west->key);
 
 	cellhd.rows = atoi(parm.rows->answer);
 	cellhd.cols = atoi(parm.cols->answer);
@@ -463,8 +471,8 @@ int main(int argc, char *argv[])
 	G_warning(
 	    _("East-West (ewres: %f) and North-South (nwres: %f) "
 	      "resolution differ significantly. "
-	      "Did you assign east= and west= correctly?"),
-	    cellhd.ew_res, cellhd.ns_res);
+	      "Did you assign %s= and %s= correctly?"),
+	    cellhd.ew_res, cellhd.ns_res, parm.east->key, parm.west->key);
 
     grass_nrows = nrows = cellhd.rows;
     grass_ncols = ncols = cellhd.cols;

raster/r.mapcalc/main.c

@@ -142,7 +142,8 @@ int main(int argc, char **argv)
     overwrite_flag = module->overwrite;
 
     if (expr->answer && file->answer)
-	G_fatal_error(_("file= and expression= are mutually exclusive"));
+	G_fatal_error(_("%s= and %s= are mutually exclusive"),
+			expr->key, file->key);
 
     if (expr->answer)
 	result = parse_string(expr->answer);

raster/r.neighbors/main.c

@@ -257,10 +257,12 @@ int main(int argc, char *argv[])
     ncb.dist = ncb.nsize / 2;
 
     if (parm.weight->answer && flag.circle->answer)
-	G_fatal_error(_("weight= and -c are mutually exclusive"));
+	G_fatal_error(_("-%c and %s= are mutually exclusive"),
+			flag.circle->key, parm.weight->key);
 
     if (parm.weight->answer && parm.gauss->answer)
-	G_fatal_error(_("weight= and gauss= are mutually exclusive"));
+	G_fatal_error(_("%s= and %s= are mutually exclusive"),
+			parm.weight->key, parm.gauss->key);
 
     ncb.oldcell = parm.input->answer;
 
@@ -286,7 +288,8 @@ int main(int argc, char *argv[])
     for (i = 0; parm.method->answers[i]; i++)
 	;
     if (num_outputs != i)
-	G_fatal_error(_("output= and method= must have the same number of values"));
+	G_fatal_error(_("%s= and %s= must have the same number of values"),
+			parm.output->key, parm.method->key);
 
     outputs = G_calloc(num_outputs, sizeof(struct output));
 

raster/r.out.bin/main.c

@@ -364,7 +364,8 @@ int main(int argc, char *argv[])
 
     if (flag.swap->answer) {
 	if (strcmp(parm.order->answer, "native") != 0)
-	    G_fatal_error(_("order= and -s are mutually exclusive"));
+	    G_fatal_error(_("-%c and %s= are mutually exclusive"),
+			    flag.swap->key, parm.order->key);
 	order = G_is_little_endian() ? 0 : 1;
     }
 
@@ -373,7 +374,8 @@ int main(int argc, char *argv[])
     do_stdout = strcmp("-", outfile) == 0;
 
     if (flag.int_out->answer && flag.float_out->answer)
-	G_fatal_error(_("-i and -f are mutually exclusive"));
+	G_fatal_error(_("-%c and -%c are mutually exclusive"),
+			flag.int_out->key, flag.float_out->key);
 
     fd = Rast_open_old(name, "");
 
@@ -392,11 +394,13 @@ int main(int argc, char *argv[])
 	bytes = 2;
 
     if (is_fp && bytes < 4)
-	G_fatal_error(_("Floating-point output requires bytes=4 or bytes=8"));
+	G_fatal_error(_("Floating-point output requires %s=4 or %s=8"),
+			parm.bytes->key, parm.bytes->key);
 
 #ifndef HAVE_LONG_LONG_INT
     if (!is_fp && bytes > 4)
-	G_fatal_error(_("Integer output doesn't support bytes=8 in this build"));
+	G_fatal_error(_("Integer output doesn't support %s=8 in this build"),
+			parm.bytes->key);
 #endif
 
     G_get_window(&region);
@@ -433,12 +437,14 @@ int main(int argc, char *argv[])
     out_buf = G_malloc(ncols * bytes);
 
     if (is_fp) {
-	G_message(_("Exporting raster as floating values (bytes=%d)"), bytes);
+	G_message(_("Exporting raster as floating values (%s=%d)"),
+			parm.bytes->key, bytes);
 	if (flag.gmt_hd->answer)
 	    G_message(_("Writing GMT float format ID=1"));
     }
     else {
-	G_message(_("Exporting raster as integer values (bytes=%d)"), bytes);
+	G_message(_("Exporting raster as integer values (%s=%d)"),
+			parm.bytes->key, bytes);
 	if (flag.gmt_hd->answer)
 	    G_message(_("Writing GMT integer format ID=2"));
     }

raster/r.quant/main.c

@@ -108,7 +108,8 @@ int main(int argc, char *argv[])
     if (rules->answer)
 	i++;
     if (i > 1)
-	G_fatal_error(_("-t, -r, rules=, basemap= and fprange= are mutually exclusive"));
+	G_fatal_error(_("-%c, -%c, %s=, %s= and %s= are mutually exclusive"),
+			trunc->key, rnd->key, rules->key, basemap->key, fprange->key);
 
     i = 0;
     if (fprange->answer)
@@ -116,7 +117,8 @@ int main(int argc, char *argv[])
     if (range->answer)
 	i++;
     if (i == 1)
-	G_fatal_error(_("fprange= and range= must be used together"));
+	G_fatal_error(_("%s= and %s= must be used together"),
+			fprange->key, range->key);
 
     for (noi = 0; input->answers[noi]; noi++)
 	;
@@ -158,9 +160,11 @@ int main(int argc, char *argv[])
     else if (fprange->answer)
     {
 	if (sscanf(fprange->answer, "%lf,%lf", &new_dmin, &new_dmax) != 2)
-	    G_fatal_error(_("invalid value for fprange= <%s>"), fprange->answer);
+	    G_fatal_error(_("invalid value for %s= <%s>"),
+			    fprange->key, fprange->answer);
 	if (sscanf(range->answer, "%d,%d", &new_min, &new_max) != 2)
-	    G_fatal_error(_("invalid value for range= <%s>"), range->answer);
+	    G_fatal_error(_("invalid value for %s= <%s>"),
+			    range->key, range->answer);
 	G_message(_("Setting quant rules for input map(s) to (%f,%f) -> (%d,%d)"),
 		  new_dmin, new_dmax, new_min, new_max);
 	Rast_quant_add_rule(&quant_struct, new_dmin, new_dmax, new_min, new_max);

raster/r.resamp.filter/main.c

@@ -429,13 +429,16 @@ int main(int argc, char *argv[])
 
     if (parm.radius->answer) {
 	if (parm.x_radius->answer || parm.y_radius->answer)
-	    G_fatal_error(_("radius= and x_radius=/y_radius= are mutually exclusive"));
+	    G_fatal_error(_("%s= and %s=/%s= are mutually exclusive"),
+			    parm.radius->key, parm.x_radius->key, parm.y_radius->key);
     }
     else {
 	if (!parm.x_radius->answer && !parm.y_radius->answer)
-	    G_fatal_error(_("Either radius= or x_radius=/y_radius= required"));
+	    G_fatal_error(_("Either %s= or %s=/%s= required"),
+			    parm.radius->key, parm.x_radius->key, parm.y_radius->key);
 	if (!parm.x_radius->answer || !parm.y_radius->answer)
-	    G_fatal_error(_("Both x_radius= and y_radius= required"));
+	    G_fatal_error(_("Both %s= and %s= required"),
+			    parm.x_radius->key, parm.y_radius->key);
     }
 
     nulls = flag.nulls->answer;

raster/r.series.accumulate/main.c

@@ -207,10 +207,12 @@ int main(int argc, char *argv[])
         tshift = 0.;
     
     if (parm.input->answer && parm.file->answer)
-        G_fatal_error(_("input= and file= are mutually exclusive"));
+        G_fatal_error(_("%s= and %s= are mutually exclusive"),
+			parm.input->key, parm.file->key);
     
     if (!parm.input->answer && !parm.file->answer)
-        G_fatal_error(_("Please specify input= or file="));
+        G_fatal_error(_("Please specify %s= or %s="),
+			parm.input->key, parm.file->key);
     
     max_inputs = 0;
     
@@ -455,4 +457,4 @@ int main(int argc, char *argv[])
     }
     
     exit(EXIT_SUCCESS);
-}
+}

raster/r.series.interp/main.c

@@ -113,28 +113,36 @@ int main(int argc, char *argv[])
 	exit(EXIT_FAILURE);
 
     if (parm.output->answer && parm.outfile->answer)
-        G_fatal_error(_("output= and outfile= are mutually exclusive"));
+        G_fatal_error(_("%s= and %s= are mutually exclusive"),
+			parm.output->key, parm.outfile->key);
  
     if (parm.samplingpos->answer && parm.outfile->answer)
-        G_fatal_error(_("samplingpos= and outfile= are mutually exclusive"));
+        G_fatal_error(_("%s= and %s= are mutually exclusive"),
+			parm.samplingpos->key, parm.outfile->key);
  
     if (!parm.output->answer && !parm.outfile->answer)
-        G_fatal_error(_("Please specify output= or outfile="));
+        G_fatal_error(_("Please specify %s= or %s="),
+			parm.output->key, parm.outfile->key);
  
     if (parm.output->answer && !parm.samplingpos->answer)
-        G_fatal_error(_("Please specify output= and samplingpos="));
+        G_fatal_error(_("Please specify %s= and %s="),
+			parm.output->key, parm.samplingpos->key);
 
     if (parm.input->answer && parm.infile->answer)
-        G_fatal_error(_("input= and infile= are mutually exclusive"));
+        G_fatal_error(_("%s= and %s= are mutually exclusive"),
+			parm.input->key, parm.infile->key);
  
     if (parm.datapos->answer && parm.infile->answer)
-        G_fatal_error(_("datapos= and infile= are mutually exclusive"));
+        G_fatal_error(_("%s= and %s= are mutually exclusive"),
+			parm.datapos->key, parm.infile->key);
  
     if (!parm.input->answer && !parm.infile->answer)
-        G_fatal_error(_("Please specify input= or infile="));
+        G_fatal_error(_("Please specify %s= or %s="),
+			parm.input->key, parm.infile->key);
  
     if (parm.input->answer && !parm.datapos->answer)
-        G_fatal_error(_("Please specify input= and datapos="));
+        G_fatal_error(_("Please specify %s= and %s="),
+			parm.input->key, parm.datapos->key);
 
     if(G_strncasecmp(parm.method->answer, "linear", 6) == 0)
         interpol_method = LINEAR_INTERPOLATION;

raster/r.series/main.c

@@ -195,10 +195,12 @@ int main(int argc, char *argv[])
     }
     
     if (parm.input->answer && parm.file->answer)
-        G_fatal_error(_("input= and file= are mutually exclusive"));
+        G_fatal_error(_("%s= and %s= are mutually exclusive"),
+			parm.input->key, parm.file->key);
  
     if (!parm.input->answer && !parm.file->answer)
-        G_fatal_error(_("Please specify input= or file="));
+        G_fatal_error(_("Please specify %s= or %s="),
+			parm.input->key, parm.file->key);
 
 
     /* process the input maps from the file */

raster/r.stats.quantile/main.c

@@ -439,10 +439,12 @@ int main(int argc, char *argv[])
     print = flag.p->answer;
 
     if (!print && !opt.output->answers)
-	G_fatal_error(_("Either -p or output= must be given"));
+	G_fatal_error(_("Either -%c or %s= must be given"),
+			flag.p->key, opt.output->key);
 
     if (print && opt.output->answers)
-	G_fatal_error(_("-p and output= are mutually exclusive"));
+	G_fatal_error(_("-%c and %s= are mutually exclusive"),
+			flag.p->key, opt.output->key);
 
     num_slots = atoi(opt.slots->answer);
 

vector/v.colors/main.c

@@ -204,7 +204,7 @@ int main(int argc, char *argv[])
     }
 
     if (opt.rast->answer && opt.volume->answer)
-        G_fatal_error(_("Options <%s> and <%s> are mutually exclusive"),
+        G_fatal_error(_("%s= and %s= are mutually exclusive"),
 		      opt.rast->key, opt.volume->key);
 
     cmap = NULL;
@@ -214,21 +214,20 @@ int main(int argc, char *argv[])
         cmap = opt.volume->answer;
     
     if (!cmap && !style && !rules && !remove && !convert)
-        G_fatal_error(_("One of -%c, -%c or options <%s>, <%s> or <%s> "
+        G_fatal_error(_("One of -%c, -%c or %s=, %s= or %s= "
 			"must be specified"), flag.r->key, flag.c->key, 
 		      opt.colr->key, opt.rast->key, opt.rules->key);
     
     if (!!style + !!cmap + !!rules > 1)
-        G_fatal_error(_("Options <%s>, <%s>, and <%s> are mutually "
-			"exclusive"), opt.colr->key, opt.rules->key,
-		      opt.rast->key);
+        G_fatal_error(_("%s=, %s= and %s= are mutually exclusive"),
+			opt.colr->key, opt.rules->key, opt.rast->key);
 
     if (flag.g->answer && flag.a->answer)
-        G_fatal_error(_("Flags -%c and -%c are mutually exclusive"),
+        G_fatal_error(_("-%c and -%c are mutually exclusive"),
 		      flag.g->key, flag.a->key);
 
     if (flag.c->answer && !rgbcolumn) 
-	G_fatal_error(_("Option <%s> required for flag -%c"),
+	G_fatal_error(_("%s= required for -%c"),
 		      opt.rgbcol->key, flag.c->key);
 
     is_from_stdin = rules && strcmp(rules, "-") == 0;

vector/v.external.out/args.c

@@ -85,17 +85,17 @@ void parse_args(int argc, char **argv,
     /* check options */
     if (options->dsn->answer && options->format->answer &&
         options->input->answer)
-        G_fatal_error(_("Options <%s/%s> and <%s> are mutually exclusive"),
-                      options->dsn->key, options->format->key,
-                      options->input->key);
+        G_fatal_error(_("%s= and %s=/%s= are mutually exclusive"),
+                      options->input->key,
+                      options->dsn->key, options->format->key);
     if (flags->f->answer || flags->p->answer || flags->r->answer || flags->g->answer ||
         options->output->answer)
         return;
 
     if (!options->dsn->answer && !options->input->answer)
-        G_fatal_error(_("One of options <%s> or <%s> must be specified"),
+        G_fatal_error(_("%s= or %s= must be specified"),
                       options->dsn->key, options->input->key);
     if (options->dsn->answer && !options->format->answer)
-        G_fatal_error(_("Option <%s> must be specified"),
+        G_fatal_error(_("%s= must be specified"),
                       options->format->key);
 }