开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 操作系统开发 > 查看源码
LIB.T
资源名称：minix.instalation.cd-rom-2.0.rar　[点击查看]
上传用户：jnzhq888
上传日期：2007-01-18
资源大小：51694k
文件大小：969k
源码类别：

操作系统开发

开发平台：

WINDOWS

LIB.T：源码内容
  1. 47848                 default:
  2. 47849                         /* not recognized, like %q */
  3. 47850                         return conv || (ic != EOF) ? done : EOF;
  4. 47851                         break;
  5. 47852                 case 'n':
  6. 47853                         if (!(flags & FL_NOASSIGN)) {   /* silly, though */
  7. 47854                                 if (flags & FL_SHORT)
  8. 47855                                         *va_arg(ap, short *) = (short) nrchars;
  9. 47856                                 else if (flags & FL_LONG)
  10. 47857                                         *va_arg(ap, long *) = (long) nrchars;
  11. 47858                                 else
  12. 47859                                         *va_arg(ap, int *) = (int) nrchars;
  13. 47860                         }
  14. 47861                         break;
  15. 47862                 case 'p':               /* pointer */
  16. 47863                         set_pointer(flags);
  17. 47864                         /* fallthrough */
  18. 47865                 case 'b':               /* binary */
  19. 47866                 case 'd':               /* decimal */
  20. 47867                 case 'i':               /* general integer */
  21. 47868                 case 'o':               /* octal */
  22. 47869                 case 'u':               /* unsigned */
  23. 47870                 case 'x':               /* hexadecimal */
  24. 47871                 case 'X':               /* ditto */
  25. 47872                         if (!(flags & FL_WIDTHSPEC) || width > NUMLEN)
  26. 47873                                 width = NUMLEN;
  27. 47874                         if (!width) return done;
  28. .Op 439 src/lib/stdio/doscan.c
  29. 47875
  30. 47876                         str = o_collect(ic, stream, kind, width, &base);
  31. 47877                         if (str < inp_buf
  32. 47878                             || (str == inp_buf
  33. 47879                                     && (*str == '-'
  34. 47880                                         || *str == '+'))) return done;
  35. 47881
  36. 47882                         /*
  37. 47883                          * Although the length of the number is str-inp_buf+1
  38. 47884                          * we don't add the 1 since we counted it already
  39. 47885                          */
  40. 47886                         nrchars += str - inp_buf;
  41. 47887
  42. 47888                         if (!(flags & FL_NOASSIGN)) {
  43. 47889                                 if (kind == 'd' || kind == 'i')
  44. 47890                                     val = strtol(inp_buf, &tmp_string, base);
  45. 47891                                 else
  46. 47892                                     val = strtoul(inp_buf, &tmp_string, base);
  47. 47893                                 if (flags & FL_LONG)
  48. 47894                                         *va_arg(ap, unsigned long *) = (unsigned long) val;
  49. 47895                                 else if (flags & FL_SHORT)
  50. 47896                                         *va_arg(ap, unsigned short *) = (unsigned short) val;
  51. 47897                                 else
  52. 47898                                         *va_arg(ap, unsigned *) = (unsigned) val;
  53. 47899                         }
  54. 47900                         break;
  55. 47901                 case 'c':
  56. 47902                         if (!(flags & FL_WIDTHSPEC))
  57. 47903                                 width = 1;
  58. 47904                         if (!(flags & FL_NOASSIGN))
  59. 47905                                 str = va_arg(ap, char *);
  60. 47906                         if (!width) return done;
  61. 47907
  62. 47908                         while (width && ic != EOF) {
  63. 47909                                 if (!(flags & FL_NOASSIGN))
  64. 47910                                         *str++ = (char) ic;
  65. 47911                                 if (--width) {
  66. 47912                                         ic = getc(stream);
  67. 47913                                         nrchars++;
  68. 47914                                 }
  69. 47915                         }
  70. 47916
  71. 47917                         if (width) {
  72. 47918                                 if (ic != EOF) ungetc(ic,stream);
  73. 47919                                 nrchars--;
  74. 47920                         }
  75. 47921                         break;
  76. 47922                 case 's':
  77. 47923                         if (!(flags & FL_WIDTHSPEC))
  78. 47924                                 width = 0xffff;
  79. 47925                         if (!(flags & FL_NOASSIGN))
  80. 47926                                 str = va_arg(ap, char *);
  81. 47927                         if (!width) return done;
  82. 47928
  83. 47929                         while (width && ic != EOF && !isspace(ic)) {
  84. 47930                                 if (!(flags & FL_NOASSIGN))
  85. 47931                                         *str++ = (char) ic;
  86. 47932                                 if (--width) {
  87. 47933                                         ic = getc(stream);
  88. 47934                                         nrchars++;
  89. .Ep 440 src/lib/stdio/doscan.c
  90. 47935                                 }
  91. 47936                         }
  92. 47937                         /* terminate the string */
  93. 47938                         if (!(flags & FL_NOASSIGN))
  94. 47939                                 *str = '';    
  95. 47940                         if (width) {
  96. 47941                                 if (ic != EOF) ungetc(ic,stream);
  97. 47942                                 nrchars--;
  98. 47943                         }
  99. 47944                         break;
  100. 47945                 case '[':
  101. 47946                         if (!(flags & FL_WIDTHSPEC))
  102. 47947                                 width = 0xffff;
  103. 47948                         if (!width) return done;
  104. 47949
  105. 47950                         if ( *++format == '^' ) {
  106. 47951                                 reverse = 1;
  107. 47952                                 format++;
  108. 47953                         } else
  109. 47954                                 reverse = 0;
  110. 47955
  111. 47956                         for (str = Xtable; str < &Xtable[NR_CHARS]
  112. 47957                                                         ; str++)
  113. 47958                                 *str = 0;
  114. 47959
  115. 47960                         if (*format == ']') Xtable[*format++] = 1;
  116. 47961
  117. 47962                         while (*format && *format != ']') {
  118. 47963                                 Xtable[*format++] = 1;
  119. 47964                                 if (*format == '-') {
  120. 47965                                         format++;
  121. 47966                                         if (*format
  122. 47967                                             && *format != ']'
  123. 47968                                             && *(format) >= *(format -2)) {
  124. 47969                                                 int c;
  125. 47970
  126. 47971                                                 for( c = *(format -2) + 1
  127. 47972                                                     ; c <= *format ; c++)
  128. 47973                                                         Xtable[c] = 1;
  129. 47974                                                 format++;
  130. 47975                                         }
  131. 47976                                         else Xtable['-'] = 1;
  132. 47977                                 }
  133. 47978                         }
  134. 47979                         if (!*format) return done;
  135. 47980                         
  136. 47981                         if (!(Xtable[ic] ^ reverse)) return done;
  137. 47982
  138. 47983                         if (!(flags & FL_NOASSIGN))
  139. 47984                                 str = va_arg(ap, char *);
  140. 47985
  141. 47986                         do {
  142. 47987                                 if (!(flags & FL_NOASSIGN))
  143. 47988                                         *str++ = (char) ic;
  144. 47989                                 if (--width) {
  145. 47990                                         ic = getc(stream);
  146. 47991                                         nrchars++;
  147. 47992                                 }
  148. 47993                         } while (width && ic != EOF && (Xtable[ic] ^ reverse));
  149. 47994
  150. .Op 441 src/lib/stdio/doscan.c
  151. 47995                         if (width) {
  152. 47996                                 if (ic != EOF) ungetc(ic, stream);
  153. 47997                                 nrchars--;
  154. 47998                         }
  155. 47999                         if (!(flags & FL_NOASSIGN)) {   /* terminate string */
  156. 48000                                 *str = '';    
  157. 48001                         }
  158. 48002                         break;
  159. 48003 #ifndef NOFLOAT
  160. 48004                 case 'e':
  161. 48005                 case 'E':
  162. 48006                 case 'f':
  163. 48007                 case 'g':
  164. 48008                 case 'G':
  165. 48009                         if (!(flags & FL_WIDTHSPEC) || width > NUMLEN)
  166. 48010                                 width = NUMLEN;
  167. 48011
  168. 48012                         if (!width) return done;
  169. 48013                         str = f_collect(ic, stream, width);
  170. 48014
  171. 48015                         if (str < inp_buf
  172. 48016                             || (str == inp_buf
  173. 48017                                 && (*str == '-'
  174. 48018                                     || *str == '+'))) return done;
  175. 48019
  176. 48020                         /*
  177. 48021                          * Although the length of the number is str-inp_buf+1
  178. 48022                          * we don't add the 1 since we counted it already
  179. 48023                          */
  180. 48024                         nrchars += str - inp_buf;
  181. 48025
  182. 48026                         if (!(flags & FL_NOASSIGN)) {
  183. 48027                                 ld_val = strtod(inp_buf, &tmp_string);
  184. 48028                                 if (flags & FL_LONGDOUBLE)
  185. 48029                                         *va_arg(ap, long double *) = (long double) ld_val;
  186. 48030                                 else
  187. 48031                                     if (flags & FL_LONG)
  188. 48032                                         *va_arg(ap, double *) = (double) ld_val;
  189. 48033                                 else
  190. 48034                                         *va_arg(ap, float *) = (float) ld_val;
  191. 48035                         }
  192. 48036                         break;
  193. 48037 #endif
  194. 48038                 }               /* end switch */
  195. 48039                 conv++;
  196. 48040                 if (!(flags & FL_NOASSIGN) && kind != 'n') done++;
  197. 48041                 format++;
  198. 48042         }
  199. 48043         return conv || (ic != EOF) ? done : EOF;
  200. 48044 }
  201. .Ep 442 src/lib/stdio/ecvt.c
  203. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  204. src/lib/stdio/ecvt.c    
  205. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  207. 48100 /* $Header: ecvt.c,v 1.4 90/02/27 16:47:28 eck Exp $ */
  208. 48101
  209. 48102 #ifndef NOFLOAT
  210. 48103
  211. 48104 #include        "../ansi/ext_fmt.h"
  212. 48105 void _dbl_ext_cvt(double value, struct EXTEND *e);
  213. 48106 char *_ext_str_cvt(struct EXTEND *e, int ndigit, int *decpt, int * sign, int ecvtflag);
  214. 48107
  215. 48108 static char *
  216. 48109 cvt(long double value, int ndigit, int *decpt, int *sign, int ecvtflag)
  217. 48110 {
  218. 48111         struct EXTEND e;
  219. 48112
  220. 48113         _dbl_ext_cvt(value, &e);
  221. 48114         return _ext_str_cvt(&e, ndigit, decpt, sign, ecvtflag);
  222. 48115 }
  224. 48117 char *
  225. 48118 _ecvt(long double value, int ndigit, int *decpt, int *sign)
  226. 48119 {
  227. 48120
  228. 48121         return cvt(value, ndigit, decpt, sign, 1);
  229. 48122 }
  231. 48124 char *
  232. 48125 _fcvt(long double value, int ndigit, int *decpt, int *sign)
  233. 48126 {
  234. 48127         return cvt(value, ndigit, decpt, sign, 0);
  235. 48128 }
  237. 48130 #endif  /* NOFLOAT */
  243. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  244. src/lib/stdio/fclose.c    
  245. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  247. 48200 /*
  248. 48201  * fclose.c - flush a stream and close the file
  249. 48202  */
  250. 48203 /* $Header: fclose.c,v 1.4 90/01/22 11:10:54 eck Exp $ */
  251. 48204
  252. 48205 #include        <stdio.h>
  253. 48206 #include        <stdlib.h>
  254. 48207 #include        "loc_incl.h"
  255. 48208
  256. 48209 int _close(int d);
  257. 48210
  258. 48211 int
  259. 48212 fclose(FILE *fp)
  260. 48213 {
  261. 48214         register int i, retval = 0;
  262. .Op 443 src/lib/stdio/fclose.c
  263. 48215
  264. 48216         for (i=0; i<FOPEN_MAX; i++)
  265. 48217                 if (fp == __iotab[i]) {
  266. 48218                         __iotab[i] = 0;
  267. 48219                         break;
  268. 48220                 }
  269. 48221         if (i >= FOPEN_MAX)
  270. 48222                 return EOF;
  271. 48223         if (fflush(fp)) retval = EOF;
  272. 48224         if (_close(fileno(fp))) retval = EOF;
  273. 48225         if ( io_testflag(fp,_IOMYBUF) && fp->_buf )
  274. 48226                 free((void *)fp->_buf);
  275. 48227         if (fp != stdin && fp != stdout && fp != stderr)
  276. 48228                 free((void *)fp);
  277. 48229         return retval;
  278. 48230 }
  284. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  285. src/lib/stdio/feof.c    
  286. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  288. 48300 /*
  289. 48301  * feof.c - test if eof on a stream occurred
  290. 48302  */
  291. 48303 /* $Header: feof.c,v 1.2 89/12/18 15:00:39 eck Exp $ */
  292. 48304
  293. 48305 #include        <stdio.h>
  294. 48306
  295. 48307 int
  296. 48308 (feof)(FILE *stream)
  297. 48309 {
  298. 48310         return feof(stream);
  299. 48311 }
  304. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  305. src/lib/stdio/ferror.c    
  306. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  308. 48400 /*
  309. 48401  * ferror .c - test if an error on a stream occurred
  310. 48402  */
  311. 48403 /* $Header: ferror.c,v 1.2 89/12/18 15:00:47 eck Exp $ */
  312. 48404
  313. 48405 #include        <stdio.h>
  314. 48406
  315. 48407 int
  316. 48408 (ferror)(FILE *stream)
  317. 48409 {
  318. 48410         return ferror(stream);
  319. 48411 }
  320. .Ep 444 src/lib/stdio/fflush.c
  322. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  323. src/lib/stdio/fflush.c    
  324. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  326. 48500 /*
  327. 48501  * fflush.c - flush stream(s)
  328. 48502  */
  329. 48503 /* $Header: fflush.c,v 1.6 90/04/04 15:52:01 eck Exp $ */
  330. 48504
  331. 48505 #include        <sys/types.h>
  332. 48506 #include        <stdio.h>
  333. 48507 #include        "loc_incl.h"
  334. 48508
  335. 48509 ssize_t _write(int d, const char *buf, size_t nbytes);
  336. 48510 off_t _lseek(int fildes, off_t offset, int whence);
  337. 48511
  338. 48512 int
  339. 48513 fflush(FILE *stream)
  340. 48514 {
  341. 48515         int count, c1, i, retval = 0;
  342. 48516
  343. 48517         if (!stream) {
  344. 48518             for(i= 0; i < FOPEN_MAX; i++)
  345. 48519                 if (__iotab[i] && fflush(__iotab[i]))
  346. 48520                         retval = EOF;
  347. 48521             return retval;
  348. 48522         }
  349. 48523
  350. 48524         if (!stream->_buf
  351. 48525             || (!io_testflag(stream, _IOREADING)
  352. 48526                 && !io_testflag(stream, _IOWRITING)))
  353. 48527                 return 0;
  354. 48528         if (io_testflag(stream, _IOREADING)) {
  355. 48529                 /* (void) fseek(stream, 0L, SEEK_CUR); */
  356. 48530                 int adjust = 0;
  357. 48531                 if (stream->_buf && !io_testflag(stream,_IONBF))
  358. 48532                         adjust = stream->_count;
  359. 48533                 stream->_count = 0;
  360. 48534                 _lseek(fileno(stream), (off_t) adjust, SEEK_CUR);
  361. 48535                 if (io_testflag(stream, _IOWRITE))
  362. 48536                         stream->_flags &= ~(_IOREADING | _IOWRITING);
  363. 48537                 stream->_ptr = stream->_buf;
  364. 48538                 return 0;
  365. 48539         } else if (io_testflag(stream, _IONBF)) return 0;
  366. 48540
  367. 48541         if (io_testflag(stream, _IOREAD))               /* "a" or "+" mode */
  368. 48542                 stream->_flags &= ~_IOWRITING;
  369. 48543
  370. 48544         count = stream->_ptr - stream->_buf;
  371. 48545         stream->_ptr = stream->_buf;
  372. 48546
  373. 48547         if ( count <= 0 )
  374. 48548                 return 0;
  375. 48549
  376. 48550         if (io_testflag(stream, _IOAPPEND)) {
  377. 48551                 if (_lseek(fileno(stream), 0L, SEEK_END) == -1) {
  378. 48552                         stream->_flags |= _IOERR;
  379. 48553                         return EOF;
  380. 48554                 }
  381. .Op 445 src/lib/stdio/fflush.c
  382. 48555         }
  383. 48556         c1 = _write(stream->_fd, (char *)stream->_buf, count);
  384. 48557
  385. 48558         stream->_count = 0;
  386. 48559
  387. 48560         if ( count == c1 )
  388. 48561                 return 0;
  389. 48562
  390. 48563         stream->_flags |= _IOERR;
  391. 48564         return EOF; 
  392. 48565 }
  394. 48567 void
  395. 48568 __cleanup(void)
  396. 48569 {
  397. 48570         register int i;
  398. 48571
  399. 48572         for(i= 0; i < FOPEN_MAX; i++)
  400. 48573                 if (__iotab[i] && io_testflag(__iotab[i], _IOWRITING))
  401. 48574                         (void) fflush(__iotab[i]);
  402. 48575 }
  408. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  409. src/lib/stdio/fgetc.c    
  410. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  412. 48600 /*
  413. 48601  * fgetc - get an unsigned character and return it as an int
  414. 48602  */
  415. 48603 /* $Header: fgetc.c,v 1.1 89/05/30 13:27:35 eck Exp $ */
  416. 48604
  417. 48605 #include        <stdio.h>
  418. 48606
  419. 48607 int
  420. 48608 fgetc(FILE *stream)
  421. 48609 {
  422. 48610         return getc(stream);
  423. 48611 }
  428. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  429. src/lib/stdio/fgetpos.c    
  430. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  432. 48700 /*
  433. 48701  * fgetpos.c - get the position in the file
  434. 48702  */
  435. 48703 /* $Header: fgetpos.c,v 1.2 89/12/18 15:01:03 eck Exp $ */
  436. 48704
  437. 48705 #include        <stdio.h>
  438. 48706
  439. 48707 int
  440. 48708 fgetpos(FILE *stream, fpos_t *pos)
  441. 48709 {
  442. .Ep 446 src/lib/stdio/fgetpos.c
  443. 48710         *pos = ftell(stream);
  444. 48711         if (*pos == -1) return -1;
  445. 48712         return 0;
  446. 48713 }
  449. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  450. src/lib/stdio/fgets.c    
  451. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  453. 48800 /*
  454. 48801  * fgets.c - get a string from a file
  455. 48802  */
  456. 48803 /* $Header: fgets.c,v 1.3 89/12/18 15:01:11 eck Exp $ */
  457. 48804
  458. 48805 #include        <stdio.h>
  459. 48806
  460. 48807 char *
  461. 48808 fgets(char *s, register int n, register FILE *stream)
  462. 48809 {
  463. 48810         register int ch;
  464. 48811         register char *ptr;
  465. 48812
  466. 48813         ptr = s;
  467. 48814         while (--n > 0 && (ch = getc(stream)) != EOF) {
  468. 48815                 *ptr++ = ch;
  469. 48816                 if ( ch == 'n')
  470. 48817                         break;
  471. 48818         }
  472. 48819         if (ch == EOF) {
  473. 48820                 if (feof(stream)) {
  474. 48821                         if (ptr == s) return NULL;
  475. 48822                 } else return NULL;
  476. 48823         }
  477. 48824         *ptr = '';
  478. 48825         return s;
  479. 48826 }
  484. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  485. src/lib/stdio/fileno.c    
  486. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  488. 48900 /*
  489. 48901  * fileno .c - map a stream to a file descriptor
  490. 48902  */
  491. 48903 /* $Header: fileno.c,v 1.1 89/12/18 14:59:31 eck Exp $ */
  492. 48904
  493. 48905 #include        <stdio.h>
  494. 48906
  495. 48907 int
  496. 48908 (fileno)(FILE *stream)
  497. 48909 {
  498. 48910         return stream->_fd;
  499. 48911 }
  500. .Op 447 src/lib/stdio/fillbuf.c
  502. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  503. src/lib/stdio/fillbuf.c    
  504. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  506. 49000 /*
  507. 49001  * fillbuf.c - fill a buffer
  508. 49002  */
  509. 49003 /* $Header: fillbuf.c,v 1.5 90/06/21 11:13:23 eck Exp $ */
  510. 49004
  511. 49005 #if     defined(_POSIX_SOURCE)
  512. 49006 #include        <sys/types.h>
  513. 49007 #endif
  514. 49008 #include        <stdio.h>
  515. 49009 #include        <stdlib.h>
  516. 49010 #include        "loc_incl.h"
  517. 49011
  518. 49012 ssize_t _read(ssize_t d, char *buf, size_t nbytes);
  519. 49013
  520. 49014 int
  521. 49015 __fillbuf(register FILE *stream)
  522. 49016 {
  523. 49017         static unsigned char ch[FOPEN_MAX];
  524. 49018         register int i;
  525. 49019
  526. 49020         stream->_count = 0;
  527. 49021         if (fileno(stream) < 0) return EOF;
  528. 49022         if (io_testflag(stream, (_IOEOF | _IOERR ))) return EOF; 
  529. 49023         if (!io_testflag(stream, _IOREAD))
  530. 49024              { stream->_flags |= _IOERR; return EOF; }
  531. 49025         if (io_testflag(stream, _IOWRITING))
  532. 49026              { stream->_flags |= _IOERR; return EOF; }
  533. 49027
  534. 49028         if (!io_testflag(stream, _IOREADING))
  535. 49029                 stream->_flags |= _IOREADING;
  536. 49030         
  537. 49031         if (!io_testflag(stream, _IONBF) && !stream->_buf) {
  538. 49032                 stream->_buf = (unsigned char *) malloc(BUFSIZ);
  539. 49033                 if (!stream->_buf) {
  540. 49034                         stream->_flags |= _IONBF;
  541. 49035                 }
  542. 49036                 else {
  543. 49037                         stream->_flags |= _IOMYBUF;
  544. 49038                         stream->_bufsiz = BUFSIZ;
  545. 49039                 }
  546. 49040         }
  547. 49041
  548. 49042         /* flush line-buffered output when filling an input buffer */
  549. 49043         for (i = 0; i < FOPEN_MAX; i++) {
  550. 49044                 if (__iotab[i] && io_testflag(__iotab[i], _IOLBF))
  551. 49045                         if (io_testflag(__iotab[i], _IOWRITING))
  552. 49046                                 (void) fflush(__iotab[i]);
  553. 49047         }
  554. 49048
  555. 49049         if (!stream->_buf) {
  556. 49050                 stream->_buf = &ch[fileno(stream)];
  557. 49051                 stream->_bufsiz = 1;
  558. 49052         }
  559. 49053         stream->_ptr = stream->_buf;
  560. 49054         stream->_count = _read(stream->_fd, (char *)stream->_buf, stream->_bufsiz);
  561. .Ep 448 src/lib/stdio/fillbuf.c
  562. 49055
  563. 49056         if (stream->_count <= 0){
  564. 49057                 if (stream->_count == 0) {
  565. 49058                         stream->_flags |= _IOEOF;
  566. 49059                 }
  567. 49060                 else 
  568. 49061                         stream->_flags |= _IOERR;
  569. 49062
  570. 49063                 return EOF;
  571. 49064         }
  572. 49065         stream->_count--;
  573. 49066
  574. 49067         return *stream->_ptr++;
  575. 49068 }
  578. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  579. src/lib/stdio/flushbuf.c    
  580. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  582. 49100 /*
  583. 49101  * flushbuf.c - flush a buffer
  584. 49102  */
  585. 49103 /* $Header: flushbuf.c,v 1.6 91/06/10 17:07:10 ceriel Exp $ */
  586. 49104
  587. 49105 #include        <stdio.h>
  588. 49106 #include        <stdlib.h>
  589. 49107 #include        "loc_incl.h"
  590. 49108
  591. 49109 #include        <sys/types.h>
  592. 49110
  593. 49111 off_t _lseek(int fildes, off_t offset, int whence);
  594. 49112 ssize_t _write(int d, const char *buf, size_t nbytes);
  595. 49113 int _isatty(int d);
  596. 49114 extern void (*_clean)(void);
  597. 49115
  598. 49116 static int
  599. 49117 do_write(int d, char *buf, int nbytes)
  600. 49118 {
  601. 49119         int c;
  602. 49120
  603. 49121         /* POSIX actually allows write() to return a positive value less
  604. 49122            than nbytes, so loop ...
  605. 49123         */
  606. 49124         while ((c = _write(d, buf, nbytes)) > 0 && c < nbytes) {
  607. 49125                 nbytes -= c;
  608. 49126                 buf += c;
  609. 49127         }
  610. 49128         return c > 0;
  611. 49129 }
  613. 49131 int
  614. 49132 __flushbuf(int c, FILE * stream)
  615. 49133 {
  616. 49134         _clean = __cleanup;
  617. 49135         if (fileno(stream) < 0) return EOF;
  618. 49136         if (!io_testflag(stream, _IOWRITE)) return EOF;
  619. 49137         if (io_testflag(stream, _IOREADING) && !feof(stream)) return EOF;
  620. 49138
  621. 49139         stream->_flags &= ~_IOREADING;
  622. .Op 449 src/lib/stdio/flushbuf.c
  623. 49140         stream->_flags |= _IOWRITING;
  624. 49141         if (!io_testflag(stream, _IONBF)) {
  625. 49142                 if (!stream->_buf) {
  626. 49143                         if (stream == stdout && _isatty(fileno(stdout))) {
  627. 49144                                 if (!(stream->_buf =
  628. 49145                                             (unsigned char *) malloc(BUFSIZ))) {
  629. 49146                                         stream->_flags |= _IONBF;
  630. 49147                                 } else {
  631. 49148                                         stream->_flags |= _IOLBF|_IOMYBUF;
  632. 49149                                         stream->_bufsiz = BUFSIZ;
  633. 49150                                         stream->_count = -1;
  634. 49151                                 }
  635. 49152                         } else {
  636. 49153                                 if (!(stream->_buf =
  637. 49154                                             (unsigned char *) malloc(BUFSIZ))) {
  638. 49155                                         stream->_flags |= _IONBF;
  639. 49156                                 } else {
  640. 49157                                         stream->_flags |= _IOMYBUF;
  641. 49158                                         stream->_bufsiz = BUFSIZ;
  642. 49159                                         if (!io_testflag(stream, _IOLBF))
  643. 49160                                                 stream->_count = BUFSIZ - 1;
  644. 49161                                         else    stream->_count = -1;
  645. 49162                                 }
  646. 49163                         }
  647. 49164                         stream->_ptr = stream->_buf;
  648. 49165                 }
  649. 49166         }
  650. 49167
  651. 49168         if (io_testflag(stream, _IONBF)) {
  652. 49169                 char c1 = c;
  653. 49170
  654. 49171                 stream->_count = 0;
  655. 49172                 if (io_testflag(stream, _IOAPPEND)) {
  656. 49173                         if (_lseek(fileno(stream), 0L, SEEK_END) == -1) {
  657. 49174                                 stream->_flags |= _IOERR;
  658. 49175                                 return EOF;
  659. 49176                         }
  660. 49177                 }
  661. 49178                 if (_write(fileno(stream), &c1, 1) != 1) {
  662. 49179                         stream->_flags |= _IOERR;
  663. 49180                         return EOF;
  664. 49181                 }
  665. 49182                 return c;
  666. 49183         } else if (io_testflag(stream, _IOLBF)) {
  667. 49184                 *stream->_ptr++ = c;
  668. 49185                 if (c == 'n' || stream->_count == -stream->_bufsiz) {
  669. 49186                         if (io_testflag(stream, _IOAPPEND)) {
  670. 49187                                 if (_lseek(fileno(stream), 0L, SEEK_END) == -1) {
  671. 49188                                         stream->_flags |= _IOERR;
  672. 49189                                         return EOF;
  673. 49190                                 }
  674. 49191                         }
  675. 49192                         if (! do_write(fileno(stream), (char *)stream->_buf,
  676. 49193                                         -stream->_count)) {
  677. 49194                                 stream->_flags |= _IOERR;
  678. 49195                                 return EOF;
  679. 49196                         } else {
  680. 49197                                 stream->_ptr  = stream->_buf;
  681. 49198                                 stream->_count = 0;
  682. 49199                         }
  683. .Ep 450 src/lib/stdio/flushbuf.c
  684. 49200                 }
  685. 49201         } else {
  686. 49202                 int count = stream->_ptr - stream->_buf;
  687. 49203
  688. 49204                 stream->_count = stream->_bufsiz - 1;
  689. 49205                 stream->_ptr = stream->_buf + 1;
  690. 49206
  691. 49207                 if (count > 0) {
  692. 49208                         if (io_testflag(stream, _IOAPPEND)) {
  693. 49209                                 if (_lseek(fileno(stream), 0L, SEEK_END) == -1) {
  694. 49210                                         stream->_flags |= _IOERR;
  695. 49211                                         return EOF;
  696. 49212                                 }
  697. 49213                         }
  698. 49214                         if (! do_write(fileno(stream), (char *)stream->_buf, count)) {
  699. 49215                                 *(stream->_buf) = c;
  700. 49216                                 stream->_flags |= _IOERR;
  701. 49217                                 return EOF;
  702. 49218                         }
  703. 49219                 }
  704. 49220                 *(stream->_buf) = c;
  705. 49221         }
  706. 49222         return c;
  707. 49223 }
  710. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  711. src/lib/stdio/fopen.c    
  712. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  714. 49300 /*
  715. 49301  * fopen.c - open a stream
  716. 49302  */
  717. 49303 /* $Header: fopen.c,v 1.8 91/02/22 16:29:46 ceriel Exp $ */
  718. 49304
  719. 49305 #if     defined(_POSIX_SOURCE)
  720. 49306 #include        <sys/types.h>
  721. 49307 #endif
  722. 49308 #include        <stdio.h>
  723. 49309 #include        <stdlib.h>
  724. 49310 #include        "loc_incl.h"
  725. 49311
  726. 49312 #define PMODE           0666
  727. 49313
  728. 49314 /* The next 3 defines are true in all UNIX systems known to me.
  729. 49315  */
  730. 49316 #define O_RDONLY        0
  731. 49317 #define O_WRONLY        1
  732. 49318 #define O_RDWR          2
  733. 49319
  734. 49320 /* Since the O_CREAT flag is not available on all systems, we can't get it
  735. 49321  * from the standard library. Furthermore, even if we know that <fcntl.h>
  736. 49322  * contains such a flag, it's not sure whether it can be used, since we
  737. 49323  * might be cross-compiling for another system, which may use an entirely
  738. 49324  * different value for O_CREAT (or not support such a mode). The safest
  739. 49325  * thing is to just use the Version 7 semantics for open, and use creat()
  740. 49326  * whenever necessary.
  741. 49327  *
  742. 49328  * Another problem is O_APPEND, for which the same holds. When "a"
  743. 49329  * open-mode is used, an lseek() to the end is done before every write()
  744. .Op 451 src/lib/stdio/fopen.c
  745. 49330  * system-call.
  746. 49331  *
  747. 49332  * The O_CREAT, O_TRUNC and O_APPEND given here, are only for convenience.
  748. 49333  * They are not passed to open(), so the values don't have to match a value
  749. 49334  * from the real world. It is enough when they are unique.
  750. 49335  */
  751. 49336 #define O_CREAT         0x010
  752. 49337 #define O_TRUNC         0x020
  753. 49338 #define O_APPEND        0x040
  754. 49339
  755. 49340 int _open(const char *path, int flags);
  756. 49341 int _creat(const char *path, Mode_t mode);
  757. 49342 int _close(int d);
  758. 49343
  759. 49344 FILE *
  760. 49345 fopen(const char *name, const char *mode)
  761. 49346 {
  762. 49347         register int i;
  763. 49348         int rwmode = 0, rwflags = 0;
  764. 49349         FILE *stream;
  765. 49350         int fd, flags = 0;
  766. 49351
  767. 49352         for (i = 0; __iotab[i] != 0 ; i++) 
  768. 49353                 if ( i >= FOPEN_MAX-1 )
  769. 49354                         return (FILE *)NULL;
  770. 49355
  771. 49356         switch(*mode++) {
  772. 49357         case 'r':
  773. 49358                 flags |= _IOREAD | _IOREADING;  
  774. 49359                 rwmode = O_RDONLY;
  775. 49360                 break;
  776. 49361         case 'w':
  777. 49362                 flags |= _IOWRITE | _IOWRITING;
  778. 49363                 rwmode = O_WRONLY;
  779. 49364                 rwflags = O_CREAT | O_TRUNC;
  780. 49365                 break;
  781. 49366         case 'a': 
  782. 49367                 flags |= _IOWRITE | _IOWRITING | _IOAPPEND;
  783. 49368                 rwmode = O_WRONLY;
  784. 49369                 rwflags |= O_APPEND | O_CREAT;
  785. 49370                 break;         
  786. 49371         default:
  787. 49372                 return (FILE *)NULL;
  788. 49373         }
  789. 49374
  790. 49375         while (*mode) {
  791. 49376                 switch(*mode++) {
  792. 49377                 case 'b':
  793. 49378                         continue;
  794. 49379                 case '+':
  795. 49380                         rwmode = O_RDWR;
  796. 49381                         flags |= _IOREAD | _IOWRITE;
  797. 49382                         continue;
  798. 49383                 /* The sequence may be followed by additional characters */
  799. 49384                 default:
  800. 49385                         break;
  801. 49386                 }
  802. 49387                 break;
  803. 49388         }
  804. 49389
  805. .Ep 452 src/lib/stdio/fopen.c
  806. 49390         /* Perform a creat() when the file should be truncated or when
  807. 49391          * the file is opened for writing and the open() failed.
  808. 49392          */
  809. 49393         if ((rwflags & O_TRUNC)
  810. 49394             || (((fd = _open(name, rwmode)) < 0)
  811. 49395                     && (rwflags & O_CREAT))) {
  812. 49396                 if (((fd = _creat(name, PMODE)) > 0) && flags  | _IOREAD) {
  813. 49397                         (void) _close(fd);
  814. 49398                         fd = _open(name, rwmode);
  815. 49399                 }
  816. 49400                         
  817. 49401         }
  818. 49402
  819. 49403         if (fd < 0) return (FILE *)NULL;
  820. 49404
  821. 49405         if (( stream = (FILE *) malloc(sizeof(FILE))) == NULL ) {
  822. 49406                 _close(fd);
  823. 49407                 return (FILE *)NULL;
  824. 49408         }
  825. 49409
  826. 49410         if ((flags & (_IOREAD | _IOWRITE))  == (_IOREAD | _IOWRITE))
  827. 49411                 flags &= ~(_IOREADING | _IOWRITING);
  828. 49412
  829. 49413         stream->_count = 0;
  830. 49414         stream->_fd = fd;
  831. 49415         stream->_flags = flags;
  832. 49416         stream->_buf = NULL;
  833. 49417         __iotab[i] = stream;
  834. 49418         return stream;
  835. 49419 }
  842. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  843. src/lib/stdio/fprintf.c    
  844. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  846. 49500 /*
  847. 49501  * fprintf - write output on a stream
  848. 49502  */
  849. 49503 /* $Header: fprintf.c,v 1.3 89/12/18 15:01:54 eck Exp $ */
  850. 49504
  851. 49505 #include        <stdio.h>
  852. 49506 #include        <stdarg.h>
  853. 49507 #include        "loc_incl.h"
  854. 49508
  855. 49509 int
  856. 49510 fprintf(FILE *stream, const char *format, ...)
  857. 49511 {
  858. 49512         va_list ap;
  859. 49513         int retval;
  860. 49514         
  861. 49515         va_start(ap, format);
  862. 49516
  863. 49517         retval = _doprnt (format, ap, stream);
  864. 49518
  865. 49519         va_end(ap);
  866. .Op 453 src/lib/stdio/fprintf.c
  867. 49520
  868. 49521         return retval;
  869. 49522 }
  873. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  874. src/lib/stdio/fputc.c    
  875. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  877. 49600 /*
  878. 49601  * fputc.c - print an unsigned character
  879. 49602  */
  880. 49603 /* $Header: fputc.c,v 1.1 89/05/30 13:28:45 eck Exp $ */
  881. 49604
  882. 49605 #include        <stdio.h>
  883. 49606
  884. 49607 int
  885. 49608 fputc(int c, FILE *stream)
  886. 49609 {
  887. 49610         return putc(c, stream);
  888. 49611 }
  893. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  894. src/lib/stdio/fputs.c    
  895. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  897. 49700 /*
  898. 49701  * fputs - print a string
  899. 49702  */
  900. 49703 /* $Header: fputs.c,v 1.2 89/12/18 15:02:01 eck Exp $ */
  901. 49704
  902. 49705 #include        <stdio.h>
  903. 49706
  904. 49707 int
  905. 49708 fputs(register const char *s, register FILE *stream)
  906. 49709 {
  907. 49710         register int i = 0;
  908. 49711
  909. 49712         while (*s) 
  910. 49713                 if (putc(*s++, stream) == EOF) return EOF;
  911. 49714                 else i++;
  912. 49715
  913. 49716         return i;
  914. 49717 }
  915. .Ep 454 src/lib/stdio/fread.c
  917. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  918. src/lib/stdio/fread.c    
  919. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  921. 49800 /*
  922. 49801  * fread.c - read a number of members into an array
  923. 49802  */
  924. 49803 /* $Header: fread.c,v 1.2 89/12/18 15:02:09 eck Exp $ */
  925. 49804
  926. 49805 #include        <stdio.h>
  927. 49806
  928. 49807 size_t
  929. 49808 fread(void *ptr, size_t size, size_t nmemb, register FILE *stream)
  930. 49809 {
  931. 49810         register char *cp = ptr;
  932. 49811         register int c;
  933. 49812         size_t ndone = 0;
  934. 49813         register size_t s;
  935. 49814
  936. 49815         if (size)
  937. 49816                 while ( ndone < nmemb ) {
  938. 49817                         s = size;
  939. 49818                         do {
  940. 49819                                 if ((c = getc(stream)) != EOF)
  941. 49820                                         *cp++ = c;
  942. 49821                                 else
  943. 49822                                         return ndone;
  944. 49823                         } while (--s);
  945. 49824                         ndone++;
  946. 49825                 }
  947. 49826
  948. 49827         return ndone;
  949. 49828 }
  952. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  953. src/lib/stdio/freopen.c    
  954. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  956. 49900 /*
  957. 49901  * freopen.c - open a file and associate a stream with it
  958. 49902  */
  959. 49903 /* $Header: freopen.c,v 1.8 90/08/28 13:44:48 eck Exp $ */
  960. 49904
  961. 49905 #if     defined(_POSIX_SOURCE)
  962. 49906 #include        <sys/types.h>
  963. 49907 #endif
  964. 49908 #include        <stdio.h>
  965. 49909 #include        <stdlib.h>
  966. 49910 #include        "loc_incl.h"
  967. 49911
  968. 49912 #define PMODE           0666
  969. 49913
  970. 49914 /* Do not "optimize" this file to use the open with O_CREAT if the file
  971. 49915  * does not exist. The reason is given in fopen.c.
  972. 49916  */
  973. 49917 #define O_RDONLY        0
  974. 49918 #define O_WRONLY        1
  975. 49919 #define O_RDWR          2
  976. .Op 455 src/lib/stdio/freopen.c
  977. 49920
  978. 49921 #define O_CREAT         0x010
  979. 49922 #define O_TRUNC         0x020
  980. 49923 #define O_APPEND        0x040
  981. 49924
  982. 49925 int _open(const char *path, int flags);
  983. 49926 int _creat(const char *path, Mode_t mode);
  984. 49927 int _close(int d);
  985. 49928
  986. 49929 FILE *
  987. 49930 freopen(const char *name, const char *mode, FILE *stream)
  988. 49931 {
  989. 49932         register int i;
  990. 49933         int rwmode = 0, rwflags = 0;
  991. 49934         int fd, flags = stream->_flags & (_IONBF | _IOFBF | _IOLBF | _IOMYBUF);
  992. 49935
  993. 49936         (void) fflush(stream);                          /* ignore errors */
  994. 49937         (void) _close(fileno(stream));
  995. 49938
  996. 49939         switch(*mode++) {
  997. 49940         case 'r':
  998. 49941                 flags |= _IOREAD;       
  999. 49942                 rwmode = O_RDONLY;
  1000. 49943                 break;
  1001. 49944         case 'w':
  1002. 49945                 flags |= _IOWRITE;
  1003. 49946                 rwmode = O_WRONLY;
  1004. 49947                 rwflags = O_CREAT | O_TRUNC;
  1005. 49948                 break;
  1006. 49949         case 'a': 
  1007. 49950                 flags |= _IOWRITE | _IOAPPEND;
  1008. 49951                 rwmode = O_WRONLY;
  1009. 49952                 rwflags |= O_APPEND | O_CREAT;
  1010. 49953                 break;         
  1011. 49954         default:
  1012. 49955                 return (FILE *)NULL;
  1013. 49956         }
  1014. 49957
  1015. 49958         while (*mode) {
  1016. 49959                 switch(*mode++) {
  1017. 49960                 case 'b':
  1018. 49961                         continue;
  1019. 49962                 case '+':
  1020. 49963                         rwmode = O_RDWR;
  1021. 49964                         flags |= _IOREAD | _IOWRITE;
  1022. 49965                         continue;
  1023. 49966                 /* The sequence may be followed by aditional characters */
  1024. 49967                 default:
  1025. 49968                         break;
  1026. 49969                 }
  1027. 49970                 break;
  1028. 49971         }
  1029. 49972
  1030. 49973         if ((rwflags & O_TRUNC)
  1031. 49974             || (((fd = _open(name, rwmode)) < 0)
  1032. 49975                     && (rwflags & O_CREAT))) {
  1033. 49976                 if (((fd = _creat(name, PMODE)) < 0) && flags | _IOREAD) {
  1034. 49977                         (void) _close(fd);
  1035. 49978                         fd = _open(name, rwmode);
  1036. 49979                 }
  1037. .Ep 456 src/lib/stdio/freopen.c
  1038. 49980         }
  1039. 49981
  1040. 49982         if (fd < 0) {
  1041. 49983                 for( i = 0; i < FOPEN_MAX; i++) {
  1042. 49984                         if (stream == __iotab[i]) {
  1043. 49985                                 __iotab[i] = 0;
  1044. 49986                                 break;
  1045. 49987                         }
  1046. 49988                 }
  1047. 49989                 if (stream != stdin && stream != stdout && stream != stderr)
  1048. 49990                         free((void *)stream);
  1049. 49991                 return (FILE *)NULL;
  1050. 49992         }
  1051. 49993
  1052. 49994         stream->_count = 0;
  1053. 49995         stream->_fd = fd;
  1054. 49996         stream->_flags = flags;
  1055. 49997         return stream;
  1056. 49998 }
  1059. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1060. src/lib/stdio/fscanf.c    
  1061. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1063. 50000 /*
  1064. 50001  * fscanf.c - read formatted input from stream
  1065. 50002  */
  1066. 50003 /* $Header: fscanf.c,v 1.1 89/05/30 13:29:17 eck Exp $ */
  1067. 50004
  1068. 50005 #include        <stdio.h>
  1069. 50006 #include        <stdarg.h>
  1070. 50007 #include        "loc_incl.h"
  1071. 50008
  1072. 50009 int
  1073. 50010 fscanf(FILE *stream, const char *format, ...)
  1074. 50011 {
  1075. 50012         va_list ap;
  1076. 50013         int retval;
  1077. 50014
  1078. 50015         va_start(ap, format);
  1079. 50016
  1080. 50017         retval = _doscan(stream, format, ap);
  1081. 50018
  1082. 50019         va_end(ap);
  1083. 50020
  1084. 50021         return retval;
  1085. 50022 }
  1086. .Op 457 src/lib/stdio/fseek.c
  1088. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1089. src/lib/stdio/fseek.c    
  1090. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1092. 50100 /*
  1093. 50101  * fseek.c - perform an fseek
  1094. 50102  */
  1095. 50103 /* $Header: fseek.c,v 1.4 90/01/22 11:12:00 eck Exp $ */
  1096. 50104
  1097. 50105 #include        <stdio.h>
  1098. 50106
  1099. 50107 #if     (SEEK_CUR != 1) || (SEEK_END != 2) || (SEEK_SET != 0)
  1100. 50108 #error SEEK_* values are wrong
  1101. 50109 #endif
  1102. 50110
  1103. 50111 #include        "loc_incl.h"
  1104. 50112
  1105. 50113 #include        <sys/types.h>
  1106. 50114
  1107. 50115 off_t _lseek(int fildes, off_t offset, int whence);
  1108. 50116
  1109. 50117 int
  1110. 50118 fseek(FILE *stream, long int offset, int whence)
  1111. 50119 {
  1112. 50120         int adjust = 0;
  1113. 50121         long pos;
  1114. 50122
  1115. 50123         stream->_flags &= ~(_IOEOF | _IOERR);
  1116. 50124         /* Clear both the end of file and error flags */
  1117. 50125
  1118. 50126         if (io_testflag(stream, _IOREADING)) {
  1119. 50127                 if (whence == SEEK_CUR
  1120. 50128                     && stream->_buf
  1121. 50129                     && !io_testflag(stream,_IONBF))
  1122. 50130                         adjust = stream->_count;
  1123. 50131                 stream->_count = 0;
  1124. 50132         } else if (io_testflag(stream,_IOWRITING)) {
  1125. 50133                 fflush(stream);
  1126. 50134         } else  /* neither reading nor writing. The buffer must be empty */
  1127. 50135                 /* EMPTY */ ;
  1128. 50136
  1129. 50137         pos = _lseek(fileno(stream), offset - adjust, whence);
  1130. 50138         if (io_testflag(stream, _IOREAD) && io_testflag(stream, _IOWRITE))
  1131. 50139                 stream->_flags &= ~(_IOREADING | _IOWRITING);
  1132. 50140
  1133. 50141         stream->_ptr = stream->_buf;
  1134. 50142         return ((pos == -1) ? -1 : 0);
  1135. 50143 }
  1136. .Ep 458 src/lib/stdio/fsetpos.c
  1138. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1139. src/lib/stdio/fsetpos.c    
  1140. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1142. 50200 /*
  1143. 50201  * fsetpos.c - set the position in the file
  1144. 50202  */
  1145. 50203 /* $Header: fsetpos.c,v 1.1 89/05/30 13:29:34 eck Exp $ */
  1146. 50204
  1147. 50205 #include        <stdio.h>
  1148. 50206
  1149. 50207 int
  1150. 50208 fsetpos(FILE *stream, fpos_t *pos)
  1151. 50209 {
  1152. 50210         return fseek(stream, *pos, SEEK_SET);
  1153. 50211 }
  1158. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1159. src/lib/stdio/ftell.c    
  1160. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1162. 50300 /*
  1163. 50301  * ftell.c - obtain the value of the file-position indicator of a stream
  1164. 50302  */
  1165. 50303 /* $Header: ftell.c,v 1.4 90/01/22 11:12:12 eck Exp $ */
  1166. 50304
  1167. 50305 #include        <stdio.h>
  1168. 50306
  1169. 50307 #if     (SEEK_CUR != 1) || (SEEK_SET != 0) || (SEEK_END != 2)
  1170. 50308 #error SEEK_* values are wrong
  1171. 50309 #endif
  1172. 50310
  1173. 50311 #include        "loc_incl.h"
  1174. 50312
  1175. 50313 #include        <sys/types.h>
  1176. 50314
  1177. 50315 off_t _lseek(int fildes, off_t offset, int whence);
  1178. 50316
  1179. 50317 long ftell(FILE *stream)
  1180. 50318 {
  1181. 50319         long result;
  1182. 50320         int adjust = 0;
  1183. 50321
  1184. 50322         if (io_testflag(stream,_IOREADING))
  1185. 50323                 adjust = -stream->_count;
  1186. 50324         else if (io_testflag(stream,_IOWRITING)
  1187. 50325                     && stream->_buf
  1188. 50326                     && !io_testflag(stream,_IONBF))
  1189. 50327                 adjust = stream->_ptr - stream->_buf;
  1190. 50328         else adjust = 0;
  1191. 50329
  1192. 50330         result = _lseek(fileno(stream), (off_t)0, SEEK_CUR);
  1193. 50331
  1194. 50332         if ( result == -1 )
  1195. 50333                 return result;
  1196. 50334
  1197. .Op 459 src/lib/stdio/ftell.c
  1198. 50335         result += (long) adjust;
  1199. 50336         return result;
  1200. 50337 }
  1204. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1205. src/lib/stdio/fwrite.c    
  1206. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1208. 50400 /*
  1209. 50401  * fwrite.c - write a number of array elements on a file
  1210. 50402  */
  1211. 50403 /* $Header: fwrite.c,v 1.3 89/12/18 15:02:39 eck Exp $ */
  1212. 50404
  1213. 50405 #include        <stdio.h>
  1214. 50406
  1215. 50407 size_t
  1216. 50408 fwrite(const void *ptr, size_t size, size_t nmemb,
  1217. 50409             register FILE *stream)
  1218. 50410 {
  1219. 50411         register const unsigned char *cp = ptr;
  1220. 50412         register size_t s;
  1221. 50413         size_t ndone = 0;
  1222. 50414
  1223. 50415         if (size)
  1224. 50416                 while ( ndone < nmemb ) {
  1225. 50417                         s = size;
  1226. 50418                         do {
  1227. 50419                                 if (putc((int)*cp, stream)
  1228. 50420                                         == EOF)
  1229. 50421                                         return ndone;
  1230. 50422                                 cp++;
  1231. 50423                         } 
  1232. 50424                         while (--s);
  1233. 50425                         ndone++;
  1234. 50426                 }
  1235. 50427         return ndone;
  1236. 50428 }
  1239. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1240. src/lib/stdio/getc.c    
  1241. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1243. 50500 /*
  1244. 50501  * getc.c - read an unsigned character
  1245. 50502  */
  1246. 50503 /* $Header: getc.c,v 1.2 89/12/18 15:02:45 eck Exp $ */
  1247. 50504
  1248. 50505 #include        <stdio.h>
  1249. 50506
  1250. 50507 int
  1251. 50508 (getc)(FILE *stream)
  1252. 50509 {
  1253. 50510         return getc(stream);
  1254. 50511 }
  1255. .Ep 460 src/lib/stdio/getchar.c
  1257. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1258. src/lib/stdio/getchar.c    
  1259. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1261. 50600 /*
  1262. 50601  * getchar.c - read a character from the standard input stream
  1263. 50602  */
  1264. 50603 /* $Header: getchar.c,v 1.2 89/12/18 15:02:53 eck Exp $ */
  1265. 50604
  1266. 50605 #include        <stdio.h>
  1267. 50606
  1268. 50607 int
  1269. 50608 (getchar)(void)
  1270. 50609 {
  1271. 50610         return getchar();
  1272. 50611 }
  1277. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1278. src/lib/stdio/gets.c    
  1279. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1281. 50700 /*
  1282. 50701  * gets.c - read a line from a stream
  1283. 50702  */
  1284. 50703 /* $Header: gets.c,v 1.2 89/12/18 15:03:00 eck Exp $ */
  1285. 50704
  1286. 50705 #include        <stdio.h>
  1287. 50706
  1288. 50707 char *
  1289. 50708 gets(char *s)
  1290. 50709 {
  1291. 50710         register FILE *stream = stdin;
  1292. 50711         register int ch;
  1293. 50712         register char *ptr;
  1294. 50713
  1295. 50714         ptr = s;
  1296. 50715         while ((ch = getc(stream)) != EOF && ch != 'n')
  1297. 50716                 *ptr++ = ch;
  1298. 50717
  1299. 50718         if (ch == EOF) {
  1300. 50719                 if (feof(stream)) {
  1301. 50720                         if (ptr == s) return NULL;
  1302. 50721                 } else return NULL;
  1303. 50722         }
  1304. 50723
  1305. 50724         *ptr = '';
  1306. 50725         return s;
  1307. 50726 }
  1308. .Op 461 src/lib/stdio/icompute.c
  1310. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1311. src/lib/stdio/icompute.c    
  1312. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1314. 50800 /*
  1315. 50801  * icompute.c - compute an integer
  1316. 50802  */
  1317. 50803 /* $Header: icompute.c,v 1.1 89/12/18 14:59:38 eck Exp $ */
  1318. 50804
  1319. 50805 #include        "loc_incl.h"
  1320. 50806
  1321. 50807 /* This routine is used in doprnt.c as well as in tmpfile.c and tmpnam.c. */
  1322. 50808
  1323. 50809 char *
  1324. 50810 _i_compute(unsigned long val, int base, char *s, int nrdigits)
  1325. 50811 {
  1326. 50812         int c;
  1327. 50813
  1328. 50814         c= val % base ;
  1329. 50815         val /= base ;
  1330. 50816         if (val || nrdigits > 1)
  1331. 50817                 s = _i_compute(val, base, s, nrdigits - 1);
  1332. 50818         *s++ = (c>9 ? c-10+'a' : c+'0');
  1333. 50819         return s;
  1334. 50820 }
  1340. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1341. src/lib/stdio/perror.c    
  1342. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1344. 50900 /*
  1345. 50901  * perror.c - print an error message on the standard error output
  1346. 50902  */
  1347. 50903 /* $Header: perror.c,v 1.1 89/05/30 13:31:30 eck Exp $ */
  1348. 50904
  1349. 50905 #if     defined(_POSIX_SOURCE)
  1350. 50906 #include        <sys/types.h>
  1351. 50907 #endif
  1352. 50908 #include        <stdio.h>
  1353. 50909 #include        <errno.h>
  1354. 50910 #include        <stdio.h>
  1355. 50911 #include        <string.h>
  1356. 50912 #include        "loc_incl.h"
  1357. 50913
  1358. 50914 ssize_t _write(int d, const char *buf, size_t nbytes);
  1359. 50915
  1360. 50916 void
  1361. 50917 perror(const char *s)
  1362. 50918 {
  1363. 50919         char *p;
  1364. 50920         int fd;
  1365. 50921
  1366. 50922         p = strerror(errno);
  1367. 50923         fd = fileno(stderr);
  1368. 50924         fflush(stdout);
  1369. .Ep 462 src/lib/stdio/perror.c
  1370. 50925         fflush(stderr);
  1371. 50926         if (s && *s) {
  1372. 50927                 _write(fd, s, strlen(s));
  1373. 50928                 _write(fd, ": ", 2);
  1374. 50929         }
  1375. 50930         _write(fd, p, strlen(p));
  1376. 50931         _write(fd, "n", 1);
  1377. 50932 }
  1381. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1382. src/lib/stdio/printf.c    
  1383. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1385. 51000 /*
  1386. 51001  * printf - write on the standard output stream
  1387. 51002  */
  1388. 51003 /* $Header: printf.c,v 1.3 89/12/18 15:03:08 eck Exp $ */
  1389. 51004
  1390. 51005 #include        <stdio.h>
  1391. 51006 #include        <stdarg.h>
  1392. 51007 #include        "loc_incl.h"
  1393. 51008
  1394. 51009 int
  1395. 51010 printf(const char *format, ...)
  1396. 51011 {
  1397. 51012         va_list ap;
  1398. 51013         int retval;
  1399. 51014
  1400. 51015         va_start(ap, format);
  1401. 51016
  1402. 51017         retval = _doprnt(format, ap, stdout);
  1403. 51018
  1404. 51019         va_end(ap);
  1405. 51020
  1406. 51021         return retval;
  1407. 51022 }
  1411. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1412. src/lib/stdio/putc.c    
  1413. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1415. 51100 /*
  1416. 51101  * putc.c - print (or buffer) one character
  1417. 51102  */
  1418. 51103 /* $Header: putc.c,v 1.2 89/12/18 15:03:15 eck Exp $ */
  1419. 51104
  1420. 51105 #include        <stdio.h>
  1421. 51106
  1422. 51107 int
  1423. 51108 (putc)(int c, FILE *stream)
  1424. 51109 {
  1425. 51110         return putc(c, stream);
  1426. 51111 }
  1427. .Op 463 src/lib/stdio/putchar.c
  1429. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1430. src/lib/stdio/putchar.c    
  1431. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1433. 51200 /*
  1434. 51201  * putchar.c - print (or buffer) a character on the standard output stream
  1435. 51202  */
  1436. 51203 /* $Header: putchar.c,v 1.2 89/12/18 15:03:23 eck Exp $ */
  1437. 51204
  1438. 51205 #include        <stdio.h>
  1439. 51206
  1440. 51207 int
  1441. 51208 (putchar)(int c)
  1442. 51209 {
  1443. 51210         return putchar(c);
  1444. 51211 }
  1449. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1450. src/lib/stdio/puts.c    
  1451. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1453. 51300 /*
  1454. 51301  * puts.c - print a string onto the standard output stream
  1455. 51302  */
  1456. 51303 /* $Header: puts.c,v 1.2 89/12/18 15:03:30 eck Exp $ */
  1457. 51304
  1458. 51305 #include        <stdio.h>
  1459. 51306
  1460. 51307 int
  1461. 51308 puts(register const char *s)
  1462. 51309 {
  1463. 51310         register FILE *file = stdout;
  1464. 51311         register int i = 0;
  1465. 51312
  1466. 51313         while (*s) {
  1467. 51314                 if (putc(*s++, file) == EOF) return EOF;
  1468. 51315                 else i++;
  1469. 51316         }
  1470. 51317         if (putc('n', file) == EOF) return EOF;
  1471. 51318         return i + 1;
  1472. 51319 }
  1473. .Ep 464 src/lib/stdio/remove.c
  1475. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1476. src/lib/stdio/remove.c    
  1477. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1479. 51400 /*
  1480. 51401  * remove.c - remove a file
  1481. 51402  */
  1482. 51403 /* $Header: remove.c,v 1.2 90/01/22 11:12:44 eck Exp $ */
  1483. 51404
  1484. 51405 #include        <stdio.h>
  1485. 51406
  1486. 51407 int _unlink(const char *path);
  1487. 51408
  1488. 51409 int
  1489. 51410 remove(const char *filename) {
  1490. 51411         return _unlink(filename);
  1491. 51412 }
  1495. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1496. src/lib/stdio/rewind.c    
  1497. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1499. 51500 /*
  1500. 51501  * rewind.c - set the file position indicator of a stream to the start
  1501. 51502  */
  1502. 51503 /* $Header: rewind.c,v 1.1 89/05/30 13:32:52 eck Exp $ */
  1503. 51504
  1504. 51505 #include        <stdio.h>
  1505. 51506 #include        "loc_incl.h"
  1506. 51507
  1507. 51508 void
  1508. 51509 rewind(FILE *stream)
  1509. 51510 {
  1510. 51511         (void) fseek(stream, 0L, SEEK_SET);
  1511. 51512         clearerr(stream);
  1512. 51513 }
  1515. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1516. src/lib/stdio/scanf.c    
  1517. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1519. 51600 /*
  1520. 51601  * scanf.c - read formatted input from the standard input stream
  1521. 51602  */
  1522. 51603 /* $Header: scanf.c,v 1.1 89/05/30 13:33:03 eck Exp $ */
  1523. 51604
  1524. 51605 #include        <stdio.h>
  1525. 51606 #include        <stdarg.h>
  1526. 51607 #include        "loc_incl.h"
  1527. 51608
  1528. 51609 int
  1529. 51610 scanf(const char *format, ...)
  1530. 51611 {
  1531. 51612         va_list ap;
  1532. 51613         int retval;
  1533. 51614
  1534. .Op 465 src/lib/stdio/scanf.c
  1535. 51615         va_start(ap, format);
  1536. 51616
  1537. 51617         retval = _doscan(stdin, format, ap);
  1538. 51618
  1539. 51619         va_end(ap);
  1540. 51620
  1541. 51621         return retval;
  1542. 51622 }
  1551. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1552. src/lib/stdio/setbuf.c    
  1553. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1555. 51700 /*
  1556. 51701  * setbuf.c - control buffering of a stream
  1557. 51702  */
  1558. 51703 /* $Header: setbuf.c,v 1.2 89/06/26 10:36:22 eck Exp $ */
  1559. 51704
  1560. 51705 #include        <stdio.h>
  1561. 51706 #include        "loc_incl.h"
  1562. 51707
  1563. 51708 void
  1564. 51709 setbuf(register FILE *stream, char *buf)
  1565. 51710 {
  1566. 51711         (void) setvbuf(stream, buf, (buf ? _IOFBF : _IONBF), (size_t) BUFSIZ);
  1567. 51712 }
  1571. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1572. src/lib/stdio/setvbuf.c    
  1573. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1575. 51800 /*
  1576. 51801  * setbuf.c - control buffering of a stream
  1577. 51802  */
  1578. 51803 /* $Id: setvbuf.c,v 1.8 1995/12/18 11:02:18 ceriel Exp $ */
  1579. 51804
  1580. 51805 #include        <stdio.h>
  1581. 51806 #include        <stdlib.h>
  1582. 51807 #include        "loc_incl.h"
  1583. 51808
  1584. 51809 extern void (*_clean)(void);
  1585. 51810
  1586. 51811 int
  1587. 51812 setvbuf(register FILE *stream, char *buf, int mode, size_t size)
  1588. 51813 {
  1589. 51814         int retval = 0;
  1590. 51815
  1591. 51816         _clean = __cleanup;
  1592. 51817         if (mode != _IOFBF && mode != _IOLBF && mode != _IONBF)
  1593. 51818                 return EOF;
  1594. 51819
  1595. .Ep 466 src/lib/stdio/setvbuf.c
  1596. 51820         if (stream->_buf && io_testflag(stream,_IOMYBUF) )
  1597. 51821                 free((void *)stream->_buf);
  1598. 51822
  1599. 51823         stream->_flags &= ~(_IOMYBUF | _IONBF | _IOLBF);
  1600. 51824
  1601. 51825         if (buf && size <= 0) retval = EOF;
  1602. 51826         if (!buf && (mode != _IONBF)) {
  1603. 51827                 if (size <= 0 || (buf = (char *) malloc(size)) == NULL) {
  1604. 51828                         retval = EOF;
  1605. 51829                 } else {
  1606. 51830                         stream->_flags |= _IOMYBUF;
  1607. 51831                 }
  1608. 51832         }
  1609. 51833
  1610. 51834         stream->_buf = (unsigned char *) buf;
  1611. 51835
  1612. 51836         stream->_count = 0;
  1613. 51837         stream->_flags |= mode;
  1614. 51838         stream->_ptr = stream->_buf;
  1615. 51839
  1616. 51840         if (!buf) {
  1617. 51841                 stream->_bufsiz = 1;
  1618. 51842         } else {
  1619. 51843                 stream->_bufsiz = size;
  1620. 51844         }
  1621. 51845
  1622. 51846         return retval;
  1623. 51847 }
  1627. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1628. src/lib/stdio/sprintf.c    
  1629. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1631. 51900 /*
  1632. 51901  * sprintf - print formatted output on an array
  1633. 51902  */
  1634. 51903 /* $Header: sprintf.c,v 1.2 89/12/18 15:03:52 eck Exp $ */
  1635. 51904
  1636. 51905 #include        <stdio.h>
  1637. 51906 #include        <stdarg.h>
  1638. 51907 #include        "loc_incl.h"
  1639. 51908
  1640. 51909 int
  1641. 51910 sprintf(char * s, const char *format, ...)
  1642. 51911 {
  1643. 51912         va_list ap;
  1644. 51913         int retval;
  1645. 51914         FILE tmp_stream;
  1646. 51915
  1647. 51916         va_start(ap, format);
  1648. 51917
  1649. 51918         tmp_stream._fd     = -1;
  1650. 51919         tmp_stream._flags  = _IOWRITE + _IONBF + _IOWRITING;
  1651. 51920         tmp_stream._buf    = (unsigned char *) s;
  1652. 51921         tmp_stream._ptr    = (unsigned char *) s;
  1653. 51922         tmp_stream._count  = 32767;
  1654. 51923
  1655. 51924         retval = _doprnt(format, ap, &tmp_stream);
  1656. .Op 467 src/lib/stdio/sprintf.c
  1657. 51925         putc('',&tmp_stream);
  1658. 51926
  1659. 51927         va_end(ap);
  1660. 51928
  1661. 51929         return retval;
  1662. 51930 }
  1668. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1669. src/lib/stdio/sscanf.c    
  1670. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1672. 52000 /*
  1673. 52001  * sscanf - read formatted output from a string
  1674. 52002  */
  1675. 52003 /* $Header: sscanf.c,v 1.3 90/09/26 13:17:39 eck Exp $ */
  1676. 52004
  1677. 52005 #include        <stdio.h>
  1678. 52006 #include        <stdarg.h>
  1679. 52007 #include        <string.h>
  1680. 52008 #include        "loc_incl.h"
  1681. 52009
  1682. 52010 int sscanf(const char *s, const char *format, ...)
  1683. 52011 {
  1684. 52012         va_list ap;
  1685. 52013         int retval;
  1686. 52014         FILE tmp_stream;
  1687. 52015
  1688. 52016         va_start(ap, format);
  1689. 52017
  1690. 52018         tmp_stream._fd     = -1;
  1691. 52019         tmp_stream._flags  = _IOREAD + _IONBF + _IOREADING;
  1692. 52020         tmp_stream._buf    = (unsigned char *) s;
  1693. 52021         tmp_stream._ptr    = (unsigned char *) s;
  1694. 52022         tmp_stream._count  = strlen(s);
  1695. 52023
  1696. 52024         retval = _doscan(&tmp_stream, format, ap);
  1697. 52025
  1698. 52026         va_end(ap);
  1699. 52027
  1700. 52028         return retval;
  1701. 52029 }
  1702. .Ep 468 src/lib/stdio/tmpfile.c
  1704. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1705. src/lib/stdio/tmpfile.c    
  1706. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1708. 52100 /*
  1709. 52101  * tmpfile.c - create and open a temporary file
  1710. 52102  */
  1711. 52103 /* $Header: tmpfile.c,v 1.3 90/01/22 11:13:15 eck Exp $ */
  1712. 52104
  1713. 52105 #if     defined(_POSIX_SOURCE)
  1714. 52106 #include        <sys/types.h>
  1715. 52107 #endif
  1716. 52108 #include        <stdio.h>
  1717. 52109 #include        <string.h>
  1718. 52110 #include        "loc_incl.h"
  1719. 52111
  1720. 52112 pid_t _getpid(void);
  1721. 52113
  1722. 52114 FILE *
  1723. 52115 tmpfile(void) {
  1724. 52116         static char name_buffer[L_tmpnam] = "/tmp/tmp." ;
  1725. 52117         static char *name = NULL;
  1726. 52118         FILE *file;
  1727. 52119
  1728. 52120         if (!name) {
  1729. 52121                 name = name_buffer + strlen(name_buffer);
  1730. 52122                 name = _i_compute(_getpid(), 10, name, 5);
  1731. 52123                 *name = '';
  1732. 52124         }
  1733. 52125
  1734. 52126         file = fopen(name_buffer,"wb+");
  1735. 52127         if (!file) return (FILE *)NULL;
  1736. 52128         (void) remove(name_buffer);
  1737. 52129         return file;
  1738. 52130 }
  1744. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1745. src/lib/stdio/tmpnam.c    
  1746. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1748. 52200 /*
  1749. 52201  * tmpnam.c - create a unique filename
  1750. 52202  */
  1751. 52203 /* $Header: tmpnam.c,v 1.4 91/02/26 09:28:39 ceriel Exp $ */
  1752. 52204
  1753. 52205 #if     defined(_POSIX_SOURCE)
  1754. 52206 #include        <sys/types.h>
  1755. 52207 #endif
  1756. 52208 #include        <stdio.h>
  1757. 52209 #include        <string.h>
  1758. 52210 #include        "loc_incl.h"
  1759. 52211
  1760. 52212 pid_t _getpid(void);
  1761. 52213
  1762. 52214 char *
  1763. .Op 469 src/lib/stdio/tmpnam.c
  1764. 52215 tmpnam(char *s) {
  1765. 52216         static char name_buffer[L_tmpnam] = "/tmp/tmp.";
  1766. 52217         static unsigned long count = 0;
  1767. 52218         static char *name = NULL;
  1768. 52219
  1769. 52220         if (!name) { 
  1770. 52221                 name = name_buffer + strlen(name_buffer);
  1771. 52222                 name = _i_compute((unsigned long)_getpid(), 10, name, 5);
  1772. 52223                 *name++ = '.';
  1773. 52224                 *name = '';
  1774. 52225         }
  1775. 52226         if (++count > TMP_MAX) count = 1;       /* wrap-around */
  1776. 52227         *_i_compute(count, 10, name, 3) = '';
  1777. 52228         if (s) return strcpy(s, name_buffer);
  1778. 52229         else return name_buffer;
  1779. 52230 }
  1785. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1786. src/lib/stdio/ungetc.c    
  1787. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1789. 52300 /*
  1790. 52301  * ungetc.c - push a character back onto an input stream
  1791. 52302  */
  1792. 52303 /* $Header: ungetc.c,v 1.3 90/03/28 16:33:05 eck Exp $ */
  1793. 52304
  1794. 52305 #include        <stdio.h>
  1795. 52306 #include        "loc_incl.h"
  1796. 52307
  1797. 52308 int
  1798. 52309 ungetc(int ch, FILE *stream)
  1799. 52310 {
  1800. 52311         unsigned char *p;
  1801. 52312
  1802. 52313         if (ch == EOF  || !io_testflag(stream,_IOREADING))
  1803. 52314                 return EOF;
  1804. 52315         if (stream->_ptr == stream->_buf) {
  1805. 52316                 if (stream->_count != 0) return EOF;
  1806. 52317                 stream->_ptr++;
  1807. 52318         }
  1808. 52319         stream->_count++;
  1809. 52320         p = --(stream->_ptr);           /* ??? Bloody vax assembler !!! */
  1810. 52321         /* ungetc() in sscanf() shouldn't write in rom */
  1811. 52322         if (*p != (unsigned char) ch)
  1812. 52323                 *p = (unsigned char) ch;
  1813. 52324         return ch;
  1814. 52325 }
  1815. .Ep 470 src/lib/stdio/vfprintf.c
  1817. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1818. src/lib/stdio/vfprintf.c    
  1819. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1821. 52400 /*
  1822. 52401  * vfprintf - formatted output without ellipsis
  1823. 52402  */
  1824. 52403 /* $Header: vfprintf.c,v 1.2 89/12/18 15:04:07 eck Exp $ */
  1825. 52404
  1826. 52405 #include        <stdio.h>
  1827. 52406 #include        <stdarg.h>
  1828. 52407 #include        "loc_incl.h"
  1829. 52408
  1830. 52409 int
  1831. 52410 vfprintf(FILE *stream, const char *format, va_list arg)
  1832. 52411 {
  1833. 52412         return _doprnt (format, arg, stream);
  1834. 52413 }
  1837. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1838. src/lib/stdio/vprintf.c    
  1839. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1841. 52500 /*
  1842. 52501  * vprintf - formatted output without ellipsis to the standard output stream
  1843. 52502  */
  1844. 52503 /* $Header: vprintf.c,v 1.3 89/12/18 15:04:14 eck Exp $ */
  1845. 52504
  1846. 52505 #include        <stdio.h>
  1847. 52506 #include        <stdarg.h>
  1848. 52507 #include        "loc_incl.h"
  1849. 52508
  1850. 52509 int
  1851. 52510 vprintf(const char *format, va_list arg)
  1852. 52511 {
  1853. 52512         return _doprnt(format, arg, stdout);
  1854. 52513 }
  1857. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1858. src/lib/stdio/vsprintf.c    
  1859. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1861. 52600 /*
  1862. 52601  * vsprintf - print formatted output without ellipsis on an array
  1863. 52602  */
  1864. 52603 /* $Header: vsprintf.c,v 1.2 90/11/13 10:56:53 eck Exp $ */
  1865. 52604
  1866. 52605 #include        <stdio.h>
  1867. 52606 #include        <stdarg.h>
  1868. 52607 #include        "loc_incl.h"
  1869. 52608
  1870. 52609 int
  1871. 52610 vsprintf(char *s, const char *format, va_list arg)
  1872. 52611 {
  1873. 52612         int retval;
  1874. 52613         FILE tmp_stream;
  1875. 52614
  1876. .Op 471 src/lib/stdio/vsprintf.c
  1877. 52615         tmp_stream._fd     = -1;
  1878. 52616         tmp_stream._flags  = _IOWRITE + _IONBF + _IOWRITING;
  1879. 52617         tmp_stream._buf    = (unsigned char *) s;
  1880. 52618         tmp_stream._ptr    = (unsigned char *) s;
  1881. 52619         tmp_stream._count  = 32767;
  1882. 52620
  1883. 52621         retval = _doprnt(format, arg, &tmp_stream);
  1884. 52622         putc('',&tmp_stream);
  1885. 52623
  1886. 52624         return retval;
  1887. 52625 }
  1893. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1894. src/lib/stdio/vscanf.c    
  1895. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1897. 52700 /*
  1898. 52701  * vscanf.c - read formatted input from the standard input stream
  1899. 52702  */
  1900. 52703
  1901. 52704 #include        <stdio.h>
  1902. 52705 #include        <stdarg.h>
  1903. 52706 #include        "loc_incl.h"
  1904. 52707
  1905. 52708 int
  1906. 52709 vscanf(const char *format, va_list ap)
  1907. 52710 {
  1908. 52711         return _doscan(stdin, format, ap);
  1909. 52712 }
  1913. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1914. src/lib/stdio/vsscanf.c    
  1915. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1917. 52800 /*
  1918. 52801  * vsscanf - read formatted output from a string
  1919. 52802  */
  1920. 52803
  1921. 52804 #include        <stdio.h>
  1922. 52805 #include        <stdarg.h>
  1923. 52806 #include        <string.h>
  1924. 52807 #include        "loc_incl.h"
  1925. 52808
  1926. 52809 int vsscanf(const char *s, const char *format, va_list ap)
  1927. 52810 {
  1928. 52811         FILE tmp_stream;
  1929. 52812
  1930. 52813         tmp_stream._fd     = -1;
  1931. 52814         tmp_stream._flags  = _IOREAD + _IONBF + _IOREADING;
  1932. 52815         tmp_stream._buf    = (unsigned char *) s;
  1933. 52816         tmp_stream._ptr    = (unsigned char *) s;
  1934. 52817         tmp_stream._count  = strlen(s);
  1935. 52818
  1936. 52819         return _doscan(&tmp_stream, format, ap);
  1937. .Ep 472 src/lib/stdio/vsscanf.c
  1938. 52820 }
  1944. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1945. src/lib/syscall/_exit.s    
  1946. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1948. 52900 .sect .text
  1949. 52901 .extern ___exit
  1950. 52902 .define __exit
  1951. 52903 .align 2
  1952. 52904
  1953. 52905 __exit:
  1954. 52906         jmp     ___exit
  1959. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1960. src/lib/syscall/access.s    
  1961. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1963. 53000 .sect .text
  1964. 53001 .extern __access
  1965. 53002 .define _access
  1966. 53003 .align 2
  1967. 53004
  1968. 53005 _access:
  1969. 53006         jmp     __access
  1974. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1975. src/lib/syscall/alarm.s    
  1976. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1978. 53100 .sect .text
  1979. 53101 .extern __alarm
  1980. 53102 .define _alarm
  1981. 53103 .align 2
  1982. 53104
  1983. 53105 _alarm:
  1984. 53106         jmp     __alarm
  1985. .Op 473 src/lib/syscall/brk.s
  1987. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1988. src/lib/syscall/brk.s    
  1989. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1991. 53200 .sect .text
  1992. 53201 .extern __brk
  1993. 53202 .define _brk
  1994. 53203 .align 2
  1995. 53204
  1996. 53205 _brk:
  1997. 53206         jmp     __brk
  2002. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2003. src/lib/syscall/cfgetispeed.s    
  2004. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2006. 53300 .sect .text
  2007. 53301 .extern __cfgetispeed
  2008. 53302 .define _cfgetispeed
  2009. 53303 .align 2
  2010. 53304
  2011. 53305 _cfgetispeed:
  2012. 53306         jmp     __cfgetispeed
  2017. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2018. src/lib/syscall/cfgetospeed.s    
  2019. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2021. 53400 .sect .text
  2022. 53401 .extern __cfgetospeed
  2023. 53402 .define _cfgetospeed
  2024. 53403 .align 2
  2025. 53404
  2026. 53405 _cfgetospeed:
  2027. 53406         jmp     __cfgetospeed
  2032. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2033. src/lib/syscall/cfsetispeed.s    
  2034. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2036. 53500 .sect .text
  2037. 53501 .extern __cfsetispeed
  2038. 53502 .define _cfsetispeed
  2039. 53503 .align 2
  2040. 53504
  2041. 53505 _cfsetispeed:
  2042. 53506         jmp     __cfsetispeed
  2043. .Ep 474 src/lib/syscall/cfsetospeed.s
  2045. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2046. src/lib/syscall/cfsetospeed.s    
  2047. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2049. 53600 .sect .text
  2050. 53601 .extern __cfsetospeed
  2051. 53602 .define _cfsetospeed
  2052. 53603 .align 2
  2053. 53604
  2054. 53605 _cfsetospeed:
  2055. 53606         jmp     __cfsetospeed
  2060. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2061. src/lib/syscall/chdir.s    
  2062. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2064. 53700 .sect .text
  2065. 53701 .extern __chdir
  2066. 53702 .define _chdir
  2067. 53703 .align 2
  2068. 53704
  2069. 53705 _chdir:
  2070. 53706         jmp     __chdir
  2075. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2076. src/lib/syscall/chmod.s    
  2077. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2079. 53800 .sect .text
  2080. 53801 .extern __chmod
  2081. 53802 .define _chmod
  2082. 53803 .align 2
  2083. 53804
  2084. 53805 _chmod:
  2085. 53806         jmp     __chmod
  2090. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2091. src/lib/syscall/chown.s    
  2092. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2094. 53900 .sect .text
  2095. 53901 .extern __chown
  2096. 53902 .define _chown
  2097. 53903 .align 2
  2098. 53904
  2099. 53905 _chown:
  2100. 53906         jmp     __chown
  2101. .Op 475 src/lib/syscall/chroot.s
  2103. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2104. src/lib/syscall/chroot.s    
  2105. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2107. 54000 .sect .text
  2108. 54001 .extern __chroot
  2109. 54002 .define _chroot
  2110. 54003 .align 2
  2111. 54004
  2112. 54005 _chroot:
  2113. 54006         jmp     __chroot
  2118. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2119. src/lib/syscall/close.s    
  2120. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2122. 54100 .sect .text
  2123. 54101 .extern __close
  2124. 54102 .define _close
  2125. 54103 .align 2
  2126. 54104
  2127. 54105 _close:
  2128. 54106         jmp     __close
  2133. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2134. src/lib/syscall/closedir.s    
  2135. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2137. 54200 .sect .text
  2138. 54201 .extern __closedir
  2139. 54202 .define _closedir
  2140. 54203 .align 2
  2141. 54204
  2142. 54205 _closedir:
  2143. 54206         jmp     __closedir
  2148. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2149. src/lib/syscall/creat.s    
  2150. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2152. 54300 .sect .text
  2153. 54301 .extern __creat
  2154. 54302 .define _creat
  2155. 54303 .align 2
  2156. 54304
  2157. 54305 _creat:
  2158. 54306         jmp     __creat
  2159. .Ep 476 src/lib/syscall/dup.s
  2161. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2162. src/lib/syscall/dup.s    
  2163. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2165. 54400 .sect .text
  2166. 54401 .extern __dup
  2167. 54402 .define _dup
  2168. 54403 .align 2
  2169. 54404
  2170. 54405 _dup:
  2171. 54406         jmp     __dup
  2176. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2177. src/lib/syscall/dup2.s    
  2178. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2180. 54500 .sect .text
  2181. 54501 .extern __dup2
  2182. 54502 .define _dup2
  2183. 54503 .align 2
  2184. 54504
  2185. 54505 _dup2:
  2186. 54506         jmp     __dup2
  2191. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2192. src/lib/syscall/execl.s    
  2193. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2195. 54600 .sect .text
  2196. 54601 .extern __execl
  2197. 54602 .define _execl
  2198. 54603 .align 2
  2199. 54604
  2200. 54605 _execl:
  2201. 54606         jmp     __execl
  2206. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2207. src/lib/syscall/execle.s    
  2208. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2210. 54700 .sect .text
  2211. 54701 .extern __execle
  2212. 54702 .define _execle
  2213. 54703 .align 2
  2214. 54704
  2215. 54705 _execle:
  2216. 54706         jmp     __execle
  2217. .Op 477 src/lib/syscall/execv.s
  2219. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2220. src/lib/syscall/execv.s    
  2221. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2223. 54800 .sect .text
  2224. 54801 .extern __execv
  2225. 54802 .define _execv
  2226. 54803 .align 2
  2227. 54804
  2228. 54805 _execv:
  2229. 54806         jmp     __execv
  2234. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2235. src/lib/syscall/execve.s    
  2236. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2238. 54900 .sect .text
  2239. 54901 .extern __execve
  2240. 54902 .define _execve
  2241. 54903 .align 2
  2242. 54904
  2243. 54905 _execve:
  2244. 54906         jmp     __execve
  2249. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2250. src/lib/syscall/fcntl.s    
  2251. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2253. 55000 .sect .text
  2254. 55001 .extern __fcntl
  2255. 55002 .define _fcntl
  2256. 55003 .align 2
  2257. 55004
  2258. 55005 _fcntl:
  2259. 55006         jmp     __fcntl
  2264. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2265. src/lib/syscall/fork.s    
  2266. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2268. 55100 .sect .text
  2269. 55101 .extern __fork
  2270. 55102 .define _fork
  2271. 55103 .align 2
  2272. 55104
  2273. 55105 _fork:
  2274. 55106         jmp     __fork
  2275. .Ep 478 src/lib/syscall/fpathconf.s
  2277. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2278. src/lib/syscall/fpathconf.s    
  2279. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2281. 55200 .sect .text
  2282. 55201 .extern __fpathconf
  2283. 55202 .define _fpathconf
  2284. 55203 .align 2
  2285. 55204
  2286. 55205 _fpathconf:
  2287. 55206         jmp     __fpathconf
  2292. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2293. src/lib/syscall/fstat.s    
  2294. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2296. 55300 .sect .text
  2297. 55301 .extern __fstat
  2298. 55302 .define _fstat
  2299. 55303 .align 2
  2300. 55304
  2301. 55305 _fstat:
  2302. 55306         jmp     __fstat
  2307. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2308. src/lib/syscall/getcwd.s    
  2309. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2311. 55400 .sect .text
  2312. 55401 .extern __getcwd
  2313. 55402 .define _getcwd
  2314. 55403 .align 2
  2315. 55404
  2316. 55405 _getcwd:
  2317. 55406         jmp     __getcwd
  2322. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2323. src/lib/syscall/getegid.s    
  2324. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2326. 55500 .sect .text
  2327. 55501 .extern __getegid
  2328. 55502 .define _getegid
  2329. 55503 .align 2
  2330. 55504
  2331. 55505 _getegid:
  2332. 55506         jmp     __getegid
  2333. .Op 479 src/lib/syscall/geteuid.s
  2335. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2336. src/lib/syscall/geteuid.s    
  2337. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2339. 55600 .sect .text
  2340. 55601 .extern __geteuid
  2341. 55602 .define _geteuid
  2342. 55603 .align 2
  2343. 55604
  2344. 55605 _geteuid:
  2345. 55606         jmp     __geteuid
  2350. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2351. src/lib/syscall/getgid.s    
  2352. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2354. 55700 .sect .text
  2355. 55701 .extern __getgid
  2356. 55702 .define _getgid
  2357. 55703 .align 2
  2358. 55704
  2359. 55705 _getgid:
  2360. 55706         jmp     __getgid
  2365. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2366. src/lib/syscall/getgroups.s    
  2367. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2369. 55800 .sect .text
  2370. 55801 .extern __getgroups
  2371. 55802 .define _getgroups
  2372. 55803 .align 2
  2373. 55804
  2374. 55805 _getgroups:
  2375. 55806         jmp     __getgroups
  2380. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2381. src/lib/syscall/getpgrp.s    
  2382. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2384. 55900 .sect .text
  2385. 55901 .extern __getpgrp
  2386. 55902 .define _getpgrp
  2387. 55903 .align 2
  2388. 55904
  2389. 55905 _getpgrp:
  2390. 55906         jmp     __getpgrp
  2391. .Ep 480 src/lib/syscall/getpid.s
  2393. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2394. src/lib/syscall/getpid.s    
  2395. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2397. 56000 .sect .text
  2398. 56001 .extern __getpid
  2399. 56002 .define _getpid
  2400. 56003 .align 2
  2401. 56004
  2402. 56005 _getpid:
  2403. 56006         jmp     __getpid
  2408. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2409. src/lib/syscall/getppid.s    
  2410. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2412. 56100 .sect .text
  2413. 56101 .extern __getppid
  2414. 56102 .define _getppid
  2415. 56103 .align 2
  2416. 56104
  2417. 56105 _getppid:
  2418. 56106         jmp     __getppid
  2423. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2424. src/lib/syscall/getuid.s    
  2425. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2427. 56200 .sect .text
  2428. 56201 .extern __getuid
  2429. 56202 .define _getuid
  2430. 56203 .align 2
  2431. 56204
  2432. 56205 _getuid:
  2433. 56206         jmp     __getuid
  2438. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2439. src/lib/syscall/ioctl.s    
  2440. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2442. 56300 .sect .text
  2443. 56301 .extern __ioctl
  2444. 56302 .define _ioctl
  2445. 56303 .align 2
  2446. 56304
  2447. 56305 _ioctl:
  2448. 56306         jmp     __ioctl
  2449. .Op 481 src/lib/syscall/isatty.s
  2451. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2452. src/lib/syscall/isatty.s    
  2453. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2455. 56400 .sect .text
  2456. 56401 .extern __isatty
  2457. 56402 .define _isatty
  2458. 56403 .align 2
  2459. 56404
  2460. 56405 _isatty:
  2461. 56406         jmp     __isatty
  2466. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2467. src/lib/syscall/kill.s    
  2468. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2470. 56500 .sect .text
  2471. 56501 .extern __kill
  2472. 56502 .define _kill
  2473. 56503 .align 2
  2474. 56504
  2475. 56505 _kill:
  2476. 56506         jmp     __kill
  2481. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2482. src/lib/syscall/link.s    
  2483. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2485. 56600 .sect .text
  2486. 56601 .extern __link
  2487. 56602 .define _link
  2488. 56603 .align 2
  2489. 56604
  2490. 56605 _link:
  2491. 56606         jmp     __link
  2496. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2497. src/lib/syscall/lseek.s    
  2498. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2500. 56700 .sect .text
  2501. 56701 .extern __lseek
  2502. 56702 .define _lseek
  2503. 56703 .align 2
  2504. 56704
  2505. 56705 _lseek:
  2506. 56706         jmp     __lseek
  2507. .Ep 482 src/lib/syscall/mkdir.s
  2509. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2510. src/lib/syscall/mkdir.s    
  2511. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2513. 56800 .sect .text
  2514. 56801 .extern __mkdir
  2515. 56802 .define _mkdir
  2516. 56803 .align 2
  2517. 56804
  2518. 56805 _mkdir:
  2519. 56806         jmp     __mkdir
  2524. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2525. src/lib/syscall/mkfifo.s    
  2526. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2528. 56900 .sect .text
  2529. 56901 .extern __mkfifo
  2530. 56902 .define _mkfifo
  2531. 56903 .align 2
  2532. 56904
  2533. 56905 _mkfifo:
  2534. 56906         jmp     __mkfifo
  2539. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2540. src/lib/syscall/mknod.s    
  2541. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2543. 57000 .sect .text
  2544. 57001 .extern __mknod
  2545. 57002 .define _mknod
  2546. 57003 .align 2
  2547. 57004
  2548. 57005 _mknod:
  2549. 57006         jmp     __mknod
  2554. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2555. src/lib/syscall/mktemp.s    
  2556. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2558. 57100 .sect .text
  2559. 57101 .extern __mktemp
  2560. 57102 .define _mktemp
  2561. 57103 .align 2
  2562. 57104
  2563. 57105 _mktemp:
  2564. 57106         jmp     __mktemp
  2565. .Op 483 src/lib/syscall/mount.s
  2567. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2568. src/lib/syscall/mount.s    
  2569. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2571. 57200 .sect .text
  2572. 57201 .extern __mount
  2573. 57202 .define _mount
  2574. 57203 .align 2
  2575. 57204
  2576. 57205 _mount:
  2577. 57206         jmp     __mount
  2582. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2583. src/lib/syscall/open.s    
  2584. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2586. 57300 .sect .text
  2587. 57301 .extern __open
  2588. 57302 .define _open
  2589. 57303 .align 2
  2590. 57304
  2591. 57305 _open:
  2592. 57306         jmp     __open
  2597. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2598. src/lib/syscall/opendir.s    
  2599. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2601. 57400 .sect .text
  2602. 57401 .extern __opendir
  2603. 57402 .define _opendir
  2604. 57403 .align 2
  2605. 57404
  2606. 57405 _opendir:
  2607. 57406         jmp     __opendir
  2612. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2613. src/lib/syscall/pathconf.s    
  2614. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2616. 57500 .sect .text
  2617. 57501 .extern __pathconf
  2618. 57502 .define _pathconf
  2619. 57503 .align 2
  2620. 57504
  2621. 57505 _pathconf:
  2622. 57506         jmp     __pathconf
  2623. .Ep 484 src/lib/syscall/pause.s
  2625. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2626. src/lib/syscall/pause.s    
  2627. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2629. 57600 .sect .text
  2630. 57601 .extern __pause
  2631. 57602 .define _pause
  2632. 57603 .align 2
  2633. 57604
  2634. 57605 _pause:
  2635. 57606         jmp     __pause
  2640. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2641. src/lib/syscall/pipe.s    
  2642. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2644. 57700 .sect .text
  2645. 57701 .extern __pipe
  2646. 57702 .define _pipe
  2647. 57703 .align 2
  2648. 57704
  2649. 57705 _pipe:
  2650. 57706         jmp     __pipe
  2655. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2656. src/lib/syscall/ptrace.s    
  2657. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2659. 57800 .sect .text
  2660. 57801 .extern __ptrace
  2661. 57802 .define _ptrace
  2662. 57803 .align 2
  2663. 57804
  2664. 57805 _ptrace:
  2665. 57806         jmp     __ptrace
  2670. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2671. src/lib/syscall/read.s    
  2672. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2674. 57900 .sect .text
  2675. 57901 .extern __read
  2676. 57902 .define _read
  2677. 57903 .align 2
  2678. 57904
  2679. 57905 _read:
  2680. 57906         jmp     __read
  2681. .Op 485 src/lib/syscall/readdir.s
  2683. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2684. src/lib/syscall/readdir.s    
  2685. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2687. 58000 .sect .text
  2688. 58001 .extern __readdir
  2689. 58002 .define _readdir
  2690. 58003 .align 2
  2691. 58004
  2692. 58005 _readdir:
  2693. 58006         jmp     __readdir
  2698. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2699. src/lib/syscall/reboot.s    
  2700. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2702. 58100 .sect .text
  2703. 58101 .extern __reboot
  2704. 58102 .define _reboot
  2705. 58103 .align 2
  2706. 58104
  2707. 58105 _reboot:
  2708. 58106         jmp     __reboot
  2713. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2714. src/lib/syscall/rename.s    
  2715. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2717. 58200 .sect .text
  2718. 58201 .extern __rename
  2719. 58202 .define _rename
  2720. 58203 .align 2
  2721. 58204
  2722. 58205 _rename:
  2723. 58206         jmp     __rename
  2728. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2729. src/lib/syscall/rewinddir.s    
  2730. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2732. 58300 .sect .text
  2733. 58301 .extern __rewinddir
  2734. 58302 .define _rewinddir
  2735. 58303 .align 2
  2736. 58304
  2737. 58305 _rewinddir:
  2738. 58306         jmp     __rewinddir
  2739. .Ep 486 src/lib/syscall/rmdir.s
  2741. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2742. src/lib/syscall/rmdir.s    
  2743. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2745. 58400 .sect .text
  2746. 58401 .extern __rmdir
  2747. 58402 .define _rmdir
  2748. 58403 .align 2
  2749. 58404
  2750. 58405 _rmdir:
  2751. 58406         jmp     __rmdir
  2756. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2757. src/lib/syscall/sbrk.s    
  2758. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2760. 58500 .sect .text
  2761. 58501 .extern __sbrk
  2762. 58502 .define _sbrk
  2763. 58503 .align 2
  2764. 58504
  2765. 58505 _sbrk:
  2766. 58506         jmp     __sbrk
  2771. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2772. src/lib/syscall/seekdir.s    
  2773. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2775. 58600 .sect .text
  2776. 58601 .extern __seekdir
  2777. 58602 .define _seekdir
  2778. 58603 .align 2
  2779. 58604
  2780. 58605 _seekdir:
  2781. 58606         jmp     __seekdir
  2786. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2787. src/lib/syscall/setgid.s    
  2788. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2790. 58700 .sect .text
  2791. 58701 .extern __setgid
  2792. 58702 .define _setgid
  2793. 58703 .align 2
  2794. 58704
  2795. 58705 _setgid:
  2796. 58706         jmp     __setgid
  2797. .Op 487 src/lib/syscall/setsid.s
  2799. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2800. src/lib/syscall/setsid.s    
  2801. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2803. 58800 .sect .text
  2804. 58801 .extern __setsid
  2805. 58802 .define _setsid
  2806. 58803 .align 2
  2807. 58804
  2808. 58805 _setsid:
  2809. 58806         jmp     __setsid
  2814. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2815. src/lib/syscall/setuid.s    
  2816. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2818. 58900 .sect .text
  2819. 58901 .extern __setuid
  2820. 58902 .define _setuid
  2821. 58903 .align 2
  2822. 58904
  2823. 58905 _setuid:
  2824. 58906         jmp     __setuid
  2829. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2830. src/lib/syscall/sigaction.s    
  2831. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2833. 59000 .sect .text
  2834. 59001 .extern __sigaction
  2835. 59002 .define _sigaction
  2836. 59003 .align 2
  2837. 59004
  2838. 59005 _sigaction:
  2839. 59006         jmp     __sigaction
  2844. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2845. src/lib/syscall/sigaddset.s    
  2846. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2848. 59100 .sect .text
  2849. 59101 .extern __sigaddset
  2850. 59102 .define _sigaddset
  2851. 59103 .align 2
  2852. 59104
  2853. 59105 _sigaddset:
  2854. 59106         jmp     __sigaddset
  2855. .Ep 488 src/lib/syscall/sigdelset.s
  2857. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2858. src/lib/syscall/sigdelset.s    
  2859. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2861. 59200 .sect .text
  2862. 59201 .extern __sigdelset
  2863. 59202 .define _sigdelset
  2864. 59203 .align 2
  2865. 59204
  2866. 59205 _sigdelset:
  2867. 59206         jmp     __sigdelset
  2872. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2873. src/lib/syscall/sigemptyset.s    
  2874. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2876. 59300 .sect .text
  2877. 59301 .extern __sigemptyset
  2878. 59302 .define _sigemptyset
  2879. 59303 .align 2
  2880. 59304
  2881. 59305 _sigemptyset:
  2882. 59306         jmp     __sigemptyset
  2887. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2888. src/lib/syscall/sigfillset.s    
  2889. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2891. 59400 .sect .text
  2892. 59401 .extern __sigfillset
  2893. 59402 .define _sigfillset
  2894. 59403 .align 2
  2895. 59404
  2896. 59405 _sigfillset:
  2897. 59406         jmp     __sigfillset
  2902. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2903. src/lib/syscall/sigismember.s    
  2904. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2906. 59500 .sect .text
  2907. 59501 .extern __sigismember
  2908. 59502 .define _sigismember
  2909. 59503 .align 2
  2910. 59504
  2911. 59505 _sigismember:
  2912. 59506         jmp     __sigismember
  2913. .Op 489 src/lib/syscall/sigpending.s
  2915. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2916. src/lib/syscall/sigpending.s    
  2917. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2919. 59600 .sect .text
  2920. 59601 .extern __sigpending
  2921. 59602 .define _sigpending
  2922. 59603 .align 2
  2923. 59604
  2924. 59605 _sigpending:
  2925. 59606         jmp     __sigpending
  2930. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2931. src/lib/syscall/sigprocmask.s    
  2932. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2934. 59700 .sect .text
  2935. 59701 .extern __sigprocmask
  2936. 59702 .define _sigprocmask
  2937. 59703 .align 2
  2938. 59704
  2939. 59705 _sigprocmask:
  2940. 59706         jmp     __sigprocmask
  2945. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2946. src/lib/syscall/sigreturn.s    
  2947. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2949. 59800 .sect .text
  2950. 59801 .extern __sigreturn
  2951. 59802 .define _sigreturn
  2952. 59803 .align 2
  2953. 59804
  2954. 59805 _sigreturn:
  2955. 59806         jmp     __sigreturn
  2960. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2961. src/lib/syscall/sigsuspend.s    
  2962. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2964. 59900 .sect .text
  2965. 59901 .extern __sigsuspend
  2966. 59902 .define _sigsuspend
  2967. 59903 .align 2
  2968. 59904
  2969. 59905 _sigsuspend:
  2970. 59906         jmp     __sigsuspend
  2971. .Ep 490 src/lib/syscall/sleep.s
  2973. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2974. src/lib/syscall/sleep.s    
  2975. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2977. 60000 .sect .text
  2978. 60001 .extern __sleep
  2979. 60002 .define _sleep
  2980. 60003 .align 2
  2981. 60004
  2982. 60005 _sleep:
  2983. 60006         jmp     __sleep
  2988. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2989. src/lib/syscall/stat.s    
  2990. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2992. 60100 .sect .text
  2993. 60101 .extern __stat
  2994. 60102 .define _stat
  2995. 60103 .align 2
  2996. 60104
  2997. 60105 _stat:
  2998. 60106         jmp     __stat
  3003. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3004. src/lib/syscall/stime.s    
  3005. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3007. 60200 .sect .text
  3008. 60201 .extern __stime
  3009. 60202 .define _stime
  3010. 60203 .align 2
  3011. 60204
  3012. 60205 _stime:
  3013. 60206         jmp     __stime
  3018. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3019. src/lib/syscall/sync.s    
  3020. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3022. 60300 .sect .text
  3023. 60301 .extern __sync
  3024. 60302 .define _sync
  3025. 60303 .align 2
  3026. 60304
  3027. 60305 _sync:
  3028. 60306         jmp     __sync
  3029. .Op 491 src/lib/syscall/tcdrain.s
  3031. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3032. src/lib/syscall/tcdrain.s    
  3033. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3035. 60400 .sect .text
  3036. 60401 .extern __tcdrain
  3037. 60402 .define _tcdrain
  3038. 60403 .align 2
  3039. 60404
  3040. 60405 _tcdrain:
  3041. 60406         jmp     __tcdrain
  3046. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3047. src/lib/syscall/tcflow.s    
  3048. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3050. 60500 .sect .text
  3051. 60501 .extern __tcflow
  3052. 60502 .define _tcflow
  3053. 60503 .align 2
  3054. 60504
  3055. 60505 _tcflow:
  3056. 60506         jmp     __tcflow
  3061. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3062. src/lib/syscall/tcflush.s    
  3063. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3065. 60600 .sect .text
  3066. 60601 .extern __tcflush
  3067. 60602 .define _tcflush
  3068. 60603 .align 2
  3069. 60604
  3070. 60605 _tcflush:
  3071. 60606         jmp     __tcflush
  3076. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3077. src/lib/syscall/tcgetattr.s    
  3078. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3080. 60700 .sect .text
  3081. 60701 .extern __tcgetattr
  3082. 60702 .define _tcgetattr
  3083. 60703 .align 2
  3084. 60704
  3085. 60705 _tcgetattr:
  3086. 60706         jmp     __tcgetattr
  3087. .Ep 492 src/lib/syscall/tcsendbreak.s
  3089. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3090. src/lib/syscall/tcsendbreak.s    
  3091. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3093. 60800 .sect .text
  3094. 60801 .extern __tcsendbreak
  3095. 60802 .define _tcsendbreak
  3096. 60803 .align 2
  3097. 60804
  3098. 60805 _tcsendbreak:
  3099. 60806         jmp     __tcsendbreak
  3104. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3105. src/lib/syscall/tcsetattr.s    
  3106. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3108. 60900 .sect .text
  3109. 60901 .extern __tcsetattr
  3110. 60902 .define _tcsetattr
  3111. 60903 .align 2
  3112. 60904
  3113. 60905 _tcsetattr:
  3114. 60906         jmp     __tcsetattr
  3119. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3120. src/lib/syscall/time.s    
  3121. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3123. 61000 .sect .text
  3124. 61001 .extern __time
  3125. 61002 .define _time
  3126. 61003 .align 2
  3127. 61004
  3128. 61005 _time:
  3129. 61006         jmp     __time
  3134. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3135. src/lib/syscall/times.s    
  3136. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3138. 61100 .sect .text
  3139. 61101 .extern __times
  3140. 61102 .define _times
  3141. 61103 .align 2
  3142. 61104
  3143. 61105 _times:
  3144. 61106         jmp     __times
  3145. .Op 493 src/lib/syscall/umask.s
  3147. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3148. src/lib/syscall/umask.s    
  3149. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3151. 61200 .sect .text
  3152. 61201 .extern __umask
  3153. 61202 .define _umask
  3154. 61203 .align 2
  3155. 61204
  3156. 61205 _umask:
  3157. 61206         jmp     __umask
  3162. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3163. src/lib/syscall/umount.s    
  3164. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3166. 61300 .sect .text
  3167. 61301 .extern __umount
  3168. 61302 .define _umount
  3169. 61303 .align 2
  3170. 61304
  3171. 61305 _umount:
  3172. 61306         jmp     __umount
  3177. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3178. src/lib/syscall/uname.s    
  3179. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3181. 61400 .sect .text
  3182. 61401 .extern __uname
  3183. 61402 .define _uname
  3184. 61403 .align 2
  3185. 61404
  3186. 61405 _uname:
  3187. 61406         jmp     __uname
  3192. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3193. src/lib/syscall/unlink.s    
  3194. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3196. 61500 .sect .text
  3197. 61501 .extern __unlink
  3198. 61502 .define _unlink
  3199. 61503 .align 2
  3200. 61504
  3201. 61505 _unlink:
  3202. 61506         jmp     __unlink
  3203. .Ep 494 src/lib/syscall/utime.s
  3205. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3206. src/lib/syscall/utime.s    
  3207. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3209. 61600 .sect .text
  3210. 61601 .extern __utime
  3211. 61602 .define _utime
  3212. 61603 .align 2
  3213. 61604
  3214. 61605 _utime:
  3215. 61606         jmp     __utime
  3220. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3221. src/lib/syscall/wait.s    
  3222. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3224. 61700 .sect .text
  3225. 61701 .extern __wait
  3226. 61702 .define _wait
  3227. 61703 .align 2
  3228. 61704
  3229. 61705 _wait:
  3230. 61706         jmp     __wait
  3235. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3236. src/lib/syscall/waitpid.s    
  3237. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3239. 61800 .sect .text
  3240. 61801 .extern __waitpid
  3241. 61802 .define _waitpid
  3242. 61803 .align 2
  3243. 61804
  3244. 61805 _waitpid:
  3245. 61806         jmp     __waitpid
  3250. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3251. src/lib/syscall/write.s    
  3252. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3254. 61900 .sect .text
  3255. 61901 .extern __write
  3256. 61902 .define _write
  3257. 61903 .align 2
  3258. 61904
  3259. 61905 _write:
  3260. 61906         jmp     __write
  3261. .Op 495 src/lib/syslib/syslib.h
  3263. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3264. src/lib/syslib/syslib.h    
  3265. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3267. 62000 /*      syslib.h - System library common definitions.   */
  3268. 62001
  3269. 62002 #define _SYSTEM
  3270. 62003
  3271. 62004 #include <lib.h>
  3272. 62005 #include <minix/com.h>
  3273. 62006 #include <minix/syslib.h>
  3278. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3279. src/lib/syslib/sys_abort.c    
  3280. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3282. 62100 #include "syslib.h"
  3283. 62101 #include <stdarg.h>
  3284. 62102 #include <unistd.h>
  3285. 62103
  3286. 62104 PUBLIC int sys_abort(int how, ...)
  3287. 62105 {
  3288. 62106 /* Something awful has happened.  Abandon ship. */
  3289. 62107
  3290. 62108   message m;
  3291. 62109   va_list ap;
  3292. 62110
  3293. 62111   va_start(ap, how);
  3294. 62112   if ((m.m1_i1 = how) == RBT_MONITOR) m.m1_p1 = va_arg(ap, char *);
  3295. 62113   va_end(ap);
  3296. 62114
  3297. 62115   return(_taskcall(SYSTASK, SYS_ABORT, &m));
  3298. 62116 }
  3303. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3304. src/lib/syslib/sys_copy.c    
  3305. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3307. 62200 #include "syslib.h"
  3308. 62201
  3309. 62202 PUBLIC int sys_copy(src_proc, src_seg, src_vir,
  3310. 62203                                         dst_proc, dst_seg, dst_vir, bytes)
  3311. 62204 int src_proc;                   /* source process */
  3312. 62205 int src_seg;                    /* source segment: T, D, or S */
  3313. 62206 phys_bytes src_vir;             /* source virtual address (phys addr for ABS)*/
  3314. 62207 int dst_proc;                   /* dest process */
  3315. 62208 int dst_seg;                    /* dest segment: T, D, or S */
  3316. 62209 phys_bytes dst_vir;             /* dest virtual address (phys addr for ABS) */
  3317. 62210 phys_bytes bytes;               /* how many bytes */
  3318. 62211 {
  3319. 62212 /* Transfer a block of data.  The source and destination can each either be a
  3320. 62213  * process (including MM) or absolute memory, indicate by setting 'src_proc'
  3321. 62214  * or 'dst_proc' to ABS.
  3322. .Ep 496 src/lib/syslib/sys_copy.c
  3323. 62215  */
  3324. 62216
  3325. 62217   message copy_mess;
  3326. 62218
  3327. 62219   if (bytes == 0L) return(OK);
  3328. 62220   copy_mess.SRC_SPACE = src_seg;
  3329. 62221   copy_mess.SRC_PROC_NR = src_proc;
  3330. 62222   copy_mess.SRC_BUFFER = (long) src_vir;
  3331. 62223
  3332. 62224   copy_mess.DST_SPACE = dst_seg;
  3333. 62225   copy_mess.DST_PROC_NR = dst_proc;
  3334. 62226   copy_mess.DST_BUFFER = (long) dst_vir;
  3335. 62227
  3336. 62228   copy_mess.COPY_BYTES = (long) bytes;
  3337. 62229   return(_taskcall(SYSTASK, SYS_COPY, &copy_mess));
  3338. 62230 }
  3344. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3345. src/lib/syslib/sys_endsig.c    
  3346. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3348. 62300 #include "syslib.h"
  3349. 62301
  3350. 62302 PUBLIC int sys_endsig(proc)
  3351. 62303 int proc;
  3352. 62304 {
  3353. 62305   message m;
  3354. 62306
  3355. 62307   m.m1_i1 = proc;
  3356. 62308   return(_taskcall(SYSTASK, SYS_ENDSIG, &m));
  3357. 62309 }
  3364. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3365. src/lib/syslib/sys_exec.c    
  3366. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3368. 62400 #include "syslib.h"
  3369. 62401
  3370. 62402 PUBLIC int sys_exec(proc, ptr, traced, prog_name, initpc)
  3371. 62403 int proc;                       /* process that did exec */
  3372. 62404 char *ptr;                      /* new stack pointer */
  3373. 62405 int traced;                     /* is tracing enabled? */
  3374. 62406 char *prog_name;                /* name of the new program */
  3375. 62407 vir_bytes initpc;
  3376. 62408 {
  3377. 62409 /* A process has exec'd.  Tell the kernel. */
  3378. 62410
  3379. 62411   message m;
  3380. 62412
  3381. 62413   m.m1_i1 = proc;
  3382. 62414   m.m1_i2 = traced;
  3383. .Op 497 src/lib/syslib/sys_exec.c
  3384. 62415   m.m1_p1 = ptr;
  3385. 62416   m.m1_p2 = prog_name;
  3386. 62417   m.m1_p3 = (char *)initpc;
  3387. 62418   return(_taskcall(SYSTASK, SYS_EXEC, &m));
  3388. 62419 }
  3395. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3396. src/lib/syslib/sys_fork.c    
  3397. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3399. 62500 #include "syslib.h"
  3400. 62501
  3401. 62502 PUBLIC int sys_fork(parent, child, pid, child_base_or_shadow)
  3402. 62503 int parent;                     /* process doing the fork */
  3403. 62504 int child;                      /* which proc has been created by the fork */
  3404. 62505 int pid;                        /* process id assigned by MM */
  3405. 62506 phys_clicks child_base_or_shadow;       /* position for child [VM386];
  3406. 62507                                  * memory allocated for shadow [68000] */
  3407. 62508 {
  3408. 62509 /* A process has forked.  Tell the kernel. */
  3409. 62510
  3410. 62511   message m;
  3411. 62512
  3412. 62513   m.m1_i1 = parent;
  3413. 62514   m.m1_i2 = child;
  3414. 62515   m.m1_i3 = pid;
  3415. 62516   m.m1_p1 = (char *) child_base_or_shadow;
  3416. 62517   return(_taskcall(SYSTASK, SYS_FORK, &m));
  3417. 62518 }
  3420. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3421. src/lib/syslib/sys_fresh.c    
  3422. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3424. 62600 #include "syslib.h"
  3425. 62601
  3426. 62602 PUBLIC int sys_fresh(proc, ptr, dc, basep, sizep)
  3427. 62603 int proc;                       /* process whose map is to be changed */
  3428. 62604 struct mem_map *ptr;            /* pointer to new map */
  3429. 62605 phys_clicks dc;                 /* size of initialized data */
  3430. 62606 phys_clicks *basep, *sizep;     /* base and size for free_mem() */
  3431. 62607 {
  3432. 62608 /* Create a fresh process image for exec().  Tell the kernel. */
  3433. 62609
  3434. 62610   message m;
  3435. 62611   int r;
  3436. 62612
  3437. 62613   m.m1_i1 = proc;
  3438. 62614   m.m1_i2 = (int) dc;
  3439. 62615   m.m1_p1 = (char *) ptr;
  3440. 62616   r = _taskcall(SYSTASK, SYS_FRESH, &m);
  3441. 62617   *basep = (phys_clicks) m.m1_i1;
  3442. 62618   *sizep = (phys_clicks) m.m1_i2;
  3443. 62619   return(r);
  3444. .Ep 498 src/lib/syslib/sys_fresh.c
  3445. 62620 }
  3451. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3452. src/lib/syslib/sys_getmap.c    
  3453. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3455. 62700 #include "syslib.h"
  3456. 62701
  3457. 62702 PUBLIC int sys_getmap(proc, ptr)
  3458. 62703 int proc;                       /* process whose map is to be fetched */
  3459. 62704 struct mem_map *ptr;            /* pointer to new map */
  3460. 62705 {
  3461. 62706 /* Want to know map of a process, ask the kernel. */
  3462. 62707
  3463. 62708   message m;
  3464. 62709
  3465. 62710   m.m1_i1 = proc;
  3466. 62711   m.m1_p1 = (char *) ptr;
  3467. 62712   return(_taskcall(SYSTASK, SYS_GETMAP, &m));
  3468. 62713 }
  3471. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3472. src/lib/syslib/sys_getsp.c    
  3473. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3475. 62800 #include "syslib.h"
  3476. 62801
  3477. 62802 PUBLIC int sys_getsp(proc, newsp)
  3478. 62803 int proc;                       /* process whose sp is wanted */
  3479. 62804 vir_bytes *newsp;               /* place to put sp read from kernel */
  3480. 62805 {
  3481. 62806 /* Ask the kernel what the sp is. */
  3482. 62807
  3483. 62808   message m;
  3484. 62809   int r;
  3485. 62810
  3486. 62811   m.m1_i1 = proc;
  3487. 62812   r = _taskcall(SYSTASK, SYS_GETSP, &m);
  3488. 62813   *newsp = (vir_bytes) m.STACK_PTR;
  3489. 62814   return(r);
  3490. 62815 }
  3491. .Op 499 src/lib/syslib/sys_kill.c
  3493. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3494. src/lib/syslib/sys_kill.c    
  3495. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3497. 62900 #include "syslib.h"
  3498. 62901
  3499. 62902 PUBLIC int sys_kill(proc, signr)
  3500. 62903 int proc;                       /* which proc has exited */
  3501. 62904 int signr;                      /* signal number: 1 - 16 */
  3502. 62905 {
  3503. 62906 /* A proc has to be signaled via MM.  Tell the kernel. */
  3504. 62907   message m;
  3505. 62908
  3506. 62909   m.m6_i1 = proc;
  3507. 62910   m.m6_i2 = signr;
  3508. 62911   return(_taskcall(SYSTASK, SYS_KILL, &m));
  3509. 62912 }
  3513. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3514. src/lib/syslib/sys_newmap.c    
  3515. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3517. 63000 #include "syslib.h"
  3518. 63001
  3519. 63002 PUBLIC int sys_newmap(proc, ptr)
  3520. 63003 int proc;                       /* process whose map is to be changed */
  3521. 63004 struct mem_map *ptr;            /* pointer to new map */
  3522. 63005 {
  3523. 63006 /* A process has been assigned a new memory map.  Tell the kernel. */
  3524. 63007
  3525. 63008   message m;
  3526. 63009
  3527. 63010   m.m1_i1 = proc;
  3528. 63011   m.m1_p1 = (char *) ptr;
  3529. 63012   return(_taskcall(SYSTASK, SYS_NEWMAP, &m));
  3530. 63013 }
  3533. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3534. src/lib/syslib/sys_oldsig.c    
  3535. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3537. 63100 #include "syslib.h"
  3538. 63101
  3539. 63102 PUBLIC int sys_oldsig(proc, sig, sighandler)
  3540. 63103 int proc;                       /* process to be signaled  */
  3541. 63104 int sig;                        /* signal number: 1 to _NSIG */
  3542. 63105 sighandler_t sighandler;        /* pointer to signal handler in user space */
  3543. 63106 {
  3544. 63107 /* A proc has to be signaled.  Tell the kernel. This function is obsolete. */
  3545. 63108
  3546. 63109   message m;
  3547. 63110
  3548. 63111   m.m6_i1 = proc;
  3549. 63112   m.m6_i2 = sig;
  3550. 63113   m.m6_f1 = sighandler;
  3551. 63114   return(_taskcall(SYSTASK, SYS_OLDSIG, &m));
  3552. .Ep 500 src/lib/syslib/sys_oldsig.c
  3553. 63115 }
  3559. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3560. src/lib/syslib/sys_sendsig.c    
  3561. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3563. 63200 #include "syslib.h"
  3564. 63201
  3565. 63202 PUBLIC int sys_sendsig(proc, smp)
  3566. 63203 int proc;
  3567. 63204 struct sigmsg *smp;
  3568. 63205 {
  3569. 63206   message m;
  3570. 63207
  3571. 63208   m.m1_i1 = proc;
  3572. 63209   m.m1_p1 = (char *) smp;
  3573. 63210   return(_taskcall(SYSTASK, SYS_SENDSIG, &m));
  3574. 63211 }
  3579. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3580. src/lib/syslib/sys_sigret.c    
  3581. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3583. 63300 #include "syslib.h"
  3584. 63301
  3585. 63302 PUBLIC int sys_sigreturn(proc, scp, flags)
  3586. 63303 int proc;
  3587. 63304 vir_bytes scp;
  3588. 63305 int flags;
  3589. 63306 {
  3590. 63307   message m;
  3591. 63308
  3592. 63309   m.m1_i1 = proc;
  3593. 63310   m.m1_i2 = flags;
  3594. 63311   m.m1_p1 = (char *) scp;
  3595. 63312   return(_taskcall(SYSTASK, SYS_SIGRETURN, &m));
  3596. 63313 }
  3599. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3600. src/lib/syslib/sys_times.c    
  3601. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3603. 63400 #include "syslib.h"
  3604. 63401
  3605. 63402 PUBLIC int sys_times(proc, ptr)
  3606. 63403 int proc;                       /* proc whose times are needed */
  3607. 63404 clock_t ptr[5];                 /* pointer to time buffer */
  3608. 63405 {
  3609. 63406 /* Fetch the accounting info for a proc. */
  3610. 63407   message m;
  3611. 63408   int r;
  3612. 63409
  3613. .Op 501 src/lib/syslib/sys_times.c
  3614. 63410   m.m1_i1 = proc;
  3615. 63411   m.m1_p1 = (char *)ptr;
  3616. 63412   r = _taskcall(SYSTASK, SYS_TIMES, &m);
  3617. 63413   ptr[0] = m.USER_TIME;
  3618. 63414   ptr[1] = m.SYSTEM_TIME;
  3619. 63415   ptr[2] = m.CHILD_UTIME;
  3620. 63416   ptr[3] = m.CHILD_STIME;
  3621. 63417   ptr[4] = m.BOOT_TICKS;
  3622. 63418   return(r);
  3623. 63419 }
  3630. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3631. src/lib/syslib/sys_trace.c    
  3632. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3634. 63500 #include "syslib.h"
  3635. 63501
  3636. 63502 PUBLIC int sys_trace(req, procnr, addr, data_p)
  3637. 63503 int req, procnr;
  3638. 63504 long addr, *data_p;
  3639. 63505 {
  3640. 63506   message m;
  3641. 63507   int r;
  3642. 63508
  3643. 63509   m.m2_i1 = procnr;
  3644. 63510   m.m2_i2 = req;
  3645. 63511   m.m2_l1 = addr;
  3646. 63512   if (data_p) m.m2_l2 = *data_p;
  3647. 63513   r = _taskcall(SYSTASK, SYS_TRACE, &m);
  3648. 63514   if (data_p) *data_p = m.m2_l2;
  3649. 63515   return(r);
  3650. 63516 }
  3655. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3656. src/lib/syslib/sys_xit.c    
  3657. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3659. 63600 #include "syslib.h"
  3660. 63601
  3661. 63602 PUBLIC int sys_xit(parent, proc, basep, sizep)
  3662. 63603 int parent;                     /* parent of exiting process */
  3663. 63604 int proc;                       /* which process has exited */
  3664. 63605 phys_clicks *basep;             /* where to return base of shadow [68000] */
  3665. 63606 phys_clicks *sizep;             /* where to return size of shadow [68000] */
  3666. 63607 {
  3667. 63608 /* A process has exited.  Tell the kernel. */
  3668. 63609
  3669. 63610   message m;
  3670. 63611   int r;
  3671. 63612
  3672. 63613   m.m1_i1 = parent;
  3673. 63614   m.m1_i2 = proc;
  3674. .Ep 502 src/lib/syslib/sys_xit.c
  3675. 63615   r = _taskcall(SYSTASK, SYS_XIT, &m);
  3676. 63616   *basep = (phys_clicks) m.m1_i1;
  3677. 63617   *sizep = (phys_clicks) m.m1_i2;
  3678. 63618   return(r);
  3679. 63619 }
  3686. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3687. src/lib/syslib/taskcall.c    
  3688. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  3690. 63700 /* _taskcall() is the same as _syscall() except it returns negative error
  3691. 63701  * codes directly and not in errno.  This is a better interface for MM and
  3692. 63702  * FS.
  3693. 63703  */
  3694. 63704
  3695. 63705 #include <lib.h>
  3696. 63706 #include <minix/syslib.h>
  3697. 63707
  3698. 63708 PUBLIC int _taskcall(who, syscallnr, msgptr)
  3699. 63709 int who;
  3700. 63710 int syscallnr;
  3701. 63711 register message *msgptr;
  3702. 63712 {
  3703. 63713   int status;
  3704. 63714
  3705. 63715   msgptr->m_type = syscallnr;
  3706. 63716   status = _sendrec(who, msgptr);
  3707. 63717   if (status != 0) return(status);
  3708. 63718   return(msgptr->m_type);
  3709. 63719 }