Refactoring option handling.

diff --git a/MagickCore/option.c b/MagickCore/option.c
index 89e8140b6e93e4f0d0edd072f13f392ae64bfe74..097a5c2e30560bbe8c211b62f579be2b995330d6 100644 (file)
--- a/MagickCore/option.c
+++ b/MagickCore/option.c
@@ -179,17 +179,17 @@ static const OptionInfo
            sort -k 1.2  t1 | diff t1 -
        Should not show any differences...
     */
-    { "(", 0L, SpecialOptionFlag, MagickTrue },
-    { ")", 0L, SpecialOptionFlag, MagickTrue },
-    { "{", 0L, SpecialOptionFlag, MagickTrue },
-    { "}", 0L, SpecialOptionFlag, MagickTrue },
-    { "--", 1L, SpecialOptionFlag, MagickTrue },
+    { "(", 0L, NoImageOperatorFlag, MagickTrue },
+    { ")", 0L, NoImageOperatorFlag, MagickTrue },
+    { "{", 0L, NoImageOperatorFlag, MagickTrue },
+    { "}", 0L, NoImageOperatorFlag, MagickTrue },
+    { "--", 1L, NoImageOperatorFlag, MagickTrue },
     { "+adaptive-blur", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-adaptive-blur", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-adaptive-blur", 1L, SimpleOperatorFlag, MagickFalse },
     { "+adaptive-resize", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-adaptive-resize", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-adaptive-resize", 1L, SimpleOperatorFlag, MagickFalse },
     { "+adaptive-sharpen", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-adaptive-sharpen", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-adaptive-sharpen", 1L, SimpleOperatorFlag, MagickFalse },
     { "+adjoin", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-adjoin", 0L, ImageInfoOptionFlag, MagickFalse },
     { "+affine", 0L, ReplacedOptionFlag | DrawInfoOptionFlag, MagickTrue },
@@ -197,25 +197,25 @@ static const OptionInfo
     { "+affinity", 0L, DeprecateOptionFlag, MagickTrue },
     { "-affinity", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
     { "+alpha", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-alpha", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-alpha", 1L, SimpleOperatorFlag, MagickFalse },
     { "+annotate", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-annotate", 2L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-annotate", 2L, SimpleOperatorFlag, MagickFalse },
     { "+antialias", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
     { "-antialias", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
-    { "+append", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
-    { "-append", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+    { "+append", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
+    { "-append", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
     { "+attenuate", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-attenuate", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+authenticate", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-authenticate", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+auto-gamma", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-auto-gamma", 0L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-auto-gamma", 0L, SimpleOperatorFlag, MagickFalse },
     { "+auto-level", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-auto-level", 0L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-auto-level", 0L, SimpleOperatorFlag, MagickFalse },
     { "+auto-orient", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-auto-orient", 0L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-auto-orient", 0L, SimpleOperatorFlag, MagickFalse },
     { "+average", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-average", 0L, ReplacedOptionFlag | ListOperatorOptionFlag | FireOptionFlag, MagickTrue },
+    { "-average", 0L, ReplacedOptionFlag | ListOperatorFlag | FireOptionFlag, MagickTrue },
     { "+backdrop", 0L, NonMagickOptionFlag, MagickFalse },
     { "-backdrop", 1L, NonMagickOptionFlag, MagickFalse },
     { "+background", 0L, ImageInfoOptionFlag, MagickFalse },
@@ -227,17 +227,17 @@ static const OptionInfo
     { "+black-point-compensation", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-black-point-compensation", 0L, ImageInfoOptionFlag, MagickFalse },
     { "+black-threshold", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-black-threshold", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-black-threshold", 1L, SimpleOperatorFlag, MagickFalse },
     { "+blend", 0L, NonMagickOptionFlag, MagickFalse },
     { "-blend", 1L, NonMagickOptionFlag, MagickFalse },
     { "+blue-primary", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-blue-primary", 1L, ImageInfoOptionFlag, MagickFalse },
-    { "+blue-shift", 1L, SimpleOperatorOptionFlag, MagickFalse },
-    { "-blue-shift", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "+blue-shift", 1L, SimpleOperatorFlag, MagickFalse },
+    { "-blue-shift", 1L, SimpleOperatorFlag, MagickFalse },
     { "+blur", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-blur", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-blur", 1L, SimpleOperatorFlag, MagickFalse },
     { "+border", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-border", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-border", 1L, SimpleOperatorFlag, MagickFalse },
     { "+bordercolor", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
     { "-bordercolor", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
     { "+borderwidth", 0L, NonMagickOptionFlag, MagickFalse },
@@ -245,88 +245,88 @@ static const OptionInfo
     { "+box", 0L, ReplacedOptionFlag | ImageInfoOptionFlag | DrawInfoOptionFlag, MagickTrue },
     { "-box", 1L, ReplacedOptionFlag | ImageInfoOptionFlag | DrawInfoOptionFlag, MagickTrue },
     { "+brightness-contrast", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-brightness-contrast", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-brightness-contrast", 1L, SimpleOperatorFlag, MagickFalse },
     { "+cache", 0L, GlobalOptionFlag, MagickFalse },
     { "-cache", 1L, GlobalOptionFlag, MagickFalse },
     { "+caption", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-caption", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+cdl", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-cdl", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-cdl", 1L, SimpleOperatorFlag, MagickFalse },
     { "+channel", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-channel", 1L, ImageInfoOptionFlag, MagickFalse },
-    { "-channel-fx", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+    { "-channel-fx", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
     { "+charcoal", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-charcoal", 0L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-charcoal", 0L, SimpleOperatorFlag, MagickFalse },
     { "+chop", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-chop", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-chop", 1L, SimpleOperatorFlag, MagickFalse },
     { "+clamp", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-clamp", 0L, SimpleOperatorOptionFlag, MagickFalse },
-    { "+clip", 0L, SimpleOperatorOptionFlag, MagickFalse },
-    { "-clip", 0L, SimpleOperatorOptionFlag, MagickFalse },
-    { "+clip-mask", 0L, SimpleOperatorOptionFlag, MagickFalse },
-    { "-clip-mask", 1L, SimpleOperatorOptionFlag, MagickFalse },
-    { "+clip-path", 1L, SimpleOperatorOptionFlag, MagickFalse },
-    { "-clip-path", 1L, SimpleOperatorOptionFlag, MagickFalse },
-    { "+clone", 0L, SpecialOptionFlag, MagickFalse },
-    { "-clone", 1L, SpecialOptionFlag, MagickFalse },
+    { "-clamp", 0L, SimpleOperatorFlag, MagickFalse },
+    { "+clip", 0L, SimpleOperatorFlag, MagickFalse },
+    { "-clip", 0L, SimpleOperatorFlag, MagickFalse },
+    { "+clip-mask", 0L, SimpleOperatorFlag, MagickFalse },
+    { "-clip-mask", 1L, SimpleOperatorFlag, MagickFalse },
+    { "+clip-path", 1L, SimpleOperatorFlag, MagickFalse },
+    { "-clip-path", 1L, SimpleOperatorFlag, MagickFalse },
+    { "+clone", 0L, NoImageOperatorFlag, MagickFalse },
+    { "-clone", 1L, NoImageOperatorFlag, MagickFalse },
     { "+clut", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
-    { "-clut", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+    { "-clut", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
     { "+coalesce", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
-    { "-coalesce", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+    { "-coalesce", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
     { "+color-matrix", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-color-matrix", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-color-matrix", 1L, SimpleOperatorFlag, MagickFalse },
     { "+colorize", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-colorize", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-colorize", 1L, SimpleOperatorFlag, MagickFalse },
     { "+colormap", 0L, NonMagickOptionFlag, MagickFalse },
     { "-colormap", 1L, NonMagickOptionFlag, MagickFalse },
     { "+colors", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-colors", 1L, SimpleOperatorOptionFlag, MagickFalse },
-    { "+colorspace", 0L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
-    { "-colorspace", 1L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
+    { "-colors", 1L, SimpleOperatorFlag, MagickFalse },
+    { "+colorspace", 0L, ImageInfoOptionFlag | SimpleOperatorFlag, MagickFalse },
+    { "-colorspace", 1L, ImageInfoOptionFlag | SimpleOperatorFlag, MagickFalse },
     { "+combine", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
-    { "-combine", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+    { "-combine", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
     { "+comment", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-comment", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+compose", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-compose", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+composite", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
-    { "-composite", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+    { "-composite", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
     { "+compress", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-compress", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+concurrent", 0L, DeprecateOptionFlag, MagickTrue },
     { "-concurrent", 0L, GenesisOptionFlag, MagickFalse },
-    { "+contrast", 0L, ReplacedOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
-    { "-contrast", 0L, ReplacedOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
+    { "+contrast", 0L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue },
+    { "-contrast", 0L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue },
     { "+contrast-stretch", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-contrast-stretch", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-contrast-stretch", 1L, SimpleOperatorFlag, MagickFalse },
     { "+convolve", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-convolve", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-convolve", 1L, SimpleOperatorFlag, MagickFalse },
     { "+crop", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
-    { "-crop", 1L, SimpleOperatorOptionFlag | FireOptionFlag, MagickFalse },
+    { "-crop", 1L, SimpleOperatorFlag | FireOptionFlag, MagickFalse },
     { "+cycle", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-cycle", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-cycle", 1L, SimpleOperatorFlag, MagickFalse },
     { "+debug", 0L, GlobalOptionFlag | FireOptionFlag, MagickFalse },
     { "-debug", 1L, GlobalOptionFlag | FireOptionFlag, MagickFalse },
     { "+decipher", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-decipher", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-decipher", 1L, SimpleOperatorFlag, MagickFalse },
     { "+deconstruct", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-deconstruct", 0L, ReplacedOptionFlag | ListOperatorOptionFlag | FireOptionFlag, MagickTrue },
+    { "-deconstruct", 0L, ReplacedOptionFlag | ListOperatorFlag | FireOptionFlag, MagickTrue },
     { "+define", 1L, ImageInfoOptionFlag, MagickFalse },
     { "-define", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+delay", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-delay", 1L, ImageInfoOptionFlag, MagickFalse },
-    { "+delete", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
-    { "-delete", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+    { "+delete", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
+    { "-delete", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
     { "+density", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
     { "-density", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
-    { "+depth", 0L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
-    { "-depth", 1L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
+    { "+depth", 0L, ImageInfoOptionFlag | SimpleOperatorFlag, MagickFalse },
+    { "-depth", 1L, ImageInfoOptionFlag | SimpleOperatorFlag, MagickFalse },
     { "+descend", 0L, NonMagickOptionFlag, MagickFalse },
     { "-descend", 1L, NonMagickOptionFlag, MagickFalse },
-    { "+deskew", 0L, SimpleOperatorOptionFlag, MagickFalse },
-    { "-deskew", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "+deskew", 0L, SimpleOperatorFlag, MagickFalse },
+    { "-deskew", 1L, SimpleOperatorFlag, MagickFalse },
     { "+despeckle", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-despeckle", 0L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-despeckle", 0L, SimpleOperatorFlag, MagickFalse },
     { "+direction", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
     { "-direction", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
     { "+displace", 0L, NonMagickOptionFlag, MagickFalse },
@@ -339,57 +339,57 @@ static const OptionInfo
     { "-dissolve", 1L, NonMagickOptionFlag, MagickFalse },
     { "+dissimilarity-threshold", 0L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse },
     { "-dissimilarity-threshold", 1L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse },
-    { "+distort", 2L, SimpleOperatorOptionFlag, MagickFalse },
-    { "-distort", 2L, SimpleOperatorOptionFlag, MagickFalse },
+    { "+distort", 2L, SimpleOperatorFlag, MagickFalse },
+    { "-distort", 2L, SimpleOperatorFlag, MagickFalse },
     { "+dither", 0L, ImageInfoOptionFlag | QuantizeInfoOptionFlag, MagickFalse },
     { "-dither", 1L, ImageInfoOptionFlag | QuantizeInfoOptionFlag, MagickFalse },
     { "+draw", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-draw", 1L, SimpleOperatorOptionFlag, MagickFalse },
-    { "+duplicate", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
-    { "-duplicate", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+    { "-draw", 1L, SimpleOperatorFlag, MagickFalse },
+    { "+duplicate", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
+    { "-duplicate", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
     { "+duration", 1L, GenesisOptionFlag, MagickFalse },
     { "-duration", 1L, GenesisOptionFlag, MagickFalse },
     { "+edge", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-edge", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-edge", 1L, SimpleOperatorFlag, MagickFalse },
     { "+emboss", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-emboss", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-emboss", 1L, SimpleOperatorFlag, MagickFalse },
     { "+encipher", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-encipher", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-encipher", 1L, SimpleOperatorFlag, MagickFalse },
     { "+encoding", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
     { "-encoding", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
     { "+endian", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-endian", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+enhance", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-enhance", 0L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-enhance", 0L, SimpleOperatorFlag, MagickFalse },
     { "+equalize", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-equalize", 0L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-equalize", 0L, SimpleOperatorFlag, MagickFalse },
     { "+evaluate", 2L, DeprecateOptionFlag, MagickTrue },
-    { "-evaluate", 2L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-evaluate", 2L, SimpleOperatorFlag, MagickFalse },
     { "+evaluate-sequence", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
-    { "-evaluate-sequence", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+    { "-evaluate-sequence", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
     { "-exit", 0L, SpecialOptionFlag, MagickFalse },
     { "+extent", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-extent", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-extent", 1L, SimpleOperatorFlag, MagickFalse },
     { "+extract", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-extract", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+family", 0L, DeprecateOptionFlag, MagickTrue },
     { "-family", 1L, DrawInfoOptionFlag, MagickFalse },
-    { "+features", 0L, SimpleOperatorOptionFlag | FireOptionFlag, MagickFalse },
-    { "-features", 1L, SimpleOperatorOptionFlag | FireOptionFlag, MagickFalse },
-    { "+fft", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
-    { "-fft", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+    { "+features", 0L, SimpleOperatorFlag | FireOptionFlag, MagickFalse },
+    { "-features", 1L, SimpleOperatorFlag | FireOptionFlag, MagickFalse },
+    { "+fft", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
+    { "-fft", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
     { "+fill", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
     { "-fill", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
     { "+filter", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-filter", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+flatten", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-flatten", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+    { "-flatten", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
     { "+flip", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-flip", 0L, SimpleOperatorOptionFlag, MagickFalse },
-    { "+floodfill", 2L, SimpleOperatorOptionFlag, MagickFalse },
-    { "-floodfill", 2L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-flip", 0L, SimpleOperatorFlag, MagickFalse },
+    { "+floodfill", 2L, SimpleOperatorFlag, MagickFalse },
+    { "-floodfill", 2L, SimpleOperatorFlag, MagickFalse },
     { "+flop", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-flop", 0L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-flop", 0L, SimpleOperatorFlag, MagickFalse },
     { "+font", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
     { "-font", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
     { "+foreground", 0L, NonMagickOptionFlag, MagickFalse },
@@ -397,27 +397,27 @@ static const OptionInfo
     { "+format", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-format", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+frame", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-frame", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-frame", 1L, SimpleOperatorFlag, MagickFalse },
     { "+function", 2L, DeprecateOptionFlag, MagickTrue },
-    { "-function", 2L,SimpleOperatorOptionFlag, MagickFalse },
+    { "-function", 2L,SimpleOperatorFlag, MagickFalse },
     { "+fuzz", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-fuzz", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+fx", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
-    { "-fx", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
-    { "+gamma", 0L, SimpleOperatorOptionFlag, MagickFalse },
-    { "-gamma", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-fx", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
+    { "+gamma", 0L, SimpleOperatorFlag, MagickFalse },
+    { "-gamma", 1L, SimpleOperatorFlag, MagickFalse },
     { "+gaussian", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-gaussian", 1L, ReplacedOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
+    { "-gaussian", 1L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue },
     { "+gaussian-blur", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-gaussian-blur", 1L, SimpleOperatorOptionFlag, MagickFalse },
-    { "+geometry", 0L, SimpleOperatorOptionFlag, MagickFalse },
-    { "-geometry", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-gaussian-blur", 1L, SimpleOperatorFlag, MagickFalse },
+    { "+geometry", 0L, SimpleOperatorFlag, MagickFalse },
+    { "-geometry", 1L, SimpleOperatorFlag, MagickFalse },
     { "+gravity", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
     { "-gravity", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
     { "+green-primary", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-green-primary", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+hald-clut", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
-    { "-hald-clut", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+    { "-hald-clut", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
     { "+highlight-color", 0L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse },
     { "-highlight-color", 1L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse },
     { "+iconGeometry", 0L, NonMagickOptionFlag, MagickFalse },
@@ -425,15 +425,15 @@ static const OptionInfo
     { "+iconic", 0L, NonMagickOptionFlag, MagickFalse },
     { "-iconic", 1L, NonMagickOptionFlag, MagickFalse },
     { "+identify", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
-    { "-identify", 0L, SimpleOperatorOptionFlag | FireOptionFlag, MagickFalse },
-    { "+ift", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
-    { "-ift", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+    { "-identify", 0L, SimpleOperatorFlag | FireOptionFlag, MagickFalse },
+    { "+ift", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
+    { "-ift", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
     { "+immutable", 0L, NonMagickOptionFlag, MagickFalse },
     { "-immutable", 0L, NonMagickOptionFlag, MagickFalse },
     { "+implode", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-implode", 1L, SimpleOperatorOptionFlag, MagickFalse },
-    { "+insert", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
-    { "-insert", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+    { "-implode", 1L, SimpleOperatorFlag, MagickFalse },
+    { "+insert", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
+    { "-insert", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
     { "+intent", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-intent", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+interlace", 0L, ImageInfoOptionFlag, MagickFalse },
@@ -443,7 +443,7 @@ static const OptionInfo
     { "+interpolate", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-interpolate", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+interpolative-resize", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-interpolative-resize", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-interpolative-resize", 1L, SimpleOperatorFlag, MagickFalse },
     { "+interword-spacing", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
     { "-interword-spacing", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
     { "+kerning", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
@@ -451,21 +451,21 @@ static const OptionInfo
     { "+label", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-label", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+lat", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-lat", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-lat", 1L, SimpleOperatorFlag, MagickFalse },
     { "+layers", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
-    { "-layers", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
-    { "+level", 1L, SimpleOperatorOptionFlag, MagickFalse },
-    { "-level", 1L, SimpleOperatorOptionFlag, MagickFalse },
-    { "+level-colors", 1L, SimpleOperatorOptionFlag, MagickFalse },
-    { "-level-colors", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-layers", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
+    { "+level", 1L, SimpleOperatorFlag, MagickFalse },
+    { "-level", 1L, SimpleOperatorFlag, MagickFalse },
+    { "+level-colors", 1L, SimpleOperatorFlag, MagickFalse },
+    { "-level-colors", 1L, SimpleOperatorFlag, MagickFalse },
     { "+limit", 0L, DeprecateOptionFlag, MagickTrue },
     { "-limit", 2L, GlobalOptionFlag | FireOptionFlag, MagickFalse },
     { "+linear-stretch", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-linear-stretch", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-linear-stretch", 1L, SimpleOperatorFlag, MagickFalse },
     { "+liquid-rescale", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-liquid-rescale", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-liquid-rescale", 1L, SimpleOperatorFlag, MagickFalse },
     { "+list", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-list", 1L, SpecialOptionFlag, MagickFalse },
+    { "-list", 1L, NoImageOperatorFlag, MagickFalse },
     { "+log", 0L, DeprecateOptionFlag, MagickFalse },
     { "-log", 1L, GlobalOptionFlag, MagickFalse },
     { "+loop", 0L, ImageInfoOptionFlag, MagickFalse },
@@ -474,57 +474,57 @@ static const OptionInfo
     { "-lowlight-color", 1L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse },
     { "+magnify", 0L, NonMagickOptionFlag, MagickFalse },
     { "-magnify", 1L, NonMagickOptionFlag, MagickFalse },
-    { "+map", 0L, ReplacedOptionFlag | ListOperatorOptionFlag | FireOptionFlag, MagickTrue },
-    { "-map", 1L, ReplacedOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
-    { "+mask", 0L, SimpleOperatorOptionFlag, MagickFalse },
-    { "-mask", 1L, SimpleOperatorOptionFlag, MagickFalse },
-    { "+matte", 0L, ReplacedOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
-    { "-matte", 0L, ReplacedOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
+    { "+map", 0L, ReplacedOptionFlag | ListOperatorFlag | FireOptionFlag, MagickTrue },
+    { "-map", 1L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue },
+    { "+mask", 0L, SimpleOperatorFlag, MagickFalse },
+    { "-mask", 1L, SimpleOperatorFlag, MagickFalse },
+    { "+matte", 0L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue },
+    { "-matte", 0L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue },
     { "+mattecolor", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-mattecolor", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+maximum", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
     { "-maximum", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
     { "+median", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-median", 1L, ReplacedOptionFlag | SimpleOperatorOptionFlag | FireOptionFlag, MagickTrue },
+    { "-median", 1L, ReplacedOptionFlag | SimpleOperatorFlag | FireOptionFlag, MagickTrue },
     { "+metric", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-metric", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+minimum", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
     { "-minimum", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
     { "+mode", 1L, NonMagickOptionFlag, MagickFalse },
-    { "-mode", 1L, ReplacedOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
+    { "-mode", 1L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue },
     { "+modulate", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-modulate", 1L, SimpleOperatorOptionFlag, MagickFalse },
-    { "+monitor", 0L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
-    { "-monitor", 0L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
+    { "-modulate", 1L, SimpleOperatorFlag, MagickFalse },
+    { "+monitor", 0L, ImageInfoOptionFlag | SimpleOperatorFlag, MagickFalse },
+    { "-monitor", 0L, ImageInfoOptionFlag | SimpleOperatorFlag, MagickFalse },
     { "+monochrome", 0L, ImageInfoOptionFlag, MagickFalse },
-    { "-monochrome", 0L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
+    { "-monochrome", 0L, ImageInfoOptionFlag | SimpleOperatorFlag, MagickFalse },
     { "+morph", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
-    { "-morph", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+    { "-morph", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
     { "+morphology", 2L, DeprecateOptionFlag, MagickTrue },
-    { "-morphology", 2L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-morphology", 2L, SimpleOperatorFlag, MagickFalse },
     { "+mosaic", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-mosaic", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+    { "-mosaic", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
     { "+motion-blur", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-motion-blur", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-motion-blur", 1L, SimpleOperatorFlag, MagickFalse },
     { "+name", 0L, NonMagickOptionFlag, MagickFalse },
     { "-name", 1L, NonMagickOptionFlag, MagickFalse },
-    { "+negate", 0L, SimpleOperatorOptionFlag, MagickFalse },
-    { "-negate", 0L, SimpleOperatorOptionFlag, MagickFalse },
-    { "+noise", 1L, SimpleOperatorOptionFlag, MagickFalse },
-    { "-noise", 1L, ReplacedOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
-    { "-noop", 0L, SpecialOptionFlag, MagickFalse },
+    { "+negate", 0L, SimpleOperatorFlag, MagickFalse },
+    { "-negate", 0L, SimpleOperatorFlag, MagickFalse },
+    { "+noise", 1L, SimpleOperatorFlag, MagickFalse },
+    { "-noise", 1L, ReplacedOptionFlag | SimpleOperatorFlag, MagickFalse },
+    { "-noop", 0L, NoImageOperatorFlag, MagickFalse },
     { "+normalize", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-normalize", 0L, SimpleOperatorOptionFlag, MagickFalse },
-    { "+opaque", 1L, SimpleOperatorOptionFlag, MagickFalse },
-    { "-opaque", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-normalize", 0L, SimpleOperatorFlag, MagickFalse },
+    { "+opaque", 1L, SimpleOperatorFlag, MagickFalse },
+    { "-opaque", 1L, SimpleOperatorFlag, MagickFalse },
     { "+ordered-dither", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-ordered-dither", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-ordered-dither", 1L, SimpleOperatorFlag, MagickFalse },
     { "+orient", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-orient", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+page", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-page", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+paint", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-paint", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-paint", 1L, SimpleOperatorFlag, MagickFalse },
     { "+path", 0L, NonMagickOptionFlag, MagickFalse },
     { "-path", 1L, NonMagickOptionFlag, MagickFalse },
     { "+pause", 0L, NonMagickOptionFlag, MagickFalse },
@@ -533,20 +533,20 @@ static const OptionInfo
     { "-ping", 0L, ImageInfoOptionFlag, MagickFalse },
     { "+pointsize", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
     { "-pointsize", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
-    { "+polaroid", 0L, SimpleOperatorOptionFlag, MagickFalse },
-    { "-polaroid", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "+polaroid", 0L, SimpleOperatorFlag, MagickFalse },
+    { "-polaroid", 1L, SimpleOperatorFlag, MagickFalse },
     { "+posterize", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-posterize", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-posterize", 1L, SimpleOperatorFlag, MagickFalse },
     { "+precision", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-precision", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+preview", 0L, DeprecateOptionFlag, MagickTrue },
     { "-preview", 1L, GlobalOptionFlag, MagickFalse },
     { "+print", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
-    { "-print", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+    { "-print", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
     { "+process", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
-    { "-process", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
-    { "+profile", 1L, SimpleOperatorOptionFlag, MagickFalse },
-    { "-profile", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-process", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
+    { "+profile", 1L, SimpleOperatorFlag, MagickFalse },
+    { "-profile", 1L, SimpleOperatorFlag, MagickFalse },
     { "+quality", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-quality", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+quantize", 0L, QuantizeInfoOptionFlag, MagickFalse },
@@ -554,126 +554,126 @@ static const OptionInfo
     { "+quiet", 0L, GlobalOptionFlag | FireOptionFlag, MagickFalse },
     { "-quiet", 0L, GlobalOptionFlag | FireOptionFlag, MagickFalse },
     { "+radial-blur", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-radial-blur", 1L, SimpleOperatorOptionFlag, MagickFalse },
-    { "+raise", 1L, SimpleOperatorOptionFlag, MagickFalse },
-    { "-raise", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-radial-blur", 1L, SimpleOperatorFlag, MagickFalse },
+    { "+raise", 1L, SimpleOperatorFlag, MagickFalse },
+    { "-raise", 1L, SimpleOperatorFlag, MagickFalse },
     { "+random-threshold", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-random-threshold", 1L, SimpleOperatorOptionFlag, MagickFalse },
-    { "-read", 1L, SpecialOptionFlag, MagickFalse },
+    { "-random-threshold", 1L, SimpleOperatorFlag, MagickFalse },
+    { "-read", 1L, NoImageOperatorFlag, MagickFalse },
     { "+recolor", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-recolor", 1L, ReplacedOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
+    { "-recolor", 1L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue },
     { "+red-primary", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-red-primary", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+regard-warnings", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-regard-warnings", 0L, ImageInfoOptionFlag, MagickFalse },
-    { "+region", 0L, SpecialOptionFlag, MagickFalse },
-    { "-region", 1L, SpecialOptionFlag, MagickFalse },
-    { "+remap", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
-    { "-remap", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "+region", 0L, NoImageOperatorFlag, MagickFalse },
+    { "-region", 1L, NoImageOperatorFlag, MagickFalse },
+    { "+remap", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
+    { "-remap", 1L, SimpleOperatorFlag, MagickFalse },
     { "+remote", 0L, NonMagickOptionFlag, MagickFalse },
     { "-remote", 1L, NonMagickOptionFlag, MagickFalse },
     { "+render", 0L, DrawInfoOptionFlag, MagickFalse },
     { "-render", 0L, DrawInfoOptionFlag, MagickFalse },
-    { "+repage", 0L, SimpleOperatorOptionFlag, MagickFalse },
-    { "-repage", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "+repage", 0L, SimpleOperatorFlag, MagickFalse },
+    { "-repage", 1L, SimpleOperatorFlag, MagickFalse },
     { "+resample", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-resample", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-resample", 1L, SimpleOperatorFlag, MagickFalse },
     { "+resize", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-resize", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-resize", 1L, SimpleOperatorFlag, MagickFalse },
     { "+respect-parenthesis", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-respect-parenthesis", 0L, ImageInfoOptionFlag, MagickFalse },
     { "+reverse", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
-    { "-reverse", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+    { "-reverse", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
     { "+roll", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-roll", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-roll", 1L, SimpleOperatorFlag, MagickFalse },
     { "+rotate", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-rotate", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-rotate", 1L, SimpleOperatorFlag, MagickFalse },
     { "+sample", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-sample", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-sample", 1L, SimpleOperatorFlag, MagickFalse },
     { "+sampling-factor", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-sampling-factor", 1L, ImageInfoOptionFlag, MagickFalse },
-    { "+sans", 1L, SpecialOptionFlag, MagickTrue },
-    { "-sans", 1L, SpecialOptionFlag, MagickTrue },
-    { "+sans0", 0L, SpecialOptionFlag, MagickTrue }, /* equivelent to 'noop' */
-    { "-sans0", 0L, SpecialOptionFlag, MagickTrue },
-    { "+sans2", 2L, SpecialOptionFlag, MagickTrue },
-    { "-sans2", 2L, SpecialOptionFlag, MagickTrue },
+    { "+sans", 1L, NoImageOperatorFlag, MagickTrue },
+    { "-sans", 1L, NoImageOperatorFlag, MagickTrue },
+    { "+sans0", 0L, NoImageOperatorFlag, MagickTrue }, /* equivelent to 'noop' */
+    { "-sans0", 0L, NoImageOperatorFlag, MagickTrue },
+    { "+sans2", 2L, NoImageOperatorFlag, MagickTrue },
+    { "-sans2", 2L, NoImageOperatorFlag, MagickTrue },
     { "+scale", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-scale", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-scale", 1L, SimpleOperatorFlag, MagickFalse },
     { "+scene", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-scene", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+scenes", 0L, NonMagickOptionFlag, MagickFalse },
     { "-scenes", 1L, NonMagickOptionFlag, MagickFalse },
     { "+screen", 0L, NonMagickOptionFlag, MagickFalse },
     { "-screen", 1L, NonMagickOptionFlag, MagickFalse },
-    { "-script", 1L, UndefinedOptionFlag, MagickFalse }, /* special handling */
+    { "-script", 1L, SpecialOptionFlag, MagickFalse },
     { "+seed", 0L, GlobalOptionFlag, MagickFalse },
     { "-seed", 1L, GlobalOptionFlag, MagickFalse },
     { "+segment", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-segment", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-segment", 1L, SimpleOperatorFlag, MagickFalse },
     { "+selective-blur", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-selective-blur", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-selective-blur", 1L, SimpleOperatorFlag, MagickFalse },
     { "+separate", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
-    { "-separate", 0L, SimpleOperatorOptionFlag | FireOptionFlag, MagickFalse },
+    { "-separate", 0L, SimpleOperatorFlag | FireOptionFlag, MagickFalse },
     { "+sepia-tone", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-sepia-tone", 1L, SimpleOperatorOptionFlag, MagickFalse },
-    { "+set", 1L, SimpleOperatorOptionFlag, MagickFalse },
-    { "-set", 2L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-sepia-tone", 1L, SimpleOperatorFlag, MagickFalse },
+    { "+set", 1L, SimpleOperatorFlag, MagickFalse },
+    { "-set", 2L, SimpleOperatorFlag, MagickFalse },
     { "+shade", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-shade", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-shade", 1L, SimpleOperatorFlag, MagickFalse },
     { "+shadow", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-shadow", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-shadow", 1L, SimpleOperatorFlag, MagickFalse },
     { "+shared-memory", 0L, NonMagickOptionFlag, MagickFalse },
     { "-shared-memory", 1L, NonMagickOptionFlag, MagickFalse },
     { "+sharpen", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-sharpen", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-sharpen", 1L, SimpleOperatorFlag, MagickFalse },
     { "+shave", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-shave", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-shave", 1L, SimpleOperatorFlag, MagickFalse },
     { "+shear", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-shear", 1L, SimpleOperatorOptionFlag, MagickFalse },
-    { "+sigmoidal-contrast", 1L, SimpleOperatorOptionFlag, MagickFalse },
-    { "-sigmoidal-contrast", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-shear", 1L, SimpleOperatorFlag, MagickFalse },
+    { "+sigmoidal-contrast", 1L, SimpleOperatorFlag, MagickFalse },
+    { "-sigmoidal-contrast", 1L, SimpleOperatorFlag, MagickFalse },
     { "+silent", 0L, NonMagickOptionFlag, MagickFalse },
     { "-silent", 1L, NonMagickOptionFlag, MagickFalse },
     { "+size", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-size", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+sketch", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-sketch", 1L, SimpleOperatorOptionFlag, MagickFalse },
-    { "+smush", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
-    { "-smush", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+    { "-sketch", 1L, SimpleOperatorFlag, MagickFalse },
+    { "+smush", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
+    { "-smush", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
     { "+snaps", 0L, NonMagickOptionFlag, MagickFalse },
     { "-snaps", 1L, NonMagickOptionFlag, MagickFalse },
     { "+solarize", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-solarize", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-solarize", 1L, SimpleOperatorFlag, MagickFalse },
     { "+sparse-color", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-sparse-color", 2L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-sparse-color", 2L, SimpleOperatorFlag, MagickFalse },
     { "+splice", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-splice", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-splice", 1L, SimpleOperatorFlag, MagickFalse },
     { "+spread", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-spread", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-spread", 1L, SimpleOperatorFlag, MagickFalse },
     { "+statistic", 2L, DeprecateOptionFlag, MagickTrue },
-    { "-statistic", 2L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-statistic", 2L, SimpleOperatorFlag, MagickFalse },
     { "+stegano", 0L, NonMagickOptionFlag, MagickFalse },
     { "-stegano", 1L, NonMagickOptionFlag, MagickFalse },
     { "+stereo", 0L, DeprecateOptionFlag, MagickTrue },
     { "-stereo", 1L, NonMagickOptionFlag, MagickFalse },
     { "+stretch", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-stretch", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-stretch", 1L, SimpleOperatorFlag, MagickFalse },
     { "+strip", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-strip", 0L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-strip", 0L, SimpleOperatorFlag, MagickFalse },
     { "+stroke", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
     { "-stroke", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
     { "+strokewidth", 1L, ImageInfoOptionFlag, MagickFalse },
     { "-strokewidth", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
     { "+style", 0L, DrawInfoOptionFlag, MagickFalse },
     { "-style", 1L, DrawInfoOptionFlag, MagickFalse },
-//  { "+subimage-search", 0L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse },
-//  { "-subimage-search", 0L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse },
-    { "-subimage", 0L, ListOperatorOptionFlag, MagickFalse },
-    { "+swap", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
-    { "-swap", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+    { "+subimage-search", 0L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse },
+    { "-subimage-search", 0L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse },
+    { "-subimage", 0L, ListOperatorFlag, MagickFalse },
+    { "+swap", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
+    { "-swap", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
     { "+swirl", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-swirl", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-swirl", 1L, SimpleOperatorFlag, MagickFalse },
     { "+synchronize", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-synchronize", 0L, ImageInfoOptionFlag, MagickFalse },
     { "+taint", 0L, ImageInfoOptionFlag, MagickFalse },
@@ -682,44 +682,44 @@ static const OptionInfo
     { "-text-font", 1L, NonMagickOptionFlag, MagickFalse },
     { "+texture", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-texture", 1L, ImageInfoOptionFlag, MagickFalse },
-    { "+threshold", 0L, SimpleOperatorOptionFlag, MagickFalse },
-    { "-threshold", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "+threshold", 0L, SimpleOperatorFlag, MagickFalse },
+    { "-threshold", 1L, SimpleOperatorFlag, MagickFalse },
     { "+thumbnail", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-thumbnail", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-thumbnail", 1L, SimpleOperatorFlag, MagickFalse },
     { "+tile", 0L, DrawInfoOptionFlag, MagickFalse },
     { "-tile", 1L, DrawInfoOptionFlag, MagickFalse },
     { "+tile-offset", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-tile-offset", 1L, ImageInfoOptionFlag, MagickFalse },
-    { "+tint", 1L, SimpleOperatorOptionFlag, MagickFalse },
-    { "-tint", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "+tint", 1L, SimpleOperatorFlag, MagickFalse },
+    { "-tint", 1L, SimpleOperatorFlag, MagickFalse },
     { "+title", 0L, NonMagickOptionFlag, MagickFalse },
     { "-title", 1L, NonMagickOptionFlag, MagickFalse },
     { "+transform", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-transform", 0L, ReplacedOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
-    { "+transparent", 1L, SimpleOperatorOptionFlag, MagickFalse },
-    { "-transparent", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-transform", 0L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue },
+    { "+transparent", 1L, SimpleOperatorFlag, MagickFalse },
+    { "-transparent", 1L, SimpleOperatorFlag, MagickFalse },
     { "+transparent-color", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-transparent-color", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+transpose", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-transpose", 0L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-transpose", 0L, SimpleOperatorFlag, MagickFalse },
     { "+transverse", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-transverse", 0L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-transverse", 0L, SimpleOperatorFlag, MagickFalse },
     { "+treedepth", 1L, DeprecateOptionFlag, MagickTrue },
     { "-treedepth", 1L, QuantizeInfoOptionFlag, MagickFalse },
     { "+trim", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-trim", 0L, SimpleOperatorOptionFlag, MagickFalse },
-    { "+type", 0L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
-    { "-type", 1L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
+    { "-trim", 0L, SimpleOperatorFlag, MagickFalse },
+    { "+type", 0L, ImageInfoOptionFlag | SimpleOperatorFlag, MagickFalse },
+    { "-type", 1L, ImageInfoOptionFlag | SimpleOperatorFlag, MagickFalse },
     { "+undercolor", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
     { "-undercolor", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
-    { "+unique", 0L, SimpleOperatorOptionFlag, MagickFalse },
-    { "-unique", 0L, SimpleOperatorOptionFlag, MagickFalse },
+    { "+unique", 0L, SimpleOperatorFlag, MagickFalse },
+    { "-unique", 0L, SimpleOperatorFlag, MagickFalse },
     { "+unique-colors", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-unique-colors", 0L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-unique-colors", 0L, SimpleOperatorFlag, MagickFalse },
     { "+units", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-units", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+unsharp", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-unsharp", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-unsharp", 1L, SimpleOperatorFlag, MagickFalse },
     { "+update", 0L, NonMagickOptionFlag, MagickFalse },
     { "-update", 1L, NonMagickOptionFlag, MagickFalse },
     { "+use-pixmap", 0L, NonMagickOptionFlag, MagickFalse },
@@ -727,11 +727,11 @@ static const OptionInfo
     { "+verbose", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-verbose", 0L, ImageInfoOptionFlag, MagickFalse },
     { "+version", 0L, DeprecateOptionFlag, MagickTrue },
-    { "-version", 0L, SpecialOptionFlag, MagickFalse },
+    { "-version", 0L, NoImageOperatorFlag, MagickFalse },
     { "+view", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-view", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+vignette", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-vignette", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-vignette", 1L, SimpleOperatorFlag, MagickFalse },
     { "+virtual-pixel", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-virtual-pixel", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+visual", 0L, NonMagickOptionFlag, MagickFalse },
@@ -739,19 +739,19 @@ static const OptionInfo
     { "+watermark", 0L, NonMagickOptionFlag, MagickFalse },
     { "-watermark", 1L, NonMagickOptionFlag, MagickFalse },
     { "+wave", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-wave", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-wave", 1L, SimpleOperatorFlag, MagickFalse },
     { "+weight", 1L, DeprecateOptionFlag, MagickTrue },
     { "-weight", 1L, DrawInfoOptionFlag, MagickFalse },
     { "+white-point", 0L, ImageInfoOptionFlag, MagickFalse },
     { "-white-point", 1L, ImageInfoOptionFlag, MagickFalse },
     { "+white-threshold", 1L, DeprecateOptionFlag, MagickTrue },
-    { "-white-threshold", 1L, SimpleOperatorOptionFlag, MagickFalse },
+    { "-white-threshold", 1L, SimpleOperatorFlag, MagickFalse },
     { "+window", 0L, NonMagickOptionFlag, MagickFalse },
     { "-window", 1L, NonMagickOptionFlag, MagickFalse },
     { "+window-group", 0L, NonMagickOptionFlag, MagickFalse },
     { "-window-group", 1L, NonMagickOptionFlag, MagickFalse },
-    { "+write", 1L, SpecialOptionFlag | FireOptionFlag, MagickFalse },
-    { "-write", 1L, SpecialOptionFlag | FireOptionFlag, MagickFalse },
+    { "+write", 1L, NoImageOperatorFlag | FireOptionFlag, MagickFalse },
+    { "-write", 1L, NoImageOperatorFlag | FireOptionFlag, MagickFalse },
     { (char *) NULL, 0L, UndefinedOptionFlag, MagickFalse }
   },
   ComposeOptions[] =

diff --git a/MagickCore/option.h b/MagickCore/option.h
index a235380f38f5f2b30d4a464fbb098df2b4e05297..3a045e5e2fbdcce07f97aaeb6abfc3c15dae0997 100644 (file)
--- a/MagickCore/option.h
+++ b/MagickCore/option.h
@@ -112,19 +112,6 @@ typedef enum
   AllValidate = 0x7fffffff
 } ValidateType;
 
-typedef struct _OptionInfo
-{
-  const char
-    *mnemonic;
-
-  ssize_t
-    type,
-    flags;
-
-  MagickBooleanType
-    stealth;
-} OptionInfo;
-
 /*
   Flags to describe classes of image processing options.
   These are used to determine how a option should be processed, and
@@ -140,20 +127,34 @@ typedef enum
   GlobalOptionFlag          = 0x0008,  /* Global Setting or Control */
   SettingOptionFlags        = 0x000F,  /* mask for all setting options */
 
-  SimpleOperatorOptionFlag  = 0x0010,  /* Simple Image processing operator */
-  ListOperatorOptionFlag    = 0x0020,  /* Multi-Image processing operator */
-  SpecialOptionFlag         = 0x0040,  /* Special handled Option */
+  NoImageOperatorFlag       = 0x0010,  /* Images not required operator */
+  SimpleOperatorFlag        = 0x0020,  /* Simple Image processing operator */
+  ListOperatorFlag          = 0x0040,  /* Multi-Image processing operator */
   GenesisOptionFlag         = 0x0080,  /* MagickCommandGenesis() Only Option */
 
-  ImageRequiredFlags        = 0x0030,  /* Flags also means Images Required */
+  SpecialOptionFlag         = 0x0100,  /* Operator with Special Requirements */
+                                       /* EG: for specific CLI commands */
 
   NonMagickOptionFlag       = 0x1000,  /* Option not used by Magick Command */
   FireOptionFlag            = 0x2000,  /* Convert operation seq firing point */
   DeprecateOptionFlag       = 0x4000,  /* Deprecate option (no code) */
-  ReplacedOptionFlag        = 0x8000   /* Replaced Option (still works) */
+  ReplacedOptionFlag        = 0x8000   /* Replaced Option (but still works) */
 
 } CommandOptionFlags;
 
+typedef struct _OptionInfo
+{
+  const char
+    *mnemonic;
+
+  ssize_t
+    type,
+    flags;
+
+  MagickBooleanType
+    stealth;
+} OptionInfo;
+
 
 extern MagickExport char
   **GetCommandOptions(const CommandOption),

diff --git a/MagickWand/magick-cli.c b/MagickWand/magick-cli.c
index a926368d3df04885fc62472e0a9f67bde90569f5..e46292e18b0f95ec7d797d4383c6e8224ba99c58 100644 (file)
--- a/MagickWand/magick-cli.c
+++ b/MagickWand/magick-cli.c
@@ -209,7 +209,6 @@ WandExport void ProcessScriptOptions(MagickCLI *cli_wand,int argc,char **argv,
   option = arg1 = arg2 = (char*)NULL;
   while (1) {
 
-    /* Get a option */
     { MagickBooleanType status = GetScriptToken(token_info);
       cli_wand->line=token_info->token_line;
       cli_wand->column=token_info->token_column;
@@ -220,15 +219,14 @@ WandExport void ProcessScriptOptions(MagickCLI *cli_wand,int argc,char **argv,
     /* save option details */
     CloneString(&option,token_info->token);
 
-    { /* get option type and argument count */
-      const OptionInfo *option_info = GetCommandOptionInfo(option);
-      count=option_info->type;
-      option_type=(CommandOptionFlags) option_info->flags;
+    /* get option, its argument count, and option type */
+    cli_wand->command = GetCommandOptionInfo(option);
+    count=cli_wand->command->type;
+    option_type=(CommandOptionFlags) cli_wand->command->flags;
 #if 0
-      (void) FormatLocaleFile(stderr, "Script: %u,%u: \"%s\" matched \"%s\"\n",
-             cli_wand->line, cli_wand->line, option, option_info->mnemonic );
+    (void) FormatLocaleFile(stderr, "Script: %u,%u: \"%s\" matched \"%s\"\n",
+          cli_wand->line, cli_wand->line, option, cli_wand->command->mnemonic );
 #endif
-    }
 
     /* handle a undefined option - image read? */
     if ( option_type == UndefinedOptionFlag ||
@@ -239,18 +237,12 @@ WandExport void ProcessScriptOptions(MagickCLI *cli_wand,int argc,char **argv,
 #endif
       if ( IfMagickFalse(IsCommandOption(option))) {
         /* non-option -- treat as a image read */
-        CLISpecialOperator(cli_wand,"-read",option);
-        goto next_token;
-      }
-      if ( LocaleCompare(option,"-script") == 0 ) {
-        option_type=SpecialOptionFlag;
-        count=1;
-        /* fall thru - collect one argument */
-      }
-      else {
-        CLIWandExceptionBreak(OptionFatalError,"UnrecognizedOption",option);
+        cli_wand->command=(const OptionInfo *)NULL;
+        CLIOption(cli_wand,"-read",option);
         goto next_token;
       }
+      CLIWandExceptionBreak(OptionFatalError,"UnrecognizedOption",option);
+      goto next_token;
     }
 
     if ( count >= 1 ) {
@@ -269,6 +261,7 @@ WandExport void ProcessScriptOptions(MagickCLI *cli_wand,int argc,char **argv,
     else
       CloneString(&arg2,(char *)NULL);
 
+
     /*
       Process Options
     */
@@ -280,7 +273,7 @@ WandExport void ProcessScriptOptions(MagickCLI *cli_wand,int argc,char **argv,
     /* Hard Depreciated Options, no code to execute - error */
     if ( (option_type & DeprecateOptionFlag) != 0 ) {
       CLIWandException(OptionError,"DeprecatedOptionNoCode",option);
-      if ( CLICatchException(cli_wand, MagickFalse) != MagickFalse )
+      if ( IfMagickTrue(CLICatchException(cli_wand, MagickFalse)) )
         break;
       goto next_token;
     }
@@ -295,41 +288,19 @@ WandExport void ProcessScriptOptions(MagickCLI *cli_wand,int argc,char **argv,
       if ( LocaleCompare(option,"-exit") == 0 ) {
         break; /* forced end of script */
       }
-      else if ( LocaleCompare(option,"-script") == 0 ) {
+      if ( LocaleCompare(option,"-script") == 0 ) {
         /* FUTURE: call new script from this script */
         CLIWandExceptionBreak(OptionError,"InvalidUseOfOption",option);
         goto next_token;
       }
       /* FUTURE: handle special script-argument options here */
       /* handle any other special operators now */
-      CLISpecialOperator(cli_wand,option,arg1);
-    }
-
-    if ( (option_type & SettingOptionFlags) != 0 ) {
-      CLISettingOptionInfo(cli_wand, option, arg1, arg2);
-      // FUTURE: Sync Specific Settings into Image Properities (not global)
-    }
-
-    /* FUTURE: The not a setting part below is a temporary hack to stop gap
-     * measure for options that are BOTH settings and optional 'Simple/List'
-     * operators.  Specifically -monitor, -depth, and  -colorspace */
-    if ( cli_wand->wand.images == (Image *)NULL ) {
-      if (((option_type & ImageRequiredFlags) != 0 ) &&
-          ((option_type & SettingOptionFlags) == 0 ))  /* temp hack */
-        CLIWandException(OptionError,"NoImagesFound",option);
+      CLIWandExceptionBreak(OptionError,"InvalidUseOfOption",option);
       goto next_token;
     }
 
-    /* FUTURE: this is temporary - get 'settings' to handle
-       distribution of settings to images attributes,proprieties,artifacts */
-    SyncImagesSettings(cli_wand->wand.image_info,cli_wand->wand.images,
-          cli_wand->wand.exception);
-
-    if ( (option_type & SimpleOperatorOptionFlag) != 0)
-      CLISimpleOperatorImages(cli_wand, option, arg1, arg2);
-
-    if ( (option_type & ListOperatorOptionFlag) != 0 )
-      CLIListOperatorImages(cli_wand, option, arg1, arg2);
+    /* Process non-specific Option */
+    CLIOption(cli_wand, option, arg1, arg2);
 
 next_token:
 #if MagickCommandDebug >= 9
@@ -468,14 +439,14 @@ WandExport int ProcessCommandOptions(MagickCLI *cli_wand, int argc,
     option=argv[i];
     cli_wand->line=i;  /* note the argument for this option */
 
-    { const OptionInfo *option_info = GetCommandOptionInfo(argv[i]);
-      count=option_info->type;
-      option_type=(CommandOptionFlags) option_info->flags;
+    /* get option, its argument count, and option type */
+    cli_wand->command = GetCommandOptionInfo(argv[i]);
+    count=cli_wand->command->type;
+    option_type=(CommandOptionFlags) cli_wand->command->flags;
 #if 0
-      (void) FormatLocaleFile(stderr, "CLI %d: \"%s\" matched \"%s\"\n",
-            i, argv[i], option_info->mnemonic );
+    (void) FormatLocaleFile(stderr, "CLI %d: \"%s\" matched \"%s\"\n",
+          i, argv[i], cli_wand->command->mnemonic );
 #endif
-    }
 
     if ( option_type == UndefinedOptionFlag ||
          (option_type & NonMagickOptionFlag) != 0 ) {
@@ -483,26 +454,31 @@ WandExport int ProcessCommandOptions(MagickCLI *cli_wand, int argc,
       (void) FormatLocaleFile(stderr, "CLI %d Non-Option: \"%s\"\n", i, option);
 #endif
       if ( IfMagickFalse(IsCommandOption(option)) ) {
-         if ( (cli_wand->process_flags & ProcessNonOptionImageRead) != 0 )
-           /* non-option -- treat as a image read */
-           CLISpecialOperator(cli_wand,"-read",option);
-         else
-           CLIWandException(OptionFatalError,"UnrecognizedOption",option);
-         goto next_argument;
-      }
-      if ( ((cli_wand->process_flags & ProcessScriptOption) != 0) &&
-           (LocaleCompare(option,"-script") == 0) ) {
-        /* Call Script from CLI, with a filename as a zeroth argument.
-           NOTE: -script may need to use 'implict write filename' so it
-           must be handled here to prevent 'missing argument' error.
-        */
-        ProcessScriptOptions(cli_wand,argc,argv,i+1);
-        return(argc);  /* Script does not return to CLI -- Yet -- FUTURE */
+        if ( (cli_wand->process_flags & ProcessNonOptionImageRead) != 0 ) {
+          /* non-option -- treat as a image read */
+          cli_wand->command=(const OptionInfo *)NULL;
+          CLIOption(cli_wand,"-read",option);
+          goto next_argument;
+        }
       }
       CLIWandException(OptionFatalError,"UnrecognizedOption",option);
       goto next_argument;
     }
 
+    if ( ((option_type & SpecialOptionFlag) != 0 ) &&
+         ((cli_wand->process_flags & ProcessScriptOption) != 0) &&
+         (LocaleCompare(option,"-script") == 0) ) {
+      /* Call Script from CLI, with a filename as a zeroth argument.
+         NOTE: -script may need to use the 'implict write filename' argument
+         so it must be handled specially to prevent a 'missing argument' error.
+      */
+      if ( (i+count) >= argc )
+        CLIWandException(OptionFatalError,"MissingArgument",option);
+      ProcessScriptOptions(cli_wand,argc,argv,i+1);
+      return(argc);  /* Script does not return to CLI -- Yet */
+                     /* FUTURE: when it does, their may be no write arg! */
+    }
+
     if ((i+count) >= end ) {
       CLIWandException(OptionFatalError,"MissingArgument",option);
       if ( CLICatchException(cli_wand, MagickFalse) != MagickFalse )
@@ -521,49 +497,19 @@ WandExport int ProcessCommandOptions(MagickCLI *cli_wand, int argc,
       "CLI %u Option: \"%s\"  Count: %d  Flags: %04x  Args: \"%s\" \"%s\"\n",
           i,option,count,option_type,arg1,arg2);
 #endif
-    /* Hard Depreciated Options, no code to execute - error */
-    if ( (option_type & DeprecateOptionFlag) != 0 ) {
-      CLIWandException(OptionError,"DeprecatedOptionNoCode",option);
-      goto next_argument;
-    }
 
-    /* Ignore MagickCommandGenesis() only option on CLI */
     if ( (option_type & GenesisOptionFlag) != 0 )
-      goto next_argument;
+      goto next_argument; /* ignored this from command line args */
 
     if ( (option_type & SpecialOptionFlag) != 0 ) {
       if ( (cli_wand->process_flags & ProcessExitOption) != 0
            && LocaleCompare(option,"-exit") == 0 )
         return(i+count);
-      /* handle any other special operators now */
-      CLISpecialOperator(cli_wand,option,arg1);
-    }
-
-    if ( (option_type & SettingOptionFlags) != 0 ) {
-      CLISettingOptionInfo(cli_wand, option, arg1, arg2);
-      // FUTURE: Sync individual Settings into images (no SyncImageSettings())
-    }
-
-    /* FUTURE: The not a setting part below is a temporary hack to stop gap
-     * measure for options that are BOTH settings and optional 'Simple/List'
-     * operators.  Specifically -monitor, -depth, and  -colorspace */
-    if ( cli_wand->wand.images == (Image *)NULL ) {
-      if (((option_type & ImageRequiredFlags) != 0 ) &&
-          ((option_type & SettingOptionFlags) == 0 )  )  /* temp hack */
-        CLIWandException(OptionError,"NoImagesFound",option);
       goto next_argument;
     }
 
-    /* FUTURE: this is temporary - get 'settings' to handle
-       distribution of settings to images attributes,proprieties,artifacts */
-    SyncImagesSettings(cli_wand->wand.image_info,cli_wand->wand.images,
-          cli_wand->wand.exception);
-
-    if ( (option_type & SimpleOperatorOptionFlag) != 0)
-      CLISimpleOperatorImages(cli_wand, option, arg1, arg2);
-
-    if ( (option_type & ListOperatorOptionFlag) != 0 )
-      CLIListOperatorImages(cli_wand, option, arg1, arg2);
+    /* Process non-specific Option */
+    CLIOption(cli_wand, option, arg1, arg2);
 
 next_argument:
 #if MagickCommandDebug >= 9
@@ -614,7 +560,8 @@ next_argument:
     return(argc);
   }
 
-  CLISpecialOperator(cli_wand,"-write",option);
+  cli_wand->command=(const OptionInfo *)NULL;
+  CLIOption(cli_wand,"-write",option);
   return(argc);
 }
 \f
@@ -804,17 +751,17 @@ WandExport MagickBooleanType MagickImageCommand(ImageInfo *image_info,
 
   /* Special Case: Version Information and Abort */
   if (argc == 2) {
-    if (LocaleCompare("-version",argv[1]) == 0) {
-      CLISpecialOperator(cli_wand, "-version", (char *)NULL);
+    if (LocaleCompare("-version",argv[1]) == 0) { /* just version */
+      CLIOption(cli_wand, "-version");
       goto Magick_Command_Exit;
     }
     if ((LocaleCompare("-help",argv[1]) == 0)   || /* GNU standard option */
-        (LocaleCompare("--help",argv[1]) == 0) ) {
+        (LocaleCompare("--help",argv[1]) == 0) ) { /* just a brief summary */
       MagickUsage(MagickFalse);
       goto Magick_Command_Exit;
     }
-    if (LocaleCompare("-usage",argv[1]) == 0) {
-      CLISpecialOperator(cli_wand, "-version", (char *)NULL);
+    if (LocaleCompare("-usage",argv[1]) == 0) {   /* both version & usage */
+      CLIOption(cli_wand, "-version");
       MagickUsage(MagickTrue);
       goto Magick_Command_Exit;
     }
@@ -830,7 +777,7 @@ WandExport MagickBooleanType MagickImageCommand(ImageInfo *image_info,
 
   /* List Information and Abort */
   if (LocaleCompare("-list",argv[1]) == 0) {
-    CLISpecialOperator(cli_wand, argv[1], argv[2]);
+    CLIOption(cli_wand, argv[1]);
     goto Magick_Command_Exit;
   }
 
@@ -861,9 +808,9 @@ Magick_Command_Cleanup:
   /* recover original image_info and clean up stacks
      FUTURE: "-reset stacks" option  */
   while (cli_wand->image_list_stack != (Stack *)NULL)
-    CLISpecialOperator(cli_wand,")",(const char *)NULL);
+    CLIOption(cli_wand,")");
   while (cli_wand->image_info_stack != (Stack *)NULL)
-    CLISpecialOperator(cli_wand,"}",(const char *)NULL);
+    CLIOption(cli_wand,"}");
 
   /* assert we have recovered the original structures */
   assert(cli_wand->wand.image_info == image_info);

diff --git a/MagickWand/operation.c b/MagickWand/operation.c
index 5488e8b2d9d9dfd2dc3077c82732bf92c0b5e58f..c77beecf83f257036e7457c8bf289ea7829756a8 100644 (file)
--- a/MagickWand/operation.c
+++ b/MagickWand/operation.c
@@ -366,7 +366,7 @@ static Image *SparseColorOption(const Image *image,
 %                                                                             %
 %                                                                             %
 %                                                                             %
-+   C L I S e t t i n g O p t i o n I n f o                                   %
+%   C L I S e t t i n g O p t i o n I n f o                                   %
 %                                                                             %
 %                                                                             %
 %                                                                             %
@@ -397,27 +397,6 @@ static Image *SparseColorOption(const Image *image,
 %    o arg1, arg2: optional argument strings to the operation
 %        arg2 is currently only used by "-limit"
 %
-% Example usage...
-%
-%    CLISettingOptionInfo(cli_wand, "-background", "Red", NULL); // set value
-%    CLISettingOptionInfo(cli_wand, "-adjoin", NULL, NULL);      // set boolean
-%    CLISettingOptionInfo(cli_wand, "+adjoin", NULL, NULL);      // unset
-%
-% Or for handling command line arguments EG: +/-option ["arg1"]
-%
-%    argc,argv
-%    i=index in argv
-%
-%    option_info = GetCommandOptionInfo(argv[i]);
-%    count=option_info->type;
-%    option_type=option_info->flags;
-%
-%    if ( (option_type & SettingOperatorOptionFlags) != 0 )
-%      CLISettingOptionInfo(cli_wand, argv[i],
-%                   (count>=1) ? argv[i+1] : (char *)NULL,
-%                   (count>=2) ? argv[i+2] : (char *)NULL);
-%    i += count+1;
-%
 */
 WandExport void CLISettingOptionInfo(MagickCLI *cli_wand,
      const char *option,const char *arg1, const char *arg2)
@@ -452,7 +431,7 @@ WandExport void CLISettingOptionInfo(MagickCLI *cli_wand,
         }
       if (LocaleCompare("affine",option+1) == 0)
         {
-          CLIWandWarnDepreciated("-draw 'affine ...'");
+          CLIWandWarnReplaced("-draw 'affine ...'");
           if (IfSetOption)
             (void) ParseAffineGeometry(arg1,&_draw_info->affine,_exception);
           else
@@ -558,7 +537,7 @@ WandExport void CLISettingOptionInfo(MagickCLI *cli_wand,
         }
       if (LocaleCompare("box",option+1) == 0)
         {
-          CLIWandWarnDepreciated("-undercolor");
+          CLIWandWarnReplaced("-undercolor");
           CLISettingOptionInfo(cli_wand,"-undercolor",arg1, arg2);
           break;
         }
@@ -1601,30 +1580,6 @@ WandExport void CLISettingOptionInfo(MagickCLI *cli_wand,
 %
 %    o arg1, arg2: optional argument strings to the operation
 %
-% Any problems will be added to the 'exception' entry of the given wand.
-%
-% Example usage...
-%
-%  CLISimpleOperatorImages(cli_wand, "-crop","100x100+20+30",NULL);
-%  CLISimpleOperatorImages(cli_wand, "+repage",NULL,NULL);
-%  CLISimpleOperatorImages(cli_wand, "+distort","SRT","45");
-%
-% Or for handling command line arguments EG: +/-option ["arg1"]
-%
-%    cli_wand
-%    argc,argv
-%    i=index in argv
-%
-%    option_info = GetCommandOptionInfo(argv[i]);
-%    count=option_info->type;
-%    option_type=option_info->flags;
-%
-%    if ( (option_type & SimpleOperatorOptionFlag) != 0 )
-%      CLISimpleOperatorImages(cli_wand, argv[i],
-%          count>=1 ? argv[i+1] : (char *)NULL,
-%          count>=2 ? argv[i+2] : (char *)NULL );
-%    i += count+1;
-%
 */
 
 /*
@@ -1679,8 +1634,6 @@ static void CLISimpleOperatorImage(MagickCLI *cli_wand,
   if (IfMagickTrue(cli_wand->wand.debug))
     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",cli_wand->wand.name);
 
-  (void) SyncImageSettings(_image_info,_image,_exception);
-
   SetGeometryInfo(&geometry_info);
 
   new_image = (Image *)NULL; /* the replacement image, if not null at end */
@@ -2070,7 +2023,7 @@ static void CLISimpleOperatorImage(MagickCLI *cli_wand,
         }
       if (LocaleCompare("contrast",option+1) == 0)
         {
-          CLIWandWarnDepreciated(normal_op?"-level":"+level");
+          CLIWandWarnReplaced(normal_op?"-level":"+level");
           (void) ContrastImage(_image,normal_op,_exception);
           break;
         }
@@ -2440,7 +2393,7 @@ static void CLISimpleOperatorImage(MagickCLI *cli_wand,
         }
       if (LocaleCompare("gaussian",option+1) == 0)
         {
-          CLIWandWarnDepreciated("-gaussian-blur");
+          CLIWandWarnReplaced("-gaussian-blur");
           CLISimpleOperatorImage(cli_wand,"-gaussian-blur",arg1,NULL);
         }
       if (LocaleCompare("geometry",option+1) == 0)
@@ -2647,7 +2600,7 @@ static void CLISimpleOperatorImage(MagickCLI *cli_wand,
     {
       if (LocaleCompare("map",option+1) == 0)
         {
-          CLIWandWarnDepreciated("-remap");
+          CLIWandWarnReplaced("-remap");
           CLISimpleOperatorImage(cli_wand,"-remap",NULL,NULL);
           break;
         }
@@ -2671,21 +2624,21 @@ static void CLISimpleOperatorImage(MagickCLI *cli_wand,
         }
       if (LocaleCompare("matte",option+1) == 0)
         {
-          CLIWandWarnDepreciated(IfNormalOp?"-alpha Set":"-alpha Off");
+          CLIWandWarnReplaced(IfNormalOp?"-alpha Set":"-alpha Off");
           (void) SetImageAlphaChannel(_image,IfNormalOp ? SetAlphaChannel :
                          DeactivateAlphaChannel, _exception);
           break;
         }
       if (LocaleCompare("median",option+1) == 0)
         {
-          CLIWandWarnDepreciated("-statistic Median");
+          CLIWandWarnReplaced("-statistic Median");
           CLISimpleOperatorImage(cli_wand,"-statistic","Median",arg1);
           break;
         }
       if (LocaleCompare("mode",option+1) == 0)
         {
           /* FUTURE: note this is also a special "montage" option */
-          CLIWandWarnDepreciated("-statistic Mode");
+          CLIWandWarnReplaced("-statistic Mode");
           CLISimpleOperatorImage(cli_wand,"-statistic","Mode",arg1);
           break;
         }
@@ -2772,7 +2725,7 @@ static void CLISimpleOperatorImage(MagickCLI *cli_wand,
 
           if (IfNormalOp)
             {
-              CLIWandWarnDepreciated("-statistic NonPeak");
+              CLIWandWarnReplaced("-statistic NonPeak");
               CLISimpleOperatorImage(cli_wand,"-statistic","NonPeak",arg1);
               break;
             }
@@ -2964,7 +2917,7 @@ static void CLISimpleOperatorImage(MagickCLI *cli_wand,
         }
       if (LocaleCompare("recolor",option+1) == 0)
         {
-          CLIWandWarnDepreciated("-color-matrix");
+          CLIWandWarnReplaced("-color-matrix");
           CLISimpleOperatorImage(cli_wand,"-color-matrix",arg1,NULL);
         }
       if (LocaleCompare("remap",option+1) == 0)
@@ -3321,7 +3274,7 @@ static void CLISimpleOperatorImage(MagickCLI *cli_wand,
         }
       if (LocaleCompare("transform",option+1) == 0)
         {
-          CLIWandWarnDepreciated("+distort AffineProjection");
+          CLIWandWarnReplaced("+distort AffineProjection");
           new_image=AffineTransformImage(_image,&_draw_info->affine,_exception);
           break;
         }
@@ -3536,27 +3489,6 @@ WandExport void CLISimpleOperatorImages(MagickCLI *cli_wand,
 %    o arg1, arg2: optional argument strings to the operation
 %        arg2 is currently not used
 %
-% Example usage...
-%
-%  CLIListOperatorImages(cli_wand,MagickFalse,"-duplicate", "3",  NULL);
-%  CLIListOperatorImages(cli_wand,MagickTrue, "+append",    NULL, NULL);
-%
-% Or for handling command line arguments EG: +/-option ["arg1"]
-%
-%    cli_wand
-%    argc,argv
-%    i=index in argv
-%
-%    option_info = GetCommandOptionInfo(argv[i]);
-%    count=option_info->type;
-%    option_type=option_info->flags;
-%
-%    if ( (option_type & ListOperatorOptionFlag) != 0 )
-%      CLIListOperatorImages(cli_wand,argv[i],
-%          count>=1 ? argv[i+1] : (char *)NULL,
-%          count>=2 ? argv[i+2] : (char *)NULL );
-%    i += count+1;
-%
 */
 WandExport void CLIListOperatorImages(MagickCLI *cli_wand,
      const char *option,const char *arg1, const char *magick_unused(arg2))
@@ -3583,8 +3515,6 @@ WandExport void CLIListOperatorImages(MagickCLI *cli_wand,
   if (IfMagickTrue(cli_wand->wand.debug))
     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",cli_wand->wand.name);
 
-  (void) SyncImagesSettings(_image_info,_images,_exception);
-
   new_images=NewImageList();
 
   switch (*(option+1))
@@ -3598,7 +3528,7 @@ WandExport void CLIListOperatorImages(MagickCLI *cli_wand,
         }
       if (LocaleCompare("average",option+1) == 0)
         {
-          CLIWandWarnDepreciated("-evaluate-sequence Mean");
+          CLIWandWarnReplaced("-evaluate-sequence Mean");
           CLIListOperatorImages(cli_wand,"-evaluate-sequence","Mean",NULL);
           break;
         }
@@ -3722,7 +3652,7 @@ WandExport void CLIListOperatorImages(MagickCLI *cli_wand,
     {
       if (LocaleCompare("deconstruct",option+1) == 0)
         {
-          CLIWandWarnDepreciated("-layer CompareAny");
+          CLIWandWarnReplaced("-layer CompareAny");
           CLIListOperatorImages(cli_wand,"-layer","CompareAny",NULL);
           break;
         }
@@ -4020,7 +3950,7 @@ WandExport void CLIListOperatorImages(MagickCLI *cli_wand,
     {
       if (LocaleCompare("map",option+1) == 0)
         {
-          CLIWandWarnDepreciated("+remap");
+          CLIWandWarnReplaced("+remap");
           (void) RemapImages(_quantize_info,_images,(Image *) NULL,_exception);
           break;
         }
@@ -4291,7 +4221,7 @@ WandExport void CLIListOperatorImages(MagickCLI *cli_wand,
 %                                                                             %
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %
-%  CLISpecialOperator() Applies operations that may not actually need images
+%  CLINoImageOperator() Applies operations that may not actually need images
 %  in an image list wen it is applied.
 %
 %  The classic operators of this type is -read, which actually creates images
@@ -4301,10 +4231,10 @@ WandExport void CLIListOperatorImages(MagickCLI *cli_wand,
 %  Note: unlike other Operators, these may involve other special 'option'
 %  character prefixes, other than simply '-' or '+'.
 %
-%  The format of the CLISpecialOption method is:
+%  The format of the CLINoImageOption method is:
 %
-%      void CLISpecialOption(MagickCLI *cli_wand,const char *option,
-%           const char *arg1)
+%      void CLINoImageOption(MagickCLI *cli_wand,const char *option,
+%           const char *arg1, const char *arg2)
 %
 %  A description of each parameter follows:
 %
@@ -4312,31 +4242,12 @@ WandExport void CLIListOperatorImages(MagickCLI *cli_wand,
 %
 %    o option: The special option (with any switch char) to process
 %
-%    o arg1: Argument for option, if required
-%
-% Example Usage...
-%
-%  CLISpecialOperator(cli_wand,"-read","rose:");
-%
-% Or for handling command line arguments EG: +/-option ["arg1"]
-%
-%    cli_wand
-%    argc,argv
-%    i=index in argv
-%
-%    option_info = GetCommandOptionInfo(argv[i]);
-%    count=option_info->type;
-%    option_type=option_info->flags;
-%
-%    if ( (option_type & SpecialOptionFlag) != 0 )
-%      CLISpecialOperator(cli_wand,argv[i],
-%          count>=1 ? argv[i+1] : (char *)NULL);
-%    i += count+1;
+%    o arg1 & arg2: Argument for option, if required
+%                   Currently arg2 is not used.
 %
 */
-
-WandExport void CLISpecialOperator(MagickCLI *cli_wand,
-  const char *option, const char *arg1)
+WandExport void CLINoImageOperator(MagickCLI *cli_wand,
+  const char *option, const char *arg1, const char *magick_unused(arg2))
 {
 #define _image_info     (cli_wand->wand.image_info)
 #define _images         (cli_wand->wand.images)
@@ -4350,9 +4261,6 @@ WandExport void CLISpecialOperator(MagickCLI *cli_wand,
   if (IfMagickTrue(cli_wand->wand.debug))
     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",cli_wand->wand.name);
 
-  if(_images != (Image *)NULL)
-    (void) SyncImagesSettings(cli_wand->wand.image_info,_images,_exception);
-
   /*
     No-op options  (ignore these)
   */
@@ -4673,3 +4581,143 @@ WandExport void CLISpecialOperator(MagickCLI *cli_wand,
 #undef IfNormalOp
 #undef IfPlusOp
 }
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                                                                             %
++   C L I O p t i o n O p e r a t i o n s                                     %
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+%  CLIOption() Processes the given option using the given CLI Magick Wand.
+%
+%  If the cli_wand->command pointer is non-null, then it is assumed that the
+%  option has already been search for up from the CommandOptions[] table in
+%  "MagickCore/options.c" using  GetCommandOptionInfo(), so that any command
+%  specific options (such as "magick" scripting options, or "display" settings)
+%  can be handled separatally.
+%
+%  The format of the CLIOption method is:
+%
+%       void CLIOption(MagickCLI *cli_wand,const char *option, ...)
+%
+%  A description of each parameter follows:
+%
+%     o cli_wand: the main CLI Wand to use.
+%
+%     o option: The special option (with any switch char) to process
+%
+%     o args: any required arguments for an option
+%
+%  Example Usage...
+%
+%    CLIoption(cli_wand,"-read","rose:");
+%    CLIoption(cli_wand,"-virtual-pixel","transparent");
+%    CLIoption(cli_wand,"-distort","SRT:","30");
+%    CLIoption(cli_wand,"-write","rotated_rose.png");
+%
+*/
+WandExport void CLIOption(MagickCLI *cli_wand,const char *option,...)
+{
+  const char
+    *arg1,
+    *arg2;
+
+  CommandOptionFlags
+    option_type;
+
+  assert(cli_wand != (MagickCLI *) NULL);
+  assert(cli_wand->signature == WandSignature);
+  assert(cli_wand->wand.signature == WandSignature);
+  if (IfMagickTrue(cli_wand->wand.debug))
+    (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",cli_wand->wand.name);
+
+  if ( cli_wand->command == (const OptionInfo *) NULL )
+    cli_wand->command = GetCommandOptionInfo(option);
+#if 0
+    (void) FormatLocaleFile(stderr, "CLIOption \"%s\" matched \"%s\"\n",
+          option, cli_wand->command->mnemonic );
+#endif
+
+  option_type=(CommandOptionFlags) cli_wand->command->flags;
+
+  if ( option_type == UndefinedOptionFlag )
+    CLIWandExceptionReturn(OptionFatalError,"UnrecognizedOption",option);
+
+  assert( LocaleCompare(cli_wand->command->mnemonic,option) == 0 );
+
+  if ((option_type & (SpecialOptionFlag|GenesisOptionFlag)) != 0 )
+    CLIWandExceptionReturn(OptionFatalError,"InvalidUseOfOption",option);
+
+  if ( (option_type & DeprecateOptionFlag) != 0 )
+    CLIWandExceptionReturn(OptionError,"DeprecatedOptionNoCode",option);
+
+  if ( IfMagickTrue(CLICatchException(cli_wand, MagickFalse)) )
+    return;
+
+
+  { size_t
+      count = cli_wand->command->type;
+
+    va_list
+      operands;
+
+    va_start(operands,option);
+
+    arg1=arg2=NULL;
+    if ( count >= 1 )
+      arg1=(const char *) va_arg(operands, const char *);
+    if ( count >= 2 )
+      arg2=(const char *) va_arg(operands, const char *);
+
+    va_end(operands);
+
+#if 1
+    (void) FormatLocaleFile(stderr,
+      "CLIOption: \"%s\"  Count: %d  Flags: %04x  Args: \"%s\" \"%s\"\n",
+          option,count,option_type,arg1,arg2);
+#endif
+  }
+
+  cli_wand->command = (const OptionInfo *) NULL; /* prevent re-use later */
+
+
+  /*
+     Call the appropriate option handler
+  */
+
+  /* FUTURE: this is temporary - get 'settings' to handle
+     distribution of settings to images attributes,proprieties,artifacts */
+  if ( cli_wand->wand.images != (Image *)NULL )
+    SyncImagesSettings(cli_wand->wand.image_info,cli_wand->wand.images,
+        cli_wand->wand.exception);
+
+  if ( (option_type & SettingOptionFlags) != 0 ) {
+    CLISettingOptionInfo(cli_wand, option, arg1, arg2);
+    // FUTURE: Sync Specific Settings into Image Properities (not global)
+  }
+
+  if ( (option_type & NoImageOperatorFlag) != 0)
+    CLINoImageOperator(cli_wand, option, arg1, arg2);
+
+  /* FUTURE: The not a setting part below is a temporary hack due to
+   * some options being both a Setting and a Simple operator.
+   * Specifically -monitor, -depth, and  -colorspace */
+  if ( cli_wand->wand.images == (Image *)NULL ) {
+    if ( ((option_type & (SimpleOperatorFlag|ListOperatorFlag)) != 0 ) &&
+         ((option_type & SettingOptionFlags) == 0 ))  /* temp hack */
+      CLIWandException(OptionError,"NoImagesFound",option);
+    return; /* on its own this is not an error */
+  }
+
+  if ( (option_type & SimpleOperatorFlag) != 0)
+    CLISimpleOperatorImages(cli_wand, option, arg1, arg2);
+
+  if ( (option_type & ListOperatorFlag) != 0 )
+    CLIListOperatorImages(cli_wand, option, arg1, arg2);
+
+}

diff --git a/MagickWand/operation.h b/MagickWand/operation.h
index 6726ec874b82032ab9c8cbf544159eee94ac67bc..bc996bc94e9799ade5b622e4f5c9742b2df30060 100644 (file)
--- a/MagickWand/operation.h
+++ b/MagickWand/operation.h
@@ -22,11 +22,16 @@
 extern "C" {
 #endif
 
+/* These actually private */
 extern WandExport void
   CLISettingOptionInfo(MagickCLI *,const char *,const char *, const char *),
   CLISimpleOperatorImages(MagickCLI *,const char *,const char *,const char *),
   CLIListOperatorImages(MagickCLI *, const char *,const char *,const char *),
-  CLISpecialOperator(MagickCLI *,const char *,const char *);
+  CLINoImageOperator(MagickCLI *, const char *,const char *,const char *);
+
+/* This can be used by used using WandCLI API */
+extern WandExport void
+  CLIOption(MagickCLI *,const char *,...);
 
 #if defined(__cplusplus) || defined(c_plusplus)
 }

diff --git a/MagickWand/wandcli-private.h b/MagickWand/wandcli-private.h
index b0d350b44ab68ee2e86a0cf865af239b00130afd..d0b0b6d42a82f5388982d9d37712f96c001eb918 100644 (file)
--- a/MagickWand/wandcli-private.h
+++ b/MagickWand/wandcli-private.h
@@ -30,10 +30,10 @@ extern "C" {
   (void) CLIThrowException(cli_wand,GetMagickModule(),severity,tag, \
        "'%s' '%s'",option, arg)
 
-#define CLIWandWarnDepreciated(message) \
+#define CLIWandWarnReplaced(message) \
   if ( (cli_wand->process_flags & ProcessWarnDepreciated) != 0 ) \
     (void) CLIThrowException(cli_wand,GetMagickModule(),OptionWarning, \
-       "DeprecatedOption", "'%s', use \"%s\"",option,message)
+       "ReplacedOption", "'%s', use \"%s\"",option,message)
 
 #define CLIWandExceptionFile(severity,tag,context) \
 { char *message=GetExceptionMessage(errno); \
@@ -108,16 +108,19 @@ struct _MagickCLI       /* CLI interface version of MagickWand */
   DrawInfo
     *draw_info;         /* for CLI API usage, not used by MagickWand API */
 
+  ProcessOptionFlags
+    process_flags;      /* When handling CLI, what options do we process? */
+
+  const OptionInfo
+    *command;           /* The option entry that is being processed */
+
   Stack
     *image_list_stack,  /* Stacks of Image Lists and Image Info settings */
     *image_info_stack;
 
-  ProcessOptionFlags
-    process_flags;      /* when handling CLI, what options do we process? */
-
   const char            /* Location of option being processed for exception */
     *location,          /* location format string for exception reports */
-    *filename;          /* "CLI", "unknown", or script filename */
+    *filename;          /* "CLI", "unknown", or the script filename */
 
   size_t
     line,               /* location of current option from source */

diff --git a/MagickWand/wandcli.c b/MagickWand/wandcli.c
index 8363edf977fe29a634251876ebfe6169024f9cd3..414fc75cd310b22adb776e04caaa5ca5262f7781 100644 (file)
--- a/MagickWand/wandcli.c
+++ b/MagickWand/wandcli.c
@@ -117,17 +117,19 @@ WandExport MagickCLI *AcquireMagickCLI(ImageInfo *image_info,
   /* Initialize CLI Part of MagickCLI */
   cli_wand->draw_info=CloneDrawInfo(cli_wand->wand.image_info,(DrawInfo *) NULL);
   cli_wand->quantize_info=AcquireQuantizeInfo(cli_wand->wand.image_info);
+  cli_wand->process_flags=MagickCommandOptionFlags;  /* assume "magick" CLI */
+  cli_wand->command=(const OptionInfo *)NULL;     /* no option at this time */
   cli_wand->image_list_stack=(Stack *)NULL;
   cli_wand->image_info_stack=(Stack *)NULL;
-  cli_wand->process_flags=MagickCommandOptionFlags;  /* assume "magick" CLI */
 
   /* default exception location...
      EG: sprintf(locaiton, filename, line, column);
   */
-  cli_wand->location="from \"%s\"";   /* location format: */
-  cli_wand->filename="unknown";       /* unknown source */
-  cli_wand->line=0;
-  cli_wand->column=0;
+  cli_wand->location="from \"%s\"";   /* location format using arguments: */
+                                      /*      filename, line, column */
+  cli_wand->filename="unknown";       /* script filename, unknown source */
+  cli_wand->line=0;                   /* line from script OR CLI argument */
+  cli_wand->column=0;                 /* column from script */
 
   cli_wand->signature=WandSignature;
   if (IfMagickTrue(cli_wand->wand.debug))
@@ -213,7 +215,7 @@ WandExport MagickCLI *DestroyMagickCLI(MagickCLI *cli_wand)
 %  CLICatchException() will report exceptions, either just non-fatal warnings
 %  only, or all errors, according to 'all_execeptions' boolean argument.
 %
-%  The function returns true is errors are fatal, in which case the caller
+%  The function returns true if errors are fatal, in which case the caller
 %  should abort and re-call with an 'all_exceptions' argument of true before
 %  quitting.
 %
@@ -225,6 +227,12 @@ WandExport MagickCLI *DestroyMagickCLI(MagickCLI *cli_wand)
 %    MagickBooleanType CLICatchException(MagickCLI *cli_wand,
 %              const MagickBooleanType all_exceptions );
 %
+%  Arguments are
+%
+%    o cli_wand:   The Wand CLI that holds the exception Information
+%
+%    o all_exceptions:   Report all exceptions, including the fatal one
+%
 */
 WandExport MagickBooleanType CLICatchException(MagickCLI *cli_wand,
      const MagickBooleanType all_exceptions )

diff --git a/config/english.xml b/config/english.xml
index caaeedd50620be906585ed6c8f0d0aa0120ec983..dae1a8962c7031e48fd87c7ec3a159a4496e2877 100644 (file)
--- a/config/english.xml
+++ b/config/english.xml
@@ -930,8 +930,8 @@
         </message>
       </fatalerror>
       <warning>
-        <message name="DeprecatedOption">
-          option is deprecated
+        <message name="ReplacedOption">
+          option has been replaced
         </message>
         <message name="GeometryDoesNotContainImage">
           geometry does not contain image

diff --git a/config/francais.xml b/config/francais.xml
index 4b24790aceb0ad4c06910c630ad5828121325329..d54e1b67b85c72a5acafb3d94915bf32de40b004 100644 (file)
--- a/config/francais.xml
+++ b/config/francais.xml
@@ -922,7 +922,7 @@
       </fatalerror>
       <warning>
         <message name="DepreciatedOption">
-          option est obsolète
+          Option a été remplacée
         </message>
         <message name="GeometryDoesNotContainImage">
           image non incluse dans la géométrie