home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / std_unix / mod.std.unix.v3 / text0032.txt < prev    next >
Encoding:
Internet Message Format  |  1987-06-30  |  7.5 KB
  1. Date: Fri, 22 Nov 85 04:15:24 est
  2. From: seismo!hadron!jsdy (Joseph S. D. Yao)
  3.  
  4. One person suggested that having separate <limits.h> and
  5. /etc/limits files might lead to inconsistency.  True.  But
  6. it was a deliberate (and, i apologise, unspoken) design
  7. decision that reading limits.h implied knowing too much
  8. about the machine -- such as how long are longs, what byte
  9. order are ints vs longs vs ... (not to mention floats,
  10. which I completely ignore below, and which I shouldn't!),
  11. and so forth.  Reading a separate file gives me the freedom
  12. to read an n-ary list of ints, formatted God Alone knows
  13. how, which I can convert at my leisure to whatever I want.
  14.  
  15. Nevertheless, we aim to please, and I made the minor mods
  16. to limits.c to make limits2.c, designed to read a single
  17. int or long int from a define line.  As I said, I completely
  18. ignored floats, which in a working program is unforgivable.
  19. But the person who wants to read in floats may send me
  20. (readable!) code to do so PORTABLY.
  21.  
  22. The following is a compressed context diff.
  23.  
  24. *** limits.c    Sat Nov 16 15:08:15 1985
  25. --- limits2.c    Fri Nov 22 00:00:00 1985
  26. ***************
  27. *** 66,73
  28.   **    void endlimits()
  29. ! **    static int getnum(str)
  30.   **
  31.   ** Declared:
  32. ! **    static char limfile[] = "/etc/limits"
  33. ! **    static char *curlimfile = limfile
  34. ! **    static FILE *limf = (FILE *) NULL
  35.   **
  36. --- 66,75 -----
  37.   **    void endlimits()
  38. ! **    static int getnum(str, buf, n)
  39. ! **    static int getnbits()
  40.   **
  41.   ** Declared:
  42. ! **    static char defn[]    = "#define"
  43. ! **    static char limfile[]    = "/etc/limits"
  44. ! **    static char *curlimfile    = limfile
  45. ! **    static FILE *limf    = (FILE *) NULL
  46.   **
  47. ***************
  48. *** 136,138
  49.   #define NL    '\n'
  50. ! #define COMMENT    '#'
  51.   #define COMMA    ','
  52. --- 138,141 -----
  53.   #define NL    '\n'
  54. ! #define COMM1    '/'
  55. ! #define COMM2    '*'
  56.   #define COMMA    ','
  57. ***************
  58. *** 141,145
  59.   
  60. ! static char limfile[] = "/etc/limits";
  61. ! static char *curlimfile = limfile;
  62.   
  63. ! static FILE *limf = (FILE *) NULL;
  64.   
  65. --- 144,158 -----
  66.   
  67. + #ifdef    EBUG
  68. + #define WDPLG    2
  69. + #  else
  70. + #define WDPLG    (sizeof(long int)/sizeof(int))
  71. + #endif    EBUG
  72. + 
  73. + typedef char byte;    /* Very small signed value */
  74. + 
  75. + static char defn[]    = "#define";
  76. ! static char limfile[]    = "/etc/limits";
  77. ! static char *curlimfile    = limfile;
  78.   
  79. ! static FILE *limf    = (FILE *) NULL;
  80.   
  81. ***************
  82. *** 200,201
  83.       register int n;
  84.       bool been_here;
  85. --- 212,214 -----
  86.       register int n;
  87. +     register int defnlen = strlen(defn);
  88.       bool been_here;
  89. ***************
  90. *** 204,205
  91.       off_t current;
  92.       extern char *index();
  93. --- 213,219 -----
  94.       off_t current;
  95. +     int getnum();
  96.       extern char *index();
  97. ***************
  98. *** 225,240
  99.               if (new_line &&
  100. !                 /* and not a comment line */
  101. !                 *cp != COMMENT &&
  102. !                 /* and not a continuation line */
  103. !                 !isspace(*cp) &&
  104. !                 /* and the limit name is first */
  105. !                 strneq(cp, name, n) &&
  106. !                 /* followed by white space */
  107. !                 isspace(cp[n]))
  108. !                 break;    /* go handle it. */
  109.   
  110.               /* Check whether a NL terminated the read. */
  111. --- 243,259 -----
  112.               if (new_line &&
  113. !                 /* and starts with "#define" */
  114. !                 strneq(cp, defn, defnlen)) {
  115.   
  116. +                 /* Skip over defn */
  117. +                 cp += defnlen;
  118. +                 while (isspace(*cp))
  119. +                     ++cp;
  120. + 
  121. +                 /* If the limit name is first */
  122. +                 if (strneq(cp, name, n) &&
  123. +                     /* followed by white space */
  124. +                     isspace(cp[n]))
  125. +                     break;    /* go handle it. */
  126. +             }
  127. + 
  128.               /* Check whether a NL terminated the read. */
  129. ***************
  130. *** 269,334
  131.       cp += n + 1;
  132. -     n = 0;
  133. -     /* Check whether a NL terminated the read. */
  134. -     new_line = (index(cp, NL) != (char *) NULL);
  135.   
  136.       /*
  137. !     ** Our value may be preceded by whitespace, and is ended
  138. !     ** by a comma or whitespace or comment or EOL.
  139.       */
  140.       for ever {
  141. !         /* Skip any initial white space. */
  142. !         while (isspace(*cp))
  143.               ++cp;
  144. ! 
  145. !         /* Check whether line is done. */
  146. !         if (*cp == COMMENT || *cp == NUL) {
  147. !             /* Save current position */
  148. !             current = ftell(limf);
  149. !             /* Get new line. */
  150. !             cp = fgets(inbuf, sizeof(inbuf), limf);
  151. !             /* If EOF, do it over again at loc 0. */
  152. !             if (cp == (char *) NULL) {
  153. !                 (void) fseek(limf, (off_t) 0L, 0);
  154. !                 current = (off_t) 0L;
  155. !                 cp = fgets(inbuf, sizeof(inbuf), limf);
  156. !                 /* There has to be data here. */
  157. !                 if (cp == (char *) NULL) {
  158. !                     /* "never happen" */
  159. !                     break;
  160. !                 }
  161. !             }
  162. ! 
  163. !             /*
  164. !             ** If new line is start of line but no white
  165. !             ** space, go back to start of line and return.
  166. !             */
  167. !             if (!new_line || !isspace(*cp)) {
  168. !                 (void) fseek(limf, current, 0);
  169. !                 break;
  170. !             }
  171. ! 
  172. !             /* Check whether a NL terminated the read. */
  173. !             new_line = (index(cp, NL) != (char *) NULL);
  174. ! 
  175. !             continue;
  176. !         }
  177. ! 
  178. !         /* If it can fit, store the present value. */
  179. !         if (n < length)
  180. !             buf[n] = getnum(cp);
  181. ! 
  182. !         /* Count another value. */
  183. !         ++n;
  184. ! 
  185. !         /*
  186. !         ** We want to break but not skip on space, COMMENT, and
  187. !         ** NUL.  We want to skip and break on COMMA.  We want
  188. !         ** just to skip over everything else.
  189. !         */
  190. !         while (!isspace(*cp) && *cp != COMMENT && *cp != NUL &&
  191. !                *cp++ != COMMA);
  192.       }
  193.   
  194. !     /* Return the number of values found. */
  195. !     return(n);
  196.   }
  197. --- 288,312 -----
  198.       cp += n + 1;
  199.   
  200.       /*
  201. !     ** Our value may be preceded by whitespace, or a comment.
  202.       */
  203.       for ever {
  204. !         if (isspace(*cp))
  205.               ++cp;
  206. !           else if (*cp == COMM1 && cp[1] == COMM2) {
  207. !             cp += 2;
  208. !             while (*cp != NUL) {
  209. !                 if (*cp++ != COMM2)
  210. !                     continue;
  211. !                 if (*cp == COMM1) {
  212. !                     ++cp;
  213. !                     break;
  214. !                 }
  215. !             }
  216. !         } else
  217. !             break;
  218.       }
  219.   
  220. !     /* Return the size (number of ints) of values found. */
  221. !     return(getnum(cp, buf, length));
  222.   }
  223. ***************
  224. *** 351,361
  225.   ** used because it doesn't allow different bases, and for the
  226. ! ** sake of consistency.
  227.   */
  228. ! static int getnum(str)
  229. !   register char *str;
  230.   {
  231.       register int base = 10;
  232. !     register int i = 0, digit;
  233. !     register int sign = 1;
  234.   
  235.       while (isspace(*str) || *str == PLUS || *str == MINUS) {
  236. --- 329,351 -----
  237.   ** used because it doesn't allow different bases, and for the
  238. ! ** sake of consistency.  Postfix 'L' or 'l' indicates long.
  239. ! **
  240. ! ** As long as we're reading in only one (variably sized) value,
  241. ! ** we'll also take on the task of storing it.
  242.   */
  243. ! static int getnum(str, buf, n)
  244. !   register char *str;        /* String containing number */
  245. !   int *buf;            /* Address of int storage array */
  246. !   int n;            /* Length of storage array */
  247.   {
  248.       register int base = 10;
  249. !     register int j, digit;
  250. !     register long int i = 0;
  251. !     byte sign = 1;
  252. !     bool is_long = FALSE; 
  253. !     static int nbits = 0;
  254.   
  255. +     /* If no room to store, don't bother. */
  256. +     if (n <= 0)
  257. +         return(0);
  258. + 
  259.       while (isspace(*str) || *str == PLUS || *str == MINUS) {
  260. ***************
  261. *** 430,432
  262.               break;
  263.   
  264.             default:    break;
  265. --- 420,427 -----
  266.               break;
  267.   
  268. +           case 'L':    /* Not a digit -- "long" indicator. */
  269. +           case 'l':
  270. +             is_long = TRUE;
  271. +             break;
  272. + 
  273.             default:    break;
  274. ***************
  275. *** 442,445
  276.       if (sign < 0)
  277. !         return(-i);
  278. !     return(i);
  279.   }
  280. --- 433,470 -----
  281.       if (sign < 0)
  282. !         i = -i;
  283. ! 
  284. !     buf[0] = i;
  285. ! 
  286. !     if (!is_long)        /* Value wasn't really long. */
  287. !         return(1);
  288. ! 
  289. !     if (nbits == 0)        /* Figure out #bits/int */
  290. !         nbits = getnbits();
  291. ! 
  292. !     if (n > WDPLG)        /* Return only long, at most. */
  293. !         n = WDPLG;
  294. ! 
  295. !     for (j = 1; j < n; j++) {
  296. !         i >>= nbits;
  297. !         *++buf = i;
  298. !     }
  299. ! 
  300. !     return(n);
  301. ! }
  302. ! 
  303. ! static int getnbits()
  304. ! {
  305. !     register int i, n;
  306. ! 
  307. ! #ifdef    EBUG
  308. !     return(16);
  309. ! #endif    EBUG
  310. !     n = 0;
  311. !     for (i = 1; i != 0; i <<= 1)
  312. !         ++n;
  313. !     return(n);
  314.   }
  315.  
  316.     Joe Yao        hadron!jsdy@seismo.{CSS.GOV,ARPA,UUCP}
  317.  
  318. Volume-Number: Volume 3, Number 34
  319.  
  320.