Changeset 7709bf in git


Ignore:
Timestamp:
Sep 22, 1998, 4:15:04 PM (26 years ago)
Author:
Hans Schönemann <hannes@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', '648d28f488f6ff08f5607ff229b9ad9e4a5b93c2')
Children:
6594d42df45662b198c336ed0437cfba5e77a91a
Parents:
e0d91ca23156d80a43dde9ffd342ab947b5cc298
Message:
* hannes: cosmetic changes


git-svn-id: file:///usr/local/Singular/svn/trunk@2514 2c84dea3-7e68-4137-9b89-c4e89433aadc
Location:
Singular
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • Singular/find_exec.c

    re0d91c r7709bf  
    1313#include "mod2.h"
    1414
    15 #if ! defined(MSDOS) && ! defined(__MWERKS__) 
     15#if ! defined(MSDOS) && ! defined(__MWERKS__)
    1616
    1717#include <unistd.h> /* always defiend */
  • Singular/getopt.c

    re0d91c r7709bf  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: getopt.c,v 1.2 1998-04-17 07:53:41 Singular Exp $ */
     4/* $Id: getopt.c,v 1.3 1998-09-22 14:15:03 Singular Exp $ */
    55
    66/* Getopt for GNU.
     
    1010
    1111   Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94
    12         Free Software Foundation, Inc.
     12        Free Software Foundation, Inc.
    1313
    1414   This program is free software; you can redistribute it and/or modify it
     
    2727
    2828/* adapted for use with Singular by obachman@mathematik.uni-kl.de 4/98*/
    29 
    3029
    3130
     
    5958/* This needs to come after some library #include
    6059   to get __GNU_LIBRARY__ defined.  */
    61 #ifdef  __GNU_LIBRARY__
     60#ifdef  __GNU_LIBRARY__
    6261/* Don't include stdlib.h for non-GNU C libraries because some of them
    6362   contain conflicting prototypes for getopt.  */
    6463#include <stdlib.h>
    65 #endif  /* GNU C library.  */
     64#endif  /* GNU C library.  */
    6665
    6766/* If GETOPT_COMPAT is defined, `+' as well as `--' can introduce a
     
    164163} ordering;
    165164
    166 
    167 #ifdef  __GNU_LIBRARY__
     165#ifdef  __GNU_LIBRARY__
    168166/* We want to avoid inclusion of string.h with non-GNU libraries
    169167   because there are many ways it can cause trouble.
     
    171169   in GCC.  */
    172170#include <string.h>
    173 #define my_index        strchr
    174 #define my_strlen       strlen
     171#define my_index        strchr
     172#define my_strlen       strlen
    175173#else
    176174
     
    207205    {
    208206      if (*str == chr)
    209         return (char *) str;
     207        return (char *) str;
    210208      str++;
    211209    }
     
    213211}
    214212
    215 #endif                          /* GNU C library.  */
    216 
     213#endif                          /* GNU C library.  */
    217214
    218215/* Handle permutation of arguments.  */
     
    277274}
    278275
    279 
    280276/* Scan elements of ARGV (whose length is ARGC) for option characters
    281277   given in OPTSTRING.
     
    361357
    362358      if (optstring[0] == '-')
    363         {
    364           ordering = RETURN_IN_ORDER;
    365           ++optstring;
    366         }
     359        {
     360          ordering = RETURN_IN_ORDER;
     361          ++optstring;
     362        }
    367363      else if (optstring[0] == '+')
    368         {
    369           ordering = REQUIRE_ORDER;
    370           ++optstring;
    371         }
     364        {
     365          ordering = REQUIRE_ORDER;
     366          ++optstring;
     367        }
    372368      else if (getenv ("POSIXLY_CORRECT") != NULL)
    373         ordering = REQUIRE_ORDER;
     369        ordering = REQUIRE_ORDER;
    374370      else
    375         ordering = PERMUTE;
     371        ordering = PERMUTE;
    376372    }
    377373
     
    379375    {
    380376      if (ordering == PERMUTE)
    381         {
    382           /* If we have just processed some options following some non-options,
    383              exchange them so that the options come first.  */
    384 
    385           if (first_nonopt != last_nonopt && last_nonopt != optind)
    386             exchange ((char **) argv);
    387           else if (last_nonopt != optind)
    388             first_nonopt = optind;
    389 
    390           /* Now skip any additional non-options
    391              and extend the range of non-options previously skipped.  */
    392 
    393           while (optind < argc
    394                 && (argv[optind][0] != '-' || argv[optind][1] == '\0')
     377        {
     378          /* If we have just processed some options following some non-options,
     379             exchange them so that the options come first.  */
     380
     381          if (first_nonopt != last_nonopt && last_nonopt != optind)
     382            exchange ((char **) argv);
     383          else if (last_nonopt != optind)
     384            first_nonopt = optind;
     385
     386          /* Now skip any additional non-options
     387             and extend the range of non-options previously skipped.  */
     388
     389          while (optind < argc
     390                && (argv[optind][0] != '-' || argv[optind][1] == '\0')
    395391#ifdef GETOPT_COMPAT
    396                 && (longopts == NULL
    397                      || argv[optind][0] != '+' || argv[optind][1] == '\0')
    398 #endif                          /* GETOPT_COMPAT */
    399                 )
    400             optind++;
    401           last_nonopt = optind;
    402         }
     392                && (longopts == NULL
     393                     || argv[optind][0] != '+' || argv[optind][1] == '\0')
     394#endif                          /* GETOPT_COMPAT */
     395                )
     396            optind++;
     397          last_nonopt = optind;
     398        }
    403399
    404400      /* Special ARGV-element `--' means premature end of options.
    405         Skip it like a null option,
    406         then exchange with previous non-options as if it were an option,
    407         then skip everything else like a non-option.  */
     401        Skip it like a null option,
     402        then exchange with previous non-options as if it were an option,
     403        then skip everything else like a non-option.  */
    408404
    409405      if (optind != argc && !strcmp (argv[optind], "--"))
    410         {
    411           optind++;
    412 
    413           if (first_nonopt != last_nonopt && last_nonopt != optind)
    414             exchange ((char **) argv);
    415           else if (first_nonopt == last_nonopt)
    416             first_nonopt = optind;
    417           last_nonopt = argc;
    418 
    419           optind = argc;
    420         }
     406        {
     407          optind++;
     408
     409          if (first_nonopt != last_nonopt && last_nonopt != optind)
     410            exchange ((char **) argv);
     411          else if (first_nonopt == last_nonopt)
     412            first_nonopt = optind;
     413          last_nonopt = argc;
     414
     415          optind = argc;
     416        }
    421417
    422418      /* If we have done all the ARGV-elements, stop the scan
    423         and back over any non-options that we skipped and permuted.  */
     419        and back over any non-options that we skipped and permuted.  */
    424420
    425421      if (optind == argc)
    426         {
    427           /* Set the next-arg-index to point at the non-options
    428              that we previously skipped, so the caller will digest them.  */
    429           if (first_nonopt != last_nonopt)
    430             optind = first_nonopt;
    431           return EOF;
    432         }
     422        {
     423          /* Set the next-arg-index to point at the non-options
     424             that we previously skipped, so the caller will digest them.  */
     425          if (first_nonopt != last_nonopt)
     426            optind = first_nonopt;
     427          return EOF;
     428        }
    433429
    434430      /* If we have come to a non-option and did not permute it,
    435         either stop the scan or describe it to the caller and pass it by.  */
     431        either stop the scan or describe it to the caller and pass it by.  */
    436432
    437433      if ((argv[optind][0] != '-' || argv[optind][1] == '\0')
    438434#ifdef GETOPT_COMPAT
    439           && (longopts == NULL
    440               || argv[optind][0] != '+' || argv[optind][1] == '\0')
    441 #endif                          /* GETOPT_COMPAT */
    442           )
    443         {
    444           if (ordering == REQUIRE_ORDER)
    445             return EOF;
    446           optarg = argv[optind++];
    447           return 1;
    448         }
     435          && (longopts == NULL
     436              || argv[optind][0] != '+' || argv[optind][1] == '\0')
     437#endif                          /* GETOPT_COMPAT */
     438          )
     439        {
     440          if (ordering == REQUIRE_ORDER)
     441            return EOF;
     442          optarg = argv[optind++];
     443          return 1;
     444        }
    449445
    450446      /* We have found another option-ARGV-element.
    451         Start decoding its characters.  */
     447        Start decoding its characters.  */
    452448
    453449      nextchar = (argv[optind] + 1
    454                   + (longopts != NULL && argv[optind][1] == '-'));
     450                  + (longopts != NULL && argv[optind][1] == '-'));
    455451    }
    456452
    457453  if (longopts != NULL
    458454      && ((argv[optind][0] == '-'
    459            && (argv[optind][1] == '-' || long_only))
     455           && (argv[optind][1] == '-' || long_only))
    460456#ifdef GETOPT_COMPAT
    461           || argv[optind][0] == '+'
    462 #endif                          /* GETOPT_COMPAT */
    463           ))
     457          || argv[optind][0] == '+'
     458#endif                          /* GETOPT_COMPAT */
     459          ))
    464460    {
    465461      const struct option *p;
     
    471467
    472468      while (*s && *s != '=')
    473         s++;
     469        s++;
    474470
    475471      /* Test all options for either exact match or abbreviated matches.  */
    476472      for (p = longopts, option_index = 0; p->name;
    477            p++, option_index++)
    478         if (!strncmp (p->name, nextchar, s - nextchar))
    479           {
    480             if (s - nextchar == my_strlen (p->name))
    481               {
    482                 /* Exact match found.  */
    483                 pfound = p;
    484                 indfound = option_index;
    485                 exact = 1;
    486                 break;
    487               }
    488             else if (pfound == NULL)
    489               {
    490                 /* First nonexact match found.  */
    491                 pfound = p;
    492                 indfound = option_index;
    493               }
    494             else
    495               /* Second nonexact match found.  */
    496               ambig = 1;
    497           }
     473           p++, option_index++)
     474        if (!strncmp (p->name, nextchar, s - nextchar))
     475          {
     476            if (s - nextchar == my_strlen (p->name))
     477              {
     478                /* Exact match found.  */
     479                pfound = p;
     480                indfound = option_index;
     481                exact = 1;
     482                break;
     483              }
     484            else if (pfound == NULL)
     485              {
     486                /* First nonexact match found.  */
     487                pfound = p;
     488                indfound = option_index;
     489              }
     490            else
     491              /* Second nonexact match found.  */
     492              ambig = 1;
     493          }
    498494
    499495      if (ambig && !exact)
    500         {
    501           if (opterr)
    502             fprintf (stderr, "%s: option `%s' is ambiguous\n",
    503                      argv[0], argv[optind]);
    504           nextchar += my_strlen (nextchar);
    505           optind++;
    506           return BAD_OPTION;
    507         }
     496        {
     497          if (opterr)
     498            fprintf (stderr, "%s: option `%s' is ambiguous\n",
     499                     argv[0], argv[optind]);
     500          nextchar += my_strlen (nextchar);
     501          optind++;
     502          return BAD_OPTION;
     503        }
    508504
    509505      if (pfound != NULL)
    510         {
    511           option_index = indfound;
    512           optind++;
    513           if (*s)
    514             {
    515               /* Don't test has_arg with >, because some C compilers don't
    516                 allow it to be used on enums.  */
    517               if (pfound->has_arg)
    518                 optarg = s + 1;
    519               else
    520                 {
    521                   if (opterr)
    522                     {
    523                       if (argv[optind - 1][1] == '-')
    524                         /* --option */
    525                         fprintf (stderr,
    526                                 "%s: option `--%s' doesn't allow an argument\n",
    527                                 argv[0], pfound->name);
    528                       else
    529                         /* +option or -option */
    530                         fprintf (stderr,
    531                              "%s: option `%c%s' doesn't allow an argument\n",
    532                              argv[0], argv[optind - 1][0], pfound->name);
    533                     }
    534                   nextchar += my_strlen (nextchar);
    535                   return BAD_OPTION;
    536                 }
    537             }
    538           else if (pfound->has_arg == 1)
    539             {
    540               if (optind < argc)
    541                 optarg = argv[optind++];
    542               else
    543                 {
    544                   if (opterr)
    545                     fprintf (stderr, "%s: option `%s' requires an argument\n",
    546                              argv[0], argv[optind - 1]);
    547                   nextchar += my_strlen (nextchar);
    548                   return optstring[0] == ':' ? ':' : BAD_OPTION;
    549                 }
    550             }
    551           nextchar += my_strlen (nextchar);
    552           if (longind != NULL)
    553             *longind = option_index;
    554           if (pfound->flag)
    555             {
    556               *(pfound->flag) = pfound->val;
    557               return 0;
    558             }
    559           return pfound->val;
    560         }
     506        {
     507          option_index = indfound;
     508          optind++;
     509          if (*s)
     510            {
     511              /* Don't test has_arg with >, because some C compilers don't
     512                allow it to be used on enums.  */
     513              if (pfound->has_arg)
     514                optarg = s + 1;
     515              else
     516                {
     517                  if (opterr)
     518                    {
     519                      if (argv[optind - 1][1] == '-')
     520                        /* --option */
     521                        fprintf (stderr,
     522                                "%s: option `--%s' doesn't allow an argument\n",
     523                                argv[0], pfound->name);
     524                      else
     525                        /* +option or -option */
     526                        fprintf (stderr,
     527                             "%s: option `%c%s' doesn't allow an argument\n",
     528                             argv[0], argv[optind - 1][0], pfound->name);
     529                    }
     530                  nextchar += my_strlen (nextchar);
     531                  return BAD_OPTION;
     532                }
     533            }
     534          else if (pfound->has_arg == 1)
     535            {
     536              if (optind < argc)
     537                optarg = argv[optind++];
     538              else
     539                {
     540                  if (opterr)
     541                    fprintf (stderr, "%s: option `%s' requires an argument\n",
     542                             argv[0], argv[optind - 1]);
     543                  nextchar += my_strlen (nextchar);
     544                  return optstring[0] == ':' ? ':' : BAD_OPTION;
     545                }
     546            }
     547          nextchar += my_strlen (nextchar);
     548          if (longind != NULL)
     549            *longind = option_index;
     550          if (pfound->flag)
     551            {
     552              *(pfound->flag) = pfound->val;
     553              return 0;
     554            }
     555          return pfound->val;
     556        }
    561557      /* Can't find it as a long option.  If this is not getopt_long_only,
    562         or the option starts with '--' or is not a valid short
    563         option, then it's an error.
    564         Otherwise interpret it as a short option.  */
     558        or the option starts with '--' or is not a valid short
     559        option, then it's an error.
     560        Otherwise interpret it as a short option.  */
    565561      if (!long_only || argv[optind][1] == '-'
    566562#ifdef GETOPT_COMPAT
    567           || argv[optind][0] == '+'
    568 #endif                          /* GETOPT_COMPAT */
    569           || my_index (optstring, *nextchar) == NULL)
    570         {
    571           if (opterr)
    572             {
    573               if (argv[optind][1] == '-')
    574                 /* --option */
    575                 fprintf (stderr, "%s: unrecognized option `--%s'\n",
    576                         argv[0], nextchar);
    577               else
    578                 /* +option or -option */
    579                 fprintf (stderr, "%s: unrecognized option `%c%s'\n",
    580                         argv[0], argv[optind][0], nextchar);
    581             }
    582           nextchar = (char *) "";
    583           optind++;
    584           return BAD_OPTION;
    585         }
     563          || argv[optind][0] == '+'
     564#endif                          /* GETOPT_COMPAT */
     565          || my_index (optstring, *nextchar) == NULL)
     566        {
     567          if (opterr)
     568            {
     569              if (argv[optind][1] == '-')
     570                /* --option */
     571                fprintf (stderr, "%s: unrecognized option `--%s'\n",
     572                        argv[0], nextchar);
     573              else
     574                /* +option or -option */
     575                fprintf (stderr, "%s: unrecognized option `%c%s'\n",
     576                        argv[0], argv[optind][0], nextchar);
     577            }
     578          nextchar = (char *) "";
     579          optind++;
     580          return BAD_OPTION;
     581        }
    586582    }
    587583
     
    598594    if (temp == NULL || c == ':')
    599595      {
    600         if (opterr)
    601           {
     596        if (opterr)
     597          {
    602598#if 0
    603             if (c < 040 || c >= 0177)
    604               fprintf (stderr, "%s: unrecognized option, character code 0%o\n",
    605                        argv[0], c);
    606             else
    607               fprintf (stderr, "%s: unrecognized option `-%c'\n", argv[0], c);
     599            if (c < 040 || c >= 0177)
     600              fprintf (stderr, "%s: unrecognized option, character code 0%o\n",
     601                       argv[0], c);
     602            else
     603              fprintf (stderr, "%s: unrecognized option `-%c'\n", argv[0], c);
    608604#else
    609             /* 1003.2 specifies the format of this message.  */
    610             fprintf (stderr, "%s: illegal option -- %c\n", argv[0], c);
     605            /* 1003.2 specifies the format of this message.  */
     606            fprintf (stderr, "%s: illegal option -- %c\n", argv[0], c);
    611607#endif
    612           }
    613         optopt = c;
    614         return BAD_OPTION;
     608          }
     609        optopt = c;
     610        return BAD_OPTION;
    615611      }
    616612    if (temp[1] == ':')
    617613      {
    618         if (temp[2] == ':')
    619           {
    620             /* This is an option that accepts an argument optionally.  */
    621             if (*nextchar != '\0')
    622               {
    623                 optarg = nextchar;
    624                 optind++;
    625               }
    626             else
    627               optarg = 0;
    628             nextchar = NULL;
    629           }
    630         else
    631           {
    632             /* This is an option that requires an argument.  */
    633             if (*nextchar != '\0')
    634               {
    635                 optarg = nextchar;
    636                 /* If we end this ARGV-element by taking the rest as an arg,
    637                    we must advance to the next element now.  */
    638                 optind++;
    639               }
    640             else if (optind == argc)
    641               {
    642                 if (opterr)
    643                   {
     614        if (temp[2] == ':')
     615          {
     616            /* This is an option that accepts an argument optionally.  */
     617            if (*nextchar != '\0')
     618              {
     619                optarg = nextchar;
     620                optind++;
     621              }
     622            else
     623              optarg = 0;
     624            nextchar = NULL;
     625          }
     626        else
     627          {
     628            /* This is an option that requires an argument.  */
     629            if (*nextchar != '\0')
     630              {
     631                optarg = nextchar;
     632                /* If we end this ARGV-element by taking the rest as an arg,
     633                   we must advance to the next element now.  */
     634                optind++;
     635              }
     636            else if (optind == argc)
     637              {
     638                if (opterr)
     639                  {
    644640#if 0
    645                     fprintf (stderr, "%s: option `-%c' requires an argument\n",
    646                              argv[0], c);
     641                    fprintf (stderr, "%s: option `-%c' requires an argument\n",
     642                             argv[0], c);
    647643#else
    648                     /* 1003.2 specifies the format of this message.  */
    649                     fprintf (stderr, "%s: option requires an argument -- %c\n",
    650                              argv[0], c);
     644                    /* 1003.2 specifies the format of this message.  */
     645                    fprintf (stderr, "%s: option requires an argument -- %c\n",
     646                             argv[0], c);
    651647#endif
    652                   }
    653                 optopt = c;
    654                 if (optstring[0] == ':')
    655                   c = ':';
    656                 else
    657                   c = BAD_OPTION;
    658               }
    659             else
    660               /* We already incremented `optind' once;
    661                 increment it again when taking next ARGV-elt as argument.  */
    662               optarg = argv[optind++];
    663             nextchar = NULL;
    664           }
     648                  }
     649                optopt = c;
     650                if (optstring[0] == ':')
     651                  c = ':';
     652                else
     653                  c = BAD_OPTION;
     654              }
     655            else
     656              /* We already incremented `optind' once;
     657                increment it again when taking next ARGV-elt as argument.  */
     658              optarg = argv[optind++];
     659            nextchar = NULL;
     660          }
    665661      }
    666662    return c;
     
    675671{
    676672  return _getopt_internal (argc, argv, optstring,
    677                            (const struct option *) 0,
    678                            (int *) 0,
    679                            0);
     673                           (const struct option *) 0,
     674                           (int *) 0,
     675                           0);
    680676}
    681677
     
    691687}
    692688
    693 #endif  /* _LIBC or not __GNU_LIBRARY__.  */
    694 
     689#endif  /* _LIBC or not __GNU_LIBRARY__.  */
    695690
    696691#ifdef TEST_GETOPT
     
    713708      c = getopt (argc, argv, "abc:d:0123456789");
    714709      if (c == EOF)
    715         break;
     710        break;
    716711
    717712      switch (c)
    718         {
    719         case '0':
    720         case '1':
    721         case '2':
    722         case '3':
    723         case '4':
    724         case '5':
    725         case '6':
    726         case '7':
    727         case '8':
    728         case '9':
    729           if (digit_optind != 0 && digit_optind != this_option_optind)
    730             printf ("digits occur in two different argv-elements.\n");
    731           digit_optind = this_option_optind;
    732           printf ("option %c\n", c);
    733           break;
    734 
    735         case 'a':
    736           printf ("option a\n");
    737           break;
    738 
    739         case 'b':
    740           printf ("option b\n");
    741           break;
    742 
    743         case 'c':
    744           printf ("option c with value `%s'\n", optarg);
    745           break;
    746 
    747         case BAD_OPTION:
    748           break;
    749 
    750         default:
    751           printf ("?? getopt returned character code 0%o ??\n", c);
    752         }
     713        {
     714        case '0':
     715        case '1':
     716        case '2':
     717        case '3':
     718        case '4':
     719        case '5':
     720        case '6':
     721        case '7':
     722        case '8':
     723        case '9':
     724          if (digit_optind != 0 && digit_optind != this_option_optind)
     725            printf ("digits occur in two different argv-elements.\n");
     726          digit_optind = this_option_optind;
     727          printf ("option %c\n", c);
     728          break;
     729
     730        case 'a':
     731          printf ("option a\n");
     732          break;
     733
     734        case 'b':
     735          printf ("option b\n");
     736          break;
     737
     738        case 'c':
     739          printf ("option c with value `%s'\n", optarg);
     740          break;
     741
     742        case BAD_OPTION:
     743          break;
     744
     745        default:
     746          printf ("?? getopt returned character code 0%o ??\n", c);
     747        }
    753748    }
    754749
     
    757752      printf ("non-option ARGV-elements: ");
    758753      while (optind < argc)
    759         printf ("%s ", argv[optind++]);
     754        printf ("%s ", argv[optind++]);
    760755      printf ("\n");
    761756    }
Note: See TracChangeset for help on using the changeset viewer.