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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 操作系统开发 > 查看源码
LIB.TXT
资源名称：os_source.zip　[点击查看]
上传用户：datang2001
上传日期：2007-02-01
资源大小：53269k
文件大小：979k
源码类别：

操作系统开发

开发平台：

C/C++

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