getopts.c

来自「国外网站上的一些精典的C程序」· C语言 代码 · 共 945 行 · 第 1/3 页

                        if (ptr->Default)
                              arg_ptr = ptr->Default;
                        else  return PSerror;
                  }
                  else  arg_ptr = &swStr[2];

                  long_var = dround(getopts_eval(arg_ptr));
                  if (ptr->additive)
                        *((long *)(ptr->buf)) += long_var;
                  else  *((long *)(ptr->buf))  = long_var;
                  bounds(ptr);
                  searching = False_;
                  break;

            case DWord_Tag:
                  if (!swStr[2])
                  {
                        if (ptr->Default)
                              arg_ptr = ptr->Default;
                        else  return PSerror;
                  }
                  else  arg_ptr = &swStr[2];

                  sscanf(arg_ptr, "%lx", (unsigned long *)(dword_var));
                  if (ptr->additive)
                        *((unsigned long *)(ptr->buf)) += dword_var;
                  else  *((unsigned long *)(ptr->buf))  = dword_var;
                  bounds(ptr);
                  searching = False_;
                  break;

            case Float_Tag:
                  if (!swStr[2])
                  {
                        if (ptr->Default)
                              arg_ptr = ptr->Default;
                        else  return PSerror;
                  }
                  else  arg_ptr = &swStr[2];

                  double_var = (double)getopts_eval(arg_ptr);
                  if (ptr->additive)
                        *((double *)(ptr->buf)) += double_var;
                  else  *((double *)(ptr->buf))  = double_var;
                  bounds(ptr);
                  searching = False_;
                  break;

            case DFloat_Tag:
                  if (!swStr[2])
                  {
                        if (ptr->Default)
                              arg_ptr = ptr->Default;
                        else  return PSerror;
                  }
                  else  arg_ptr = &swStr[2];

                  double_var = (double)getopts_eval(arg_ptr);
                  if (ptr->additive)
                        *((double *)(ptr->buf)) += double_var;
                  else  *((double *)(ptr->buf))  = double_var;
                  bounds(ptr);
                  searching = False_;
                  break;

            case String_Tag:
                  if (!swStr[2] && ptr->Default && ptr->Default[0])
                  {
                        if (ptr->additive)
                              strcat(ptr->buf, (char *)(ptr->Default));
                        else  strcpy(ptr->buf, (char *)(ptr->Default));
                  }
                  else if (!swStr[2])
                  {
                        string_pending    = True_;
                        additive_pending  = ptr->additive;
                        pending_buf       = ptr->buf;
                  }
                  else
                  {
                        if (ptr->additive)
                              strcat(ptr->buf, &swStr[2]);
                        else  strcpy(ptr->buf, &swStr[2]);
                  }
                  bounds(ptr);
                  searching = False_;
                  break;

            default:
                  ErrExit("Unrecognized switch \"%s\"", swStr);
                  return PSerror;
            }
      }
      ++count;
      if (!rspfile)
            --xargc;

      return PSok;
}

/*
**  Static function to process verbose options
**
**  Parameters: 1 - argv[i] containing the verbose option
**
**  Returns: PSok      if switch successful
**           PSerror   if invalid
**           PSliteral if literal (non-switch) argument
*/

#define MAXOPTSTR 192

static enum proc_stat VoProc(char *swStr)
{
      struct Voption_tag *ptr;
      Boolean_T searching;
      char *arg_ptr;
      unsigned char     byte_var;
      int               int_var;
      short             short_var;
      unsigned short    word_var;
      long              long_var;
      unsigned long     dword_var, bitfield_var;
      double            double_var;
      char              string_var[MAXOPTSTR];

      /*
      ** Found a verbose option
      */

      printf("VoProc(%s): Entry\n", swStr);
      for (ptr = voptions, searching = True_; searching; ++ptr)
      {
            char *p, optbuf[MAXOPTSTR];

            p = stptok(swStr, optbuf, MAXOPTSTR, "=");
            if ((p == swStr) || (p == swStr + MAXOPTSTR))
                  ErrExit("Illegal option \"%s\"", swStr);

            printf("VoProc(): optbuf=%s, ptr->optstr=%s\n", optbuf, ptr->optstr);
            if (!ptr->case_sense)
            {
                  strupr(ptr->optstr);
                  strupr(optbuf);
            }

            printf("VoProc(): optbuf=%s, ptr->optstr=%s\n", optbuf, ptr->optstr);
            if (STREQ(optbuf, ptr->optstr)) switch (ptr->type)
            {
                  case Boolean_Tag:
                        strupr(p);
                        if (STREQ(p, "Y") || STREQ(p, "YES") || STREQ(p, "TRUE"))
                              *((Boolean_T *)(ptr->buf)) = True_;
                        else if(STREQ(p, "N") || STREQ(p, "NO") || STREQ(p, "FALSE"))
                                *((Boolean_T *)(ptr->buf)) = False_;
                        else  ErrExit("Illegal boolean value %s");
                        searching = False_;
                        break;

                  case Bitfield_Tag:
                        if (NUL == *p)
                        {
                              if (ptr->Default)
                                    arg_ptr = ptr->Default;
                              else  return PSerror;
                        }
                        else  arg_ptr = p;

                        sscanf(arg_ptr, "%lx", (unsigned long *)(bitfield_var));
                        *((unsigned long *)(ptr->buf)) |= (unsigned long)bitfield_var;
                        bounds(ptr);
                        searching = False_;
                        break;

                  case Byte_Tag:
                        if (NUL == *p)
                        {
                              if (ptr->Default)
                                    arg_ptr = ptr->Default;
                              else  return PSerror;
                        }
                        else  arg_ptr = p;

                        sscanf(arg_ptr, "%lx", &long_var);
                        byte_var = (unsigned char)(long_var & 0xffL);
                        if (ptr->additive)
                              *((char *)(ptr->buf)) += byte_var;
                        else  *((char *)(ptr->buf))  = byte_var;
                        bounds(ptr);
                        searching = False_;
                        break;

                  case Int_Tag:
                        if (NUL == *p)
                        {
                              if (ptr->Default)
                                    arg_ptr = ptr->Default;
                              else  return PSerror;
                        }
                        else  arg_ptr = p;

                        int_var = (int)(dround(getopts_eval(arg_ptr)));
                        if (ptr->additive)
                              *((int *)(ptr->buf)) += (int)(dround(getopts_eval(arg_ptr)));
                        else  *((int *)(ptr->buf))  = (int)(dround(getopts_eval(arg_ptr)));
                        bounds(ptr);
                        searching = False_;
                        break;

                  case Short_Tag:
                        if (NUL == *p)
                        {
                              if (ptr->Default)
                                    arg_ptr = ptr->Default;
                              else  return PSerror;
                        }
                        else  arg_ptr = p;

                        short_var = (short)dround(getopts_eval(arg_ptr));
                        if (ptr->additive)
                              *((short *)(ptr->buf)) += short_var;
                        else  *((short *)(ptr->buf))  = short_var;
                        bounds(ptr);
                        searching = False_;
                        break;

                  case Word_Tag:
                        if (NUL == *p)
                        {
                              if (ptr->Default)
                                    arg_ptr = ptr->Default;
                              else  return PSerror;
                        }
                        else  arg_ptr = p;

                        sscanf(arg_ptr, "%hx", (unsigned short *)(&word_var));
                        if (ptr->additive)
                              *((unsigned short *)(ptr->buf)) += word_var;
                        else  *((unsigned short *)(ptr->buf))  = word_var;
                        bounds(ptr);
                        searching = False_;
                        break;

                  case Long_Tag:
                        if (NUL == *p)
                        {
                              if (ptr->Default)
                                    arg_ptr = ptr->Default;
                              else  return PSerror;
                        }
                        else  arg_ptr = p;

                        long_var = dround(getopts_eval(arg_ptr));
                        if (ptr->additive)
                              *((long *)(ptr->buf)) += long_var;
                        else  *((long *)(ptr->buf))  = long_var;
                        bounds(ptr);
                        searching = False_;
                        break;

                  case DWord_Tag:
                        if (NUL == *p)
                        {
                              if (ptr->Default)
                                    arg_ptr = ptr->Default;
                              else  return PSerror;
                        }
                        else  arg_ptr = p;

                        sscanf(arg_ptr, "%lx", (unsigned long *)(dword_var));
                        if (ptr->additive)
                              *((unsigned long *)(ptr->buf)) += dword_var;
                        else  *((unsigned long *)(ptr->buf))  = dword_var;
                        bounds(ptr);
                        searching = False_;
                        break;

                  case Float_Tag:
                        if (NUL == *p)
                        {
                              if (ptr->Default)
                                    arg_ptr = ptr->Default;
                              else  return PSerror;
                        }
                        else  arg_ptr = p;

                        double_var = (double)getopts_eval(arg_ptr);
                        if (ptr->additive)
                              *((double *)(ptr->buf)) += double_var;
                        else  *((double *)(ptr->buf))  = double_var;
                        bounds(ptr);
                        searching = False_;
                        break;

                  case DFloat_Tag:
                        if (NUL == *p)
                        {
                              if (ptr->Default)
                                    arg_ptr = ptr->Default;
                              else  return PSerror;
                        }
                        else  arg_ptr = p;

                        double_var = (double)getopts_eval(arg_ptr);
                        if (ptr->additive)
                              *((double *)(ptr->buf)) += double_var;
                        else  *((double *)(ptr->buf))  = double_var;
                        bounds(ptr);
                        searching = False_;
                        break;

                  case String_Tag:
                        if (NUL == *p && ptr->Default && ptr->Default[0])
                        {
                              if (ptr->additive)