From: anthony Date: Sun, 22 Apr 2012 08:51:01 +0000 (+0000) Subject: Refactoring option handling. X-Git-Tag: 7.0.1-0~5755 X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=464f1c476517436723780b8a8bb371464584453c;p=imagemagick Refactoring option handling. --- diff --git a/MagickCore/option.c b/MagickCore/option.c index 89e8140b6..097a5c2e3 100644 --- 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 a235380f3..3a045e5e2 100644 --- 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 a926368d3..e46292e18 100644 --- 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); } @@ -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 5488e8b2d..c77beecf8 100644 --- 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 } + +/* +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% % +% % +% % ++ 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 6726ec874..bc996bc94 100644 --- 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 b0d350b44..d0b0b6d42 100644 --- 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 8363edf97..414fc75cd 100644 --- 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 caaeedd50..dae1a8962 100644 --- a/config/english.xml +++ b/config/english.xml @@ -930,8 +930,8 @@ - - option is deprecated + + option has been replaced geometry does not contain image diff --git a/config/francais.xml b/config/francais.xml index 4b24790ac..d54e1b67b 100644 --- a/config/francais.xml +++ b/config/francais.xml @@ -922,7 +922,7 @@ - option est obsolète + Option a été remplacée image non incluse dans la géométrie