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