home *** CD-ROM | disk | FTP | other *** search
/ io Programmo 8 / IOPROG_8.ISO / install / fips / source / getopt.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-08-25  |  3.7 KB  |  206 lines
  1. /*
  2.  
  3.  *  $Header$
  4.  
  5.  *
  6.  
  7.  *  Copyright (C) 1994 Arno Schaefer
  8.  
  9.  *
  10.  
  11.  *  AU: Auswertung der Kommandozeile, der POSIX-Version von getopt ()
  12.  
  13.  *    nachempfunden.
  14.  
  15.  *
  16.  
  17.  *  PO: ANSI C
  18.  
  19.  */
  20.  
  21.  
  22.  
  23. #include <stdio.h>
  24.  
  25. #include <string.h>
  26.  
  27.  
  28.  
  29. #include "getopt.h"
  30.  
  31.  
  32.  
  33.  
  34.  
  35. /* Globale Variablen */
  36.  
  37.  
  38.  
  39. char *optarg;
  40.  
  41. int optind = 1;
  42.  
  43. int opterr = 1;
  44.  
  45. int optopt;
  46.  
  47.  
  48.  
  49. static char *nextarg = NULL;
  50.  
  51.  
  52.  
  53.  
  54.  
  55. /* Funktion */
  56.  
  57.  
  58.  
  59. int getopt (int argc, char *argv[], char *optstring)
  60.  
  61.  
  62.  
  63. /*
  64.  
  65.  *  AU: Auswertung der Kommandozeile
  66.  
  67.  *
  68.  
  69.  *  VB: argc und argv sind die Parameter, die an main () uebergeben werden.
  70.  
  71.  *    optstring ist ein String, der die Zeichen enthaelt, die als
  72.  
  73.  *    Optionen erkannt werden. Wenn ein Zeichen von einem Doppelpunkt
  74.  
  75.  *    gefolgt wird, hat die Option ein Argument, das direkt auf das Zeichen
  76.  
  77.  *    folgt oder durch Space davon getrennt ist. Gueltige Optionszeichen
  78.  
  79.  *    sind alle druckbaren Zeichen ausser '?', ' ' und ':'.
  80.  
  81.  *
  82.  
  83.  *    optind ist der Index auf das naechste Element von argv[], das
  84.  
  85.  *    bearbeitet wird.
  86.  
  87.  *
  88.  
  89.  *    opterr ist ein Flag, das festlegt, ob bei Fehlern Fehlermeldungen
  90.  
  91.  *    ausgegeben werden.
  92.  
  93.  *
  94.  
  95.  *    optarg ist ein Zeiger auf das Argument, wenn eine Option ein
  96.  
  97.  *    Argument hat.
  98.  
  99.  *
  100.  
  101.  *    optopt enthaelt bei Fehlern das Optionszeichen, das den Fehler aus-
  102.  
  103.  *    geloest hat.
  104.  
  105.  *
  106.  
  107.  *  NB: Rueckgabewert ist das jeweils naechste Optionszeichen, oder -1 am
  108.  
  109.  *    Ende der Optionsliste.
  110.  
  111.  *
  112.  
  113.  *    Die Optionsliste ist zu Ende, wenn argv[optind] NULL ist, oder
  114.  
  115.  *    argv[optind] nicht mit '-' (oder '/') beginnt, oder argv[optind]
  116.  
  117.  *    ein einzelnes "-" ist. In diesem Fall wird optind nicht erhoeht.
  118.  
  119.  *    Das Ende der Optionsliste kann mit "--" erzwungen werden, dann ist
  120.  
  121.  *    argv[optind] das erste Argument nach "--".
  122.  
  123.  *
  124.  
  125.  *  FB: Ein '?' wird zurueckgegeben, wenn ein Optionszeichen nicht in
  126.  
  127.  *    optstring enthalten war oder ein ungueltiges Optionszeichen
  128.  
  129.  *    uebergeben wurde ('?' oder ':'). Ausserdem bei einem fehlenden
  130.  
  131.  *    Argument, wenn das erste Zeichen von optstring kein ':' ist.
  132.  
  133.  *
  134.  
  135.  *    Ein ':' wird zurueckgegeben bei einem fehlenden Argument, wenn
  136.  
  137.  *    das erste Zeichen von optstring ein ':' ist.
  138.  
  139.  */
  140.  
  141.  
  142.  
  143. {
  144.  
  145.     char *search;
  146.  
  147.  
  148.  
  149.     optarg = NULL;
  150.  
  151.     
  152.  
  153.     if (nextarg == NULL)
  154.  
  155.     {
  156.  
  157.         nextarg = argv[optind];
  158.  
  159.  
  160.  
  161.         if (nextarg == NULL)
  162.  
  163.         {
  164.  
  165.             return (-1);
  166.  
  167.         }
  168.  
  169.  
  170.  
  171. #ifdef __MSDOS__
  172.  
  173.         if (*nextarg != '-' && *nextarg != '/')
  174.  
  175. #else
  176.  
  177.         if (*nextarg != '-')
  178.  
  179. #endif
  180.  
  181.         {
  182.  
  183.             return (-1);
  184.  
  185.         }
  186.  
  187.  
  188.  
  189.         nextarg++;
  190.  
  191.  
  192.  
  193.     } /* if */
  194.  
  195.  
  196.  
  197.     optopt = *nextarg++;
  198.  
  199.  
  200.  
  201.     if (optopt == 0)
  202.  
  203.     {
  204.  
  205.         return (-1);
  206.  
  207.     }
  208.  
  209.  
  210.  
  211.     optind++;
  212.  
  213.  
  214.  
  215.     if (optopt == '-' && *nextarg == 0)
  216.  
  217.     {
  218.  
  219.         return (-1);
  220.  
  221.     }
  222.  
  223.  
  224.  
  225.     if (optopt == ':' || optopt == '?')
  226.  
  227.     {
  228.  
  229.         if (opterr)
  230.  
  231.         {
  232.  
  233.             fprintf
  234.  
  235.             (
  236.  
  237.                 stderr,
  238.  
  239.                 "%s: illegal option -- %c\n",
  240.  
  241.                 argv[0],
  242.  
  243.                 optopt
  244.  
  245.             );
  246.  
  247.         }
  248.  
  249.  
  250.  
  251.         return ('?');
  252.  
  253.  
  254.  
  255.     } /* if */
  256.  
  257.  
  258.  
  259.     search = strchr (optstring, optopt);
  260.  
  261.  
  262.  
  263.     if (search == NULL)
  264.  
  265.     {
  266.  
  267.         if (opterr)
  268.  
  269.         {
  270.  
  271.             fprintf
  272.  
  273.             (
  274.  
  275.                 stderr,
  276.  
  277.                 "%s: illegal option -- %c\n",
  278.  
  279.                 argv[0],
  280.  
  281.                 optopt
  282.  
  283.             );
  284.  
  285.         }
  286.  
  287.  
  288.  
  289.         return ('?');
  290.  
  291.  
  292.  
  293.     } /* if */
  294.  
  295.  
  296.  
  297.     if (*nextarg == 0)
  298.  
  299.     {
  300.  
  301.         nextarg = NULL;
  302.  
  303.     }
  304.  
  305.  
  306.  
  307.     if (search[1] != ':')
  308.  
  309.     {
  310.  
  311.         if (nextarg != NULL)
  312.  
  313.         {
  314.  
  315.             optind--;
  316.  
  317.         }
  318.  
  319.  
  320.  
  321.         return (optopt);
  322.  
  323.     }
  324.  
  325.  
  326.  
  327.     if (nextarg != NULL)
  328.  
  329.     {
  330.  
  331.         optarg = nextarg;
  332.  
  333.         nextarg = NULL;
  334.  
  335.         return (optopt);
  336.  
  337.     }
  338.  
  339.  
  340.  
  341.     optarg = argv[optind];
  342.  
  343.  
  344.  
  345.     if (optind == argc)
  346.  
  347.     {
  348.  
  349.         if (opterr)
  350.  
  351.         {
  352.  
  353.             fprintf
  354.  
  355.             (
  356.  
  357.                 stderr,
  358.  
  359.                 "%s: option requires an argument -- %c\n",
  360.  
  361.                 argv[0],
  362.  
  363.                 optopt
  364.  
  365.             );
  366.  
  367.  
  368.  
  369.         } /* if */
  370.  
  371.  
  372.  
  373.         if (optstring[0] == ':')
  374.  
  375.         {
  376.  
  377.             return (':');
  378.  
  379.         }
  380.  
  381.         else
  382.  
  383.         {
  384.  
  385.             return ('?');
  386.  
  387.         }
  388.  
  389.  
  390.  
  391.     } /* if */
  392.  
  393.  
  394.  
  395.     else
  396.  
  397.     {
  398.  
  399.         optind++;
  400.  
  401.     }
  402.  
  403.  
  404.  
  405.     return (optopt);
  406.  
  407.  
  408.  
  409. } /* getopt () */
  410.  
  411.