getopt.c

linux下很好的截图工具。 抓取整个桌面、某个指定的窗口、以及选择的矩形区域。

                     fprintf(stderr,
                             _
                             ("%s: option `--%s' doesn't allow an argument\n"),
                             argv[0], pfound->name);
                  else
                     /* +option or -option */
                     fprintf(stderr,
                             _
                             ("%s: option `%c%s' doesn't allow an argument\n"),
                             argv[0], argv[optind - 1][0], pfound->name);

               nextchar += strlen(nextchar);

               optopt = pfound->val;
               return '?';
            }
         }
         else if (pfound->has_arg == 1)
         {
            if (optind < argc)
               optarg = argv[optind++];
            else
            {
               if (opterr)
                  fprintf(stderr, _("%s: option `%s' requires an argument\n"),
                          argv[0], argv[optind - 1]);
               nextchar += strlen(nextchar);
               optopt = pfound->val;
               return optstring[0] == ':' ? ':' : '?';
            }
         }
         nextchar += strlen(nextchar);
         if (longind != NULL)
            *longind = option_index;
         if (pfound->flag)
         {
            *(pfound->flag) = pfound->val;
            return 0;
         }
         return pfound->val;
      }

      /* Can't find it as a long option.  If this is not getopt_long_only, or 
         the option starts with '--' or is not a valid short option, then
         it's an error. Otherwise interpret it as a short option.  */
      if (!long_only || argv[optind][1] == '-'
          || my_index(optstring, *nextchar) == NULL)
      {
         if (opterr)
         {
            if (argv[optind][1] == '-')
               /* --option */
               fprintf(stderr, _("%s: unrecognized option `--%s'\n"), argv[0],
                       nextchar);
            else
               /* +option or -option */
               fprintf(stderr, _("%s: unrecognized option `%c%s'\n"), argv[0],
                       argv[optind][0], nextchar);
         }
         nextchar = (char *) "";
         optind++;
         optopt = 0;
         return '?';
      }
   }

   /* Look at and handle the next short option-character.  */

   {
      char c = *nextchar++;
      char *temp = my_index(optstring, c);

      /* Increment `optind' when we start to process its last character.  */
      if (*nextchar == '\0')
         ++optind;

      if (temp == NULL || c == ':')
      {
         if (opterr)
         {
            if (posixly_correct)
               /* 1003.2 specifies the format of this message.  */
               fprintf(stderr, _("%s: illegal option -- %c\n"), argv[0], c);
            else
               fprintf(stderr, _("%s: invalid option -- %c\n"), argv[0], c);
         }
         optopt = c;
         return '?';
      }
      /* Convenience. Treat POSIX -W foo same as long option --foo */
      if (temp[0] == 'W' && temp[1] == ';')
      {
         char *nameend;
         const struct option *p;
         const struct option *pfound = NULL;
         int exact = 0;
         int ambig = 0;
         int indfound = 0;
         int option_index;

         /* This is an option that requires an argument.  */
         if (*nextchar != '\0')
         {
            optarg = nextchar;
            /* If we end this ARGV-element by taking the rest as an arg, we
               must advance to the next element now.  */
            optind++;
         }
         else if (optind == argc)
         {
            if (opterr)
            {
               /* 1003.2 specifies the format of this message.  */
               fprintf(stderr, _("%s: option requires an argument -- %c\n"),
                       argv[0], c);
            }
            optopt = c;
            if (optstring[0] == ':')
               c = ':';
            else
               c = '?';
            return c;
         }
         else
            /* We already incremented `optind' once; increment it again when
               taking next ARGV-elt as argument.  */
            optarg = argv[optind++];

         /* optarg is now the argument, see if it's in the table of longopts. 
          */

         for (nextchar = nameend = optarg; *nameend && *nameend != '=';
              nameend++)
            /* Do nothing.  */ ;

         /* Test all long options for either exact match or abbreviated
            matches.  */
         for (p = longopts, option_index = 0; p->name; p++, option_index++)
            if (!strncmp(p->name, nextchar, nameend - nextchar))
            {
               if ((unsigned int) (nameend - nextchar) == strlen(p->name))
               {
                  /* Exact match found.  */
                  pfound = p;
                  indfound = option_index;
                  exact = 1;
                  break;
               }
               else if (pfound == NULL)
               {
                  /* First nonexact match found.  */
                  pfound = p;
                  indfound = option_index;
               }
               else
                  /* Second or later nonexact match found.  */
                  ambig = 1;
            }
         if (ambig && !exact)
         {
            if (opterr)
               fprintf(stderr, _("%s: option `-W %s' is ambiguous\n"),
                       argv[0], argv[optind]);
            nextchar += strlen(nextchar);
            optind++;
            return '?';
         }
         if (pfound != NULL)
         {
            option_index = indfound;
            if (*nameend)
            {
               /* Don't test has_arg with >, because some C compilers don't
                  allow it to be used on enums.  */
               if (pfound->has_arg)
                  optarg = nameend + 1;
               else
               {
                  if (opterr)
                     fprintf(stderr, _("\
%s: option `-W %s' doesn't allow an argument\n"), argv[0], pfound->name);

                  nextchar += strlen(nextchar);
                  return '?';
               }
            }
            else if (pfound->has_arg == 1)
            {
               if (optind < argc)
                  optarg = argv[optind++];
               else
               {
                  if (opterr)
                     fprintf(stderr,
                             _("%s: option `%s' requires an argument\n"),
                             argv[0], argv[optind - 1]);
                  nextchar += strlen(nextchar);
                  return optstring[0] == ':' ? ':' : '?';
               }
            }
            nextchar += strlen(nextchar);
            if (longind != NULL)
               *longind = option_index;
            if (pfound->flag)
            {
               *(pfound->flag) = pfound->val;
               return 0;
            }
            return pfound->val;
         }
         nextchar = NULL;
         return 'W';                        /* Let the application handle it. 
                                             */
      }
      if (temp[1] == ':')
      {
         if (temp[2] == ':')
         {
            /* This is an option that accepts an argument optionally.  */
            if (*nextchar != '\0')
            {
               optarg = nextchar;
               optind++;
            }
            else
               optarg = NULL;
            nextchar = NULL;
         }
         else
         {
            /* This is an option that requires an argument.  */
            if (*nextchar != '\0')
            {
               optarg = nextchar;
               /* If we end this ARGV-element by taking the rest as an arg,
                  we must advance to the next element now.  */
               optind++;
            }
            else if (optind == argc)
            {
               if (opterr)
               {
                  /* 1003.2 specifies the format of this message.  */
                  fprintf(stderr,
                          _("%s: option requires an argument -- %c\n"),
                          argv[0], c);
               }
               optopt = c;
               if (optstring[0] == ':')
                  c = ':';
               else
                  c = '?';
            }
            else
               /* We already incremented `optind' once; increment it again
                  when taking next ARGV-elt as argument.  */
               optarg = argv[optind++];
            nextchar = NULL;
         }
      }
      return c;
   }
}

int
getopt(argc, argv, optstring)
   int argc;
   char *const *argv;
   const char *optstring;
{
   return _getopt_internal(argc, argv, optstring, (const struct option *) 0,
                           (int *) 0, 0);
}

#endif /* Not ELIDE_CODE.  */

#ifdef TEST

/* Compile with -DTEST to make an executable for use in testing
   the above definition of `getopt'.  */

int
main(argc, argv)
   int argc;
   char **argv;
{
   int c;
   int digit_optind = 0;

   while (1)
   {
      int this_option_optind = optind ? optind : 1;

      c = getopt(argc, argv, "abc:d:0123456789");
      if (c == -1)
         break;

      switch (c)
      {
        case '0':
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
           if (digit_optind != 0 && digit_optind != this_option_optind)
              printf("digits occur in two different argv-elements.\n");
           digit_optind = this_option_optind;
           printf("option %c\n", c);
           break;

        case 'a':
           printf("option a\n");
           break;

        case 'b':
           printf("option b\n");
           break;

        case 'c':
           printf("option c with value `%s'\n", optarg);
           break;

        case '?':
           break;

        default:
           printf("?? getopt returned character code 0%o ??\n", c);
      }
   }

   if (optind < argc)
   {
      printf("non-option ARGV-elements: ");
      while (optind < argc)
         printf("%s ", argv[optind++]);
      printf("\n");
   }

   exit(0);
}

#endif /* TEST */