granicus.if.org Git - imagemagick/blob - MagickWand/magick-cli.c

   1 /*
   2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   3 %                                                                             %
   4 %                                                                             %
   5 %                                                                             %
   6 %                 M   M   AAA    GGGG  IIIII   CCCC  K   K                    %
   7 %                 MM MM  A   A  G        I    C      K  K                     %
   8 %                 M M M  AAAAA  G GGG    I    C      KKK                      %
   9 %                 M   M  A   A  G   G    I    C      K  K                     %
  10 %                 M   M  A   A   GGGG  IIIII   CCCC  K   K                    %
  11 %                                                                             %
  12 %                            CCCC  L      IIIII                               %
  13 %                           C      L        I                                 %
  14 %                           C      L        I                                 %
  15 %                           C      L        I                                 %
  16 %                            CCCC  LLLLL  IIIII                               %
  17 %                                                                             %
  18 %       Perform "Magick" on Images via the Command Line Interface             %
  19 %                                                                             %
  20 %                             Dragon Computing                                %
  21 %                             Anthony Thyssen                                 %
  22 %                               January 2012                                  %
  23 %                                                                             %
  24 %                                                                             %
  25 %  Copyright 1999-2014 ImageMagick Studio LLC, a non-profit organization      %
  26 %  dedicated to making software imaging solutions freely available.           %
  27 %                                                                             %
  28 %  You may not use this file except in compliance with the License.  You may  %
  29 %  obtain a copy of the License at                                            %
  30 %                                                                             %
  31 %    http://www.imagemagick.org/script/license.php                            %
  32 %                                                                             %
  33 %  Unless required by applicable law or agreed to in writing, software        %
  34 %  distributed under the License is distributed on an "AS IS" BASIS,          %
  35 %  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %
  36 %  See the License for the specific language governing permissions and        %
  37 %  limitations under the License.                                             %
  38 %                                                                             %
  39 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  40 %
  41 %  Read CLI arguments, script files, and pipelines, to provide options that
  42 %  manipulate images from many different formats.
  43 %
  44 */
  45 \f
  46 /*
  47   Include declarations.
  48 */
  49 #include "MagickWand/studio.h"
  50 #include "MagickWand/MagickWand.h"
  51 #include "MagickWand/magick-wand-private.h"
  52 #include "MagickWand/wandcli.h"
  53 #include "MagickWand/wandcli-private.h"
  54 #include "MagickWand/operation.h"
  55 #include "MagickWand/magick-cli.h"
  56 #include "MagickWand/script-token.h"
  57 #include "MagickCore/utility-private.h"
  58 #include "MagickCore/exception-private.h"
  59 #include "MagickCore/version.h"
  60 \f
  61 /* verbose debugging,
  62       0 - no debug lines
  63       3 - show option details  (better to use -debug Command now)
  64       5 - image counts (after option runs)
  65 */
  66 #define MagickCommandDebug 0
  67
  68 \f
  69 /*
  70 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  71 %                                                                             %
  72 %                                                                             %
  73 %                                                                             %
  74 +   P r o c e s s S c r i p t O p t i o n s                                   %
  75 %                                                                             %
  76 %                                                                             %
  77 %                                                                             %
  78 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  79 %
  80 %  ProcessScriptOptions() reads options and processes options as they are
  81 %  found in the given file, or pipeline.  The filename to open and read
  82 %  options is given as the 'index' argument of the argument array given.
  83 %
  84 %  Other arguments following index may be read by special script options
  85 %  as settings (strings), images, or as operations to be processed in various
  86 %  ways.   How they are treated is up to the script being processed.
  87 %
  88 %  Note that a script not 'return' to the command line processing, nor can
  89 %  they call (and return from) other scripts. At least not at this time.
  90 %
  91 %  There are no 'ProcessOptionFlags' control flags at this time.
  92 %
  93 %  The format of the ProcessScriptOptions method is:
  94 %
  95 %    void ProcessScriptOptions(MagickCLI *cli_wand,const char *filename,
  96 %       int argc,char **argv,int index)
  97 %
  98 %  A description of each parameter follows:
  99 %
 100 %    o cli_wand: the main CLI Wand to use.
 101 %
 102 %    o filename: the filename of script to process
 103 %
 104 %    o argc: the number of elements in the argument vector. (optional)
 105 %
 106 %    o argv: A text array containing the command line arguments. (optional)
 107 %
 108 %    o index: offset of next argment in argv (script arguments) (optional)
 109 %
 110 */
 111 WandExport void ProcessScriptOptions(MagickCLI *cli_wand,const char *filename,
 112      int argc,char **argv,int index)
 113 {
 114   ScriptTokenInfo
 115     *token_info;
 116
 117   CommandOptionFlags
 118     option_type;
 119
 120   int
 121     count;
 122
 123   char
 124     *option,
 125     *arg1,
 126     *arg2;
 127
 128   assert(filename != (char *)NULL ); /* at least one argument - script name */
 129   assert(cli_wand != (MagickCLI *) NULL);
 130   assert(cli_wand->signature == WandSignature);
 131   if (IfMagickTrue(cli_wand->wand.debug))
 132     (void) LogMagickEvent(CommandEvent,GetMagickModule(),
 133          "Processing script \"%s\"", filename);
 134
 135   /* open file script or stream, and set up tokenizer */
 136   token_info = AcquireScriptTokenInfo(filename);
 137   if (token_info == (ScriptTokenInfo *) NULL) {
 138     CLIWandExceptionFile(OptionFatalError,"UnableToOpenScript",filename);
 139     return;
 140   }
 141
 142   /* define the error location string for use in exceptions
 143      order of localtion format escapes: filename, line, column */
 144   cli_wand->location="in \"%s\" at line %u,column %u";
 145   if ( LocaleCompare("-", filename) == 0 )
 146     cli_wand->filename="stdin";
 147   else
 148     cli_wand->filename=filename;
 149
 150   /* Process Options from Script */
 151   option = arg1 = arg2 = (char*)NULL;
 152 DisableMSCWarning(4127)
 153   while (1) {
 154 RestoreMSCWarning
 155
 156     { MagickBooleanType status = GetScriptToken(token_info);
 157       cli_wand->line=token_info->token_line;
 158       cli_wand->column=token_info->token_column;
 159       if( IfMagickFalse(status) )
 160         break; /* error or end of options */
 161     }
 162
 163     do { /* use break to loop to exception handler and loop */
 164
 165       /* save option details */
 166       CloneString(&option,token_info->token);
 167
 168       /* get option, its argument count, and option type */
 169       cli_wand->command = GetCommandOptionInfo(option);
 170       count=cli_wand->command->type;
 171       option_type=(CommandOptionFlags) cli_wand->command->flags;
 172 #if 0
 173       (void) FormatLocaleFile(stderr, "Script: %u,%u: \"%s\" matched \"%s\"\n",
 174           cli_wand->line, cli_wand->line, option, cli_wand->command->mnemonic );
 175 #endif
 176
 177       /* handle a undefined option - image read - always for "magick-script" */
 178       if ( option_type == UndefinedOptionFlag ||
 179            (option_type & NonMagickOptionFlag) != 0 ) {
 180 #if MagickCommandDebug >= 3
 181         (void) FormatLocaleFile(stderr, "Script %u,%u Non-Option: \"%s\"\n",
 182                     cli_wand->line, cli_wand->line, option);
 183 #endif
 184         if ( IfMagickFalse(IsCommandOption(option))) {
 185           /* non-option -- treat as a image read */
 186           cli_wand->command=(const OptionInfo *)NULL;
 187           CLIOption(cli_wand,"-read",option);
 188           break; /* next option */
 189         }
 190         CLIWandException(OptionFatalError,"UnrecognizedOption",option);
 191         break; /* next option */
 192       }
 193
 194       if ( count >= 1 ) {
 195         if( IfMagickFalse(GetScriptToken(token_info)) )
 196           CLIWandException(OptionFatalError,"MissingArgument",option);
 197         CloneString(&arg1,token_info->token);
 198       }
 199       else
 200         CloneString(&arg1,(char *)NULL);
 201
 202       if ( count >= 2 ) {
 203         if( IfMagickFalse(GetScriptToken(token_info)) )
 204           CLIWandExceptionBreak(OptionFatalError,"MissingArgument",option);
 205         CloneString(&arg2,token_info->token);
 206       }
 207       else
 208         CloneString(&arg2,(char *)NULL);
 209
 210       /*
 211         Process Options
 212       */
 213 #if MagickCommandDebug >= 3
 214       (void) FormatLocaleFile(stderr,
 215         "Script %u,%u Option: \"%s\"  Count: %d  Flags: %04x  Args: \"%s\" \"%s\"\n",
 216             cli_wand->line,cli_wand->line,option,count,option_type,arg1,arg2);
 217 #endif
 218       /* Hard Deprecated Options, no code to execute - error */
 219       if ( (option_type & DeprecateOptionFlag) != 0 ) {
 220         CLIWandException(OptionError,"DeprecatedOptionNoCode",option);
 221         break; /* next option */
 222       }
 223
 224       /* MagickCommandGenesis() options have no place in a magick script */
 225       if ( (option_type & GenesisOptionFlag) != 0 ) {
 226         CLIWandException(OptionError,"InvalidUseOfOption",option);
 227         break; /* next option */
 228       }
 229
 230       /* handle any special 'script' options */
 231       if ( (option_type & SpecialOptionFlag) != 0 ) {
 232         if ( LocaleCompare(option,"-exit") == 0 ) {
 233           goto loop_exit; /* break out of loop - return from script */
 234         }
 235         if ( LocaleCompare(option,"-script") == 0 ) {
 236           /* FUTURE: call new script from this script - error for now */
 237           CLIWandException(OptionError,"InvalidUseOfOption",option);
 238           break; /* next option */
 239         }
 240         /* FUTURE: handle special script-argument options here */
 241         /* handle any other special operators now */
 242         CLIWandException(OptionError,"InvalidUseOfOption",option);
 243         break; /* next option */
 244       }
 245
 246       /* Process non-specific Option */
 247       CLIOption(cli_wand, option, arg1, arg2);
 248
 249 DisableMSCWarning(4127)
 250     } while (0); /* break block to next option */
 251 RestoreMSCWarning
 252
 253 #if MagickCommandDebug >= 5
 254     fprintf(stderr, "Script Image Count = %ld\n",
 255          GetImageListLength(cli_wand->wand.images) );
 256 #endif
 257     if ( IfMagickTrue(CLICatchException(cli_wand, MagickFalse)) )
 258       break;  /* exit loop */
 259   }
 260
 261   /*
 262      Loop exit - check for some tokenization error
 263   */
 264 loop_exit:
 265 #if MagickCommandDebug >= 3
 266   (void) FormatLocaleFile(stderr, "Script End: %d\n", token_info->status);
 267 #endif
 268   switch( token_info->status ) {
 269     case TokenStatusOK:
 270     case TokenStatusEOF:
 271       if (cli_wand->image_list_stack != (Stack *)NULL)
 272         CLIWandException(OptionError,"UnbalancedParenthesis", "(eof)");
 273       else if (cli_wand->image_info_stack != (Stack *)NULL)
 274         CLIWandException(OptionError,"UnbalancedBraces", "(eof)");
 275       break;
 276     case TokenStatusBadQuotes:
 277       /* Ensure last token has a sane length for error report */
 278       if( strlen(token_info->token) > INITAL_TOKEN_LENGTH-1 ) {
 279         token_info->token[INITAL_TOKEN_LENGTH-4] = '.';
 280         token_info->token[INITAL_TOKEN_LENGTH-3] = '.';
 281         token_info->token[INITAL_TOKEN_LENGTH-2] = '.';
 282         token_info->token[INITAL_TOKEN_LENGTH-1] = '\0';
 283       }
 284       CLIWandException(OptionFatalError,"ScriptUnbalancedQuotes",
 285            token_info->token);
 286       break;
 287     case TokenStatusMemoryFailed:
 288       CLIWandException(OptionFatalError,"ScriptTokenMemoryFailed","");
 289       break;
 290     case TokenStatusBinary:
 291       CLIWandException(OptionFatalError,"ScriptIsBinary","");
 292       break;
 293   }
 294   if (IfMagickTrue(cli_wand->wand.debug))
 295     (void) LogMagickEvent(CommandEvent,GetMagickModule(),
 296          "Script End \"%s\"", filename);
 297
 298   /* Clean up */
 299   token_info = DestroyScriptTokenInfo(token_info);
 300
 301   CloneString(&option,(char *)NULL);
 302   CloneString(&arg1,(char *)NULL);
 303   CloneString(&arg2,(char *)NULL);
 304
 305   return;
 306 }
 307 \f
 308 /*
 309 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 310 %                                                                             %
 311 %                                                                             %
 312 %                                                                             %
 313 +  P r o c e s s C o m m a n d O p t i o n s                                  %
 314 %                                                                             %
 315 %                                                                             %
 316 %                                                                             %
 317 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 318 %
 319 %  ProcessCommandOptions() reads and processes arguments in the given
 320 %  command line argument array. The 'index' defines where in the array we
 321 %  should begin processing
 322 %
 323 %  The 'process_flags' can be used to control and limit option processing.
 324 %  For example, to only process one option, or how unknown and special options
 325 %  are to be handled, and if the last argument in array is to be regarded as a
 326 %  final image write argument (filename or special coder).
 327 %
 328 %  The format of the ProcessCommandOptions method is:
 329 %
 330 %    int ProcessCommandOptions(MagickCLI *cli_wand,
 331 %           int argc,char **argv,int index)
 332 %
 333 %  A description of each parameter follows:
 334 %
 335 %    o cli_wand: the main CLI Wand to use.
 336 %
 337 %    o argc: the number of elements in the argument vector.
 338 %
 339 %    o argv: A text array containing the command line arguments.
 340 %
 341 %    o process_flags: What type of arguments will be processed, ignored
 342 %                     or return errors.
 343 %
 344 %    o index: index in the argv array to start processing from
 345 %
 346 % The function returns the index ot the next option to be processed. This
 347 % is really only releven if process_flags contains a ProcessOneOptionOnly
 348 % flag.
 349 %
 350 */
 351 WandExport int ProcessCommandOptions(MagickCLI *cli_wand, int argc,
 352      char **argv, int index )
 353 {
 354   const char
 355     *option,
 356     *arg1,
 357     *arg2;
 358
 359   int
 360     i,
 361     end,
 362     count;
 363
 364   CommandOptionFlags
 365     option_type;
 366
 367   assert(argc>=index); /* you may have no arguments left! */
 368   assert(argv != (char **)NULL);
 369   assert(argv[index] != (char *)NULL);
 370   assert(argv[argc-1] != (char *)NULL);
 371   assert(cli_wand != (MagickCLI *) NULL);
 372   assert(cli_wand->signature == WandSignature);
 373
 374   /* define the error location string for use in exceptions
 375      order of localtion format escapes: filename, line, column */
 376   cli_wand->location="at %s arg %u";
 377   cli_wand->filename="CLI";
 378   cli_wand->line=index;  /* note first argument we will process */
 379
 380   if (IfMagickTrue(cli_wand->wand.debug))
 381     (void) CLILogEvent(cli_wand,CommandEvent,GetMagickModule(),
 382          "- Starting (\"%s\")", argv[index]);
 383
 384   end = argc;
 385   if ( (cli_wand->process_flags & ProcessImplictWrite) != 0 )
 386     end--; /* the last arument is an implied write, do not process directly */
 387
 388   for (i=index; i < end; i += count +1) {
 389     /* Finished processing one option? */
 390     if ( (cli_wand->process_flags & ProcessOneOptionOnly) != 0 && i != index )
 391       return(i);
 392
 393     do { /* use break to loop to exception handler and loop */
 394
 395       option=argv[i];
 396       cli_wand->line=i;  /* note the argument for this option */
 397
 398       /* get option, its argument count, and option type */
 399       cli_wand->command = GetCommandOptionInfo(argv[i]);
 400       count=cli_wand->command->type;
 401       option_type=(CommandOptionFlags) cli_wand->command->flags;
 402 #if 0
 403       (void) FormatLocaleFile(stderr, "CLI %d: \"%s\" matched \"%s\"\n",
 404             i, argv[i], cli_wand->command->mnemonic );
 405 #endif
 406
 407       if ( option_type == UndefinedOptionFlag ||
 408            (option_type & NonMagickOptionFlag) != 0 ) {
 409 #if MagickCommandDebug >= 3
 410         (void) FormatLocaleFile(stderr, "CLI arg %d Non-Option: \"%s\"\n",
 411              i, option);
 412 #endif
 413         if ( IfMagickFalse(IsCommandOption(option)) ) {
 414           if ( (cli_wand->process_flags & ProcessImplictRead) != 0 ) {
 415             /* non-option -- treat as a image read */
 416             cli_wand->command=(const OptionInfo *)NULL;
 417             CLIOption(cli_wand,"-read",option);
 418             break; /* next option */
 419           }
 420         }
 421         CLIWandException(OptionFatalError,"UnrecognizedOption",option);
 422         break; /* next option */
 423       }
 424
 425       if ( ((option_type & SpecialOptionFlag) != 0 ) &&
 426            ((cli_wand->process_flags & ProcessScriptOption) != 0) &&
 427            (LocaleCompare(option,"-script") == 0) ) {
 428         /* Call Script from CLI, with a filename as a zeroth argument.
 429            NOTE: -script may need to use the 'implict write filename' argument
 430            so it must be handled specially to prevent a 'missing argument' error.
 431         */
 432         if ( (i+count) >= argc )
 433           CLIWandException(OptionFatalError,"MissingArgument",option);
 434         ProcessScriptOptions(cli_wand,argv[i+1],argc,argv,i+count);
 435         return(argc);  /* Script does not return to CLI -- Yet */
 436                        /* FUTURE: when it does, their may be no write arg! */
 437       }
 438
 439       if ((i+count) >= end ) {
 440         CLIWandException(OptionFatalError,"MissingArgument",option);
 441         if ( CLICatchException(cli_wand, MagickFalse) != MagickFalse )
 442           return(end);
 443         break; /* next option - not that their is any! */
 444       }
 445
 446       arg1 = ( count >= 1 ) ? argv[i+1] : (char *)NULL;
 447       arg2 = ( count >= 2 ) ? argv[i+2] : (char *)NULL;
 448
 449       /*
 450         Process Known Options
 451       */
 452 #if MagickCommandDebug >= 3
 453       (void) FormatLocaleFile(stderr,
 454         "CLI arg %u Option: \"%s\"  Count: %d  Flags: %04x  Args: \"%s\" \"%s\"\n",
 455             i,option,count,option_type,arg1,arg2);
 456 #endif
 457       /* ignore 'genesis options' in command line args */
 458       if ( (option_type & GenesisOptionFlag) != 0 )
 459         break; /* next option */
 460
 461       /* Handle any special options for CLI (-script handled above) */
 462       if ( (option_type & SpecialOptionFlag) != 0 ) {
 463         if ( (cli_wand->process_flags & ProcessExitOption) != 0
 464              && LocaleCompare(option,"-exit") == 0 )
 465           return(i+count);
 466         break; /* next option */
 467       }
 468
 469       /* Process standard image option */
 470       CLIOption(cli_wand, option, arg1, arg2);
 471
 472 DisableMSCWarning(4127)
 473     } while (0); /* break block to next option */
 474 RestoreMSCWarning
 475
 476 #if MagickCommandDebug >= 5
 477     (void) FormatLocaleFile(stderr, "CLI-post Image Count = %ld\n",
 478          (long) GetImageListLength(cli_wand->wand.images) );
 479 #endif
 480     if ( CLICatchException(cli_wand, MagickFalse) != MagickFalse )
 481       return(i+count);
 482   }
 483   assert(i==end);
 484
 485   if ( (cli_wand->process_flags & ProcessImplictWrite) == 0 )
 486     return(end); /* no implied write -- just return to caller */
 487
 488   assert(end==argc-1); /* end should not include last argument */
 489
 490   /*
 491      Implicit Write of images to final CLI argument
 492   */
 493   option=argv[i];
 494   cli_wand->line=i;
 495
 496   /* check that stacks are empty - or cause exception */
 497   if (cli_wand->image_list_stack != (Stack *)NULL)
 498     CLIWandException(OptionError,"UnbalancedParenthesis", "(end of cli)");
 499   else if (cli_wand->image_info_stack != (Stack *)NULL)
 500     CLIWandException(OptionError,"UnbalancedBraces", "(end of cli)");
 501   if ( CLICatchException(cli_wand, MagickFalse) != MagickFalse )
 502     return(argc);
 503
 504 #if MagickCommandDebug >= 3
 505   (void) FormatLocaleFile(stderr,"CLI arg %d Write File: \"%s\"\n",i,option);
 506 #endif
 507
 508   /* Valid 'do no write' replacement option (instead of "null:") */
 509   if (LocaleCompare(option,"-exit") == 0 )
 510     return(argc);  /* just exit, no image write */
 511
 512   /* If filename looks like an option,
 513      Or the common 'end of line' error of a single space.
 514      -- produce an error */
 515   if (IfMagickTrue(IsCommandOption(option)) ||
 516       (option[0] == ' ' && option[1] == '\0') ) {
 517     CLIWandException(OptionError,"MissingOutputFilename",option);
 518     return(argc);
 519   }
 520
 521   cli_wand->command=(const OptionInfo *)NULL;
 522   CLIOption(cli_wand,"-write",option);
 523   return(argc);
 524 }
 525 \f
 526 /*
 527 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 528 %                                                                             %
 529 %                                                                             %
 530 %                                                                             %
 531 +   M a g i c k I m a g e C o m m a n d                                       %
 532 %                                                                             %
 533 %                                                                             %
 534 %                                                                             %
 535 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 536 %
 537 %  MagickImageCommand() Handle special use CLI arguments and prepare a
 538 %  CLI MagickCLI to process the command line or directly specified script.
 539 %
 540 %  This is essentualy interface function between the MagickCore library
 541 %  initialization function MagickCommandGenesis(), and the option MagickCLI
 542 %  processing functions  ProcessCommandOptions()  or  ProcessScriptOptions()
 543 %
 544 %  The format of the MagickImageCommand method is:
 545 %
 546 %      MagickBooleanType MagickImageCommand(ImageInfo *image_info,int argc,
 547 %        char **argv,char **metadata,ExceptionInfo *exception)
 548 %
 549 %  A description of each parameter follows:
 550 %
 551 %    o image_info: the starting image_info structure
 552 %      (for compatibilty with MagickCommandGenisis())
 553 %
 554 %    o argc: the number of elements in the argument vector.
 555 %
 556 %    o argv: A text array containing the command line arguments.
 557 %
 558 %    o metadata: any metadata (for VBS) is returned here.
 559 %      (for compatibilty with MagickCommandGenisis())
 560 %
 561 %    o exception: return any errors or warnings in this structure.
 562 %
 563 */
 564
 565 static void MagickUsage(MagickBooleanType verbose)
 566 {
 567   const char
 568     *name;
 569
 570   size_t
 571     len;
 572
 573   name=GetClientName();
 574   len=strlen(name);
 575
 576   if (len>=7 && LocaleCompare("convert",name+len-7) == 0) {
 577     /* convert usage */
 578     (void) FormatLocaleFile(stdout,
 579        "Usage: %s [ {option} | {image} ... ] {output_image}\n",name);
 580     (void) FormatLocaleFile(stdout,
 581        "       %s -help | -version | -usage | -list {option}\n\n",name);
 582     return;
 583   }
 584   else if (len>=6 && LocaleCompare("script",name+len-6) == 0) {
 585     /* magick-script usage */
 586     (void) FormatLocaleFile(stdout,
 587       "Usage: %s {filename} [ {script_args} ... ]\n",name);
 588   }
 589   else {
 590     /* magick usage */
 591     (void) FormatLocaleFile(stdout,
 592        "Usage: %s [ {option} | {image} ... ] {output_image}\n",name);
 593     (void) FormatLocaleFile(stdout,
 594        "       %s [ {option} | {image} ... ] -script {filename} [ {script_args} ...]\n",
 595        name);
 596   }
 597   (void) FormatLocaleFile(stdout,
 598     "       %s -help | -version | -usage | -list {option}\n\n",name);
 599
 600   if (IfMagickFalse(verbose))
 601     return;
 602
 603   (void) FormatLocaleFile(stdout,"%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",
 604     "All options are performed in a strict 'as you see them' order\n",
 605     "You must read-in images before you can operate on them.\n",
 606     "\n",
 607     "Magick Script files can use any of the following forms...\n",
 608     "     #!/path/to/magick -script\n",
 609     "or\n",
 610     "     #!/bin/sh\n",
 611     "     :; exec magick -script \"$0\" \"$@\"; exit 10\n",
 612     "     # Magick script from here...\n",
 613     "or\n",
 614     "     #!/usr/bin/env  magick-script\n",
 615     "The latter two forms do not require the path to the command hard coded.\n",
 616     "Note: \"magick-script\" needs to be linked to the \"magick\" command.\n",
 617     "\n",
 618     "For more information on usage, options, examples, and techniques\n",
 619     "see the ImageMagick website at    ", MagickAuthoritativeURL);
 620
 621   return;
 622 }
 623
 624 /*
 625    Concatanate given file arguments to the given output argument.
 626    Used for a special -concatenate option used for specific 'delegates'.
 627    The option is not formally documented.
 628
 629       magick -concatenate files... output
 630
 631    This is much like the UNIX "cat" command, but for both UNIX and Windows,
 632    however the last argument provides the output filename.
 633 */
 634 static MagickBooleanType ConcatenateImages(int argc,char **argv,
 635      ExceptionInfo *exception )
 636 {
 637   FILE
 638     *input,
 639     *output;
 640
 641   int
 642     c;
 643
 644   register ssize_t
 645     i;
 646
 647   if (IfMagickFalse(  ExpandFilenames(&argc,&argv)  ))
 648     ThrowFileException(exception,ResourceLimitError,"MemoryAllocationFailed",
 649          GetExceptionMessage(errno));
 650
 651   output=fopen_utf8(argv[argc-1],"wb");
 652   if (output == (FILE *) NULL) {
 653     ThrowFileException(exception,FileOpenError,"UnableToOpenFile",argv[argc-1]);
 654     return(MagickFalse);
 655   }
 656   for (i=2; i < (ssize_t) (argc-1); i++) {
 657 #if 0
 658     fprintf(stderr, "DEBUG: Concatenate Image: \"%s\"\n", argv[i]);
 659 #endif
 660     input=fopen_utf8(argv[i],"rb");
 661     if (input == (FILE *) NULL) {
 662         ThrowFileException(exception,FileOpenError,"UnableToOpenFile",argv[i]);
 663         continue;
 664       }
 665     for (c=fgetc(input); c != EOF; c=fgetc(input))
 666       (void) fputc((char) c,output);
 667     (void) fclose(input);
 668     (void) remove_utf8(argv[i]);
 669   }
 670   (void) fclose(output);
 671   return(MagickTrue);
 672 }
 673
 674 WandExport MagickBooleanType MagickImageCommand(ImageInfo *image_info,
 675   int argc,char **argv,char **metadata,ExceptionInfo *exception)
 676 {
 677   MagickCLI
 678     *cli_wand;
 679
 680   size_t
 681     len;
 682
 683   assert(image_info != (ImageInfo *)NULL);
 684
 685   /* For specific OS command line requirements */
 686   ReadCommandlLine(argc,&argv);
 687
 688   /* Initialize special "CLI Wand" to hold images and settings (empty) */
 689   cli_wand=AcquireMagickCLI(image_info,exception);
 690   cli_wand->location="Initializing";
 691   cli_wand->filename=argv[0];
 692   cli_wand->line=1;
 693
 694   if (IfMagickTrue(cli_wand->wand.debug))
 695     (void) CLILogEvent(cli_wand,CommandEvent,GetMagickModule(),
 696          "\"%s\"",argv[0]);
 697
 698
 699   GetPathComponent(argv[0],TailPath,cli_wand->wand.name);
 700   SetClientName(cli_wand->wand.name);
 701   ConcatenateMagickString(cli_wand->wand.name,"-CLI",MaxTextExtent);
 702
 703   len=strlen(argv[0]);  /* precaution */
 704
 705   /* "convert" command - give a "deprecated" warning" */
 706   if (len>=7 && LocaleCompare("convert",argv[0]+len-7) == 0) {
 707     cli_wand->process_flags = ConvertCommandOptionFlags;
 708     (void) FormatLocaleFile(stderr,"WARNING: %s\n",
 709          "The convert command is deprecated in IMv7, use \"magick\"\n");
 710   }
 711
 712   /* Special Case:  If command name ends with "script" implied "-script" */
 713   if (len>=6 && LocaleCompare("script",argv[0]+len-6) == 0) {
 714     if (argc >= 2 && (  (*(argv[1]) != '-') || (strlen(argv[1]) == 1) )) {
 715       GetPathComponent(argv[1],TailPath,cli_wand->wand.name);
 716       ProcessScriptOptions(cli_wand,argv[1],argc,argv,2);
 717       goto Magick_Command_Cleanup;
 718     }
 719   }
 720
 721   /* Special Case: Version Information and Abort */
 722   if (argc == 2) {
 723     if ((LocaleCompare("-version",argv[1]) == 0)   || /* GNU standard option */
 724         (LocaleCompare("--version",argv[1]) == 0) ) { /* just version */
 725       CLIOption(cli_wand, "-version");
 726       goto Magick_Command_Exit;
 727     }
 728     if ((LocaleCompare("-help",argv[1]) == 0)   || /* GNU standard option */
 729         (LocaleCompare("--help",argv[1]) == 0) ) { /* just a brief summary */
 730       if (IfMagickTrue(cli_wand->wand.debug))
 731         (void) CLILogEvent(cli_wand,CommandEvent,GetMagickModule(),
 732             "- Special Option \"%s\"", argv[1]);
 733       MagickUsage(MagickFalse);
 734       goto Magick_Command_Exit;
 735     }
 736     if (LocaleCompare("-usage",argv[1]) == 0) {   /* both version & usage */
 737       if (IfMagickTrue(cli_wand->wand.debug))
 738         (void) CLILogEvent(cli_wand,CommandEvent,GetMagickModule(),
 739             "- Special Option \"%s\"", argv[1]);
 740       CLIOption(cli_wand, "-version" );
 741       MagickUsage(MagickTrue);
 742       goto Magick_Command_Exit;
 743     }
 744   }
 745
 746   /* not enough arguments -- including -help */
 747   if (argc < 3) {
 748     (void) FormatLocaleFile(stderr,
 749        "Error: Invalid argument or not enough arguments\n\n");
 750     MagickUsage(MagickFalse);
 751     goto Magick_Command_Exit;
 752   }
 753
 754   /* Special "concatenate option (hidden) for delegate usage */
 755   if (LocaleCompare("-concatenate",argv[1]) == 0) {
 756     if (IfMagickTrue(cli_wand->wand.debug))
 757         (void) CLILogEvent(cli_wand,CommandEvent,GetMagickModule(),
 758             "- Special Option \"%s\"", argv[1]);
 759     ConcatenateImages(argc,argv,exception);
 760     goto Magick_Command_Exit;
 761   }
 762
 763   /* List Information and Abort */
 764   if (argc == 3 && LocaleCompare("-list",argv[1]) == 0) {
 765     CLIOption(cli_wand, argv[1], argv[2]);
 766     goto Magick_Command_Exit;
 767   }
 768
 769   /* ------------- */
 770   /* The Main Call */
 771
 772   if (LocaleCompare("-script",argv[1]) == 0) {
 773     /* Start processing directly from script, no pre-script options
 774        Replace wand command name with script name
 775        First argument in the argv array is the script name to read.
 776     */
 777     GetPathComponent(argv[2],TailPath,cli_wand->wand.name);
 778     ProcessScriptOptions(cli_wand,argv[2],argc,argv,3);
 779   }
 780   else {
 781     /* Normal Command Line, assumes output file as last option */
 782     ProcessCommandOptions(cli_wand,argc,argv,1);
 783   }
 784   /* ------------- */
 785
 786 Magick_Command_Cleanup:
 787   cli_wand->location="Cleanup";
 788   cli_wand->filename=argv[0];
 789   if (IfMagickTrue(cli_wand->wand.debug))
 790     (void) CLILogEvent(cli_wand,CommandEvent,GetMagickModule(),
 791          "\"%s\"",argv[0]);
 792
 793   /* recover original image_info and clean up stacks
 794      FUTURE: "-reset stacks" option  */
 795   while (cli_wand->image_list_stack != (Stack *)NULL)
 796     CLIOption(cli_wand,")");
 797   while (cli_wand->image_info_stack != (Stack *)NULL)
 798     CLIOption(cli_wand,"}");
 799
 800   /* assert we have recovered the original structures */
 801   assert(cli_wand->wand.image_info == image_info);
 802   assert(cli_wand->wand.exception == exception);
 803
 804   /* Handle metadata for ImageMagickObject COM object for Windows VBS */
 805   if (metadata != (char **) NULL) {
 806     const char
 807       *format;
 808
 809     char
 810       *text;
 811
 812     format="%w,%h,%m";   // Get this from image_info Option splaytree
 813
 814     text=InterpretImageProperties(image_info,cli_wand->wand.images,format,
 815       exception);
 816     if (text == (char *) NULL)
 817       ThrowMagickException(exception,GetMagickModule(),ResourceLimitError,
 818         "MemoryAllocationFailed","`%s'", GetExceptionMessage(errno));
 819     else {
 820       (void) ConcatenateString(&(*metadata),text);
 821       text=DestroyString(text);
 822     }
 823   }
 824
 825 Magick_Command_Exit:
 826   cli_wand->location="Exiting";
 827   cli_wand->filename=argv[0];
 828   if (IfMagickTrue(cli_wand->wand.debug))
 829     (void) CLILogEvent(cli_wand,CommandEvent,GetMagickModule(),
 830          "\"%s\"",argv[0]);
 831
 832   /* Destroy the special CLI Wand */
 833   cli_wand->wand.image_info = (ImageInfo *)NULL; /* not these */
 834   cli_wand->wand.exception = (ExceptionInfo *)NULL;
 835   cli_wand=DestroyMagickCLI(cli_wand);
 836
 837   return(IsMagickTrue(exception->severity > ErrorException));
 838 }