home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Interactive Guide / c-cplusplus-interactive-guide.iso / c_ref / csource3 / 121_01 / local.c < prev    next >
Encoding:
C/C++ Source or Header  |  1985-08-21  |  11.9 KB  |  524 lines
  1. /*
  2. HEADER: CUG 121.??;
  3.  
  4.     TITLE:    local - misc functions used on this disk;
  5.     VERSION:    1.0;
  6.     DATE:    12/01/85;
  7.     DESCRIPTION: "This file contains functions used by call.c, if.c, tel.c
  8.         and tl370.c.  The following functions are included:
  9.         abort(), barf(), sign(), stacktop(), strncat(), strncmp(),
  10.         strncpy(), strlower(), strupper(), strindex(), index(),
  11.         findline(), getdph(), extract(), mputs(), mputc(), moready(),
  12.         mgetc(), miready(), hayesput(), hayesget(), globarg(),
  13.         posarg()";
  14.     KEYWORDS:    functions;
  15.     SYSTEM:    CP/M;
  16.     FILENAME:    LOCAL.C;
  17.     WARNINGS:    "This file contains some functions that are not used by
  18.         anything on this disk, but may be of general interest or use.";
  19.     AUTHORS:    Mike W. Meyer, Steve Kenton;
  20.     COMPILERS:    BDS-C 1.50;
  21. */
  22. /*
  23.  * local.c - the local library of C functions for BDS C.
  24.  *    copyright (c) 1981, Mike Meyer
  25.  *    parts copyright (c) 1982, Steve Kenton
  26.  *        modified stylewise to fit my conventions - mwm
  27.  *
  28.  *    modified by rfb (Dec '85) -
  29.  *        changed modem i/o to use v1.50 #defines, added mgetc()
  30.  *        changed stacktop() to use topofmem()
  31.  *        modified style & made it consistent throughout (apologies to
  32.  *        anyone offended)
  33.  *        added #include for v1.50 hardware values
  34.  */
  35.  
  36. #include <bdscio.h>
  37. #include <hardware.h>
  38. #include "local.h"
  39.  
  40. /*
  41.  * barf - exit with a non-zero value, possible printing a message
  42.  */
  43. barf(chuck)
  44. char *chuck;
  45. {
  46.     abort(chuck);
  47. }
  48.  
  49. /*
  50.  * abort - the real body of barf, used by the squeamish.
  51.  */
  52. abort(charles)
  53. char *charles;
  54. {
  55.     if (charles)
  56.         puts(charles);
  57.     exit(1);
  58. }
  59.  
  60. /*
  61.  * sign - return 0, 1, -1 depending on the sign of x
  62.  */
  63. int sign(x)
  64. {
  65.     return (x > 0) - (x < 0);
  66. }
  67.  
  68. /*
  69.  * stacktop - just returns address of the top of the stack.
  70.  *    uses v1.50 function topofmem()
  71.  */
  72. char *stacktop()
  73. {
  74.     return topofmem();
  75. }
  76.  
  77. /*
  78.  *    strncpy - copy a substring up to N characters long
  79.  */
  80. strncpy(str1, str2, n)
  81. char *str1, *str2;
  82. unsigned n;
  83. {
  84.     while (n-- && *str2)
  85.         *str1++ = *str2++;
  86.     *str1 = NULL;
  87. }
  88.  
  89. /*
  90.  * strncat - cat a substring of up to N characters
  91.  */
  92. strncat(str1, str2, n)
  93. char *str1, *str2;
  94. unsigned n;
  95. {
  96.     while (*str1++)
  97.         ;
  98.     strncpy(str1 - 1, str2, n);
  99. }
  100.  
  101. /*
  102.  *    strncmp - compare a substring up to N characters long
  103.  */
  104. int strncmp(str1, str2, n)
  105. char *str1, *str2;
  106. unsigned n;
  107. {
  108. int i;
  109.     while (n--)
  110.         if (!*str1 && !*str2)
  111.             break;
  112.         else if (i = *str2++ - *str1++)
  113.             return(i);
  114.     return(0);
  115. }
  116.  
  117. /*
  118.  * strlower - map a string to lower case
  119.  */
  120. char *strlower(string)
  121. char *string;
  122. {
  123. char *x;
  124.  
  125.     x = string;
  126.     do
  127.         *x = tolower(*x);
  128.     while (*++x);
  129.     return string;
  130. }
  131.  
  132. /*
  133.  * strupper - map a string to upper case
  134.  */
  135. char *strupper(string)
  136. char *string;
  137. {
  138. char *x;
  139.  
  140.     x = string;
  141.     do
  142.         *x = toupper(*x);
  143.     while (*++x);
  144.     return string;
  145. }
  146.  
  147. /*
  148.  *    strindex - return the index of substr in str or error
  149.  */
  150. unsigned strindex(str, substr)
  151. char *str, *substr;
  152. {
  153. int i, len, limit;
  154. char save, *savloc;    /* not needed if using strncmp */
  155.  
  156.     len = strlen(substr);
  157.     limit = strlen(str) - len + 1;
  158.     for (i = 0; i < limit; i++) {
  159.         savloc = str + len;
  160.         save = *savloc;        /* so save the current value */
  161.         *savloc = '\0';        /* and then terminate the substring */
  162.         if (strcmp(str, substr) == 0) {
  163.             *savloc = save;    /* restore the saved character */
  164.             return(i);    /* and return the index */
  165.         }
  166.         *savloc = save;        /* restore the saved character */
  167.         str++;    /* otherwise, increment the start address and repeat */
  168.     }
  169.     return(ERROR);            /* not found, so return ERROR */
  170. }
  171.  
  172. /*
  173.  *    index - return the index of the first occurrence of C
  174.  *    in str or error if it is not found
  175.  */
  176. unsigned index(str, c)
  177. char *str, c;
  178. {
  179. int i;
  180.  
  181.     for (i = 0; *str; i++)
  182.         if (*str++ == c)
  183.             return(i);    /* found it */
  184.     return(ERROR);            /* did not find it */
  185. }
  186.  
  187. /*
  188.  * findline - this routine takes a BDS C file open for formatted I/O,
  189.  *    a buffer buf, and a string.  It returns, in buf, the first line
  190.  *    in the file that matches the string, up to either a tab, a space,
  191.  *    or a semicolon in the line from the file.
  192.  */
  193. int findline(file, line, pat)
  194. char *file, *line, *pat;
  195. {
  196. char *lp, *pp;
  197.  
  198.     while (fgets(line, file))
  199.         for (lp = line, pp = pat; ; pp++, lp++)
  200.             if (!*pp && index("\t :", *lp) != ERROR)
  201.                 return TRUE;
  202.             else if (*pp != *lp || !*pp)
  203.                 break;
  204.     return FALSE;
  205. }
  206.  
  207. /*
  208.  *    getdph - return the address of a disk parameter header
  209.  *    or error if the drive is out of the range 0-15
  210.  *    To guarentee the drive is configured, it is selected first
  211.  *    This is performed by bios call 9, but the Bios() function
  212.  *    can not be used, because it returns in <A> not <HL>
  213.  *    After the header is located, the default drive is reselected
  214.  */
  215. dph *getdph(drive)
  216. int drive;
  217. {
  218. unsigned *warmstart, seldsk, result;
  219. char current;
  220.  
  221.     current = bdos(GETCURRENT, 0);    /* save the current drive */
  222.     warmstart = 1;
  223.     seldsk = *warmstart + 24;    /* address of SELDSK routine */
  224.     if ((result = call(seldsk, 0, 0, drive, 0)) == 0)
  225.         return(ERROR);        /* invalid drive */
  226.     bios(SELDSK,current);        /* restore the original disk */
  227.     return(result);
  228. }
  229.  
  230. /*
  231.  *    extract - build a name string from an dir/fcb entry
  232.  *    and place it in name.  Return the user/drive number
  233.  */
  234. char extract(entry, name)
  235. dir *entry;
  236. char *name;
  237. {
  238. int i,n;
  239.  
  240.     n = 0;
  241.     for (i = 0; (i < 8) && ((name[n] = entry -> dir_name[i]) != ' '); i++)
  242.         n++;
  243.     name[n++] = '.';
  244.     for (i = 0; (i < 3) && ((name[n] = entry -> dir_type[i]) != ' '); i++)
  245.         n++;
  246.     name[n] = '\0';
  247.     return(entry -> dir_user);
  248. }
  249.  
  250. /*
  251.  * mputs - output the given string on the modem port
  252.  */
  253. mputs(string)
  254. char *string;
  255. {
  256.     while (*string)
  257.         mputc(*string++);
  258. }
  259.  
  260. /*
  261.  * mputc - output the given character on the modem port
  262.  */
  263. mputc(byte)
  264. char byte;
  265. {
  266.     while (!moready())
  267.         ;
  268.     MOD_TDATA(byte);
  269. }
  270.  
  271. /*
  272.  * moready - is the modem ready to have a character go to it?
  273.  */
  274. int moready()
  275. {
  276.     return MOD_TBE;
  277. }
  278.  
  279. /*
  280.  * mgetc - input a character from the modem port
  281.  */
  282. char mgetc()
  283. {
  284.     while (!miready())
  285.         ;
  286.     return MOD_RDATA;
  287. }
  288.  
  289. /*
  290.  * miready - is the modem ready to give me a character?
  291.  */
  292. int miready()
  293. {
  294.     return MOD_RDA;
  295. }
  296.  
  297. /*
  298.  * hayesput - output a command string to the hayes, and check the result
  299.  */
  300. char hayesput(string)
  301. char *string;
  302. {
  303.     mputs(string);
  304.     return hayesget();
  305. }
  306.  
  307. /*
  308.  * hayesget - get a result byte from the hayes smartmodem
  309.  */
  310. char hayesget()
  311. {
  312.     while (!miready())
  313.         ;
  314.     return mgetc();
  315. }
  316.  
  317. /*
  318.  *    PARSE - last modified [18 FEB 82]
  319.  *    General argument parsing routines for ARGC, and ARGV
  320.  *    Globarg and Posarg are available to the user. All other
  321.  *    routines are for internal use.  There are no externals.
  322.  */
  323.  
  324. /*
  325.  *    GLOBARG - parse and assign global flags to variables
  326.  *    return FALSE if there were errors in any of the arguments.
  327.  *    Fmt is a format string similar to the one used by printf
  328.  *    except a mandatory prefix and optional suffix can be specified.
  329.  *    The types supported are boolean, char, string, and number.
  330.  *    A default is required for each flag, and follows it in
  331.  *    the format string delimited by a colon.  The following is
  332.  *    an example for two flag, one boolean, and one numeric
  333.  *
  334.  *    ..."s|ymbols%b:false c|opies%n:1",&symbol,&copies...
  335.  */
  336. int globarg(argc,argv,formats,args)
  337. int argc;
  338. char *argv[],*formats[],args;
  339. {
  340. int i,flag,**results;
  341.  
  342.     results = &args;
  343.     argv[0] = 1;    /* argv[0] must be MANUALLY parsed beforehand */
  344.     if (_verify(formats,results) == ERROR)
  345.         return(FALSE);
  346.     while ((i = argv[0]) < argc) {
  347.         if ((flag = _parse(argc,argv,formats,results,TRUE)) == ERROR)
  348.             return(FALSE);
  349.         else if (!flag)
  350.             _incr(argc,argv);
  351.     }
  352.     argv[0] = 0;    /* signal first time to POSARG */
  353.     return(TRUE);
  354. }
  355.  
  356. /*
  357.  *    POSARG - parse and assign positional flags to variables
  358.  *    return a pointer to the next positional paramters, EOF,
  359.  *    or FALSE if there is an error parsing one of the arguments.
  360.  *    The formats and arguments are identical to those for GLOBARG
  361.  */
  362. int posarg(argc,argv,formats,args)
  363. int argc;
  364. char *argv[],*formats[],args;
  365. {
  366. int i,flag,**results;
  367.  
  368.     results = &args;
  369.     if ((!argv[0]) && (_verify(formats,results) == ERROR))
  370.         return(FALSE);
  371.     _incr(argc,argv);    /* dump the last positional parameter */
  372.     while ((i = argv[0]) < argc) {
  373.         if ((flag = _parse(argc,argv,formats,results,FALSE)) == ERROR)
  374.             return(FALSE);
  375.         else if (!flag)
  376.             return(argv[i]);
  377.     }
  378.     return(EOF);
  379. }
  380.  
  381. /*
  382.  *    _PARSE - an internal routine to parse the flags
  383.  *    argv[0] contains the current argument index to use.
  384.  *    Return TRUE or FALSE depending on the _match, and
  385.  *    ERROR if a required argument is missing or invalid.
  386.  *    Oneonly is a flag indicating arguments must be unique
  387.  */
  388. int _parse(argc,argv,formats,results,oneonly)
  389. int argc,*results[],oneonly;
  390. char *argv[],*formats[];
  391. {
  392. int i,pos;
  393. char *str;
  394.  
  395.     if (!formats)    /* no format array specified */
  396.         return(FALSE);
  397.     pos = argv[0];
  398.     if (*argv[pos] == '-')
  399.         for (i=0; str=formats[i]; i++) {
  400.             if (_match(str,argv[pos])) {
  401.                 argv[pos++] = NULL;    /* remove it from processing */
  402.                 _incr(argc,argv);
  403.                 switch (str[index(str,'%')+1]) {
  404.                 case 'B':    /* convert to boolean */
  405.                     *results[i] = !(*results[i]);
  406.                     break;
  407.                 case 'C':    /* convert to character */
  408.                     poke(results[i],*argv[pos]);
  409.                     argv[pos++] = NULL;
  410.                     _incr(argc,argv);
  411.                     break;
  412.                 case 'N':    /* convert to numeric */
  413.                     *results[i] = atoi(argv[pos]);
  414.                     argv[pos++] = NULL;
  415.                     _incr(argc,argv);
  416.                     break;
  417.                 case 'S':    /* convert to string */
  418.                     strcpy(results[i],argv[pos]);
  419.                     argv[pos++] = NULL;
  420.                     _incr(argc,argv);
  421.                     break;
  422.                 default:
  423.                     puts("This cannot happen #1\n");
  424.                     return(ERROR);
  425.                 }
  426.             if (oneonly)    /* check for duplicated arguments */
  427.                 while (pos < argc) {
  428.                     if (_match(str,argv[pos])) {
  429.                         printf("Unique argument '%s' duplicated\n",argv[pos]);
  430.                         return(ERROR);
  431.                     }
  432.                     pos++;
  433.                 }
  434.             return(TRUE);
  435.             }
  436.         }
  437.     return(FALSE);
  438. }
  439.  
  440. /*
  441.  *    _VERIFY - verify the format strings and assign defaults
  442.  *    return OK, or ERROR depending whether errors were detected
  443.  */
  444. int _verify(formats,results)
  445. char *formats[];
  446. int *results[];
  447. {
  448. int i,valid,percent,bar,colon;
  449. char *str;
  450.  
  451.     if (!formats)    /* no format array specified */
  452.         return(OK);
  453.     valid = OK;
  454.     for (i=0; str=formats[i]; i++) {
  455.         strupper(str);    /* fold to caps for the command line */
  456.          percent = index(str,'%');
  457.         bar = index(str,'|');
  458.         colon = index(str,':');
  459.         if ((bar == 0) || (percent <= 0) || (colon <= 0)
  460.         || (colon < percent) || (index("BCNS",str[percent+1]) == ERROR)) {
  461.             printf("Argument parser format error on '%s'\n",str);
  462.             valid = ERROR;
  463.         }
  464.         switch(str[percent+1]) {
  465.         case 'B':    /* Boolean flag */
  466.             if (str[colon+1] == 'T')
  467.                 *results[i] = TRUE;
  468.             else    *results[i] = FALSE;
  469.             break;
  470.         case 'C':    /* Character flag */
  471.             poke(results[i],str[colon+1]);
  472.             break;
  473.         case 'S':    /* String flag */
  474.             strcpy(results[i],&str[colon+1]);
  475.             break;
  476.         case 'N':    /* Numeric flag */
  477.             *results[i] = atoi(&str[colon+1]);
  478.             break;
  479.         default:
  480.             puts("This cannot happen #2\n");
  481.             valid = ERROR;
  482.         }
  483.     }
  484.     return(valid);
  485. }
  486.  
  487. /*
  488.  *    _MATCH - pattern _match the argument flag prefix/suffix
  489.  *    and return TRUE or FALSE depending on the result.
  490.  *    If more than the required prefix is specified, then the
  491.  *    WHOLE string must _match both the prefix and suffix.
  492.  */
  493. int _match(pattern,string)
  494. char *pattern,*string;
  495. {
  496. int i;
  497.  
  498.     string++;
  499.     if ((i = index(pattern,'|')) == ERROR)
  500.         i = index(pattern,'%');
  501.     if (!strncmp(string,pattern,i))
  502.         return(TRUE);
  503.     return(FALSE);
  504. }
  505.  
  506. /*
  507.  *    _INCR - increment the argument index in argv[0]
  508.  *    skipping any previously parsed entries (set to NULL)
  509.  */
  510. _incr(argc,argv)
  511. int argc;
  512. char *argv[];
  513. {
  514. int i;
  515.  
  516.     for (i=argv[0]+1; i<argc; i++) {
  517.         if (argv[i]) {
  518.             argv[0] = i;
  519.             return;
  520.         }
  521.     }
  522.     argv[0] = argc;
  523. }
  524.