home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / bsd_srcs / games / trek / getpar.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-04-08  |  5.3 KB  |  298 lines
  1. /*
  2.  * Copyright (c) 1980 Regents of the University of California.
  3.  * All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  * 1. Redistributions of source code must retain the above copyright
  9.  *    notice, this list of conditions and the following disclaimer.
  10.  * 2. Redistributions in binary form must reproduce the above copyright
  11.  *    notice, this list of conditions and the following disclaimer in the
  12.  *    documentation and/or other materials provided with the distribution.
  13.  * 3. All advertising materials mentioning features or use of this software
  14.  *    must display the following acknowledgement:
  15.  *    This product includes software developed by the University of
  16.  *    California, Berkeley and its contributors.
  17.  * 4. Neither the name of the University nor the names of its contributors
  18.  *    may be used to endorse or promote products derived from this software
  19.  *    without specific prior written permission.
  20.  *
  21.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31.  * SUCH DAMAGE.
  32.  */
  33.  
  34. #ifndef lint
  35. static char sccsid[] = "@(#)getpar.c    4.8 (Berkeley) 6/1/90";
  36. #endif /* not lint */
  37.  
  38. # include    <stdio.h>
  39. # include    "getpar.h"
  40.  
  41. /**
  42.  **    get integer parameter
  43.  **/
  44.  
  45. getintpar(s)
  46. char    *s;
  47. {
  48.     register int    i;
  49.     int        n;
  50.  
  51.     while (1)
  52.     {
  53.         if (testnl() && s)
  54.             printf("%s: ", s);
  55.         i = scanf("%d", &n);
  56.         if (i < 0)
  57.             exit(1);
  58.         if (i > 0 && testterm())
  59.             return (n);
  60.         printf("invalid input; please enter an integer\n");
  61.         skiptonl(0);
  62.     }
  63. }
  64.  
  65. /**
  66.  **    get floating parameter
  67.  **/
  68.  
  69. double getfltpar(s)
  70. char    *s;
  71. {
  72.     register int        i;
  73.     double            d;
  74.  
  75.     while (1)
  76.     {
  77.         if (testnl() && s)
  78.             printf("%s: ", s);
  79.         i = scanf("%lf", &d);
  80.         if (i < 0)
  81.             exit(1);
  82.         if (i > 0 && testterm())
  83.             return (d);
  84.         printf("invalid input; please enter a double\n");
  85.         skiptonl(0);
  86.     }
  87. }
  88.  
  89. /**
  90.  **    get yes/no parameter
  91.  **/
  92.  
  93. struct cvntab    Yntab[] =
  94. {
  95.     "y",    "es",    (int (*)())1,    0,
  96.     "n",    "o",    (int (*)())0,    0,
  97.     0
  98. };
  99.  
  100. getynpar(s)
  101. char    *s;
  102. {
  103.     struct cvntab        *r;
  104.  
  105.     r = getcodpar(s, Yntab);
  106.     return ((int) r->value);
  107. }
  108.  
  109.  
  110. /**
  111.  **    get coded parameter
  112.  **/
  113.  
  114. struct cvntab *getcodpar(s, tab)
  115. char        *s;
  116. struct cvntab    tab[];
  117. {
  118.     char                input[100];
  119.     register struct cvntab        *r;
  120.     int                flag;
  121.     register char            *p, *q;
  122.     int                c;
  123.     int                f;
  124.  
  125.     flag = 0;
  126.     while (1)
  127.     {
  128.         flag |= (f = testnl());
  129.         if (flag)
  130.             printf("%s: ", s);
  131.         if (f)
  132.             cgetc(0);        /* throw out the newline */
  133.         scanf("%*[ \t;]");
  134.         if ((c = scanf("%[^ \t;\n]", input)) < 0)
  135.             exit(1);
  136.         if (c == 0)
  137.             continue;
  138.         flag = 1;
  139.  
  140.         /* if command list, print four per line */
  141.         if (input[0] == '?' && input[1] == 0)
  142.         {
  143.             c = 4;
  144.             for (r = tab; r->abrev; r++)
  145.             {
  146.                 concat(r->abrev, r->full, input);
  147.                 printf("%14.14s", input);
  148.                 if (--c > 0)
  149.                     continue;
  150.                 c = 4;
  151.                 printf("\n");
  152.             }
  153.             if (c != 4)
  154.                 printf("\n");
  155.             continue;
  156.         }
  157.  
  158.         /* search for in table */
  159.         for (r = tab; r->abrev; r++)
  160.         {
  161.             p = input;
  162.             for (q = r->abrev; *q; q++)
  163.                 if (*p++ != *q)
  164.                     break;
  165.             if (!*q)
  166.             {
  167.                 for (q = r->full; *p && *q; q++, p++)
  168.                     if (*p != *q)
  169.                         break;
  170.                 if (!*p || !*q)
  171.                     break;
  172.             }
  173.         }
  174.  
  175.         /* check for not found */
  176.         if (!r->abrev)
  177.         {
  178.             printf("invalid input; ? for valid inputs\n");
  179.             skiptonl(0);
  180.         }
  181.         else
  182.             return (r);
  183.     }
  184. }
  185.  
  186.  
  187. /**
  188.  **    get string parameter
  189.  **/
  190.  
  191. getstrpar(s, r, l, t)
  192. char    *s;
  193. char    *r;
  194. int    l;
  195. char    *t;
  196. {
  197.     register int    i;
  198.     char        format[20];
  199.     register int    f;
  200.  
  201.     if (t == 0)
  202.         t = " \t\n;";
  203.     (void)sprintf(format, "%%%d[^%s]", l, t);
  204.     while (1)
  205.     {
  206.         if ((f = testnl()) && s)
  207.             printf("%s: ", s);
  208.         if (f)
  209.             cgetc(0);
  210.         scanf("%*[\t ;]");
  211.         i = scanf(format, r);
  212.         if (i < 0)
  213.             exit(1);
  214.         if (i != 0)
  215.             return;
  216.     }
  217. }
  218.  
  219.  
  220. /**
  221.  **    test if newline is next valid character
  222.  **/
  223.  
  224. testnl()
  225. {
  226.     register char        c;
  227.  
  228.     while ((c = cgetc(0)) != '\n')
  229.         if ((c >= '0' && c <= '9') || c == '.' || c == '!' ||
  230.                 (c >= 'A' && c <= 'Z') ||
  231.                 (c >= 'a' && c <= 'z') || c == '-')
  232.         {
  233.             ungetc(c, stdin);
  234.             return(0);
  235.         }
  236.     ungetc(c, stdin);
  237.     return (1);
  238. }
  239.  
  240.  
  241. /**
  242.  **    scan for newline
  243.  **/
  244.  
  245. skiptonl(c)
  246. char    c;
  247. {
  248.     while (c != '\n')
  249.         if (!(c = cgetc(0)))
  250.             return;
  251.     ungetc('\n', stdin);
  252.     return;
  253. }
  254.  
  255.  
  256. /**
  257.  **    test for valid terminator
  258.  **/
  259.  
  260. testterm()
  261. {
  262.     register char        c;
  263.  
  264.     if (!(c = cgetc(0)))
  265.         return (1);
  266.     if (c == '.')
  267.         return (0);
  268.     if (c == '\n' || c == ';')
  269.         ungetc(c, stdin);
  270.     return (1);
  271. }
  272.  
  273.  
  274. /*
  275. **  TEST FOR SPECIFIED DELIMETER
  276. **
  277. **    The standard input is scanned for the parameter.  If found,
  278. **    it is thrown away and non-zero is returned.  If not found,
  279. **    zero is returned.
  280. */
  281.  
  282. readdelim(d)
  283. char    d;
  284. {
  285.     register char    c;
  286.  
  287.     while (c = cgetc(0))
  288.     {
  289.         if (c == d)
  290.             return (1);
  291.         if (c == ' ')
  292.             continue;
  293.         ungetc(c, stdin);
  294.         break;
  295.     }
  296.     return (0);
  297. }
  298.