home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 3 / goldfish_volume_3.bin / files / text / tex / pastex / source / driver / util / amiga / getopt.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-11  |  28.5 KB  |  1,158 lines
  1. /*
  2. **    This file generated by localize 2.9 (AmigaDOS 2.1) from GetOpt.c
  3. */
  4. /*********************************************************************
  5.  *                                                                   *
  6.  *                                                                   *
  7.  *  GetOpt.c         enthaelt die Routinen zum Auswerten der         *
  8.  *                   Kommando-Zeile und der Environment-Variable.    *
  9.  *                                                                   *
  10.  *                                     *
  11.  *                   30-May-91  Georg Hessmann                       *
  12.  *                                                                   *
  13.  *                                                                   *
  14.  *********************************************************************/
  15.  
  16. #include "defines.h"
  17.  
  18. #include <stdarg.h>
  19. #include <stdio.h>
  20. #include <stdlib.h>
  21. #include <stddef.h>
  22. #include <string.h>
  23. #include <ctype.h>
  24. #include <math.h>
  25.  
  26. #include <exec/types.h>
  27. #include <dos/dos.h>
  28. #include <workbench/workbench.h>
  29. #include <workbench/startup.h>
  30.  
  31. #include <clib/exec_protos.h>
  32. #include <clib/dos_protos.h>
  33. #include <clib/icon_protos.h>
  34.  
  35. #include <pragmas/exec_pragmas.h>
  36. #include <pragmas/dos_pragmas.h>
  37. #include <pragmas/icon_pragmas.h>
  38.  
  39. extern struct ExecBase        *SysBase;
  40. extern struct DosLibrary    *DOSBase;
  41. extern struct Library        *IconBase;
  42.  
  43. extern struct WBStartup        *WBenchMsg;
  44.  
  45.  
  46.  
  47. #include "globals.h"
  48. #include "globals.i"
  49.  
  50.  
  51. #define TEX        /* ShowDVI/DVIprint */
  52.  
  53. #include "GetOpt.h"
  54. #include "GetOpt.i"
  55.  
  56.  
  57.  
  58.  
  59. /*
  60.  * Fuer die locale-Library:
  61.  *
  62.  * Hier duerfen *nur* die MSG_#? Nummern eingebunden werden!
  63.  * Achtung:
  64.  * Es muss/sollte 'multiple-include' erlaubt sein!
  65.  */
  66. #include "local.i"
  67.  
  68. #undef  CATCOMP_ARRAY
  69. #undef  CATCOMP_BLOCK
  70. #undef  CATCOMP_STRINGS
  71. #define CATCOMP_NUMBERS
  72. #include "localstr.h"
  73.  
  74.  
  75.  
  76. /*
  77.  * lokale Funktionen
  78.  *
  79.  */
  80.  
  81. static BOOL MyNameFromLock (BPTR lock, char *buffer, long len);
  82.  
  83. static void FillLocHlpTxt         (struct Options opt[]);
  84.  
  85. static void __stdargs GetOptError (int keynr, struct Options opt[], char *format,...);
  86. static BOOL ExamineKeyword        (int keynr, char *option, BOOL *use_option, struct Options opt[]);
  87. static BOOL ScanArgVektor         (int argc, char *argv[], struct Options opt[]);
  88. static BOOL ScanString            (char *envcont, struct Options opt[]);
  89. static BOOL ScanEnvString         (char *envname, struct Options opt[]);
  90. static BOOL ScanWBArgs              (struct Options opt[]);
  91. static BOOL check_req_para        (struct Options opt[]);
  92. static int  StrOptiCmp          (char *option, char *para, char **arg);
  93.  
  94.  
  95. #ifdef TEX
  96.  
  97. /* Tabelle der Seitengroessen */
  98. struct PSizes psizes[] = {
  99.   { "A0",   84.09/2.54, 118.92/2.54 },
  100.   { "A1",   59.46/2.54,  84.09/2.54 },
  101.   { "A2",   42.04/2.54,  59.46/2.54 },
  102.   { "A3",   29.73/2.54,  42.04/2.54 },
  103.   { "A4",   21.02/2.54,  29.73/2.54 },
  104.   { "A5",   14.87/2.54,  21.02/2.54 },
  105.   { "A6",   10.51/2.54,  14.87/2.54 },
  106.   { "A7",    7.43/2.54,  10.51/2.54 },
  107.   { "A0r", 118.92/2.54,  84.09/2.54 },
  108.   { "A1r",  84.09/2.54,  59.46/2.54 },
  109.   { "A2r",  59.46/2.54,  42.04/2.54 },
  110.   { "A3r",  42.04/2.54,  29.73/2.54 },
  111.   { "A4r",  29.73/2.54,  21.02/2.54 },
  112.   { "A5r",  21.02/2.54,  14.87/2.54 },
  113.   { "A6r",  14.87/2.54,  10.51/2.54 },
  114.   { "A7r",  10.51/2.54,   7.43/2.54 },
  115.   { NULL, 0, 0}
  116. };
  117.  
  118.  
  119. /*
  120.  * dimen_to_inch() returns the dimension given in the first argument
  121.  * in inches in the second argument. It returns 0, if all is ok, otherwise
  122.  * a value != 0.
  123.  */
  124.  
  125. struct unit_table { char *unit; float factor; };
  126.  
  127. static struct unit_table unittable[] = {
  128.   {"pt", 72.27},    {"bp", 72.0},
  129.   {"cm", 2.54},        {"mm", 25.4},
  130.   {"in", 1.0},        {"mi", 1000.0},    /* "milli-inches" for TPIC */
  131.   {"pc", 72.27/12},    {"sp", 72.27/65536},
  132.   {"dd", 72.27/(1238/1157)},
  133.   {"cc", 72.27/12/(1238/1157)},
  134.   {NULL, 0.0}
  135. };
  136.  
  137. int dimen_to_inch(char *str, float *inch_value, int *isTrue)
  138. { 
  139.   register struct unit_table *d;
  140.   float value;
  141.   char  unitArr[8];    /* we need min. 2+1 characters for %2s  + 4 fuer 'true' !! */
  142.   char * unit = unitArr;
  143.   
  144.   if (sscanf(str, "%f%6s", &value, unit) != 2) {
  145.     return 1;
  146.   }
  147.   
  148.   if (strnicmp(unit, "true", 4) == 0) {
  149.     *isTrue = TRUE;
  150.     unit  += 4;
  151.   }
  152.   else {
  153. #ifdef TEX_TRUE_DIM
  154.     *isTrue = FALSE;
  155. #else
  156.     *isTrue = TRUE;
  157. #endif
  158.   }
  159.  
  160.   for (d = unittable; d->unit != NULL; d++) {
  161.     if (stricmp(d->unit, unit) == 0) {
  162.     *inch_value = value / d->factor;
  163.     return 0; // alles ok...lasse negative Werte wieder zu...wenn man die nicht will, so soll man sie wo anders ausschliessen!
  164.     //return ((*inch_value) < 0.0);    // mag keine negativen Dimensionen
  165.     }
  166.   }
  167.   return 1;
  168. }
  169.  
  170. #endif /* TEX */
  171.  
  172.  
  173.  
  174. /*
  175.  * MyNameFromLock()
  176.  *
  177.  * Macht was der Name verspricht...
  178.  * Wenn der lock auf ein Directory zeigt wird zusaetzlich noch ein '/'
  179.  * angehaengt.
  180.  *
  181.  */
  182.  
  183.  
  184. static BOOL MyNameFromLock(BPTR lock, char *buffer, long len)
  185. {
  186.   BPTR lock1;
  187.   char strh[108], *h;
  188.   struct FileInfoBlock *fib;
  189.   int l;
  190.  
  191.   if (lock == (BPTR)NULL) {
  192.     if (len < 5) {
  193.       return FALSE;
  194.     }
  195.     strcpy(buffer, "SYS:");
  196.     return TRUE;
  197.   }
  198.  
  199.   buffer[0]='\0';
  200.   l = 1;    /* 1 wg. '\0' Byte */
  201.  
  202.   fib = (struct FileInfoBlock *)xmalloc((unsigned)sizeof(struct FileInfoBlock));
  203.  
  204.   if (Examine(lock,fib) == 0) {
  205.     xfree(fib);
  206.     return FALSE;
  207.   }
  208.  
  209.   l += strlen(fib->fib_FileName);
  210.   if (l < len) {
  211.     strcpy(buffer, fib->fib_FileName);
  212.   }
  213.  
  214.   if (fib->fib_DirEntryType > 0 ) {        /* Directory? */
  215.      if (++l < len) {
  216.        strcat(buffer,"/");
  217.      }
  218.   }
  219.  
  220.   lock1 = ParentDir(lock);
  221.   /** UnLock((BPTR)lock); NEIN der uebergebene Lock wird NICHT freigegeben! */
  222.   lock = lock1;
  223.  
  224.   while (lock!=(BPTR)NULL) {
  225.     if (Examine(lock,fib)==0) {
  226.       xfree(fib);
  227.       return FALSE;
  228.     }
  229.     else {
  230.        l += strlen(fib->fib_FileName) + 1;
  231.        if (l < len) {
  232.          strcpy(strh,fib->fib_FileName);
  233.          strcat(strh,"/");
  234.          strcat(strh,buffer);
  235.          strcpy(buffer,strh);
  236.        }
  237.     }
  238.     lock1 = ParentDir(lock);
  239.     UnLock((BPTR)lock);
  240.     lock = lock1;
  241.    }
  242.   h = strchr(buffer,'/');
  243.   if (h != NULL) {
  244.     h[0] = ':';
  245.   }
  246.   xfree((char *)fib);
  247.  
  248.   return (BOOL)(l < len);
  249. }
  250.  
  251.  
  252.  
  253. /*
  254.  * FillLocHlpTxt()
  255.  *
  256.  * Nimmt die msg_ Nummern und setzt die hlp_txt Felder in opt[].
  257.  *
  258.  */
  259.  
  260. static void FillLocHlpTxt(struct Options opt[])
  261. {
  262.   int k;
  263.   
  264.   for (k=0; opt[k].type != OPT_LAST_ENTRY; k++) {
  265.     if (opt[k].msg_hlp_txt > 0) {
  266.       opt[k].hlp_txt     = GetTeXString(opt[k].msg_hlp_txt);
  267.       opt[k].msg_hlp_txt = 0;    // nur einmal GetTeXString() machen
  268.     }
  269.     if (opt[k].msg_hlp_txt2 > 0) {
  270.       opt[k].hlp_txt2     = GetTeXString(opt[k].msg_hlp_txt2);
  271.       opt[k].msg_hlp_txt2 = 0;    // nur einmal GetTeXString() machen
  272.     }
  273.   }
  274. }
  275.  
  276.  
  277.  
  278. /*
  279.  * GetOptError()
  280.  *
  281.  * keynr ist das aktuelle Keywort oder -1
  282.  * format,... ist der Errorstring.
  283.  *
  284.  */
  285.  
  286. static void __stdargs GetOptError(int keynr, struct Options opt[], char *format,...)
  287. {
  288.   va_list argptr;
  289.   char buffer[512];        /* stack! */
  290.   int len;
  291.   
  292.   va_start(argptr, format);
  293.   vsprintf(buffer, format, argptr);
  294.   va_end(argptr);
  295.  
  296.   len = strlen(buffer);
  297.   if (len >511) {
  298.     Fatal(20,MSG_GETOPT_LINEBUF_OVERFLOW);
  299.   }
  300.  
  301.   if (keynr == -1) {
  302.     Warning(MSG_GETOPT_ERROR,buffer);
  303.   }
  304.   else {
  305.     if (opt[keynr].name == NULL) {
  306.       Warning(MSG_GETOPT_ERROR,opt[keynr].hlp_txt);
  307.     }
  308.     else {
  309.       Warning(MSG_GETOPT_ERROR_KEY,opt[keynr].name, opt[keynr].hlp_txt);
  310.     }
  311.     WarningStr("\t   %s",buffer);
  312.   }
  313.  
  314. }
  315.  
  316.  
  317. /*
  318.  * ExamineKeyword()
  319.  *
  320.  * Nimmt 'keynr' und einen Option String und updated das 'result' Feld.
  321.  * use_option gibt an, ob 'option' gebraucht wurde.
  322.  *
  323.  */
  324.  
  325. static BOOL ExamineKeyword(int keynr, char *option, BOOL *use_option, struct Options opt[])
  326. {
  327.   void *res = opt[keynr].result;
  328.   BOOL  error  = 0;
  329.   float tmp;
  330.  
  331.   switch (opt[keynr].type) {
  332.      case OPT_HELP:
  333.          *(long *)res = TRUE;
  334.          *use_option = FALSE;
  335.          opt[keynr].is_given = TRUE;
  336.          break;
  337.      case OPT_BOOLEAN:
  338.      if (option == NULL) {
  339.            *(long *)res = TRUE;        /* wenn nichts angegeben => TRUE */
  340.            *use_option = FALSE;
  341.      }
  342.      else {
  343.            if (stricmp(option, "on") == 0) {
  344.              *(long *)res = TRUE;
  345.              *use_option = TRUE;
  346.            }
  347.            else {
  348.              if (stricmp(option, "off") == 0) {
  349.                *(long *)res = FALSE;
  350.                *use_option = TRUE;
  351.              }
  352.              else {
  353.                *(long *)res = TRUE;    /* wenn nichts angegeben => TRUE */
  354.                *use_option = FALSE;
  355.              }
  356.             }
  357.          }
  358.          opt[keynr].is_given = TRUE;
  359.          break;
  360.      case OPT_STRING:
  361.          if (option == NULL) {
  362.            error = 1;
  363.            GetOptError(keynr, opt, GetTeXString(MSG_GETOPT_NO_OPTION_STRING));
  364.          }
  365.          else {
  366.            *(char **)res = option;
  367.            *use_option = TRUE;
  368.            opt[keynr].is_given = TRUE;
  369.          }
  370.          break;
  371.      case OPT_LONG:
  372.          if (option == NULL) {
  373.            error = 1;
  374.            GetOptError(keynr, opt, GetTeXString(MSG_GETOPT_MISSING_NUM));
  375.          }
  376.          else {
  377.            if (sscanf(option,"%ld", res) == 1) {
  378.              *use_option = TRUE;
  379.              opt[keynr].is_given = TRUE;
  380.            }
  381.            else {
  382.              GetOptError(keynr, opt, GetTeXString(MSG_GETOPT_NO_NUMBER),option);
  383.              error = 1;
  384.            }
  385.          }
  386.          break;
  387.      case OPT_FLOAT:
  388.          if (option == NULL) {
  389.            error = 1;
  390.            GetOptError(keynr, opt, GetTeXString(MSG_GETOPT_MISSING_REAL));
  391.          }
  392.          else {
  393.            if (sscanf(option,"%f", &tmp) == 1) {
  394.              *use_option = TRUE;
  395.              *(float *)res = tmp;
  396.              opt[keynr].is_given = TRUE;
  397.            }
  398.            else {
  399.              GetOptError(keynr, opt, GetTeXString(MSG_GETOPT_NO_REAL), option);
  400.              error = 1;
  401.            }
  402.          }
  403.          break;
  404. #ifdef TEX
  405.      case OPT_TEX_DIM:
  406.          if (option == NULL) {
  407.            error = 1;
  408.            GetOptError(keynr, opt, GetTeXString(MSG_GETOPT_MISSING_TEX));
  409.          }
  410.          else {
  411.            int isTrue;
  412.            if (dimen_to_inch(option, &tmp, &isTrue)) {
  413.              error = 1;
  414.              GetOptError(keynr, opt, GetTeXString(MSG_GETOPT_NO_TEX), option);
  415.            }
  416.            else {
  417.              *use_option   = TRUE;
  418.              *(float *)res = tmp;
  419.              opt[keynr].special  = isTrue;
  420.              opt[keynr].is_given = TRUE;
  421.            }
  422.          }
  423.          break;
  424. #endif
  425.      default:
  426.          GetOptError(keynr, opt, GetTeXString(MSG_GETOPT_UNKNOWN_PARAM));
  427.          break;
  428.   }
  429.  
  430.   return error;
  431. }
  432.  
  433.  
  434. /*
  435.  * ScanArgVetor()
  436.  *
  437.  * nimmt argc/argv, opt[] und updated das result Flag
  438.  *
  439.  * LIMITATION:
  440.  *   Leider kann zu jedem Keyword nur eine Option ausgewertet werden!
  441.  *
  442.  */
  443.  
  444. static BOOL ScanArgVektor(int argc, char *argv[], struct Options opt[])
  445. {
  446.   int i, j;
  447.   int  keynr;            /* Nummer des gefundenen Keywords (-1: kein Keyword) */
  448.   char *para;            /* aktueller Parameter -- Keyword */
  449.   char *option;            /* Option zum Keyword (falls gebraucht) */
  450.   BOOL conc_opt;        /* zusammengesetzte Option */
  451.   BOOL found;
  452.   BOOL error=FALSE;        /* ist ein Fehler aufgetreten? */
  453.  
  454.   for (i=0; i<argc && !error; i++) {    /* Schleife ueber alle Argumente */
  455.  
  456.     para = argv[i];            /* aktueller Parameter */
  457.     keynr = -1;                /* bisher kein Keyword */
  458.  
  459.     found = FALSE;            /* suche nach dem passenden Keyword */
  460.     conc_opt = FALSE;
  461.  
  462.       for (j=0; opt[j].type != OPT_LAST_ENTRY; j++) {
  463.       if (opt[j].name != NULL) {
  464.  
  465.         /* suche ob Keyword passt */
  466.     char *rest = NULL;
  467.     if (StrOptiCmp(opt[j].name, para, &rest) == 0) {
  468.       if (rest != NULL) {
  469.         conc_opt = TRUE;
  470.         option = rest;
  471.       }
  472.       else {
  473.         option = (i == argc-1) ? NULL : argv[i+1];
  474.       }
  475.       found = TRUE;
  476.     }
  477.     /* opt.abbrev is case sensitive for Unix like options */
  478.     else if (opt[j].abbrev != NULL && strncmp(opt[j].abbrev, para, opt[j].alen) == 0) {
  479.       switch(para[opt[j].alen]) {
  480.         case '\0':
  481.           found = TRUE;
  482.           option = (i == argc-1) ? NULL : argv[i+1];
  483.           break;
  484.         case '=':
  485.           found = TRUE;
  486.           conc_opt = TRUE;
  487.           option = ¶[opt[j].alen+1];
  488.           break;
  489.         /*default: not found */
  490.       }
  491.     }
  492.     if (found) {
  493.       keynr = j;
  494.       break;
  495.     }
  496.       }        /* name != NULL */
  497.     }        /* for    i    */
  498.  
  499.     if (found) {                /* Keyword gefunden? */
  500.       BOOL use_option = FALSE;    /* wurde die Option fuer keynr gebraucht */
  501.       error = ExamineKeyword(keynr, option, &use_option, opt);
  502.       if (!error) {
  503.         if (use_option) {
  504.           if (!conc_opt) {
  505.             i++;                /* ein Parameter als Option verbraucht */
  506.           }
  507.         }
  508.         else {
  509.           if (conc_opt) {
  510.             if (opt[keynr].type == OPT_BOOLEAN) {
  511.               GetOptError(keynr, opt, GetTeXString(MSG_GETOPT_WRONG_ONOFF_PARAM),option);
  512.             }
  513.             else {
  514.               /* der Fall kann *nie* auftreten, aber sicher ist sicher... */
  515.               GetOptError(keynr, opt, GetTeXString(MSG_GETOPT_NO_PARAM_EXPECTED),option);
  516.             }
  517.             error = TRUE;
  518.           }
  519.         }
  520.       }
  521.     }
  522.     else {                    /* kein Keyword */
  523.       int k;
  524.       /* hier neue Bedeutung fuer 'found'! */
  525.       /* found = FALSE; */            /* Platz gefunden? */
  526.       for (k=0; opt[k].type != OPT_LAST_ENTRY; k++) {
  527.         if (opt[k].type == OPT_OPTIONSTRING && !opt[k].is_given) {
  528.           /* noch freien Option-Platz gefunden */
  529.           found = TRUE;
  530.           *((char **)opt[k].result) = strdup(argv[i]);
  531.           opt[k].is_given = TRUE;
  532.       break;
  533.         }
  534.       }
  535.       
  536.       if (!found) {
  537.         GetOptError(keynr, opt, GetTeXString(MSG_GETOPT_UNKNOWN_KEYWORD),para);
  538.         error = 1;
  539.       }
  540.  
  541.     }    /* found    */
  542.   }    /* for    i    */
  543.   
  544.   return error;
  545. }
  546.  
  547.  
  548. /*
  549.  * ScanString()
  550.  *
  551.  * Zerlegt die Ausgabe von getenv() in ein argc/argv Feld.
  552.  *    (Thank's Dave!)
  553.  */
  554.  
  555. static BOOL ScanString(char *envcont, struct Options opt[])
  556. {
  557.   register char *ptr;
  558.   int argc = 0;       /* Zähler für gefundene Argumente */
  559.   char *argv[40];     /* 40 Zeiger auf Strings */
  560.   char *begin;
  561.   char c;
  562.   BOOL somethingfound = FALSE;
  563.   BOOL inanf;        /* in Anfuehrungszeichen?? */
  564.   BOOL error = FALSE;
  565.   
  566.   ptr = envcont;
  567.  
  568.   while (isspace(*ptr)) ptr++;    /* Leerzeichen am Anfang ueberlesen */
  569.   begin = ptr;            /* begin zeigt auf den Anfang des ersten Params */
  570.   inanf = FALSE;
  571.  
  572.   while ((c = *ptr++) && argc < 40) {
  573.  
  574.     if (isspace(c)) {
  575.       if (inanf) continue;            /* SPACE in Anf.: no action */
  576.       else {
  577.         *(ptr-1) = '\0';            /* String beenden */
  578.         argv[argc++] = begin;            /* Anfang des String eintragen */
  579.         while (isspace(*ptr)) ptr ++;        /* Leerzeichen am Anfang ueberlesen */
  580.         begin = ptr;                /* begin zeigt auf den Anfang des ..*/
  581.       }
  582.     }
  583.     else {
  584.       if (c == '"') {
  585.     if (*ptr == '"') {            /* Zwei " nacheinander sind ein " */
  586.            register char *d=ptr,*s=ptr+1;
  587.            while (*d++ = *s++);            /* String zusammenziehen */
  588.                         /* kein !! ptr++; denn das 2. " ist ueberkopiert */
  589.         }
  590.         else {
  591.           inanf = !inanf;
  592.         }
  593.       }
  594.       else {
  595.         somethingfound = TRUE;
  596.       }
  597.     }
  598.   }
  599.  
  600.   if (argc >= 40) {
  601.     GetOptError(-1, opt, GetTeXString(MSG_GETOPT_TOO_MANY_ENV_ARGS));
  602.     return 1;
  603.   }
  604.  
  605.   if (somethingfound && begin != ptr) {
  606.     argv[argc++] = begin;
  607.   }
  608.  
  609.   if (argc != 0) {
  610.     error = ScanArgVektor(argc, argv, opt);
  611.   }
  612.   
  613.   return error;
  614. }
  615.  
  616.  
  617.  
  618. /*
  619.  * ScanEnvString()
  620.  *
  621.  * Liest den 'envname' String aus und ruft ScanString() auf.
  622.  *
  623.  */
  624.  
  625. static BOOL ScanEnvString(char *envname, struct Options opt[])
  626. {
  627.   char *envcont;        /* Inhalt der Env-Variablen */
  628.   char *ptr;
  629.   BOOL error = FALSE;
  630.   
  631.   if ((ptr = getenv(envname)) != NULL) {
  632.     envcont = malloc(strlen(ptr)+1);
  633.     /* envcont = strdup(ptr); */
  634.     if (envcont == NULL) {
  635.       GetOptError(-1, opt, GetTeXString(MSG_GETOPT_NO_MEM_FOR_ENV));
  636.       error = TRUE;
  637.     }
  638.     else {
  639.       strcpy(envcont, ptr);
  640.       ScanString(envcont, opt);
  641.     }
  642.   }
  643.   
  644.   return error;
  645. }
  646.  
  647.  
  648.  
  649. /*
  650.  * ScanWBArgs()
  651.  *
  652.  * Liest die Workbench Argumente.
  653.  *
  654.  */
  655.  
  656.  
  657.  
  658. static BOOL ScanWBArgs(struct Options opt[])
  659. {
  660.   BPTR oldlock;
  661.   struct WBArg *arg;
  662.   struct DiskObject *diskobj;
  663.   char *ptr, *option;
  664.   int keynr, i;
  665.   BOOL error, use_option, found, was_icon_base;
  666.   
  667.   error = FALSE;
  668.  
  669.   arg = WBenchMsg->sm_ArgList;            /* Programmname überspringen */
  670.  
  671.   if (IconBase != NULL) {
  672.     /* ShowDVI macht die selber auf und braucht die auch weiterhin... */
  673.     was_icon_base = TRUE;
  674.   }
  675.   else {
  676.     IconBase = OpenLibrary("icon.library", 0);
  677.     if (IconBase == NULL) {
  678.       return TRUE;    /* Fehler! */
  679.     }
  680.     was_icon_base = FALSE;
  681.   }
  682.  
  683.   for (i=0; i< WBenchMsg->sm_NumArgs; i++, arg++) {
  684.  
  685.     oldlock = CurrentDir(arg->wa_Lock);        /* Verzeichnis auswaehlen */
  686.     diskobj = GetDiskObject(arg->wa_Name);
  687.  
  688.     if (diskobj != NULL) {
  689.       keynr = 0;
  690.       while (opt[keynr].type != OPT_LAST_ENTRY) {
  691.  
  692.         ptr = FindToolType(diskobj->do_ToolTypes, opt[keynr].name);
  693.         if (ptr == NULL ) {
  694.           ptr = FindToolType(diskobj->do_ToolTypes, opt[keynr].abbrev);
  695.         }
  696.  
  697.         if (ptr != NULL) {
  698.           if (*ptr != '\0') {
  699.             option = strdup(ptr);            /* dupliziere String, wird laenger benoetigt */
  700.           }
  701.           else {
  702.             option = ptr;                /* leerer String muss nicht dupliziert werden */
  703.           }
  704.           if (option != NULL) {
  705.             if (*option == '\0') option = NULL;        /* leerer String == NULL String */
  706.         error = ExamineKeyword(keynr, option, &use_option, opt);
  707.         if (!error) {
  708.           if (!use_option && option != NULL) {
  709.                 if (opt[keynr].type == OPT_BOOLEAN) {
  710.                   GetOptError(keynr, opt, GetTeXString(MSG_GETOPT_WRONG_ONOFF_PARAM),option);
  711.                 }
  712.                 else {
  713.                   /* der Fall kann *nie* auftreten, aber sicher ist sicher... */
  714.                   GetOptError(keynr, opt, GetTeXString(MSG_GETOPT_NO_PARAM_EXPECTED),option);
  715.                 }
  716.                 error = TRUE;
  717.           }
  718.         }
  719.       }
  720.         }
  721.  
  722.         keynr++;
  723.       }
  724.  
  725.       if (i > 0) {
  726.         /* alle Filenamen, ausser dem Prognamen, werden als OPT_OPTIONSTING abgelegt */
  727.  
  728.         found = FALSE;                /* Platz gefunden? */
  729.         keynr = 0;
  730.         while (opt[keynr].type != OPT_LAST_ENTRY && !found) {
  731.           if (opt[keynr].type == OPT_OPTIONSTRING && *((long *)opt[keynr].result) == 0L) {
  732.             char buffer[150];
  733.         if (MyNameFromLock(arg->wa_Lock, buffer, 149)) { 
  734.           if (strlen(buffer) + strlen(arg->wa_Name) < 149) {
  735.             strcat(buffer, arg->wa_Name);
  736.                 found = TRUE;
  737.                 *((char **)opt[keynr].result) = strdup(buffer);
  738.                 opt[keynr].is_given = TRUE;
  739.           }
  740.         }
  741.           }
  742.           keynr++;
  743.         }
  744.         
  745.         if (!found) {
  746.           GetOptError(keynr, opt, GetTeXString(MSG_GETOPT_SUPER_FILE),arg->wa_Name);
  747.           error = 1;
  748.         }
  749.       }
  750.  
  751.       FreeDiskObject(diskobj);
  752.       CurrentDir(oldlock);           /* altes Verzeichnis wieder */
  753.     }
  754.     else {
  755.       /* diskobj == NULL */
  756.       GetOptError(-1, opt, GetTeXString(MSG_GETOPT_NO_INFO), arg->wa_Name);
  757.       /* error = 1; nicht unbedingt ein Fehler (wg. WB 2.0) */
  758.     }
  759.   }
  760.  
  761.   if (!was_icon_base) {
  762.     CloseLibrary(IconBase);
  763.     IconBase = NULL;
  764.   }
  765.   
  766.   return error;
  767. }
  768.  
  769.  
  770.  
  771. static BOOL check_req_para(struct Options opt[])
  772. {
  773.   int k;
  774.  
  775.   for (k=0; opt[k].type != OPT_LAST_ENTRY; k++) {
  776.     if (opt[k].required == OPT_REQUIRED && !opt[k].is_given  ) {
  777.       GetOptError(k, opt, GetTeXString(MSG_GETOPT_PARAM_REQU));
  778.       return TRUE;
  779.     }
  780.   }
  781.   return FALSE;
  782. }
  783.  
  784.  
  785.  
  786. /*
  787.  * Funktionen nach aussen. ----------------------------------------------
  788.  *
  789.  */
  790.  
  791.  
  792.  
  793.   /**********************************************************************/
  794.   /* GetOptShortHelp: Gibt eine kurze Hilfe aus.            */
  795.   /*                    helpline    Vorgegebener Zeilenanfang.        */
  796.   /*            linelength  Auf wieviel Zeichen pro Zeile soll    */
  797.   /*                    die Ausgabe formatiert werden.    */
  798.   /*            opt         Array der Parameterdefinitionen.    */
  799.   /*              Der Text wird mit der Funktion Message ausgegeben */
  800.   /**********************************************************************/
  801.  
  802. void GetOptShortHelp(char *helpline, int linelength, struct Options opt[])
  803. {
  804.   char tmp[104], line[104], *ptr;
  805.   int k, len, used;
  806.  
  807.   FillLocHlpTxt(opt);
  808.  
  809.   if (linelength > 100) linelength = 100;
  810.  
  811.   strncpy(line, helpline, 100);
  812.   len = strlen(line);
  813.   used = FALSE;
  814.  
  815.   for (k=0; opt[k].type != OPT_LAST_ENTRY; k++) {
  816.     ptr = NULL;
  817.     tmp[0] = '\0';
  818.  
  819.     switch (opt[k].type) {
  820.      case OPT_HELP:
  821.          ptr = "";
  822.          break;
  823.      case OPT_BOOLEAN:
  824.          ptr = " on|off";
  825.          break;
  826.      case OPT_STRING:
  827.          ptr = " str";
  828.          break;
  829.      case OPT_LONG:
  830.          ptr = " number";
  831.          break;
  832.      case OPT_FLOAT:
  833.          ptr = " real";
  834.          break;
  835. #ifdef TEX
  836.      case OPT_TEX_DIM:
  837.          ptr = " TeX-dim";
  838.          break;
  839. #endif
  840.      case OPT_OPTIONSTRING:
  841.          sprintf(tmp, "%.50s", opt[k].hlp_txt);
  842.          break;
  843.     }
  844.     if (ptr != NULL) {
  845.       if (opt[k].name != NULL) {
  846.         sprintf(tmp, "%.20s%s",opt[k].name, ptr);
  847.       }
  848.       /* else: gibt's nicht! opt[k].name == NULL <==> OPT_OPTIONSTRING */
  849.     }
  850.  
  851.     if (!opt[k].hidden) {
  852.       if (strlen(tmp)+len > linelength) {
  853.         if (used) {
  854.           MessageStr(line);
  855.           strcpy(line,"\t");
  856.           len = 8;
  857.           //used = FALSE;
  858.         }
  859.         else {
  860.           return;  /* ein Eintrag alleine ist schon laenger als die Zeile... */
  861.         }
  862.       }
  863.  
  864.       if (opt[k].required == OPT_NOT_REQUIRED) {
  865.         strcat(line, "[");
  866.         strcat(line, tmp);
  867.         strcat(line, "]  ");
  868.         len += 2;
  869.       }
  870.       else {
  871.         strcat(line, tmp);
  872.         strcat(line, "  ");
  873.       }
  874.       len += strlen(tmp) + 2;
  875.       used = TRUE;
  876.     }
  877.   }
  878.   if (used) MessageStr(line);
  879. }
  880.  
  881.  
  882.  
  883.   /**********************************************************************/
  884.   /* GetOptHelp:  Gibt fuer jede Option eine Zeile Hilfstext aus.    */
  885.   /*          Mit Angabe der derzeitigen Belegung des result-Feldes    */
  886.   /*          als Defaultangabe.                    */
  887.   /*            opt    Array der Parameterdefinitionen.    */
  888.   /**********************************************************************/
  889.  
  890. void GetOptHelp(struct Options opt[])
  891. {
  892.   int k;
  893.   void *res;
  894.   char helpline[200], tmp[200], t2[100];
  895.   
  896.   FillLocHlpTxt(opt);
  897.  
  898.   for (k=0; opt[k].type != OPT_LAST_ENTRY; k++) {
  899.     res = opt[k].result;
  900.     
  901.     helpline[0] = '\0';
  902.  
  903.     if (opt[k].name == NULL) {
  904.       sprintf(tmp,GetTeXString(MSG_GETOPT_TAB_TAB_DEF), opt[k].hlp_txt);
  905.     }
  906.     else {
  907.       if (opt[k].abbrev != NULL) {
  908.         sprintf(t2, "%.20s|%.20s", opt[k].name, opt[k].abbrev);
  909.       }
  910.       else {
  911.         strcpy(t2, opt[k].name);
  912.       }
  913.       if (strlen(t2) > 7) {
  914.         strcat(t2,"\t");
  915.       }
  916.       else {
  917.         strcat(t2,"\t\t");
  918.       }
  919.       if (opt[k].type == OPT_HELP) {
  920.         sprintf(tmp,"\t%.50s%.50s", t2, opt[k].hlp_txt);
  921.       }
  922.       else {
  923.         sprintf(tmp,GetTeXString(MSG_GETOPT_TAB_DEF), t2, opt[k].hlp_txt);
  924.       }
  925.     }
  926.  
  927.     /* Vorsicht vor Overflow! */
  928.     if (strlen(tmp)+strlen(helpline) > 200-20) {
  929.       continue;
  930.     }
  931.  
  932.     strcat(helpline,tmp);
  933.  
  934.     switch (opt[k].type) {
  935.      case OPT_HELP:
  936.          /* HELP hat kein Default-Wert... */
  937.          break;
  938.      case OPT_BOOLEAN:
  939.          if (*(long *)res) {
  940.            strcat(helpline,"on");
  941.          }
  942.          else {
  943.            strcat(helpline,"off");
  944.          }
  945.          break;
  946.      case OPT_STRING:
  947.          if (*(char **)res == NULL) {
  948.            strcat(helpline,GetTeXString(MSG_GETOPT_NO_DEFAULT));
  949.          }
  950.          else {
  951.            if (strlen(*(char **)res)+strlen(helpline) < 200) {
  952.              strcat(helpline, *(char **)res);
  953.            }
  954.          }
  955.          break;
  956.      case OPT_LONG:
  957.          sprintf(tmp,"%ld", *(long *)res);
  958.          strcat(helpline, tmp);
  959.          break;
  960.      case OPT_FLOAT:
  961.          sprintf(tmp, "%f", *(float *)res);
  962.          strcat(helpline, tmp);
  963.          break;
  964. #ifdef TEX
  965.      case OPT_TEX_DIM:
  966.          if (fabs((double)*(float *)res+(double)13.13) > 0.01) {
  967.            sprintf(tmp, "%.2fin", *(float *)res);
  968. #ifdef TEX_TRUE_DIM
  969.            if (opt[k].special) {
  970.              sprintf(tmp, "%.2ftruein", *(float *)res);
  971.            }
  972.            else {
  973.              sprintf(tmp, "%.2fin", *(float *)res);
  974.            }
  975. #endif
  976.            strcat(helpline, tmp);
  977.          }
  978.          else {
  979.            strcat(helpline,GetTeXString(MSG_GETOPT_NO_DEFAULT));
  980.          }
  981.          break;
  982. #endif
  983.      case OPT_OPTIONSTRING:
  984.          if (*(char **)res == NULL) {
  985.            strcat(helpline,GetTeXString(MSG_GETOPT_NO_DEFAULT));
  986.          }
  987.          else {
  988.            if (strlen(*(char **)res)+strlen(helpline) < 200) {
  989.              strcat(helpline, *(char **)res);
  990.            }
  991.          }
  992.          break;
  993.     }
  994.     if (opt[k].type != OPT_HELP) {
  995.       strcat(helpline,")");
  996.     }
  997.     if (!opt[k].hidden) {
  998.       MessageStr(helpline);                /* !!! */
  999.       if (opt[k].hlp_txt2 != NULL) {
  1000.         MessageStr("\t\t\t%s", opt[k].hlp_txt2);    /* !!! */
  1001.       }
  1002.     }
  1003.   }
  1004. }
  1005.  
  1006.  
  1007.  
  1008.   /**********************************************************************/
  1009.   /* CheckOpt_Given: Wurde Option angegeben ?                */
  1010.   /*    Die Option wird anhand des 'result' Eintrags erkannt.        */
  1011.   /*    Ergebnis: -1: nicht gefunden, 0: nicht angegeben, sonst 1.    */
  1012.   /**********************************************************************/
  1013.  
  1014. int CheckOpt_Given(void *which, struct Options opt[])
  1015. {
  1016.   struct Options *o;
  1017.  
  1018.   FillLocHlpTxt(opt);
  1019.  
  1020.   for (o=opt; o->type != OPT_LAST_ENTRY; o++) {
  1021.     if (o->result == which) return (int)o->is_given;
  1022.   }
  1023.   return -1;
  1024. }
  1025.  
  1026.  
  1027.  
  1028.  
  1029.   /**********************************************************************/
  1030.   /* GetOneOpt: Liefert den struct der Option zurueck.            */
  1031.   /**********************************************************************/
  1032. struct Options * GetOneOpt(void *which, struct Options opt[])
  1033. {
  1034.   struct Options *o;
  1035.  
  1036.   FillLocHlpTxt(opt);
  1037.  
  1038.   for (o=opt; o->type != OPT_LAST_ENTRY; o++) {
  1039.     if (o->result == which) return o;
  1040.   }
  1041.   return NULL;
  1042. }
  1043.  
  1044.  
  1045.  
  1046.   /**********************************************************************/
  1047.   /* GetOpt:    Parameter-Parse Funktion.                */
  1048.   /*        Liest erst die Environmentvariable aus und wertet dann    */
  1049.   /*        argc/argv aus.                        */
  1050.   /*            argc    Direkt aus main() zu uebernehmen.    */
  1051.   /*            argv    Direkt aus main() zu uebernehmen.    */
  1052.   /*            envname    Name der Environmentvariable.        */
  1053.   /*            opt    Array der Parameterdefinitionen.    */
  1054.   /**********************************************************************/
  1055.  
  1056.  
  1057. BOOL GetOpt(int argc, char *argv[], char *envname, int interaktiv, struct Options opt[])
  1058. {
  1059.   BOOL error;
  1060.   int k, helpfeld;
  1061.   int frmwb = FALSE;
  1062.  
  1063.   FillLocHlpTxt(opt);
  1064.  
  1065.   /* Initialisiere 'len' Feld */
  1066.   for (k=0; opt[k].type != OPT_LAST_ENTRY; k++) {
  1067.     /* auf 0 ist alles sowieso schon gesetzt */
  1068.     if (opt[k].name != NULL) {
  1069.       opt[k].len = strlen(opt[k].name);
  1070.     }
  1071.     if (opt[k].abbrev != NULL) {
  1072.       opt[k].alen = strlen(opt[k].abbrev);
  1073.     }
  1074.     if (opt[k].type == OPT_HELP) {
  1075.       helpfeld = k;
  1076.     }
  1077.   }
  1078.  
  1079.   error = ScanEnvString(envname, opt);
  1080.   if (!error) {
  1081.     if (argc == 0) {
  1082.       frmwb = TRUE;
  1083.       interaktiv = FALSE;
  1084.       error = ScanWBArgs(opt);
  1085.     }
  1086.     else {
  1087.       error = ScanArgVektor(argc-1, &(argv[1]), opt);
  1088.     }
  1089.   }
  1090.   
  1091.   if (!frmwb && opt[helpfeld].is_given) {
  1092.     char *buf, *ptr, *p, *str;
  1093.  
  1094.     if ((buf = malloc(255)) != NULL) {        // ausnahmsweise kein xmalloc()
  1095.       error = FALSE;
  1096.       GetOptShortHelp("", 73, opt);
  1097.  
  1098.       if (interaktiv) {
  1099.         fprintf(stdout,GetTeXString(MSG_GETOPT_PRESS_RET));    /*hes: printf ist ok, wenn schon fgets verwendet wird*/
  1100.         ptr = fgets(buf, 254, stdin);
  1101.  
  1102.         if (ptr) {
  1103.           p = strrchr(ptr, '\n');
  1104.           if (p != NULL) *p = '\0';
  1105.         }
  1106.         else {
  1107.           buf[0] = '\0';
  1108.         }
  1109.  
  1110.         if (buf[0] != '\0') {
  1111.           opt[helpfeld].is_given = FALSE;
  1112.           *((long *)opt[helpfeld].result) = FALSE;
  1113.           str = strdup(ptr);        /* der Speicher muss fest bleiben! */
  1114.           error = ScanString(str, opt);
  1115.         }
  1116.       }
  1117.       free(buf);                // *kein* xfree()
  1118.     }
  1119.   }
  1120.  
  1121.   if (!error) {
  1122.     error = check_req_para(opt);
  1123.   }
  1124.  
  1125.   if (opt[helpfeld].is_given) {
  1126.     error = FALSE;    /* Bei Hilfe wird alles verziehen! */
  1127.   }
  1128.   return error;
  1129. }
  1130.  
  1131.  
  1132.   /**********************************************************************/
  1133.   /* StrOptiCmp: Vergleicht Option mit Parameter, wobei mindestens    */
  1134.   /*    soviele Buchstaben uebereinstimmen muessen, wie Grossbuchstaben    */
  1135.   /*    im Optionsnamen stehen.                        */
  1136.   /*    Ergebnis: 0 fuer Ok, sonst -1                    */
  1137.   /* 'rest' wird nur bei Uebereinstimmung mit anschliessendem '='    */
  1138.   /* gueltig und zeigt dann auf den Rest des Strings nach dem '='.    */
  1139.   /**********************************************************************/
  1140. static int StrOptiCmp(char *option, char *para, char **arg)
  1141. {
  1142.    /*char *start = para;*/
  1143.    for (; *option  != '\0' && isupper(*option); option++, para++) {
  1144.      if (*para == '\0' || *option != toupper(*para)) return -1;
  1145.    }
  1146.    for (; *para; para++, option++) {
  1147.      if (*option == '\0' || toupper(*para) != toupper(*option))
  1148.        if (*para == '=') {
  1149.          *arg = para+1;
  1150.          return 0;
  1151.        }
  1152.        else {
  1153.          return -1;
  1154.        }
  1155.    }
  1156.    return 0;
  1157. }
  1158.