home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / cmdline / c_parse / parse.c next >
Encoding:
C/C++ Source or Header  |  1987-06-18  |  9.5 KB  |  307 lines
  1. #include   <stdio.h>
  2.  
  3. int    get_int (name, sig, var, argv)
  4.  
  5. char    *name;     /* string to search for */
  6. int     sig;       /* number of significant characters */
  7. int     *var;      /* pointer to output variable */
  8. char    *argv[];   /* argument vector pointer from main */
  9. {
  10.    int     argc, match;
  11.    char    *scan;
  12.  
  13.    if (name == NULL || name[0] == '\0' || --sig < 1)   /* bounds check */
  14.        return (-1);
  15.  
  16.    if (sig > strlen (name))    sig = strlen (name);
  17.  
  18.    for (argc = 0; argv[argc] != NULL; argc++)     /* scan through arg list */
  19.    {
  20.        for (match=0; name[match] == argv[argc][match]; match++)
  21.            ;
  22.  
  23.        if (match > sig)    /* enough characters matched */
  24.        {
  25.            if (argv[argc][match] != '=')   /* search for '=' */
  26.                return (-2);
  27.            else
  28.                ++match;
  29.  
  30.            scan = match + argv[argc];   /* points to rhs of equals */
  31.            if (scan[0] == '\0')
  32.                return (-3);
  33.  
  34.            if (scan[0] == '-')     /* the number could be negative */
  35.                match = 1;
  36.            else
  37.                match = 0;
  38.  
  39.            while (isdigit (scan[match++]))      /* check that all are digits */
  40.                ;
  41.            if (scan[match-1] != '\0')
  42.                return (-4);
  43.  
  44.            sscanf (scan, "%d", var);
  45.            while (argv[argc] != NULL)      /* delete this parameter */
  46.            {
  47.                argv[argc] = argv[argc+1];
  48.                ++argc;
  49.            }
  50.            --argc;      /* back up one */
  51.            break;       /* break out of for loop */
  52.        }
  53.    }
  54.    return (argc);
  55. }
  56.  
  57. int    get_float (name, sig, var, argv)
  58.  
  59. char    *name;     /* string to search for */
  60. int     sig;       /* number of significant characters */
  61. float   *var;      /* pointer to output variable */
  62. char    *argv[];   /* argument vector pointer from main */
  63. {
  64.    int     argc, match, loc, dec, neg, exp;
  65.    char    *scan;
  66.  
  67.    if (name == NULL || name[0] == '\0' || --sig < 1)   /* bounds check */
  68.        return (-1);
  69.  
  70.    if (sig > strlen (name))    sig = strlen (name);
  71.  
  72.    for (argc = 0; argv[argc] != NULL; argc++)      /* scan through arg list */
  73.    {
  74.        for (match=0; name[match] == argv[argc][match]; match++)
  75.            ;
  76.  
  77.        if (match > sig)    /* enough characters matched */
  78.        {
  79.            if (argv[argc][match] != '=')   /* search for '=' */
  80.                return (-2);
  81.            else
  82.                ++match;
  83.  
  84.            scan = match + argv[argc];   /* points to rhs of equals */
  85.            if (scan[0] == '\0')
  86.                return (-3);
  87.  
  88.            /* parse it to be sure it's a float */
  89.            loc = -1;       /* parse cursor */
  90.            exp = 0;        /* exponent flag */
  91.            dec = 0;        /* decimal point flag */
  92.            neg = 0;        /* negative flag */
  93.  
  94.            while (scan[++loc] != '\0')
  95.                if (scan[loc] == '-')
  96.                    ++neg;
  97.                else if (scan[loc] == '.')
  98.                    ++dec;
  99.                else if (scan[loc] == 'e' || scan[loc] == 'E')
  100.                {
  101.                    ++exp;
  102.                    if (neg <= 1)
  103.                        neg = 0;       /* you're allowed another minus here */
  104.                }
  105.                else if (!isdigit (scan[loc]))
  106.                    break;       /* illegal character */
  107.  
  108.            if (scan[loc] != '\0')
  109.                return (-4);
  110.  
  111.            if (neg > 1 || dec > 1 || exp > 1)
  112.                return (-5);
  113.  
  114.            sscanf (scan, "%f", var);
  115.            while (argv[argc] != NULL)      /* delete this parameter */
  116.            {
  117.                argv[argc] = argv[argc+1];
  118.                ++argc;
  119.            }
  120.            --argc;     /* back up one */
  121.            break;      /* break out of for loop */
  122.        }
  123.    }
  124.    return (argc);
  125. }
  126.  
  127. int    get_char (name, sig, var, argv)
  128.  
  129. char    *name;     /* string to search for */
  130. int    sig;        /* number of significant characters */
  131. char    *var;      /* pointer to output variable */
  132. char    *argv[];   /* argument vector pointer from main */
  133. {
  134.    int     argc, match, find, i, save, len;
  135.    char    *scan, *calloc ();
  136.  
  137.    if (name == NULL || name[0] == '\0' || --sig < 1 || var == NULL)
  138.        return (-1);       /* bounds check */
  139.  
  140.    if (sig > strlen (name))    sig = strlen (name);
  141.  
  142.    for (argc = 0; argv[argc] != NULL; argc++)      /* scan through arg list */
  143.    {
  144.        for (match=0; name[match] == argv[argc][match]; match++)
  145.            ;
  146.  
  147.        if (match > sig)    /* enough characters matched */
  148.        {
  149.            if (argv[argc][match] != '=')   /* search for '=' */
  150.                return (-2);
  151.            else
  152.                ++match;
  153.  
  154.            scan = calloc (256, 1);
  155.            strcpy (scan, match + argv[argc]);   /* points to rhs of equals */
  156.  
  157.            find = 1;
  158.            if (scan[0] == '"')      /* start of macro string */
  159.            {
  160.                /* find the next arg that ends in " */
  161.                for (find=argc; argv[find] != NULL; find++)
  162.                {
  163.                    len = strlen (argv[find]) - 1;
  164.                    if (argv[find][len] == '"')
  165.                        break;
  166.                }
  167.                if (argv[find] == NULL)     /* none was found */
  168.                    find = 1;
  169.                else
  170.                    find = find - argc + 1;
  171.            }
  172.  
  173.            for (i=1; i < find; i++)       /* build the string */
  174.            {
  175.                strcat (scan, " ");
  176.                strcat (scan, argv[argc+i]);
  177.            }
  178.  
  179.            len = strlen (scan) - 1;
  180.            if (scan[0] == '"' && scan[len] == '"')
  181.            {
  182.                scan[len] = '\0';   /* delete trailing " */
  183.                ++scan;             /* delete leading  " */
  184.                strcpy (var, scan);
  185.                free (--scan);
  186.            }
  187.            else
  188.                strcpy (var, scan);
  189.  
  190.            save = argc;
  191.            for (i=0; i<find; i++)
  192.            {
  193.                argc = save;
  194.                while (argv[argc] != NULL)      /* delete this parameter */
  195.                {
  196.                    argv[argc] = argv[argc+1];
  197.                    ++argc;
  198.                }
  199.            }
  200.  
  201.            --argc;     /* back up one */
  202.            break;      /* break out of 'for' loop */
  203.        }
  204.    }
  205.    return (argc);
  206. }
  207.  
  208. int    get_flag (name, sig, var, argv)
  209.  
  210. char    *name;     /* string to search for */
  211. int     sig;       /* number of significant characters */
  212. int     *var;      /* pointer to output variable */
  213. char    *argv[];   /* argument vector pointer from main */
  214. {
  215.    int     argc, match;
  216.  
  217.    *var = 0;
  218.    if (name == NULL || name[0] == '\0' || --sig < 1)   /* bounds check */
  219.        return (-1);
  220.  
  221.    if (sig > strlen (name))    sig = strlen (name);
  222.  
  223.    for (argc = 0; argv[argc] != NULL; argc++)       /* scan through arg list */
  224.    {
  225.        for (match=0; name[match] == argv[argc][match]; match++)
  226.            if (name[match] == '\0' || argv[argc][match] == '\0')
  227.                break;
  228.  
  229.        if (match > sig)    /* enough characters matched */
  230.        {
  231.            if (argv[argc][match] != '\0')      /* string too long */
  232.                return (-2);
  233.  
  234.            while (argv[argc] != NULL)       /* delete this parameter */
  235.            {
  236.                argv[argc] = argv[argc+1];
  237.                ++argc;
  238.            }
  239.            --argc;     /* back up one */
  240.            *var = 1;   /* indicate that flag was found */
  241.            break;      /* break out of for loop */
  242.        }
  243.    }
  244.    return (argc);
  245. }
  246.  
  247. main (argc, argv)      /* test routine for above functions */
  248. int     argc;
  249. char    *argv[];
  250. {
  251.    int     i, i_test = 9999, g_test = 0;
  252.    float   f_test = 999.9;
  253.    char    c_test[80];
  254.    strcpy (c_test, "9999");
  255.  
  256.    printf ("argument list is as follows: (%d parameters) \n", argc);
  257.    for (i=0; i < argc; i++)
  258.        printf ("'%s' ", argv[i]);
  259.    printf ("\n\n");
  260.  
  261.    argc = get_int   ("int", 3, &i_test, argv);
  262.    if (argc >= 0)
  263.    {
  264.        printf ("\nafter call to GET_INT:      (argc = %d) \n", argc);
  265.        for (i=0; i<argc; i++)
  266.            printf ("'%s' ", argv[i]);
  267.        printf ("\nreturned value is %d\n", i_test);
  268.    }
  269.    else 
  270.        printf ("\n%d returned from GET_INT\n", argc);
  271.  
  272.    argc = get_float ("float", 3, &f_test, argv);
  273.    if (argc >= 0)
  274.    {
  275.        printf ("\nafter call to GET_FLOAT:    (argc = %d) \n", argc);
  276.        for (i=0; i<argc; i++)
  277.            printf ("'%s' ", argv[i]);
  278.        printf ("\nreturned value is %0.4f\n", f_test);
  279.    }
  280.    else 
  281.        printf ("\n%d returned from GET_FLOAT\n", argc);
  282.  
  283.    argc = get_char  ("char", 3, c_test, argv);
  284.    if (argc >= 0)
  285.    {
  286.        printf ("\nafter call to GET_CHAR:     (argc = %d) \n", argc);
  287.        for (i=0; i<argc; i++)
  288.            printf ("'%s' ", argv[i]);
  289.        printf ("\nreturned value is '%s'\n", c_test);
  290.    }
  291.    else 
  292.        printf ("\n%d returned from GET_CHAR\n", argc);
  293.  
  294.    argc = get_flag  ("flag", 3, &g_test, argv);
  295.    if (argc >= 0)
  296.    {
  297.        printf ("\nafter call to GET_FLAG:     (argc = %d) \n", argc);
  298.        for (i=0; i<argc; i++)
  299.            printf ("'%s' ", argv[i]);
  300.        printf ("\nreturned value is '%d'\n", g_test);
  301.    }
  302.    else 
  303.        printf ("\n%d returned from GET_FLAG\n", argc);
  304.  
  305.    return (0);
  306. }
  307.