home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1987 / 06 / arg.c next >
Encoding:
C/C++ Source or Header  |  1987-05-18  |  7.3 KB  |  151 lines
  1. /********************************************************************
  2. *  TITEL           :  Argument-Parser                               *
  3. *                                                                   *
  4. *  DATEI           :  arg.c                                         *
  5. *  VERSION         :  1.0                                           *
  6. *  AUTOR           :  Joachim Eckart                                *
  7. *  DATUM           :  12/86                                         *
  8. ********************************************************************/
  9.  
  10. #include "arg.h"               /* Definitionen für Argument Parser */
  11.  
  12. #define islower(c) ((c)>='a' && (c)<='z')      /* Kleinbuchstabe ? */
  13. #define toupper(c) (islower(c) ? (c)-32 : (c)) /* mache gro₧       */
  14.  
  15. typedef int (*PFIP)();      /* Typ definieren: Zeiger auf Funktion */
  16.  
  17. /*******************************************************************/
  18. /*                          parse_args()                           */
  19. /*******************************************************************/
  20.  
  21. parse_args(argc,argv,arg_tab,tsize)
  22.   int argc;                    /* argc,argv wie aus Kommandozeile  */
  23.   char **argv;
  24.   register ARGUMENTS *arg_tab; /* Zeiger auf 1.Element des Vektors */
  25.   int tsize;                   /* Anzahl Elemente des Vektors      */
  26.  
  27.   {
  28.   register char **hargv; /* Hilfszeiger für argv                   */
  29.   register int i;        /* Zähler für argc                        */
  30.   register int found;    /* Boolean wird TRUE wenn Argument aus
  31.                             ARGUMENTS in argv gefunden oder wenn
  32.                             dieses optional ist                    */
  33.   int requ_arg;          /* Anzahl nötiger Argumente := tsize      */
  34.   short used[20];        /* Argument bereits benutzt ?             */
  35.  
  36.     argc--;                  /* 0.tes Element irrelevant           */
  37.     requ_arg = tsize;        /* Anzahl erforderlicher Argumente    */
  38.                              /* alle Argumente noch nicht benutzt: */
  39.     for(i = 0; i < 20; i++) used[i] = 0;
  40.                             /* SCHLEIFE über ARGUMENTE in arg_tab: */
  41.     for(;--tsize >= 0;arg_tab++)
  42.       {
  43.       hargv = argv;     /* Hilfszeiger auf args aus Kommandozeile  */
  44.       i = argc;         /* Anzahl Argumente auf i kopieren         */
  45.       found = 0;        /* gefunden auf FALSE setzen               */
  46.                         /* WHILE LOOP solange Argumente vorhanden,
  47.                            aber kein passendes gefunden wurde:     */
  48.       while(i-- && !found)
  49.         {
  50.         hargv++;                /* zeigt zu Beginn auf 2. argv     */
  51.         if(used[i] == 1)        /* Argument bereits besetzt        */
  52.           continue;             /* Argument wurde schon bearbeitet */
  53.                                                /* SWITCH schalter: */
  54.         switch(arg_tab->schalter)
  55.           {
  56.           case SCHALTER :                  /* SHALTER wird gesucht */
  57.             if(**hargv == '-' &&
  58.                toupper(*(*hargv + 1)) == toupper(arg_tab->s_char))
  59.               {                                      /* gefunden ! */
  60.                                                    /* SWITCH type: */
  61.               switch(arg_tab->type)
  62.                 {
  63.                 case STRING :          /* STRING SCHALTER mu₧ mehr
  64.                                           als 2 Zeichen haben      */
  65.                   if(strlen(*hargv) > 2)
  66.                     {
  67.                     *(char **)arg_tab->zeiger = *hargv + 2;
  68.                                 /* Adresse des Strings wird mit
  69.                                    Zeichenfolge ohne switch belegt */
  70.                     found = 1;
  71.                     }
  72.                   else
  73.                     return(MIS_STRING);
  74.                   break;
  75.                 case CHAR :             /* CHAR SCHALTER hat genau
  76.                                            3 Zeichen zu haben      */
  77.                   if(strlen(*hargv) == 3)
  78.                     {
  79.                     *(char *)arg_tab->zeiger = *(*hargv + 2);
  80.                     found = 1;
  81.                     }
  82.                   else
  83.                     return(MIS_CHAR);
  84.                   break;
  85.                 case BOOLEAN :              /* BOOLEAN SCHALTER
  86.                                                hat genau 2 Zeichen */
  87.                   if(strlen(*hargv) == 2)
  88.                     {
  89.                     *(int *)arg_tab->zeiger = 1;
  90.                     found = 1;
  91.                     }
  92.                   else
  93.                     return(WRONG_ARG);
  94.                   break;
  95.                 case INTEGER :      /* INTEGER SCHALTER wie String,
  96.                                        sollte aber Ziffern enth.   */
  97.                   if(strlen(*hargv) > 2)
  98.                     {
  99.                     *(int *)arg_tab->zeiger = atoi(*hargv + 2);
  100.                     found = 1;
  101.                     }
  102.                   else
  103.                     return(MIS_INT);
  104.                   break;
  105.                 case FUNC :   /* FUNKTIONS SCHALTER
  106.                                  Die Funktion wird hier aufgerufen */
  107.                   if(strlen(*hargv)  < 3)          /* no Parameter */
  108.                     (* (PFIP)(arg_tab->zeiger) )("");
  109.                   else                             /*  Parameter   */
  110.                     (* (PFIP)(arg_tab->zeiger) )(*hargv + 2);
  111.                   found = 1;
  112.                   break;
  113.                 default :              /* alles andere undefiniert */
  114.                   return(WRONG_ARG);
  115.                 }                               /* END SWITCH type */
  116.  
  117.               }                                 /* END IF          */
  118.             break;
  119.           case NO_SCHLT :         /* Zeichenfolge ohne '-' gesucht */
  120.             if(**hargv != '-')    /* '-' ist nicht gefragt         */
  121.               {
  122.               if(arg_tab->type == FUNC               /* Funktion ? */
  123.                  || arg_tab->type == FORCE_FUNC)     /* aufrufen   */
  124.                 (* (PFIP)(arg_tab->zeiger) )(*hargv);
  125.               else                                   /* String     */
  126.                 *(char **)arg_tab->zeiger = *hargv;
  127.               found = 1;                             /* gefunden   */
  128.               }
  129.             break;
  130.           default :                                 /* undefiniert */
  131.             return(WRONG_ARG);
  132.           break;
  133.           }                                 /* END SWITCH schalter */
  134.         if(found)
  135.           used[i] = 1;        /* Argument als benutzt kennzeichnen */
  136.         }                                        /* END WHILE LOOP */
  137.       if(!found   /* FORCE_FUNC auch aufrufen, wenn nicht gefunden */
  138.          && arg_tab->type == FORCE_FUNC
  139.          && arg_tab->schalter == NO_SCHLT)
  140.         {
  141.         (* (PFIP)(arg_tab->zeiger) )("");
  142.         found = 1;                      /* Funktion immer aufrufen */
  143.         }
  144.       if(found || arg_tab->option)
  145.         requ_arg--;                /* Argumentnachfrage befriedigt */
  146.  
  147.       }                             /* END SCHLEIFE über ARGUMENTS */
  148.     return(requ_arg);              /* sollte 0 sein, wenn alles ok */
  149.   }                                              /* END parse_args */
  150.  
  151.