Logo Search packages:      
Sourcecode: videogen version File versions  Download package

args.c

/*
 * +-------------------------------------------------------+
 * |                                                       |
 * |     videogen                                          |
 * |                                                       |
 * |     a simple XFree86 Modeline calculator              |
 * |     (c) 1997-2002, Szabolcs Rumi                      |   
 * |                                                       |
 * |     http://www.rtfm.hu/videogen                       |
 * |                                                       |
 * |     the videogen package is distributed under the     |
 * |     GNU General Public License Version 2 (GPLv2)      |
 * |                                                       |
 * +-------------------------------------------------------+   
 */





#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "config.h"
#include "videogen.h"





arg_opt_t opts[] =
{
                  {     "-h", NULL, 0     },
                  {     "-v", NULL, 0     },
                  {     "-q", NULL, 0     },
                  {     "-fb",      NULL, 0     },
                  {     "-nfb",     NULL, 0     },
                  {     "-nv",      NULL, 0     },
                  {     "-nnv",     NULL, 0     },
                  {     "-f", NULL, 0     },
                  {     "-m", NULL, 0     },
                  {     "-mdc",     NULL, 0     },
                  {     "-mhf", NULL,     0     },
                  {     "-mvf",     NULL, 0     },
                  {     "-dvf",     NULL, 0     },
                  {     "-hv",      NULL, 0     },
                  {     "-vv",      NULL, 0     },
                  {     "-hfp",     NULL, 0     },
                  {     "-hbp",     NULL, 0     },
                  {     "-hsp",     NULL, 0     },
                  {     "-vfp",     NULL, 0     },
                  {     "-vbp",     NULL, 0     },
                  {     "-vsp",     NULL, 0     },
                  {     NULL, NULL, 0     }
};





int
arg_action (arg_parse_t *ap)
{
      unsigned int x_uint, y_uint;
      double x_double;

      char *serr = NULL;            /* for using with strtol(), strtod() */



      /*
      fprintf (stdout, "argument %u matches option %u: %s == %s\n",
                  ap->aindex, ap->oindex, (*ap->options)[ap->oindex].ao_option, (*ap->options)[ap->oindex].ao_parameter);
      */

      /*
       * taking appropriate actions for each argument type
       */

      switch (ap->oindex)
      {
            case 0:     {
                        banner ();
                        usage ();
                        exit (0);   /* either reading help or using the program... */
                        break;
                  }

            case 1:     {
                        if (commit_verbose (CFG_PREC_CMDLINE, &verbose, 1) == 0)
                              pmsg (VL_DEBUG, "[cmdline] arg %u: verbose mode on\n", ap->aindex);
                        break;
                  }

            case 2:     {
                        if (commit_verbose (CFG_PREC_CMDLINE, &verbose, 0) == 0)
                              pmsg (VL_DEBUG, "[cmdline] arg %u: verbose mode off\n", ap->aindex);
                        break;
                  }

            case 3: {
                        if (commit_fbset (CFG_PREC_CMDLINE, &fbset, 1) == 0)
                                    pmsg (VL_DEBUG, "[cmdline] arg %u: fbset mode on\n", ap->aindex);
                        break;
                  }

            case 4: {
                        if (commit_fbset (CFG_PREC_CMDLINE, &fbset, 0) == 0)
                                    pmsg (VL_DEBUG, "[cmdline] arg %u: fbset mode off\n", ap->aindex);
                        break;
                  }

            case 5: {
                        if (commit_nvidia (CFG_PREC_CMDLINE, &nvidia, 1) == 0)
                                    pmsg (VL_DEBUG, "[cmdline] arg %u: nvidia compatibility mode on\n", ap->aindex);
                        break;
                  }

            case 6: {
                        if (commit_nvidia (CFG_PREC_CMDLINE, &nvidia, 0) == 0)
                                    pmsg (VL_DEBUG, "[cmdline] arg %u: nvidia compatibility mode off\n", ap->aindex);
                        break;
                  }

            case 7: {
                        if ((*ap->options)[ap->oindex].ao_flags & ARG_FOUND_PARM)
                        {
                              cfgfile = (*ap->options)[ap->oindex].ao_parameter;
                              pmsg (VL_DEBUG, "[cmdline] arg %u: config file set to %s\n", ap->aindex, cfgfile);
                        }
                        break;
                  }

            case 8: {
                        if ((*ap->options)[ap->oindex].ao_flags & ARG_FOUND_PARM)
                        {
                              if (sscanf ((*ap->options)[ap->oindex].ao_parameter, "%ux%u", &x_uint, &y_uint) == 2)
                              {
                                    switch (commit_mode (CFG_PREC_CMDLINE, &modes, &num_modes, x_uint, y_uint))
                                    {
                                          case -1:    break;

                                          case 0: {
                                                      pmsg (VL_DEBUG, "[cmdline] arg %u: added mode %ux%u\n", ap->aindex, x_uint, y_uint);
                                                      break;
                                                }

                                          case 5: {
                                                      pmsg (VL_DEBUG, "[cmdline] arg %u: too many modes, dropping %ux%u\n", ap->aindex, x_uint, y_uint);
                                                      pmsg (VL_VERBOSE, "no more than 256 modes are allowed, dropping %ux%u\n", x_uint, y_uint);
                                                      break;
                                                }

                                          default: {
                                                      pmsg (VL_DEBUG, "[cmdline] arg %u: %s has an invalid parameter \"%s\"\n", ap->aindex,
                                                            (*ap->options)[ap->oindex].ao_option, (*ap->options)[ap->oindex].ao_parameter);
                                                      pmsg (VL_VERBOSE, "argument %u (%s) has an invalid parameter\n", ap->aindex, ap->argv[ap->aindex]);
                                                      return (-1);
                                                }
                                    }
                              }
                              else
                                    return (-1);
                        }
                        else
                              return (-1);
                        
                        break;
                  }

            case 9: {
                        if ((*ap->options)[ap->oindex].ao_flags & ARG_FOUND_PARM)
                        {
                              x_double = strtod ((*ap->options)[ap->oindex].ao_parameter, &serr);

                              if ((*(*ap->options)[ap->oindex].ao_parameter != '\0') && (*serr == '\0'))
                              {
                                    switch (commit_max_dotclk (CFG_PREC_CMDLINE, &max_dotclk, x_double))
                                    {
                                          case -1:    break;

                                          case 0:     {
                                                      pmsg (VL_DEBUG, "[cmdline] arg %u: max_dotclk = %0.0f MHz\n", ap->aindex, x_double);
                                                      break;
                                                }

                                          default: {
                                                      pmsg (VL_DEBUG, "[cmdline] arg %u: %s has an invalid parameter \"%s\"\n", ap->aindex,
                                                            (*ap->options)[ap->oindex].ao_option, (*ap->options)[ap->oindex].ao_parameter);
                                                      pmsg (VL_VERBOSE, "argument %u (%s) has an invalid parameter\n", ap->aindex, ap->argv[ap->aindex]);
                                                      return (-1);
                                                }
                                    }
                              }
                              else
                                    return (-1);
                        }
                        else
                              return (-1);

                        break;
                  }

            case 10: {
                        if ((*ap->options)[ap->oindex].ao_flags & ARG_FOUND_PARM)
                        {
                              x_double = strtod ((*ap->options)[ap->oindex].ao_parameter, &serr);

                              if ((*(*ap->options)[ap->oindex].ao_parameter != '\0') && (*serr == '\0'))
                              {
                                    switch (commit_max_hfreq (CFG_PREC_CMDLINE, &max_hfreq, x_double))
                                    {
                                          case -1:    break;

                                          case 0:     {
                                                      pmsg (VL_DEBUG, "[cmdline] arg %u: max_hfreq = %0.1f kHz\n", ap->aindex, x_double);
                                                      break;
                                                }

                                          default: {
                                                      pmsg (VL_DEBUG, "[cmdline] arg %u: %s has an invalid parameter \"%s\"\n", ap->aindex,
                                                            (*ap->options)[ap->oindex].ao_option, (*ap->options)[ap->oindex].ao_parameter);
                                                      pmsg (VL_VERBOSE, "argument %u (%s) has an invalid parameter\n", ap->aindex, ap->argv[ap->aindex]);
                                                      return (-1);
                                                }
                                    }
                              }
                              else
                                    return (-1);
                        }
                        else
                              return (-1);

                        break;
                  }

            case 11: {
                        if ((*ap->options)[ap->oindex].ao_flags & ARG_FOUND_PARM)
                        {
                              x_double = strtod ((*ap->options)[ap->oindex].ao_parameter, &serr);

                              if ((*(*ap->options)[ap->oindex].ao_parameter != '\0') && (*serr == '\0'))
                              {
                                    switch (commit_max_vfreq (CFG_PREC_CMDLINE, &max_vfreq, x_double))
                                    {
                                          case -1:    break;

                                          case 0:     {
                                                      pmsg (VL_DEBUG, "[cmdline] arg %u: max_vfreq = %0.1f Hz\n", ap->aindex, x_double);
                                                      break;
                                                }

                                          default: {
                                                      pmsg (VL_DEBUG, "[cmdline] arg %u: %s has an invalid parameter \"%s\"\n", ap->aindex,
                                                            (*ap->options)[ap->oindex].ao_option, (*ap->options)[ap->oindex].ao_parameter);
                                                      pmsg (VL_VERBOSE, "argument %u (%s) has an invalid parameter\n", ap->aindex, ap->argv[ap->aindex]);
                                                      return (-1);
                                                }
                                    }
                              }
                              else
                                    return (-1);
                        }
                        else
                              return (-1);

                        break;
                  }

            case 12: {
                        if ((*ap->options)[ap->oindex].ao_flags & ARG_FOUND_PARM)
                        {
                              x_double = strtod ((*ap->options)[ap->oindex].ao_parameter, &serr);

                              if ((*(*ap->options)[ap->oindex].ao_parameter != '\0') && (*serr == '\0'))
                              {
                                    switch (commit_desired_vfreq (CFG_PREC_CMDLINE, &desired_vfreq, x_double))
                                    {
                                          case -1:    break;

                                          case 0:     {
                                                      pmsg (VL_DEBUG, "[cmdline] arg %u: desired_vfreq = %0.1f Hz\n", ap->aindex, x_double);
                                                      break;
                                                }

                                          default: {
                                                      pmsg (VL_DEBUG, "[cmdline] arg %u: %s has an invalid parameter \"%s\"\n", ap->aindex,
                                                            (*ap->options)[ap->oindex].ao_option, (*ap->options)[ap->oindex].ao_parameter);
                                                      pmsg (VL_VERBOSE, "argument %u (%s) has an invalid parameter\n", ap->aindex, ap->argv[ap->aindex]);
                                                      return (-1);
                                                }
                                    }
                              }
                              else
                                    return (-1);
                        }
                        else
                              return (-1);

                        break;
                  }

            case 13: {
                        if ((*ap->options)[ap->oindex].ao_flags & ARG_FOUND_PARM)
                        {
                              x_double = strtod ((*ap->options)[ap->oindex].ao_parameter, &serr);

                              if ((*(*ap->options)[ap->oindex].ao_parameter != '\0') && (*serr == '\0'))
                              {
                                    switch (commit_hvisible (CFG_PREC_CMDLINE, &hvisible, x_double))
                                    {
                                          case -1:    break;

                                          case 0:     {
                                                      pmsg (VL_DEBUG, "[cmdline] arg %u: hvisible = %0.0f %\n", ap->aindex, x_double);
                                                      break;
                                                }

                                          default: {
                                                      pmsg (VL_DEBUG, "[cmdline] arg %u: %s has an invalid parameter \"%s\"\n", ap->aindex,
                                                            (*ap->options)[ap->oindex].ao_option, (*ap->options)[ap->oindex].ao_parameter);
                                                      pmsg (VL_VERBOSE, "argument %u (%s) has an invalid parameter\n", ap->aindex, ap->argv[ap->aindex]);
                                                      return (-1);
                                                }
                                    }
                              }
                              else
                                    return (-1);
                        }
                        else
                              return (-1);

                        break;
                  }

            case 14: {
                        if ((*ap->options)[ap->oindex].ao_flags & ARG_FOUND_PARM)
                        {
                              x_double = strtod ((*ap->options)[ap->oindex].ao_parameter, &serr);

                              if ((*(*ap->options)[ap->oindex].ao_parameter != '\0') && (*serr == '\0'))
                              {
                                    switch (commit_vvisible (CFG_PREC_CMDLINE, &vvisible, x_double))
                                    {
                                          case -1:    break;

                                          case 0:     {
                                                      pmsg (VL_DEBUG, "[cmdline] arg %u: vvisible = %0.0f %\n", ap->aindex, x_double);
                                                      break;
                                                }

                                          default: {
                                                      pmsg (VL_DEBUG, "[cmdline] arg %u: %s has an invalid parameter \"%s\"\n", ap->aindex,
                                                            (*ap->options)[ap->oindex].ao_option, (*ap->options)[ap->oindex].ao_parameter);
                                                      pmsg (VL_VERBOSE, "argument %u (%s) has an invalid parameter\n", ap->aindex, ap->argv[ap->aindex]);
                                                      return (-1);
                                                }
                                    }
                              }
                              else
                                    return (-1);
                        }
                        else
                              return (-1);

                        break;
                  }

            case 15: {
                        if ((*ap->options)[ap->oindex].ao_flags & ARG_FOUND_PARM)
                        {
                              x_double = strtod ((*ap->options)[ap->oindex].ao_parameter, &serr);

                              if ((*(*ap->options)[ap->oindex].ao_parameter != '\0') && (*serr == '\0'))
                              {
                                    switch (commit_hfporch (CFG_PREC_CMDLINE, &hfporch, x_double))
                                    {
                                          case -1:    break;

                                          case 0:     {
                                                      pmsg (VL_DEBUG, "[cmdline] arg %u: hfporch = %0.0f ticks\n", ap->aindex, x_double);
                                                      break;
                                                }

                                          default: {
                                                      pmsg (VL_DEBUG, "[cmdline] arg %u: %s has an invalid parameter \"%s\"\n", ap->aindex,
                                                            (*ap->options)[ap->oindex].ao_option, (*ap->options)[ap->oindex].ao_parameter);
                                                      pmsg (VL_VERBOSE, "argument %u (%s) has an invalid parameter\n", ap->aindex, ap->argv[ap->aindex]);
                                                      return (-1);
                                                }
                                    }
                              }
                              else
                                    return (-1);
                        }
                        else
                              return (-1);

                        break;
                  }

            case 16: {
                        if ((*ap->options)[ap->oindex].ao_flags & ARG_FOUND_PARM)
                        {
                              x_double = strtod ((*ap->options)[ap->oindex].ao_parameter, &serr);

                              if ((*(*ap->options)[ap->oindex].ao_parameter != '\0') && (*serr == '\0'))
                              {
                                    switch (commit_hbporch (CFG_PREC_CMDLINE, &hbporch, x_double))
                                    {
                                          case -1:    break;

                                          case 0:     {
                                                      pmsg (VL_DEBUG, "[cmdline] arg %u: hbporch = %0.0f ticks\n", ap->aindex, x_double);
                                                      break;
                                                }

                                          default: {
                                                      pmsg (VL_DEBUG, "[cmdline] arg %u: %s has an invalid parameter \"%s\"\n", ap->aindex,
                                                            (*ap->options)[ap->oindex].ao_option, (*ap->options)[ap->oindex].ao_parameter);
                                                      pmsg (VL_VERBOSE, "argument %u (%s) has an invalid parameter\n", ap->aindex, ap->argv[ap->aindex]);
                                                      return (-1);
                                                }
                                    }
                              }
                              else
                                    return (-1);
                        }
                        else
                              return (-1);

                        break;
                  }

            case 17: {
                        if ((*ap->options)[ap->oindex].ao_flags & ARG_FOUND_PARM)
                        {
                              x_double = strtod ((*ap->options)[ap->oindex].ao_parameter, &serr);

                              if ((*(*ap->options)[ap->oindex].ao_parameter != '\0') && (*serr == '\0'))
                              {
                                    switch (commit_hsync (CFG_PREC_CMDLINE, &hsync, x_double))
                                    {
                                          case -1:    break;

                                          case 0:     {
                                                      pmsg (VL_DEBUG, "[cmdline] arg %u: hsync = %0.1f usec\n", ap->aindex, x_double);
                                                      break;
                                                }

                                          default: {
                                                      pmsg (VL_DEBUG, "[cmdline] arg %u: %s has an invalid parameter \"%s\"\n", ap->aindex,
                                                            (*ap->options)[ap->oindex].ao_option, (*ap->options)[ap->oindex].ao_parameter);
                                                      pmsg (VL_VERBOSE, "argument %u (%s) has an invalid parameter\n", ap->aindex, ap->argv[ap->aindex]);
                                                      return (-1);
                                                }
                                    }
                              }
                              else
                                    return (-1);
                        }
                        else
                              return (-1);

                        break;
                  }

            case 18: {
                        if ((*ap->options)[ap->oindex].ao_flags & ARG_FOUND_PARM)
                        {
                              x_double = strtod ((*ap->options)[ap->oindex].ao_parameter, &serr);

                              if ((*(*ap->options)[ap->oindex].ao_parameter != '\0') && (*serr == '\0'))
                              {
                                    switch (commit_vfporch (CFG_PREC_CMDLINE, &vfporch, x_double))
                                    {
                                          case -1:    break;

                                          case 0:     {
                                                      pmsg (VL_DEBUG, "[cmdline] arg %u: vfporch = %0.0f ticks\n", ap->aindex, x_double);
                                                      break;
                                                }

                                          default: {
                                                      pmsg (VL_DEBUG, "[cmdline] arg %u: %s has an invalid parameter \"%s\"\n", ap->aindex,
                                                            (*ap->options)[ap->oindex].ao_option, (*ap->options)[ap->oindex].ao_parameter);
                                                      pmsg (VL_VERBOSE, "argument %u (%s) has an invalid parameter\n", ap->aindex, ap->argv[ap->aindex]);
                                                      return (-1);
                                                }
                                    }
                              }
                              else
                                    return (-1);
                        }
                        else
                              return (-1);

                        break;
                  }

            case 19: {
                        if ((*ap->options)[ap->oindex].ao_flags & ARG_FOUND_PARM)
                        {
                              x_double = strtod ((*ap->options)[ap->oindex].ao_parameter, &serr);

                              if ((*(*ap->options)[ap->oindex].ao_parameter != '\0') && (*serr == '\0'))
                              {
                                    switch (commit_vbporch (CFG_PREC_CMDLINE, &vbporch, x_double))
                                    {
                                          case -1:    break;

                                          case 0:     {
                                                      pmsg (VL_DEBUG, "[cmdline] arg %u: vbporch = %0.0f ticks\n", ap->aindex, x_double);
                                                      break;
                                                }

                                          default: {
                                                      pmsg (VL_DEBUG, "[cmdline] arg %u: %s has an invalid parameter \"%s\"\n", ap->aindex,
                                                            (*ap->options)[ap->oindex].ao_option, (*ap->options)[ap->oindex].ao_parameter);
                                                      pmsg (VL_VERBOSE, "argument %u (%s) has an invalid parameter\n", ap->aindex, ap->argv[ap->aindex]);
                                                      return (-1);
                                                }
                                    }
                              }
                              else
                                    return (-1);
                        }
                        else
                              return (-1);

                        break;
                  }

            case 20: {
                        if ((*ap->options)[ap->oindex].ao_flags & ARG_FOUND_PARM)
                        {
                              x_double = strtod ((*ap->options)[ap->oindex].ao_parameter, &serr);

                              if ((*(*ap->options)[ap->oindex].ao_parameter != '\0') && (*serr == '\0'))
                              {
                                    switch (commit_vsync (CFG_PREC_CMDLINE, &vsync, x_double))
                                    {
                                          case -1:    break;

                                          case 0:     {
                                                      pmsg (VL_DEBUG, "[cmdline] arg %u: vsync = %0.0f usec\n", ap->aindex, x_double);
                                                      break;
                                                }

                                          default: {
                                                      pmsg (VL_DEBUG, "[cmdline] arg %u: %s has an invalid parameter \"%s\"\n", ap->aindex,
                                                            (*ap->options)[ap->oindex].ao_option, (*ap->options)[ap->oindex].ao_parameter);
                                                      pmsg (VL_VERBOSE, "argument %u (%s) has an invalid parameter\n", ap->aindex, ap->argv[ap->aindex]);
                                                      return (-1);
                                                }
                                    }
                              }
                              else
                                    return (-1);
                        }
                        else
                              return (-1);

                        break;
                  }

            default: {
                        pmsg (VL_DEBUG, "[cmdline] arg %u: unrecognized argument \"%s\"\n", ap->aindex, ap->argv[ap->aindex]);
                        pmsg (VL_VERBOSE, "invalid argument %u (%s)\n", ap->aindex, ap->argv[ap->aindex]);
                        return (-1);
                  }
      }

      return (0);
}





int
arg_parse (arg_parse_t *ap, int (*arg_action) (arg_parse_t *))
{
      char *eq;
      int match;



      /*
       * parse all arguments present on the command line
       */

      ap->aindex = 1;
      while (ap->aindex < ap->argc)
      {
            ap->oindex = 0;
            match = 0;

            while ((*ap->options)[ap->oindex].ao_option != NULL)
            {
                  if ((eq = strchr (ap->argv[ap->aindex], '=')) == NULL)
                  {
                        /*
                         * argument does not have a parameter
                         */

                        if (strcmp ((*ap->options)[ap->oindex].ao_option, ap->argv[ap->aindex]) == 0)
                        {
                              match++;
                              (*ap->options)[ap->oindex].ao_flags |= ARG_FOUND;

                              if ((*arg_action) (ap) < 0)
                                    return (-1);
                        }
                  }
                  else
                  {
                        /*
                         * argument does have a parameter
                         */
                        
                        *eq = '\0'; /* temporarily split string at the equal sign */

                        if (strcmp ((*ap->options)[ap->oindex].ao_option, ap->argv[ap->aindex]) == 0)
                        {
                              match++;
                              (*ap->options)[ap->oindex].ao_flags |= ARG_FOUND;
                              (*ap->options)[ap->oindex].ao_flags |= ARG_FOUND_PARM;
                              (*ap->options)[ap->oindex].ao_parameter = eq + 1;

                              *eq = '=';  /* restore equal sign */
                              if ((*arg_action) (ap) < 0)
                                    return (-1);
                        }
                        else
                              *eq = '=';  /* restore equal sign */
                  }

                  ap->oindex++;
            }

            if (((*ap->options)[ap->oindex].ao_option != NULL) && (match == 0))
            {
                  ap->oindex = -1;  /* signal unmatched argument */
                  if ((*arg_action) (ap) < 0)
                        return (-1);
            }

            ap->aindex++;
      }

      return (0);
}





/* EOF */

Generated by  Doxygen 1.6.0   Back to index