home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 2 / 2272 < prev    next >
Encoding:
Internet Message Format  |  1990-12-28  |  35.2 KB
  1. From: netnews@netcom.UUCP (USENET Administration)
  2. Newsgroups: alt.sources
  3. Subject: Public Domain Korn Shell - Part.07 of 7
  4. Message-ID: <18612@netcom.UUCP>
  5. Date: 12 Dec 90 11:39:36 GMT
  6.  
  7. #!/bin/sh
  8. # This is part 07 of ksh-pd
  9. # ============= stdc/stdio.h ==============
  10. if test ! -d 'stdc'; then
  11.     echo 'x - creating directory stdc'
  12.     mkdir 'stdc'
  13. fi
  14. if test -f 'stdc/stdio.h' -a X"$1" != X"-c"; then
  15.     echo 'x - skipping stdc/stdio.h (File already exists)'
  16. else
  17. echo 'x - extracting stdc/stdio.h (Text)'
  18. sed 's/^X//' << 'SHAR_EOF' > 'stdc/stdio.h' &&
  19. X/*
  20. X * ANSI stream IO
  21. X *
  22. X * Heavily dependent on /usr/include/stdio.h being AT&T derived.
  23. X * todo: needs L_* constants.
  24. X */
  25. X
  26. X/* $Header: stdio.h,v 1.2 88/06/23 18:32:35 egisin Locked $ */
  27. X
  28. X#if ! _STDIO_H
  29. X#define    _STDIO_H 1
  30. X
  31. X#include <stddef.h>
  32. X
  33. X/* system stdio.h goes here ... %%% */
  34. X/*
  35. X * Copyright (c) 1980 Regents of the University of California.
  36. X * All rights reserved.  The Berkeley software License Agreement
  37. X * specifies the terms and conditions for redistribution.
  38. X *
  39. X *    @(#)stdio.h    5.3 (Berkeley) 3/15/86
  40. X */
  41. X
  42. X# ifndef FILE
  43. X#define    BUFSIZ    1024
  44. Xextern    struct    _iobuf {
  45. X    int    _cnt;
  46. X    char    *_ptr;        /* should be unsigned char */
  47. X    char    *_base;        /* ditto */
  48. X    int    _bufsiz;
  49. X    short    _flag;
  50. X    char    _file;        /* should be short */
  51. X} _iob[];
  52. X
  53. X#define    _IOREAD    01
  54. X#define    _IOWRT    02
  55. X#define    _IONBF    04
  56. X#define    _IOMYBUF    010
  57. X#define    _IOEOF    020
  58. X#define    _IOERR    040
  59. X#define    _IOSTRG    0100
  60. X#define    _IOLBF    0200
  61. X#define    _IORW    0400
  62. X#define    FILE    struct _iobuf
  63. X#define    EOF    (-1)
  64. X
  65. X#define    stdin    (&_iob[0])
  66. X#define    stdout    (&_iob[1])
  67. X#define    stderr    (&_iob[2])
  68. X#ifndef lint
  69. X#define    getc(p)        (--(p)->_cnt>=0? (int)(*(unsigned char *)(p)->_ptr++):_filbuf(p))
  70. X#endif /*not lint*/
  71. X#define    getchar()    getc(stdin)
  72. X#ifndef lint
  73. X#define putc(x, p)    (--(p)->_cnt >= 0 ?\
  74. X    (int)(*(unsigned char *)(p)->_ptr++ = (x)) :\
  75. X    (((p)->_flag & _IOLBF) && -(p)->_cnt < (p)->_bufsiz ?\
  76. X        ((*(p)->_ptr = (x)) != '\n' ?\
  77. X            (int)(*(unsigned char *)(p)->_ptr++) :\
  78. X            _flsbuf(*(unsigned char *)(p)->_ptr, p)) :\
  79. X        _flsbuf((unsigned char)(x), p)))
  80. X#endif /*not lint*/
  81. X#define    putchar(x)    putc(x,stdout)
  82. X#define    feof(p)        (((p)->_flag&_IOEOF)!=0)
  83. X#define    ferror(p)    (((p)->_flag&_IOERR)!=0)
  84. X#define    fileno(p)    ((p)->_file)
  85. X#define    clearerr(p)    ((p)->_flag &= ~(_IOERR|_IOEOF))
  86. X
  87. X
  88. X#ifdef lint
  89. Xextern int printf(/*FORMAT1*/);
  90. Xextern int fprintf(/*FORMAT2*/);
  91. X#endif /*lint*/
  92. X
  93. XFILE    *fopen();
  94. XFILE    *fdopen();
  95. XFILE    *freopen();
  96. XFILE    *popen();
  97. Xlong    ftell();
  98. Xchar    *fgets();
  99. Xchar    *gets();
  100. X#ifdef vax
  101. X#endif
  102. X# endif
  103. X/* ... end system stdio.h */
  104. X#line 15 "stdio.h"
  105. X
  106. X#ifndef _IOFBF
  107. X#define    _IOFBF    00000
  108. X#endif
  109. X#ifndef _IOLBF
  110. X#define    _IOLBF    00000        /* same as _IOFBF */
  111. X#endif
  112. X
  113. X#define    SEEK_SET    0
  114. X#define    SEEK_CUR    1
  115. X#define    SEEK_END    2
  116. X
  117. X#if _SYSV
  118. X#define    _EXTERN    extern
  119. X#else
  120. X#define    _EXTERN    
  121. X#endif
  122. X
  123. X_EXTERN    int    remove ARGS((const char *name));
  124. X_EXTERN    int    rename ARGS((const char *oname, const char *nname));
  125. X_EXTERN    FILE   *tmpfile ARGS((void));
  126. X_EXTERN    char   *tmpnam ARGS((char *s));
  127. X
  128. X_EXTERN    FILE   *fopen ARGS((const char *name, const char *mode));
  129. X_EXTERN    FILE   *freopen ARGS((const char *name, const char *mode, FILE *f));
  130. X_EXTERN    FILE   *fdopen ARGS((int fd, const char *mode));
  131. X_EXTERN    int    fflush ARGS((FILE *f));
  132. X_EXTERN    int    fclose ARGS((FILE *f));
  133. X_EXTERN    void    setbuf ARGS((FILE *f, char *buf));
  134. X_EXTERN    int    setvbuf ARGS((FILE *f, char *buf, int flags, size_t len));
  135. X
  136. X_EXTERN    int    fseek ARGS((FILE *f, long off, int how));
  137. X_EXTERN    long    ftell ARGS((FILE *f));
  138. X_EXTERN    void    rewind ARGS((FILE *f));
  139. X
  140. X_EXTERN    int    printf ARGS((const char *fmt, ...));
  141. X_EXTERN    int    fprintf ARGS((FILE *f, const char *fmt, ...));
  142. X_EXTERN    int    sprintf ARGS((char *s, const char *fmt, ...));
  143. X/* we do not include <stdarg.h> to prevent <varargs.h> conflicts */
  144. X_EXTERN    int    vprintf ARGS((const char *fmt, Void *va));
  145. X_EXTERN    int    vfprintf ARGS((FILE *f, const char *fmt, Void *va));
  146. X_EXTERN    int    vsprintf ARGS((char *s, const char *fmt, Void *va));
  147. X_EXTERN    int    scanf ARGS((const char *fmt, ...));
  148. X_EXTERN    int    fscanf ARGS((FILE *f, const char *fmt, ...));
  149. X_EXTERN    int    sscanf ARGS((const char *s, const char *fmt, ...));
  150. X
  151. X_EXTERN    size_t    fread ARGS((void *ptr, size_t size, size_t n, FILE *f));
  152. X_EXTERN    size_t    frwrite ARGS((const void *ptr, size_t size, size_t n, FILE *f));
  153. X_EXTERN    int    fgetc ARGS((FILE *f));
  154. X_EXTERN    int    fputc ARGS((int c, FILE *f));
  155. X_EXTERN    char   *fgets ARGS((char *s, int len, FILE *f));
  156. X_EXTERN    int    fputs ARGS((const char *s, FILE *f));
  157. X_EXTERN    char   *gets ARGS((char *s));
  158. X_EXTERN    int     puts ARGS((const char *s));
  159. X
  160. X#endif
  161. X
  162. SHAR_EOF
  163. true || echo 'restore of stdc/stdio.h failed'
  164. fi
  165. # ============= stdc/stdio.h_std ==============
  166. if test -f 'stdc/stdio.h_std' -a X"$1" != X"-c"; then
  167.     echo 'x - skipping stdc/stdio.h_std (File already exists)'
  168. else
  169. echo 'x - extracting stdc/stdio.h_std (Text)'
  170. sed 's/^X//' << 'SHAR_EOF' > 'stdc/stdio.h_std' &&
  171. X/*
  172. X * ANSI stream IO
  173. X *
  174. X * Heavily dependent on /usr/include/stdio.h being AT&T derived.
  175. X * todo: needs L_* constants.
  176. X */
  177. X
  178. X/* $Header: stdio.h,v 1.2 88/06/23 18:32:35 egisin Locked $ */
  179. X
  180. X#if ! _STDIO_H
  181. X#define    _STDIO_H 1
  182. X
  183. X#include <stddef.h>
  184. X
  185. X/* system stdio.h goes here ... %%% */
  186. X/* ... end system stdio.h */
  187. X#line 15 "stdio.h"
  188. X
  189. X#ifndef _IOFBF
  190. X#define    _IOFBF    00000
  191. X#endif
  192. X#ifndef _IOLBF
  193. X#define    _IOLBF    00000        /* same as _IOFBF */
  194. X#endif
  195. X
  196. X#define    SEEK_SET    0
  197. X#define    SEEK_CUR    1
  198. X#define    SEEK_END    2
  199. X
  200. X#if _SYSV
  201. X#define    _EXTERN    extern
  202. X#else
  203. X#define    _EXTERN    
  204. X#endif
  205. X
  206. X_EXTERN    int    remove ARGS((const char *name));
  207. X_EXTERN    int    rename ARGS((const char *oname, const char *nname));
  208. X_EXTERN    FILE   *tmpfile ARGS((void));
  209. X_EXTERN    char   *tmpnam ARGS((char *s));
  210. X
  211. X_EXTERN    FILE   *fopen ARGS((const char *name, const char *mode));
  212. X_EXTERN    FILE   *freopen ARGS((const char *name, const char *mode, FILE *f));
  213. X_EXTERN    FILE   *fdopen ARGS((int fd, const char *mode));
  214. X_EXTERN    int    fflush ARGS((FILE *f));
  215. X_EXTERN    int    fclose ARGS((FILE *f));
  216. X_EXTERN    void    setbuf ARGS((FILE *f, char *buf));
  217. X_EXTERN    int    setvbuf ARGS((FILE *f, char *buf, int flags, size_t len));
  218. X
  219. X_EXTERN    int    fseek ARGS((FILE *f, long off, int how));
  220. X_EXTERN    long    ftell ARGS((FILE *f));
  221. X_EXTERN    void    rewind ARGS((FILE *f));
  222. X
  223. X_EXTERN    int    printf ARGS((const char *fmt, ...));
  224. X_EXTERN    int    fprintf ARGS((FILE *f, const char *fmt, ...));
  225. X_EXTERN    int    sprintf ARGS((char *s, const char *fmt, ...));
  226. X/* we do not include <stdarg.h> to prevent <varargs.h> conflicts */
  227. X_EXTERN    int    vprintf ARGS((const char *fmt, Void *va));
  228. X_EXTERN    int    vfprintf ARGS((FILE *f, const char *fmt, Void *va));
  229. X_EXTERN    int    vsprintf ARGS((char *s, const char *fmt, Void *va));
  230. X_EXTERN    int    scanf ARGS((const char *fmt, ...));
  231. X_EXTERN    int    fscanf ARGS((FILE *f, const char *fmt, ...));
  232. X_EXTERN    int    sscanf ARGS((const char *s, const char *fmt, ...));
  233. X
  234. X_EXTERN    size_t    fread ARGS((void *ptr, size_t size, size_t n, FILE *f));
  235. X_EXTERN    size_t    frwrite ARGS((const void *ptr, size_t size, size_t n, FILE *f));
  236. X_EXTERN    int    fgetc ARGS((FILE *f));
  237. X_EXTERN    int    fputc ARGS((int c, FILE *f));
  238. X_EXTERN    char   *fgets ARGS((char *s, int len, FILE *f));
  239. X_EXTERN    int    fputs ARGS((const char *s, FILE *f));
  240. X_EXTERN    char   *gets ARGS((char *s));
  241. X_EXTERN    int     puts ARGS((const char *s));
  242. X
  243. X#endif
  244. X
  245. SHAR_EOF
  246. true || echo 'restore of stdc/stdio.h_std failed'
  247. fi
  248. # ============= stdc/stdlib.h ==============
  249. if test -f 'stdc/stdlib.h' -a X"$1" != X"-c"; then
  250.     echo 'x - skipping stdc/stdlib.h (File already exists)'
  251. else
  252. echo 'x - extracting stdc/stdlib.h (Text)'
  253. sed 's/^X//' << 'SHAR_EOF' > 'stdc/stdlib.h' &&
  254. X/* ANSI utility functions */
  255. X
  256. X/* $Header: stdlib.h,v 1.1 88/03/09 21:52:59 egisin Locked $ */
  257. X
  258. X#if ! _STDLIB_H
  259. X#define    _STDLIB_H 1
  260. X
  261. X#include <stddef.h>
  262. X
  263. Xdouble    atof ARGS((const char *s));
  264. Xint    atoi ARGS((const char *s));
  265. Xlong    atol ARGS((const char *s));
  266. Xdouble    strtod ARGS((const char *s, char **));
  267. Xlong    strtol ARGS((const char *s, char **, int base));
  268. Xunsigned long    strtoul ARGS((const char *s, char **, int base));
  269. Xint    rand ARGS((void));
  270. Xvoid    srand ARGS((unsigned int seed));
  271. XVoid   *malloc ARGS((size_t size));
  272. XVoid   *realloc ARGS((void *ptr, size_t size));
  273. XVoid   *calloc ARGS((size_t n, size_t size));
  274. Xvoid    free ARGS((void *ptr));
  275. Xvoid    abort ARGS((void));
  276. Xint    atexit ARGS((void (*func)(void)));
  277. Xvoid    exit ARGS((int status));
  278. Xchar   *getenv ARGS((const char *name));
  279. Xint    system ARGS((const char *cmd));
  280. Xvoid   *bsearch ARGS ((const void *key, const void *base, size_t n, size_t size,
  281. X               int (*compar)(const void *, const void *)));
  282. Xvoid   *qsort ARGS ((const void *base, size_t n, size_t size,
  283. X             int (*compar)(const void *, const void *)));
  284. X#define    abs(a)    ((a) < 0 : -(a) : (a))
  285. X
  286. X#endif
  287. X
  288. SHAR_EOF
  289. true || echo 'restore of stdc/stdlib.h failed'
  290. fi
  291. # ============= stdc/string.h ==============
  292. if test -f 'stdc/string.h' -a X"$1" != X"-c"; then
  293.     echo 'x - skipping stdc/string.h (File already exists)'
  294. else
  295. echo 'x - extracting stdc/string.h (Text)'
  296. sed 's/^X//' << 'SHAR_EOF' > 'stdc/string.h' &&
  297. X/* ANSI string handling (missing wide char stuff) */
  298. X
  299. X#if ! _STRING_H
  300. X#define _STRING_H 1
  301. X
  302. X#include <stddef.h>        /* define NULL and size_t */
  303. X
  304. X#if __STDC__
  305. X#define    ARGS(args)    args
  306. X#define    Void    void
  307. X#else
  308. X#define    ARGS(args)    ()
  309. X#define    Void    char
  310. X#endif
  311. X
  312. XVoid   *memcpy ARGS((Void *s1, const Void *s2, size_t));
  313. XVoid   *memmove ARGS((Void *s1, const Void *s2, size_t));
  314. Xint    memcmp ARGS((const Void *s1, const Void *s2, size_t));
  315. XVoid   *memchr ARGS((const Void *s, int c, size_t));
  316. XVoid   *memset ARGS((Void *s, int c, size_t));
  317. Xsize_t    strlen ARGS((const char *s));
  318. Xchar   *strcpy ARGS((char *s1, const char *s2));
  319. Xchar   *strncpy ARGS((char *s1, const char *s2, size_t));
  320. Xchar   *strcat ARGS((char *s1, const char *s2));
  321. Xchar   *strncat ARGS((char *s1, const char *s2, size_t));
  322. Xint    strcmp ARGS((const char *s1, const char *s2));
  323. Xint    strncmp ARGS((const char *s1, const char *s2, size_t));
  324. Xchar   *strchr ARGS((const char *s1, int c));
  325. Xchar   *strrchr ARGS((const char *s1, int c));
  326. Xsize_t    strspn ARGS((const char *s1, const char *s2));
  327. Xsize_t    strcspn ARGS((const char *s1, const char *s2));
  328. Xchar   *strpbrk ARGS((const char *s1, const char *s2));
  329. Xchar   *strstr ARGS((const char *s1, const char *s2));
  330. Xchar   *strtok ARGS((char *s1, const char *s2));
  331. Xchar   *strerror ARGS((int errno));
  332. X
  333. X#endif /* _STRING_H */
  334. X
  335. SHAR_EOF
  336. true || echo 'restore of stdc/string.h failed'
  337. fi
  338. # ============= stdc/strcat.c ==============
  339. if test -f 'stdc/strcat.c' -a X"$1" != X"-c"; then
  340.     echo 'x - skipping stdc/strcat.c (File already exists)'
  341. else
  342. echo 'x - extracting stdc/strcat.c (Text)'
  343. sed 's/^X//' << 'SHAR_EOF' > 'stdc/strcat.c' &&
  344. X#include <string.h>
  345. X
  346. X/*
  347. X * strcat - append string src to dst
  348. X */
  349. Xchar *                /* dst */
  350. Xstrcat(dst, src)
  351. Xchar *dst;
  352. XConst char *src;
  353. X{
  354. X    register char *dscan;
  355. X    register Const char *sscan;
  356. X
  357. X    for (dscan = dst; *dscan != '\0'; dscan++)
  358. X        continue;
  359. X    sscan = src;
  360. X    while ((*dscan++ = *sscan++) != '\0')
  361. X        continue;
  362. X    return(dst);
  363. X}
  364. SHAR_EOF
  365. true || echo 'restore of stdc/strcat.c failed'
  366. fi
  367. # ============= stdc/sprintf.c ==============
  368. if test -f 'stdc/sprintf.c' -a X"$1" != X"-c"; then
  369.     echo 'x - skipping stdc/sprintf.c (File already exists)'
  370. else
  371. echo 'x - extracting stdc/sprintf.c (Text)'
  372. sed 's/^X//' << 'SHAR_EOF' > 'stdc/sprintf.c' &&
  373. X/*
  374. X * sprintf and vsprintf
  375. X */
  376. X
  377. X/* $Header */
  378. X
  379. X#if __STDC__
  380. X#include <stdarg.h>
  381. X#else
  382. X#include <varargs.h>
  383. X#endif
  384. X#include <stdio.h>
  385. X
  386. X#if _V7 || _BSD
  387. X
  388. Xint
  389. X#if __STDC__
  390. Xsprintf(char *s, Const char *fmt, ...) {
  391. X#else
  392. Xsprintf(va_alist) va_dcl
  393. X{
  394. X    char *s;
  395. X    char *fmt;
  396. X#endif
  397. X    register va_list va;
  398. X    int n;
  399. X
  400. X#if __STDC__
  401. X    va_start(va, fmt);
  402. X#else
  403. X    va_start(va);
  404. X    s = va_arg(va, char *);
  405. X    fmt = va_arg(va, char *);
  406. X#endif
  407. X    n = vsprintf(s, fmt, va);
  408. X    va_end(va);
  409. X    return n;
  410. X}
  411. X
  412. Xint
  413. X#if __STDC__
  414. Xvsprintf(char *s, const char *fmt, va_list va) {
  415. X#else
  416. Xvsprintf(s, fmt, va)
  417. X    char *s;
  418. X    char *fmt;
  419. X    va_list va;
  420. X{
  421. X#endif
  422. X    int n;
  423. X    static FILE siob;
  424. X
  425. X    siob._flag = _IOWRT;
  426. X    siob._base = siob._ptr = s;
  427. X    siob._cnt = BUFSIZ;
  428. X    siob._file = -1;
  429. X
  430. X    n = vfprintf(&siob, fmt, va);
  431. X    *siob._ptr = 0;
  432. X    return n;
  433. X}
  434. X
  435. X#endif
  436. X
  437. SHAR_EOF
  438. true || echo 'restore of stdc/sprintf.c failed'
  439. fi
  440. # ============= stdc/time.h ==============
  441. if test -f 'stdc/time.h' -a X"$1" != X"-c"; then
  442.     echo 'x - skipping stdc/time.h (File already exists)'
  443. else
  444. echo 'x - extracting stdc/time.h (Text)'
  445. sed 's/^X//' << 'SHAR_EOF' > 'stdc/time.h' &&
  446. X/* time, time/date conversion */
  447. X
  448. X#if ! _TIME_H
  449. X#define    _TIME_H 1
  450. X
  451. X#include <stddef.h>        /* need size_t */
  452. X
  453. Xtypedef long time_t;
  454. Xtypedef long clock_t;        /* seconds/CLK_TCK */
  455. X
  456. X#if _V7 || _SYSV
  457. X#define    CLK_TCK    60        /* todo: get from <sys/param.h> */
  458. X#endif
  459. X
  460. X#if _BSD
  461. X#define    CLK_TCK    100
  462. X#endif
  463. X
  464. X#if _ST
  465. X#define    CLK_TCK    200        /* ST system clock */
  466. X#endif
  467. X
  468. Xstruct tm {
  469. X    int    tm_sec, tm_min, tm_hour;
  470. X    int    tm_mday, tm_mon, tm_year, tm_wday, tm_yday;
  471. X    int    tm_isdst;
  472. X    long    tm_gmtoff;    /* BSD */
  473. X    char   *tm_zone;    /* BSD */
  474. X};
  475. X
  476. Xclock_t    clock ARGS((void));
  477. Xtime_t    time ARGS((time_t *tp));
  478. X#define    difftime(t1, t2)    (double)((t2)-(t1))
  479. Xtime_t    mktime ARGS((struct tm *tmp));
  480. Xchar   *asctime ARGS((const struct tm *tmp));
  481. Xchar   *ctime ARGS((const time_t *tp));
  482. Xstruct tm *gmtime ARGS((const time_t *tp));
  483. Xstruct tm *localtime ARGS((const time_t *tp));
  484. Xsize_t    strftime ARGS((char *buf, size_t len, const char *fmt, const struct tm *tmp));
  485. X
  486. X#endif
  487. X
  488. SHAR_EOF
  489. true || echo 'restore of stdc/time.h failed'
  490. fi
  491. # ============= stdc/memcpy.c ==============
  492. if test -f 'stdc/memcpy.c' -a X"$1" != X"-c"; then
  493.     echo 'x - skipping stdc/memcpy.c (File already exists)'
  494. else
  495. echo 'x - extracting stdc/memcpy.c (Text)'
  496. sed 's/^X//' << 'SHAR_EOF' > 'stdc/memcpy.c' &&
  497. X/* $Header$ */
  498. X
  499. X#include <string.h>
  500. X
  501. XVoid *
  502. Xmemcpy(dap, sap, n)
  503. X    Void *dap;
  504. X    Const Void *sap;
  505. X    register size_t n;
  506. X{
  507. X    register char *dp = dap, *sp = (Void*) sap;
  508. X
  509. X    if (n++ > 0)
  510. X        while (--n > 0)
  511. X            *dp++ = *sp++;
  512. X    return dap;
  513. X}
  514. X
  515. SHAR_EOF
  516. true || echo 'restore of stdc/memcpy.c failed'
  517. fi
  518. # ============= stdc/setvbuf.c ==============
  519. if test -f 'stdc/setvbuf.c' -a X"$1" != X"-c"; then
  520.     echo 'x - skipping stdc/setvbuf.c (File already exists)'
  521. else
  522. echo 'x - extracting stdc/setvbuf.c (Text)'
  523. sed 's/^X//' << 'SHAR_EOF' > 'stdc/setvbuf.c' &&
  524. X/*
  525. X * PD ksh needs an ANSI-compatible setvbuf.
  526. X * if (buf == NULL) it must also allocate a buffer
  527. X * and arrange for fclose to deallocate it.
  528. X * the reason for doing setvbuf(f, (char *)NULL, _IOFBF, BUFSIZ)
  529. X * in the shell is to avoid 4/8K buffers on BSD like systems.
  530. X */
  531. X
  532. X/* $Header */
  533. X
  534. X#include <stdlib.h>
  535. X#include <stdio.h>
  536. X
  537. X#if _BSD || _SYSV
  538. Xint
  539. Xsetvbuf(f, buf, type, size)
  540. X    register FILE *f;
  541. X    char *buf;
  542. X    int type;
  543. X    size_t size;
  544. X{
  545. X    if ((f->_flag&_IOMYBUF) && f->_base != NULL)
  546. X        free(f->_base);
  547. X    f->_flag &= ~(_IOMYBUF|_IONBF|_IOFBF|_IOLBF);
  548. X    switch (type) {
  549. X      case _IONBF:
  550. X        size = 0;
  551. X        buf = NULL;
  552. X        break;
  553. X      case _IOLBF:
  554. X      case _IOFBF:
  555. X        if (size == 0)
  556. X            size = BUFSIZ;
  557. X#if _V7
  558. X        else if (size != BUFSIZ)
  559. X            return -1;
  560. X#endif
  561. X        if (buf == NULL) {
  562. X            buf = malloc(size);
  563. X            if (buf == NULL)
  564. X                return -1;
  565. X            f->_flag |= _IOMYBUF;
  566. X        }
  567. X        break;
  568. X      default:
  569. X        return -1;
  570. X    }
  571. X    f->_flag |= type;
  572. X    f->_base = f->_ptr = buf;
  573. X    f->_cnt = 0;
  574. X#if _BSD
  575. X    f->_bufsiz = size;
  576. X#endif
  577. X#if _SYSV
  578. X    _bufend(f) = buf + size;
  579. X#endif
  580. X    return 0;
  581. X}
  582. X#endif
  583. X
  584. SHAR_EOF
  585. true || echo 'restore of stdc/setvbuf.c failed'
  586. fi
  587. # ============= stdc/clock.c ==============
  588. if test -f 'stdc/clock.c' -a X"$1" != X"-c"; then
  589.     echo 'x - skipping stdc/clock.c (File already exists)'
  590. else
  591. echo 'x - extracting stdc/clock.c (Text)'
  592. sed 's/^X//' << 'SHAR_EOF' > 'stdc/clock.c' &&
  593. X/* clock() */
  594. X
  595. X#include <time.h>
  596. X
  597. X#if _BSD
  598. X
  599. X#include <sys/time.h>
  600. X#include <sys/resource.h>
  601. X
  602. Xclock_t
  603. Xclock()
  604. X{
  605. X    struct timeval tv;
  606. X    struct rusage ru;
  607. X
  608. X    getrusage(RUSAGE_SELF, &ru);
  609. X    tv.tv_sec = ru.ru_utime.tv_sec + ru.ru_stime.tv_sec;
  610. X    tv.tv_usec = ru.ru_utime.tv_usec + ru.ru_stime.tv_usec;
  611. X    return tv.tv_sec*CLK_TCK + (long)tv.tv_usec*CLK_TCK/1000000;
  612. X}
  613. X
  614. X#endif
  615. X
  616. X#if _V7 || _SYSV
  617. X
  618. X#include <sys/times.h>
  619. X
  620. Xclock_t
  621. Xclock()
  622. X{
  623. X    struct tms tms;
  624. X
  625. X    (void) times(&tms);
  626. X    return tms.tms_utime + tms.tms_stime;
  627. X}
  628. X
  629. X#endif
  630. X
  631. X#if _ST
  632. X
  633. X#include <osbind.h>
  634. X
  635. Xclock_t
  636. Xclock()
  637. X{
  638. X    long save;
  639. X    clock_t c;
  640. X
  641. X    /* access the ST's 200 HZ system clock in protected memory */
  642. X    save = Super(0L);
  643. X    c = *((long *)0x04BA);
  644. X    (void)Super(save);
  645. X    return c;
  646. X}
  647. X
  648. X#endif
  649. X
  650. SHAR_EOF
  651. true || echo 'restore of stdc/clock.c failed'
  652. fi
  653. # ============= stdc/types.h ==============
  654. if test -f 'stdc/types.h' -a X"$1" != X"-c"; then
  655.     echo 'x - skipping stdc/types.h (File already exists)'
  656. else
  657. echo 'x - extracting stdc/types.h (Text)'
  658. sed 's/^X//' << 'SHAR_EOF' > 'stdc/types.h' &&
  659. X/* work around multiple typedefs in stddef.h and sys/types.h */
  660. X
  661. X#include <stddef.h>        /* defines size_t and ptrdiff_t */
  662. X#include <time.h>        /* defines time_t and clock_t */
  663. X
  664. X/* "inhibit" the typedefs in sys/types.h */
  665. X#define size_t _size_t
  666. X#define    time_t _time_t
  667. X#define    clock_t _clock_t
  668. X#include "/usr/include/sys/types.h"
  669. X#undef    size_t
  670. X#undef    time_t
  671. X#undef    clock_t
  672. X
  673. SHAR_EOF
  674. true || echo 'restore of stdc/types.h failed'
  675. fi
  676. # ============= stdc/limits.h ==============
  677. if test -f 'stdc/limits.h' -a X"$1" != X"-c"; then
  678.     echo 'x - skipping stdc/limits.h (File already exists)'
  679. else
  680. echo 'x - extracting stdc/limits.h (Text)'
  681. sed 's/^X//' << 'SHAR_EOF' > 'stdc/limits.h' &&
  682. X/* Implementation-defined limits */
  683. X
  684. X#if __STDC__
  685. X#define    Signed    signed
  686. X#else
  687. X#define    Signed    
  688. X#endif
  689. X
  690. X#define    CHAR_BIT    8
  691. X
  692. X#define    _S_MIN(type)    (-(Signed type)((unsigned type) ~0 >> 1) - 1)
  693. X#define    _S_MAX(type)    ((Signed type)((unsigned type) ~0 >> 1))
  694. X
  695. X#define    UCHAR_MIN    ((unsigned char) 0)
  696. X#define    UCHAR_MAX    ((unsigned char) ~0)
  697. X#define    SCHAR_MIN    _S_MIN(char)
  698. X#define    SCHAR_MAX    _S_MAX(char)
  699. X
  700. X#define    _U_CHAR        ((char) ~0 == (unsigned char) ~0)
  701. X#define    CHAR_MIN    (_U_CHAR ? UCHAR_MIN : SCHAR_MIN)
  702. X#define    CHAR_MAX    (_U_CHAR ? UCHAR_MAX : SCHAR_MAX)
  703. X
  704. X#define    USHRT_MAX    ((unsigned short) ~0)
  705. X#define    SHRT_MIN    _S_MIN(short)
  706. X#define    SHRT_MAX    _S_MAX(short)
  707. X
  708. X#define    UINT_MAX    ((unsigned int) ~0)
  709. X#define    INT_MIN        _S_MIN(int)
  710. X#define    INT_MAX        _S_MAX(int)
  711. X
  712. X#define    ULONG_MAX    ((unsigned long) ~0)
  713. X#define    LONG_MIN    _S_MIN(long)
  714. X#define    LONG_MAX    _S_MAX(long)
  715. X
  716. SHAR_EOF
  717. true || echo 'restore of stdc/limits.h failed'
  718. fi
  719. # ============= stdc/stdarg.h ==============
  720. if test -f 'stdc/stdarg.h' -a X"$1" != X"-c"; then
  721.     echo 'x - skipping stdc/stdarg.h (File already exists)'
  722. else
  723. echo 'x - extracting stdc/stdarg.h (Text)'
  724. sed 's/^X//' << 'SHAR_EOF' > 'stdc/stdarg.h' &&
  725. X#ifndef _STDARG_H
  726. X#define _STDARG_H
  727. X
  728. Xtypedef char *va_list;
  729. X
  730. X/* Amount of space required in an argument list for an arg of type TYPE.
  731. X   TYPE may alternatively be an expression whose type is used.  */
  732. X
  733. X#define __va_rounded_size(TYPE)  \
  734. X  (((sizeof (TYPE) + sizeof (int) - 1) / sizeof (int)) * sizeof (int))
  735. X
  736. X#define va_start(AP, LASTARG)                         \
  737. X (AP = ((char *) &(LASTARG) + __va_rounded_size (LASTARG)))
  738. X
  739. Xvoid va_end (va_list);        /* Defined in gnulib */
  740. X#define va_end(AP)
  741. X
  742. X#define va_arg(AP, TYPE)                        \
  743. X (AP += __va_rounded_size (TYPE),                    \
  744. X  *((TYPE *) (AP - __va_rounded_size (TYPE))))
  745. X
  746. X#endif /* _STDARG_H */
  747. SHAR_EOF
  748. true || echo 'restore of stdc/stdarg.h failed'
  749. fi
  750. # ============= stdc/strcmp.s ==============
  751. if test -f 'stdc/strcmp.s' -a X"$1" != X"-c"; then
  752.     echo 'x - skipping stdc/strcmp.s (File already exists)'
  753. else
  754. echo 'x - extracting stdc/strcmp.s (Text)'
  755. sed 's/^X//' << 'SHAR_EOF' > 'stdc/strcmp.s' &&
  756. X#NO_APP
  757. X.text
  758. X    .even
  759. X.globl _strcmp
  760. X_strcmp:
  761. X    link a6,#0
  762. X    movel a6@(8),a1
  763. X    movel a6@(12),a0
  764. XL2:
  765. X    moveb a1@+,d0
  766. X    moveb a0@+,d1
  767. X    cmpb d0,d1
  768. X    jne L3
  769. X    tstb d0
  770. X    jne L2
  771. XL3:
  772. X    tstb d0
  773. X    jne L4
  774. X    tstb d1
  775. X    jne L4
  776. X    clrl d0
  777. X    jra L1
  778. XL4:
  779. X    tstb d0
  780. X    jne L6
  781. X    moveq #-1,d0
  782. X    jra L1
  783. XL6:
  784. X    tstb d1
  785. X    jne L8
  786. X    moveq #1,d0
  787. X    jra L1
  788. XL8:
  789. X    extbl d0
  790. X    extbl d1
  791. X    subl d1,d0
  792. XL1:
  793. X    unlk a6
  794. X    rts
  795. SHAR_EOF
  796. true || echo 'restore of stdc/strcmp.s failed'
  797. fi
  798. # ============= stdc/strcpy.s ==============
  799. if test -f 'stdc/strcpy.s' -a X"$1" != X"-c"; then
  800.     echo 'x - skipping stdc/strcpy.s (File already exists)'
  801. else
  802. echo 'x - extracting stdc/strcpy.s (Text)'
  803. sed 's/^X//' << 'SHAR_EOF' > 'stdc/strcpy.s' &&
  804. X#NO_APP
  805. X.text
  806. X    .align 1
  807. X.globl _strcpy
  808. X_strcpy:
  809. X    .word 0x0
  810. X    movl 4(ap),r3
  811. X    movl r3,r2
  812. X    movl 8(ap),r1
  813. XL3:
  814. X    movb (r1)+,r0
  815. X    movb r0,(r2)+
  816. X    jneq L3
  817. X    movl r3,r0
  818. X    ret
  819. SHAR_EOF
  820. true || echo 'restore of stdc/strcpy.s failed'
  821. fi
  822. # ============= stdc/memchr.c ==============
  823. if test -f 'stdc/memchr.c' -a X"$1" != X"-c"; then
  824.     echo 'x - skipping stdc/memchr.c (File already exists)'
  825. else
  826. echo 'x - extracting stdc/memchr.c (Text)'
  827. sed 's/^X//' << 'SHAR_EOF' > 'stdc/memchr.c' &&
  828. X/* $Header$ */
  829. X
  830. X#include <string.h>
  831. X
  832. XVoid *
  833. Xmemchr(ap, c, n)
  834. X    Const Void *ap;
  835. X    register int c;
  836. X    register size_t n;
  837. X{
  838. X    register char *p = ap;
  839. X
  840. X    if (n++ > 0)
  841. X        while (--n > 0)
  842. X            if (*p++ == c)
  843. X                return --p;
  844. X    return NULL;
  845. X}
  846. X
  847. SHAR_EOF
  848. true || echo 'restore of stdc/memchr.c failed'
  849. fi
  850. # ============= stdc/memcmp.c ==============
  851. if test -f 'stdc/memcmp.c' -a X"$1" != X"-c"; then
  852.     echo 'x - skipping stdc/memcmp.c (File already exists)'
  853. else
  854. echo 'x - extracting stdc/memcmp.c (Text)'
  855. sed 's/^X//' << 'SHAR_EOF' > 'stdc/memcmp.c' &&
  856. X/* $Header$ */
  857. X
  858. X#include <string.h>
  859. X
  860. Xint
  861. Xmemcmp(dap, sap, n)
  862. X    Const Void *dap;
  863. X    Const Void *sap;
  864. X    register size_t n;
  865. X{
  866. X    register Const unsigned char *dp = (unsigned char Const *) dap;
  867. X    register Const unsigned char *sp = (unsigned char Const *) sap;
  868. X
  869. X    if (n++ > 0)
  870. X        while (--n > 0)
  871. X            if (*dp++ != *sp++)
  872. X                return *--dp - *--sp; /* (int)? */
  873. X    return 0;
  874. X}
  875. X
  876. SHAR_EOF
  877. true || echo 'restore of stdc/memcmp.c failed'
  878. fi
  879. # ============= stdc/memmove.c ==============
  880. if test -f 'stdc/memmove.c' -a X"$1" != X"-c"; then
  881.     echo 'x - skipping stdc/memmove.c (File already exists)'
  882. else
  883. echo 'x - extracting stdc/memmove.c (Text)'
  884. sed 's/^X//' << 'SHAR_EOF' > 'stdc/memmove.c' &&
  885. X/* $Header$ */
  886. X
  887. X#include <string.h>
  888. X
  889. XVoid *
  890. Xmemmove(dap, sap, n)
  891. X    Void *dap;
  892. X    Const Void *sap;
  893. X    register size_t n;
  894. X{
  895. X    register char *dp = dap, *sp = (Void*) sap;
  896. X
  897. X    if (n <= 0)
  898. X        ;
  899. X    else if (dp < sp)
  900. X        do *dp++ = *sp++; while (--n > 0);
  901. X    else if (dp > sp) {
  902. X        dp += n;
  903. X        sp += n;
  904. X        do *--dp = *--sp; while (--n > 0);
  905. X    }
  906. X    return dap;
  907. X}
  908. X
  909. X
  910. SHAR_EOF
  911. true || echo 'restore of stdc/memmove.c failed'
  912. fi
  913. # ============= stdc/memset.c ==============
  914. if test -f 'stdc/memset.c' -a X"$1" != X"-c"; then
  915.     echo 'x - skipping stdc/memset.c (File already exists)'
  916. else
  917. echo 'x - extracting stdc/memset.c (Text)'
  918. sed 's/^X//' << 'SHAR_EOF' > 'stdc/memset.c' &&
  919. X/* $Header$ */
  920. X
  921. X#include <string.h>
  922. X
  923. XVoid *
  924. Xmemset(ap, c, n)
  925. X    Void *ap;
  926. X    register int c;
  927. X    register size_t n;
  928. X{
  929. X    register char *p = ap;
  930. X
  931. X    if (n++ > 0)
  932. X        while (--n > 0)
  933. X            *p++ = c;
  934. X    return ap;
  935. X}
  936. X
  937. SHAR_EOF
  938. true || echo 'restore of stdc/memset.c failed'
  939. fi
  940. # ============= stdc/fprintf.c ==============
  941. if test -f 'stdc/fprintf.c' -a X"$1" != X"-c"; then
  942.     echo 'x - skipping stdc/fprintf.c (File already exists)'
  943. else
  944. echo 'x - extracting stdc/fprintf.c (Text)'
  945. sed 's/^X//' << 'SHAR_EOF' > 'stdc/fprintf.c' &&
  946. X/*
  947. X * printf and fprintf
  948. X */
  949. X
  950. X/* $Header */
  951. X
  952. X#if __STDC__
  953. X#include <stdarg.h>
  954. X#else
  955. X#include <varargs.h>
  956. X#endif
  957. X#include <stdio.h>
  958. X
  959. X#if _V7 || _BSD
  960. X
  961. X/* printf to stdout */
  962. Xint
  963. X#if __STDC__
  964. Xprintf(Const char *fmt, ...) {
  965. X#else
  966. Xprintf(va_alist) va_dcl
  967. X{
  968. X    char *fmt;
  969. X#endif
  970. X    va_list va;
  971. X
  972. X#if __STDC__
  973. X    va_start(va, fmt);
  974. X#else
  975. X    va_start(va);
  976. X    fmt = va_arg(va, char *);
  977. X#endif
  978. X    vfprintf(stdout, fmt, va);
  979. X    va_end(va);
  980. X    return 0;
  981. X}
  982. X
  983. Xint
  984. X#if __STDC__
  985. Xfprintf(FILE *f, Const char *fmt, ...) {
  986. X#else
  987. Xfprintf(va_alist) va_dcl
  988. X{
  989. X    FILE *f;
  990. X    char *fmt;
  991. X#endif
  992. X    va_list va;
  993. X
  994. X#if __STDC__
  995. X    va_start(va, fmt);
  996. X#else
  997. X    va_start(va);
  998. X    f = va_arg(va, FILE *);
  999. X    fmt = va_arg(va, char *);
  1000. X#endif
  1001. X    vfprintf(f, fmt, va);
  1002. X    va_end(va);
  1003. X    return 0;
  1004. X}
  1005. X
  1006. X#endif
  1007. SHAR_EOF
  1008. true || echo 'restore of stdc/fprintf.c failed'
  1009. fi
  1010. # ============= stdc/strtok.c ==============
  1011. if test -f 'stdc/strtok.c' -a X"$1" != X"-c"; then
  1012.     echo 'x - skipping stdc/strtok.c (File already exists)'
  1013. else
  1014. echo 'x - extracting stdc/strtok.c (Text)'
  1015. sed 's/^X//' << 'SHAR_EOF' > 'stdc/strtok.c' &&
  1016. X#include <string.h>
  1017. X
  1018. X/*
  1019. X * Get next token from string s (NULL on 2nd, 3rd, etc. calls),
  1020. X * where tokens are nonempty strings separated by runs of
  1021. X * chars from delim.  Writes NULs into s to end tokens.  delim need not
  1022. X * remain constant from call to call.
  1023. X */
  1024. X
  1025. Xstatic char *scanpoint = NULL;
  1026. X
  1027. Xchar *                /* NULL if no token left */
  1028. Xstrtok(s, delim)
  1029. Xchar *s;
  1030. Xregister Const char *delim;
  1031. X{
  1032. X    register char *scan;
  1033. X    char *tok;
  1034. X    register Const char *dscan;
  1035. X
  1036. X    if (s == NULL && scanpoint == NULL)
  1037. X        return(NULL);
  1038. X    if (s != NULL)
  1039. X        scan = s;
  1040. X    else
  1041. X        scan = scanpoint;
  1042. X
  1043. X    /*
  1044. X     * Scan leading delimiters.
  1045. X     */
  1046. X    for (; *scan != '\0'; scan++) {
  1047. X        for (dscan = delim; *dscan != '\0'; dscan++)
  1048. X            if (*scan == *dscan)
  1049. X                break;
  1050. X        if (*dscan == '\0')
  1051. X            break;
  1052. X    }
  1053. X    if (*scan == '\0') {
  1054. X        scanpoint = NULL;
  1055. X        return(NULL);
  1056. X    }
  1057. X
  1058. X    tok = scan;
  1059. X
  1060. X    /*
  1061. X     * Scan token.
  1062. X     */
  1063. X    for (; *scan != '\0'; scan++) {
  1064. X        for (dscan = delim; *dscan != '\0';)    /* ++ moved down. */
  1065. X            if (*scan == *dscan++) {
  1066. X                scanpoint = scan+1;
  1067. X                *scan = '\0';
  1068. X                return(tok);
  1069. X            }
  1070. X    }
  1071. X
  1072. X    /*
  1073. X     * Reached end of string.
  1074. X     */
  1075. X    scanpoint = NULL;
  1076. X    return(tok);
  1077. X}
  1078. SHAR_EOF
  1079. true || echo 'restore of stdc/strtok.c failed'
  1080. fi
  1081. # ============= stdc/strchr.c ==============
  1082. if test -f 'stdc/strchr.c' -a X"$1" != X"-c"; then
  1083.     echo 'x - skipping stdc/strchr.c (File already exists)'
  1084. else
  1085. echo 'x - extracting stdc/strchr.c (Text)'
  1086. sed 's/^X//' << 'SHAR_EOF' > 'stdc/strchr.c' &&
  1087. X#include <string.h>
  1088. X
  1089. X/*
  1090. X * strchr - find first occurrence of a character in a string
  1091. X */
  1092. X
  1093. Xchar *                /* found char, or NULL if none */
  1094. Xstrchr(s, charwanted)
  1095. XConst char *s;
  1096. Xregister char charwanted;
  1097. X{
  1098. X    register Const char *scan;
  1099. X
  1100. X    /*
  1101. X     * The odd placement of the two tests is so NUL is findable.
  1102. X     */
  1103. X    for (scan = s; *scan != charwanted;)    /* ++ moved down for opt. */
  1104. X        if (*scan++ == '\0')
  1105. X            return(NULL);
  1106. X    return(scan);
  1107. X}
  1108. SHAR_EOF
  1109. true || echo 'restore of stdc/strchr.c failed'
  1110. fi
  1111. # ============= stdc/strcmp.c ==============
  1112. if test -f 'stdc/strcmp.c' -a X"$1" != X"-c"; then
  1113.     echo 'x - skipping stdc/strcmp.c (File already exists)'
  1114. else
  1115. echo 'x - extracting stdc/strcmp.c (Text)'
  1116. sed 's/^X//' << 'SHAR_EOF' > 'stdc/strcmp.c' &&
  1117. X#include <string.h>
  1118. X
  1119. X/* Modified by Eric Gisin */
  1120. X
  1121. X/*
  1122. X * strcmp - compare string s1 to s2
  1123. X */
  1124. X
  1125. Xint                /* <0 for <, 0 for ==, >0 for > */
  1126. Xstrcmp(s1, s2)
  1127. XConst char *s1;
  1128. XConst char *s2;
  1129. X{
  1130. X    register Const char *scan1;
  1131. X    register Const char *scan2;
  1132. X#if 0                /* some machines prefer int to char */
  1133. X    register int c1, c2;
  1134. X#else
  1135. X    register char c1, c2;
  1136. X#endif
  1137. X
  1138. X    scan1 = s1;
  1139. X    scan2 = s2;
  1140. X    while ((c1 = *scan1++) == (c2 = *scan2++) && c1 != 0)
  1141. X        ;
  1142. X
  1143. X    /*
  1144. X     * The following case analysis is necessary so that characters
  1145. X     * which look negative collate low against normal characters but
  1146. X     * high against the end-of-string NUL.
  1147. X     */
  1148. X    if (c1 == '\0' && c2 == '\0')
  1149. X        return(0);
  1150. X    else if (c1 == '\0')
  1151. X        return(-1);
  1152. X    else if (c2 == '\0')
  1153. X        return(1);
  1154. X    else
  1155. X        return(c1 - c2);
  1156. X}
  1157. SHAR_EOF
  1158. true || echo 'restore of stdc/strcmp.c failed'
  1159. fi
  1160. # ============= stdc/strcpy.c ==============
  1161. if test -f 'stdc/strcpy.c' -a X"$1" != X"-c"; then
  1162.     echo 'x - skipping stdc/strcpy.c (File already exists)'
  1163. else
  1164. echo 'x - extracting stdc/strcpy.c (Text)'
  1165. sed 's/^X//' << 'SHAR_EOF' > 'stdc/strcpy.c' &&
  1166. X#include <string.h>
  1167. X
  1168. X/*
  1169. X * strcpy - copy string src to dst
  1170. X */
  1171. Xchar *                /* dst */
  1172. Xstrcpy(dst, src)
  1173. Xchar *dst;
  1174. XConst char *src;
  1175. X{
  1176. X    register char *dscan;
  1177. X    register Const char *sscan;
  1178. X
  1179. X    dscan = dst;
  1180. X    sscan = src;
  1181. X    while ((*dscan++ = *sscan++) != '\0')
  1182. X        continue;
  1183. X    return(dst);
  1184. X}
  1185. SHAR_EOF
  1186. true || echo 'restore of stdc/strcpy.c failed'
  1187. fi
  1188. # ============= stdc/strcspn.c ==============
  1189. if test -f 'stdc/strcspn.c' -a X"$1" != X"-c"; then
  1190.     echo 'x - skipping stdc/strcspn.c (File already exists)'
  1191. else
  1192. echo 'x - extracting stdc/strcspn.c (Text)'
  1193. sed 's/^X//' << 'SHAR_EOF' > 'stdc/strcspn.c' &&
  1194. X#include <string.h>
  1195. X
  1196. X/*
  1197. X * strcspn - find length of initial segment of s consisting entirely
  1198. X * of characters not from reject
  1199. X */
  1200. X
  1201. Xsize_t
  1202. Xstrcspn(s, reject)
  1203. XConst char *s;
  1204. XConst char *reject;
  1205. X{
  1206. X    register Const char *scan;
  1207. X    register Const char *rscan;
  1208. X    register size_t count;
  1209. X
  1210. X    count = 0;
  1211. X    for (scan = s; *scan != '\0'; scan++) {
  1212. X        for (rscan = reject; *rscan != '\0';)    /* ++ moved down. */
  1213. X            if (*scan == *rscan++)
  1214. X                return(count);
  1215. X        count++;
  1216. X    }
  1217. X    return(count);
  1218. X}
  1219. SHAR_EOF
  1220. true || echo 'restore of stdc/strcspn.c failed'
  1221. fi
  1222. # ============= stdc/strerror.c ==============
  1223. if test -f 'stdc/strerror.c' -a X"$1" != X"-c"; then
  1224.     echo 'x - skipping stdc/strerror.c (File already exists)'
  1225. else
  1226. echo 'x - extracting stdc/strerror.c (Text)'
  1227. sed 's/^X//' << 'SHAR_EOF' > 'stdc/strerror.c' &&
  1228. X#include <string.h>
  1229. X
  1230. X/*
  1231. X * strerror - map error number to descriptive string
  1232. X *
  1233. X * This version is obviously somewhat Unix-specific.
  1234. X */
  1235. Xchar *
  1236. Xstrerror(errno)
  1237. Xint errno;
  1238. X{
  1239. X    extern int sys_nerr;
  1240. X    extern char *sys_errlist[];
  1241. X
  1242. X    if (errno > 0 && errno < sys_nerr)
  1243. X        return(sys_errlist[errno]);
  1244. X    else
  1245. X        return("unknown error");
  1246. X}
  1247. SHAR_EOF
  1248. true || echo 'restore of stdc/strerror.c failed'
  1249. fi
  1250. # ============= stdc/strlen.c ==============
  1251. if test -f 'stdc/strlen.c' -a X"$1" != X"-c"; then
  1252.     echo 'x - skipping stdc/strlen.c (File already exists)'
  1253. else
  1254. echo 'x - extracting stdc/strlen.c (Text)'
  1255. sed 's/^X//' << 'SHAR_EOF' > 'stdc/strlen.c' &&
  1256. X#include <string.h>
  1257. X
  1258. X/*
  1259. X * strlen - length of string (not including NUL)
  1260. X */
  1261. Xsize_t
  1262. Xstrlen(s)
  1263. XConst char *s;
  1264. X{
  1265. X    register Const char *scan;
  1266. X    register size_t count;
  1267. X
  1268. X    count = 0;
  1269. X    scan = s;
  1270. X    while (*scan++ != '\0')
  1271. X        count++;
  1272. X    return(count);
  1273. X}
  1274. SHAR_EOF
  1275. true || echo 'restore of stdc/strlen.c failed'
  1276. fi
  1277. # ============= stdc/strncat.c ==============
  1278. if test -f 'stdc/strncat.c' -a X"$1" != X"-c"; then
  1279.     echo 'x - skipping stdc/strncat.c (File already exists)'
  1280. else
  1281. echo 'x - extracting stdc/strncat.c (Text)'
  1282. sed 's/^X//' << 'SHAR_EOF' > 'stdc/strncat.c' &&
  1283. X#include <string.h>
  1284. X
  1285. X/*
  1286. X * strncat - append at most n characters of string src to dst
  1287. X */
  1288. Xchar *                /* dst */
  1289. Xstrncat(dst, src, n)
  1290. Xchar *dst;
  1291. XConst char *src;
  1292. Xsize_t n;
  1293. X{
  1294. X    register char *dscan;
  1295. X    register Const char *sscan;
  1296. X    register size_t count;
  1297. X
  1298. X    for (dscan = dst; *dscan != '\0'; dscan++)
  1299. X        continue;
  1300. X    sscan = src;
  1301. X    count = n;
  1302. X    while (*sscan != '\0' && --count >= 0)
  1303. X        *dscan++ = *sscan++;
  1304. X    *dscan++ = '\0';
  1305. X    return(dst);
  1306. X}
  1307. SHAR_EOF
  1308. true || echo 'restore of stdc/strncat.c failed'
  1309. fi
  1310. # ============= stdc/strncmp.c ==============
  1311. if test -f 'stdc/strncmp.c' -a X"$1" != X"-c"; then
  1312.     echo 'x - skipping stdc/strncmp.c (File already exists)'
  1313. else
  1314. echo 'x - extracting stdc/strncmp.c (Text)'
  1315. sed 's/^X//' << 'SHAR_EOF' > 'stdc/strncmp.c' &&
  1316. X#include <string.h>
  1317. X
  1318. X/*
  1319. X * strncmp - compare at most n characters of string s1 to s2
  1320. X */
  1321. X
  1322. Xint                /* <0 for <, 0 for ==, >0 for > */
  1323. Xstrncmp(s1, s2, n)
  1324. XConst char *s1;
  1325. XConst char *s2;
  1326. Xsize_t n;
  1327. X{
  1328. X    register Const char *scan1;
  1329. X    register Const char *scan2;
  1330. X    register size_t count;
  1331. X
  1332. X    scan1 = s1;
  1333. X    scan2 = s2;
  1334. X    count = n;
  1335. X    while (--count >= 0 && *scan1 != '\0' && *scan1 == *scan2) {
  1336. X        scan1++;
  1337. X        scan2++;
  1338. X    }
  1339. X    if (count < 0)
  1340. X        return(0);
  1341. X
  1342. X    /*
  1343. X     * The following case analysis is necessary so that characters
  1344. X     * which look negative collate low against normal characters but
  1345. X     * high against the end-of-string NUL.
  1346. X     */
  1347. X    if (*scan1 == '\0' && *scan2 == '\0')
  1348. X        return(0);
  1349. X    else if (*scan1 == '\0')
  1350. X        return(-1);
  1351. X    else if (*scan2 == '\0')
  1352. X        return(1);
  1353. X    else
  1354. X        return(*scan1 - *scan2);
  1355. X}
  1356. SHAR_EOF
  1357. true || echo 'restore of stdc/strncmp.c failed'
  1358. fi
  1359. # ============= stdc/strncpy.c ==============
  1360. if test -f 'stdc/strncpy.c' -a X"$1" != X"-c"; then
  1361.     echo 'x - skipping stdc/strncpy.c (File already exists)'
  1362. else
  1363. echo 'x - extracting stdc/strncpy.c (Text)'
  1364. sed 's/^X//' << 'SHAR_EOF' > 'stdc/strncpy.c' &&
  1365. X#include <string.h>
  1366. X
  1367. X/*
  1368. X * strncpy - copy at most n characters of string src to dst
  1369. X */
  1370. Xchar *                /* dst */
  1371. Xstrncpy(dst, src, n)
  1372. Xchar *dst;
  1373. XConst char *src;
  1374. Xsize_t n;
  1375. X{
  1376. X    register char *dscan;
  1377. X    register Const char *sscan;
  1378. X    register size_t count;
  1379. X
  1380. X    dscan = dst;
  1381. X    sscan = src;
  1382. X    count = n;
  1383. X    while (--count >= 0 && (*dscan++ = *sscan++) != '\0')
  1384. X        continue;
  1385. X    while (--count >= 0)
  1386. X        *dscan++ = '\0';
  1387. X    return(dst);
  1388. X}
  1389. SHAR_EOF
  1390. true || echo 'restore of stdc/strncpy.c failed'
  1391. fi
  1392. # ============= stdc/strpbrk.c ==============
  1393. if test -f 'stdc/strpbrk.c' -a X"$1" != X"-c"; then
  1394.     echo 'x - skipping stdc/strpbrk.c (File already exists)'
  1395. else
  1396. echo 'x - extracting stdc/strpbrk.c (Text)'
  1397. sed 's/^X//' << 'SHAR_EOF' > 'stdc/strpbrk.c' &&
  1398. X#include <string.h>
  1399. X
  1400. X/*
  1401. X * strpbrk - find first occurrence of any char from breakat in s
  1402. X */
  1403. X
  1404. Xchar *                /* found char, or NULL if none */
  1405. Xstrpbrk(s, breakat)
  1406. XConst char *s;
  1407. XConst char *breakat;
  1408. X{
  1409. X    register Const char *sscan;
  1410. X    register Const char *bscan;
  1411. X
  1412. X    for (sscan = s; *sscan != '\0'; sscan++) {
  1413. X        for (bscan = breakat; *bscan != '\0';)    /* ++ moved down. */
  1414. X            if (*sscan == *bscan++)
  1415. X                return(sscan);
  1416. X    }
  1417. X    return(NULL);
  1418. X}
  1419. SHAR_EOF
  1420. true || echo 'restore of stdc/strpbrk.c failed'
  1421. fi
  1422. # ============= stdc/strrchr.c ==============
  1423. if test -f 'stdc/strrchr.c' -a X"$1" != X"-c"; then
  1424.     echo 'x - skipping stdc/strrchr.c (File already exists)'
  1425. else
  1426. echo 'x - extracting stdc/strrchr.c (Text)'
  1427. sed 's/^X//' << 'SHAR_EOF' > 'stdc/strrchr.c' &&
  1428. X#include <string.h>
  1429. X
  1430. X/*
  1431. X * strrchr - find last occurrence of a character in a string
  1432. X */
  1433. X
  1434. Xchar *                /* found char, or NULL if none */
  1435. Xstrrchr(s, charwanted)
  1436. XConst char *s;
  1437. Xregister char charwanted;
  1438. X{
  1439. X    register Const char *scan;
  1440. X    register Const char *place;
  1441. X
  1442. X    place = NULL;
  1443. X    for (scan = s; *scan != '\0'; scan++)
  1444. X        if (*scan == charwanted)
  1445. X            place = scan;
  1446. X    if (charwanted == '\0')
  1447. X        return(scan);
  1448. X    return(place);
  1449. X}
  1450. SHAR_EOF
  1451. true || echo 'restore of stdc/strrchr.c failed'
  1452. fi
  1453. # ============= stdc/strspn.c ==============
  1454. if test -f 'stdc/strspn.c' -a X"$1" != X"-c"; then
  1455.     echo 'x - skipping stdc/strspn.c (File already exists)'
  1456. else
  1457. echo 'x - extracting stdc/strspn.c (Text)'
  1458. sed 's/^X//' << 'SHAR_EOF' > 'stdc/strspn.c' &&
  1459. X#include <string.h>
  1460. X
  1461. X/*
  1462. X * strspn - find length of initial segment of s consisting entirely
  1463. X * of characters from accept
  1464. X */
  1465. X
  1466. Xsize_t
  1467. Xstrspn(s, accept)
  1468. XConst char *s;
  1469. XConst char *accept;
  1470. X{
  1471. X    register Const char *sscan;
  1472. X    register Const char *ascan;
  1473. X    register size_t count;
  1474. X
  1475. X    count = 0;
  1476. X    for (sscan = s; *sscan != '\0'; sscan++) {
  1477. X        for (ascan = accept; *ascan != '\0'; ascan++)
  1478. X            if (*sscan == *ascan)
  1479. X                break;
  1480. X        if (*ascan == '\0')
  1481. X            return(count);
  1482. X        count++;
  1483. X    }
  1484. X    return(count);
  1485. X}
  1486. SHAR_EOF
  1487. true || echo 'restore of stdc/strspn.c failed'
  1488. fi
  1489. # ============= stdc/strstr.c ==============
  1490. if test -f 'stdc/strstr.c' -a X"$1" != X"-c"; then
  1491.     echo 'x - skipping stdc/strstr.c (File already exists)'
  1492. else
  1493. echo 'x - extracting stdc/strstr.c (Text)'
  1494. sed 's/^X//' << 'SHAR_EOF' > 'stdc/strstr.c' &&
  1495. X#include <string.h>
  1496. X
  1497. X/*
  1498. X * strstr - find first occurrence of wanted in s
  1499. X */
  1500. X
  1501. Xchar *                /* found string, or NULL if none */
  1502. Xstrstr(s, wanted)
  1503. XConst char *s;
  1504. XConst char *wanted;
  1505. X{
  1506. X    register Const char *scan;
  1507. X    register size_t len;
  1508. X    register char firstc;
  1509. X
  1510. X    /*
  1511. X     * The odd placement of the two tests is so "" is findable.
  1512. X     * Also, we inline the first char for speed.
  1513. X     * The ++ on scan has been moved down for optimization.
  1514. X     */
  1515. X    firstc = *wanted;
  1516. X    len = strlen(wanted);
  1517. X    for (scan = s; *scan != firstc || strncmp(scan, wanted, len) != 0; )
  1518. X        if (*scan++ == '\0')
  1519. X            return(NULL);
  1520. X    return(scan);
  1521. X}
  1522. SHAR_EOF
  1523. true || echo 'restore of stdc/strstr.c failed'
  1524. fi
  1525. exit 0
  1526.