home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / GRAPHICS / SHOWGL10.ZIP / GETARGS.C < prev    next >
Encoding:
C/C++ Source or Header  |  1991-09-02  |  6.3 KB  |  288 lines
  1. #pragma linesize(132)
  2.  
  3. /* getargs.c     a UNIX-like switch reading routine
  4.  
  5. Copyright 1991, Robert C. Becker, Lantern Systems */
  6.  
  7. /*
  8. valid option flags:
  9.  
  10. A    8.5 x 11 inch paper
  11. B    11 x 17 inch paper
  12. C    17 x 22 inch paper
  13. D    22 x 34 inch paper
  14. E    34 x 44 inch paper
  15.  
  16. A4    210 x 297 mm paper
  17. A3    297 x 420 mm paper
  18. A2    420 x 594 mm paper
  19. A1    594 x 841 mm paper
  20. A0    841 x 1189 mm paper
  21.  
  22. c    force CGA 640 x 200 mode
  23. e    force EGA 640 x 350 mode
  24. v    force VGA 640 x 480 mode
  25.  
  26. dp    assume HP DraftPro coordinate system (center of page = (0,0)
  27.  
  28. Note that options are case sensitive.
  29. */
  30.  
  31. #include <stdio.h>
  32. #include <stdlib.h>
  33. #include <malloc.h>
  34. #include <string.h>
  35. #include "hpgl.h"
  36.  
  37.  
  38. #ifndef TRUE
  39. #define TRUE  1
  40. #endif
  41. #ifndef FALSE
  42. #define FALSE 0
  43. #endif
  44.  
  45. #define        ERR_F        0x1F
  46. #define        FNAME_LEN    128    /* length of longest MSDOS filename */
  47. #define        EXIT1        1
  48.  
  49. static void nfexit (int, char );
  50. static int istok ( char *, char * );
  51. static void clear_flags ( void );
  52. static int setflags ( int );
  53. static void getflags ( char * );
  54.  
  55. static char copyright[] = "Copyright 1991, Robert C. Becker, Lantern Systems";
  56.  
  57. static char cf, ef, vf, Af, Bf, Cf, Df, Ef, A4f, A3f, A2f, A1f, A0f, dpf;
  58.  
  59. static char *progname;    /* pointer to program name */
  60.  
  61. static char **files;
  62. static char *path;    /* file found at requested directory path */
  63. static char *dpath;    /* directory pathname */
  64. static char fname_bfr [FNAME_LEN];    /* handy buffer for file names */
  65. static char tokens[] = "c e v A B C D A4 A3 A2 A1 A0 dp";
  66.  
  67. struct option
  68.     {
  69.     char *opt;
  70.     int length;
  71.     int value;
  72.     };
  73.  
  74. static struct option optarray[] =
  75.     {
  76.     { "c", 1, 1},        /* these values correspond to array indices in    */
  77.     { "e", 1, 3},        /* in video_mode[] as translated by         */
  78.     { "v", 1, 6},        /* from_mode [] in hpgl.c            */
  79.     { "A4", 2, A4_paper},
  80.     { "A3", 2, A3_paper},
  81.     { "A2", 2, A2_paper},
  82.     { "A1", 2, A1_paper},
  83.     { "A0", 2, A0_paper},
  84.     { "dp", 2, DRAFTPRO},
  85.     { "A", 1, A_paper},
  86.     { "B", 1, B_paper},
  87.     { "C", 1, C_paper},
  88.     { "D", 1, D_paper},
  89.     { "E", 1, E_paper},
  90.     { "", 0, 0}    /* end of struct */
  91.     };
  92.  
  93. static struct options cmd_options;
  94.  
  95. /*----------------------------------*/
  96.  
  97. static void nfexit (int val, char opt)
  98.      {
  99.      printf ("\n%s: ", progname);
  100.     printf ("unknown option:  %c\n", opt);
  101.     printf ("usage: %s  [-%s]  <file>\n", progname, tokens);
  102.  
  103.     exit (val);
  104.     }
  105.  
  106.  
  107. /*----------------------------------*/
  108.  
  109. static int istok (char *ch, char *str)        /* match flags with chars in token [] */
  110.     {
  111.     int i;
  112.  
  113.     for (i = 0; ; i++)
  114.         {
  115.         if (optarray[i].opt[0] == ch[0])
  116.             {
  117.             if (optarray[i].length == 1) return (i);
  118.             if (optarray[i].opt[1] == ch[1]) return (i);
  119.             }
  120.         if ( !optarray[i].length ) return (ERR_F);    /* flag not found in list */
  121.         }
  122.     }
  123.  
  124. /*----------------------------------*/
  125.  
  126. static void clear_flags ( void )
  127.     {
  128.     Af = Bf = Cf = Df = Ef = 0;
  129.     A4f = A3f = A2f = A1f = A0f = 0;
  130.     cf = ef = vf = 0;
  131.     dpf = 0;
  132.  
  133.     return;
  134.     }
  135.  
  136. /*----------------------------------*/
  137.  
  138. static int setflags (int flag)
  139.     {
  140.     switch(flag)
  141.         {
  142.         case  0: cf = TRUE;
  143.             cmd_options.video = optarray[flag].value;
  144.             break;
  145.         case  1: ef = TRUE;
  146.             cmd_options.video = optarray[flag].value;
  147.             break;
  148.         case  2: vf = TRUE;
  149.             cmd_options.video = optarray[flag].value;
  150.             break;
  151.         case  3: A4f = TRUE;
  152.             cmd_options.paper = optarray[flag].value;
  153.             break;
  154.         case  4: A3f = TRUE;
  155.             cmd_options.paper = optarray[flag].value;
  156.             break;
  157.         case  5: A2f = TRUE;
  158.             cmd_options.paper = optarray[flag].value;
  159.             break;
  160.         case  6: A1f = TRUE;
  161.             cmd_options.paper = optarray[flag].value;
  162.             break;
  163.         case  7: A0f = TRUE;
  164.             cmd_options.paper = optarray[flag].value;
  165.             break;
  166.         case  8: dpf = TRUE;
  167.             cmd_options.plotter = optarray[flag].value;
  168.             break;
  169.         case  9: Af = TRUE;
  170.             cmd_options.paper = optarray[flag].value;
  171.             break;
  172.         case 10: Bf = TRUE;
  173.             cmd_options.paper = optarray[flag].value;
  174.             break;
  175.         case 11: Cf = TRUE;
  176.             cmd_options.paper = optarray[flag].value;
  177.             break;
  178.         case 12: Df = TRUE;
  179.             cmd_options.paper = optarray[flag].value;
  180.             break;
  181.         case 13: Ef = TRUE;
  182.             cmd_options.paper = optarray[flag].value;
  183.             break;
  184.         default: break;
  185.         }
  186.     return (TRUE);    /* return constant value for cheap programming simplification */
  187.     }
  188.  
  189. /*----------------------------------*/
  190.  
  191. static void getflags (char *args)
  192.     {
  193.      int i, j, index, ind=FALSE;
  194.  
  195.     for(i = 0; i < strlen (args); i++)
  196.         {
  197.         for (j = 0; ; j++)
  198.             {
  199.             if (optarray[j].opt[0] == args [i])
  200.                 {
  201.                 if (optarray[j].length == 1)
  202.                     {
  203.                     ind = setflags (j);
  204.                     break;
  205.                     }
  206.                 if (optarray[j].opt[1] == args [i + 1])
  207.                     {
  208.                     ++i;    /* advance over this char */
  209.                     ind = setflags (j);
  210.                     break;
  211.                     }
  212.                 }
  213.             if ( !optarray[j].length ) nfexit (EXIT1, args[i]);    /* flag not found in list */
  214.             }
  215.         }
  216.  
  217.     return;
  218.     }
  219.  
  220. /*----------------------------------*/
  221.  
  222. struct options *getargs (int argc, char **argv)
  223.      {
  224.     char *s;
  225.  
  226.     path = (char *) calloc (1, 215);
  227.     dpath = (char *) calloc (1, 215);
  228.     cmd_options.paper = A_paper;
  229.     cmd_options.video = 0;    /* initialize video and papersize to defaults */
  230.     cmd_options.plotter = 0;    /* no plotter specified */
  231.  
  232.     s = progname = *argv++;
  233.     --argc;
  234.     while (*s)    /* get program name */
  235.         {
  236.         if (*s == ':' || *s == '\\' || *s == '/')
  237.             progname = s + 1;
  238.         ++s;
  239.         }
  240.     strlwr (progname);
  241.  
  242.     clear_flags ();        /* zero all flags */
  243.  
  244.     if (**argv == '-')
  245.         {
  246.         while ( *(s = *argv) && (*s == '-'))    /* if we have command line flags, */
  247.             {                /*ignore environment defaults */
  248.             ++argv;
  249.             --argc;
  250.             ++s;    /* skip leading '-' */
  251.             getflags (s);
  252.             }
  253.         }
  254.     else
  255.         {
  256.         if ((s=getenv ("HPGL")) != NULL)
  257.             {
  258.             getflags (s);    /* get environment default flags */
  259.             }
  260.         }
  261.  
  262.     /* check for more than one paper size selected */
  263.     if (Af + Bf + Cf + Ef + A4f + A3f + A2f + A1f + A0f > 1)
  264.         {
  265.         printf ("%s:  more than one paper size options selected\n", progname);
  266.         exit (1);
  267.         }
  268.  
  269.     if (cf + ef + vf > 1)
  270.         {
  271.         printf ("%s: ignoring multiple video adapter modes\n", progname);
  272.         cmd_options.video = 0;    /* use automatic mode selection */
  273.         }
  274.  
  275.     if (argc < 1)
  276.         {    /* use stdin */
  277.         cmd_options.infile = stdin;
  278.         }
  279.     else
  280.         {    /* get filename */
  281.         strcpy (path, *argv);
  282.         cmd_options.infile = fopen (path, "r");    /* returns NULL if no file */
  283.         }
  284.  
  285.     return (&cmd_options);
  286.     }
  287.  
  288.