File: | include/stdio.h |
Warning: | line 392, column 6 Access to field '_w' results in a dereference of a null pointer (loaded from variable '_p') |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* $OpenBSD: ed.c,v 1.4 2019/12/02 22:17:32 jca Exp $ */ | |||
2 | ||||
3 | /* | |||
4 | * Copyright (c) 2015 Tobias Stoeckmann <tobias@openbsd.org> | |||
5 | * | |||
6 | * Permission to use, copy, modify, and distribute this software for any | |||
7 | * purpose with or without fee is hereby granted, provided that the above | |||
8 | * copyright notice and this permission notice appear in all copies. | |||
9 | * | |||
10 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES | |||
11 | * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF | |||
12 | * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR | |||
13 | * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES | |||
14 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN | |||
15 | * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF | |||
16 | * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | |||
17 | */ | |||
18 | ||||
19 | #include <sys/queue.h> | |||
20 | #include <sys/stat.h> | |||
21 | ||||
22 | #include <ctype.h> | |||
23 | #include <stdio.h> | |||
24 | #include <stdlib.h> | |||
25 | #include <string.h> | |||
26 | ||||
27 | #include "common.h" | |||
28 | #include "util.h" | |||
29 | #include "pch.h" | |||
30 | #include "inp.h" | |||
31 | ||||
32 | /* states of finite state machine */ | |||
33 | #define FSM_CMD1 1 | |||
34 | #define FSM_A2 2 | |||
35 | #define FSM_C3 3 | |||
36 | #define FSM_D4 4 | |||
37 | #define FSM_I5 5 | |||
38 | #define FSM_S6 6 | |||
39 | ||||
40 | #define SRC_INP1 1 /* line's origin is input file */ | |||
41 | #define SRC_PCH2 2 /* line's origin is patch file */ | |||
42 | ||||
43 | #define S_PATTERN"/.//" "/.//" | |||
44 | ||||
45 | static void init_lines(void); | |||
46 | static void free_lines(void); | |||
47 | static struct ed_line *get_line(LINENUM); | |||
48 | static struct ed_line *create_line(off_t); | |||
49 | static int valid_addr(LINENUM, LINENUM); | |||
50 | static int get_command(void); | |||
51 | static void write_lines(char *); | |||
52 | ||||
53 | LIST_HEAD(ed_head, ed_line)struct ed_head { struct ed_line *lh_first; } head; | |||
54 | struct ed_line { | |||
55 | LIST_ENTRY(ed_line)struct { struct ed_line *le_next; struct ed_line **le_prev; } entries; | |||
56 | int src; | |||
57 | unsigned long subst; | |||
58 | union { | |||
59 | LINENUM lineno; | |||
60 | off_t seek; | |||
61 | } pos; | |||
62 | }; | |||
63 | ||||
64 | static LINENUM first_addr; | |||
65 | static LINENUM second_addr; | |||
66 | static LINENUM line_count; | |||
67 | static struct ed_line *cline; /* current line */ | |||
68 | ||||
69 | void | |||
70 | do_ed_script(void) | |||
71 | { | |||
72 | off_t linepos; | |||
73 | struct ed_line *nline; | |||
74 | LINENUM i, range; | |||
75 | int fsm; | |||
76 | ||||
77 | init_lines(); | |||
78 | cline = NULL((void *)0); | |||
79 | fsm = FSM_CMD1; | |||
80 | ||||
81 | for (;;) { | |||
| ||||
82 | linepos = ftello(pfp); | |||
83 | if (pgetline(&buf, &bufsz, pfp) == -1) | |||
84 | break; | |||
85 | p_input_line++; | |||
86 | ||||
87 | if (fsm == FSM_CMD1) { | |||
88 | if ((fsm = get_command()) == -1) | |||
89 | break; | |||
90 | ||||
91 | switch (fsm) { | |||
92 | case FSM_C3: | |||
93 | case FSM_D4: | |||
94 | /* delete lines in specified range */ | |||
95 | if (second_addr == -1) | |||
96 | range = 1; | |||
97 | else | |||
98 | range = second_addr - first_addr + 1; | |||
99 | for (i = 0; i < range; i++) { | |||
100 | nline = LIST_NEXT(cline, entries)((cline)->entries.le_next); | |||
101 | LIST_REMOVE(cline, entries)do { if ((cline)->entries.le_next != ((void *)0)) (cline)-> entries.le_next->entries.le_prev = (cline)->entries.le_prev ; *(cline)->entries.le_prev = (cline)->entries.le_next; ; ; } while (0); | |||
102 | free(cline); | |||
103 | cline = nline; | |||
104 | line_count--; | |||
105 | } | |||
106 | cline = get_line(first_addr - 1); | |||
107 | fsm = (fsm == FSM_C3) ? FSM_A2 : FSM_CMD1; | |||
108 | break; | |||
109 | case FSM_S6: | |||
110 | cline->subst++; | |||
111 | fsm = FSM_CMD1; | |||
112 | break; | |||
113 | default: | |||
114 | break; | |||
115 | } | |||
116 | ||||
117 | continue; | |||
118 | } | |||
119 | ||||
120 | if (strcmp(buf, ".\n") == 0) { | |||
121 | fsm = FSM_CMD1; | |||
122 | continue; | |||
123 | } | |||
124 | ||||
125 | nline = create_line(linepos); | |||
126 | if (cline == NULL((void *)0)) | |||
127 | LIST_INSERT_HEAD(&head, nline, entries)do { if (((nline)->entries.le_next = (&head)->lh_first ) != ((void *)0)) (&head)->lh_first->entries.le_prev = &(nline)->entries.le_next; (&head)->lh_first = (nline); (nline)->entries.le_prev = &(&head)-> lh_first; } while (0); | |||
128 | else if (fsm == FSM_A2) | |||
129 | LIST_INSERT_AFTER(cline, nline, entries)do { if (((nline)->entries.le_next = (cline)->entries.le_next ) != ((void *)0)) (cline)->entries.le_next->entries.le_prev = &(nline)->entries.le_next; (cline)->entries.le_next = (nline); (nline)->entries.le_prev = &(cline)->entries .le_next; } while (0); | |||
130 | else | |||
131 | LIST_INSERT_BEFORE(cline, nline, entries)do { (nline)->entries.le_prev = (cline)->entries.le_prev ; (nline)->entries.le_next = (cline); *(cline)->entries .le_prev = (nline); (cline)->entries.le_prev = &(nline )->entries.le_next; } while (0); | |||
132 | cline = nline; | |||
133 | line_count++; | |||
134 | fsm = FSM_A2; | |||
135 | } | |||
136 | ||||
137 | next_intuit_at(linepos, p_input_line); | |||
138 | ||||
139 | if (skip_rest_of_patch) { | |||
140 | free_lines(); | |||
141 | return; | |||
142 | } | |||
143 | ||||
144 | write_lines(TMPOUTNAME); | |||
145 | free_lines(); | |||
146 | ||||
147 | ignore_signals(); | |||
148 | if (!check_only) { | |||
149 | if (move_file(TMPOUTNAME, outname) < 0) { | |||
150 | toutkeep = true1; | |||
151 | chmod(TMPOUTNAME, filemode); | |||
152 | } else | |||
153 | chmod(outname, filemode); | |||
154 | } | |||
155 | set_signals(1); | |||
156 | } | |||
157 | ||||
158 | static int | |||
159 | get_command(void) | |||
160 | { | |||
161 | char *p; | |||
162 | LINENUM min_addr; | |||
163 | int fsm; | |||
164 | ||||
165 | min_addr = 0; | |||
166 | fsm = -1; | |||
167 | p = buf; | |||
168 | ||||
169 | /* maybe garbage encountered at end of patch */ | |||
170 | if (!isdigit((unsigned char)*p)) | |||
171 | return -1; | |||
172 | ||||
173 | first_addr = strtolinenum(buf, &p); | |||
174 | second_addr = (*p == ',') ? strtolinenum(p + 1, &p) : -1; | |||
175 | ||||
176 | switch (*p++) { | |||
177 | case 'a': | |||
178 | if (second_addr != -1) | |||
179 | fatal("invalid address at line %ld: %s", | |||
180 | p_input_line, buf); | |||
181 | fsm = FSM_A2; | |||
182 | break; | |||
183 | case 'c': | |||
184 | fsm = FSM_C3; | |||
185 | min_addr = 1; | |||
186 | break; | |||
187 | case 'd': | |||
188 | fsm = FSM_D4; | |||
189 | min_addr = 1; | |||
190 | break; | |||
191 | case 'i': | |||
192 | if (second_addr != -1) | |||
193 | fatal("invalid address at line %ld: %s", | |||
194 | p_input_line, buf); | |||
195 | fsm = FSM_I5; | |||
196 | break; | |||
197 | case 's': | |||
198 | if (second_addr != -1) | |||
199 | fatal("unsupported address range at line %ld: %s", | |||
200 | p_input_line, buf); | |||
201 | if (strncmp(p, S_PATTERN"/.//", sizeof(S_PATTERN"/.//") - 1) != 0) | |||
202 | fatal("unsupported substitution at " | |||
203 | "line %ld: %s", p_input_line, buf); | |||
204 | p += sizeof(S_PATTERN"/.//") - 1; | |||
205 | fsm = FSM_S6; | |||
206 | min_addr = 1; | |||
207 | break; | |||
208 | default: | |||
209 | return -1; | |||
210 | /* NOTREACHED */ | |||
211 | } | |||
212 | ||||
213 | if (*p != '\n') | |||
214 | return -1; | |||
215 | ||||
216 | if (!valid_addr(first_addr, min_addr) || | |||
217 | (second_addr != -1 && !valid_addr(second_addr, first_addr))) | |||
218 | fatal("invalid address at line %ld: %s", p_input_line, buf); | |||
219 | ||||
220 | cline = get_line(first_addr); | |||
221 | ||||
222 | return fsm; | |||
223 | } | |||
224 | ||||
225 | static void | |||
226 | write_lines(char *filename) | |||
227 | { | |||
228 | FILE *ofp; | |||
229 | char *p; | |||
230 | struct ed_line *line; | |||
231 | off_t linepos; | |||
232 | ||||
233 | linepos = ftello(pfp); | |||
234 | ofp = fopen(filename, "w"); | |||
235 | if (ofp == NULL((void *)0)) | |||
236 | pfatal("can't create %s", filename); | |||
237 | ||||
238 | LIST_FOREACH(line, &head, entries)for((line) = ((&head)->lh_first); (line)!= ((void *)0) ; (line) = ((line)->entries.le_next)) { | |||
239 | if (line->src == SRC_INP1) { | |||
240 | p = ifetch(line->pos.lineno, 0); | |||
241 | /* Note: string is not NUL terminated. */ | |||
242 | for (; *p != '\n'; p++) | |||
243 | if (line->subst != 0) | |||
244 | line->subst--; | |||
245 | else | |||
246 | putc(*p, ofp)(!__isthreaded ? __sputc(*p, ofp) : (putc)(*p, ofp)); | |||
247 | putc('\n', ofp)(!__isthreaded ? __sputc('\n', ofp) : (putc)('\n', ofp)); | |||
248 | } else if (line->src == SRC_PCH2) { | |||
249 | fseeko(pfp, line->pos.seek, SEEK_SET0); | |||
250 | if (pgetline(&buf, &bufsz, pfp) == -1) | |||
251 | fatal("unexpected end of file"); | |||
252 | p = buf; | |||
253 | if (line->subst != 0) | |||
254 | for (; *p != '\0' && *p != '\n'; p++) | |||
255 | if (line->subst-- == 0) | |||
256 | break; | |||
257 | fputs(p, ofp); | |||
258 | if (strchr(p, '\n') == NULL((void *)0)) | |||
259 | putc('\n', ofp)(!__isthreaded ? __sputc('\n', ofp) : (putc)('\n', ofp)); | |||
260 | } | |||
261 | } | |||
262 | fclose(ofp); | |||
263 | ||||
264 | /* restore patch file position to match p_input_line */ | |||
265 | fseeko(pfp, linepos, SEEK_SET0); | |||
266 | } | |||
267 | ||||
268 | /* initialize list with input file */ | |||
269 | static void | |||
270 | init_lines(void) | |||
271 | { | |||
272 | struct ed_line *line; | |||
273 | LINENUM i; | |||
274 | ||||
275 | LIST_INIT(&head)do { ((&head)->lh_first) = ((void *)0); } while (0); | |||
276 | for (i = input_lines; i > 0; i--) { | |||
277 | line = malloc(sizeof(*line)); | |||
278 | if (line == NULL((void *)0)) | |||
279 | fatal("cannot allocate memory"); | |||
280 | line->src = SRC_INP1; | |||
281 | line->subst = 0; | |||
282 | line->pos.lineno = i; | |||
283 | LIST_INSERT_HEAD(&head, line, entries)do { if (((line)->entries.le_next = (&head)->lh_first ) != ((void *)0)) (&head)->lh_first->entries.le_prev = &(line)->entries.le_next; (&head)->lh_first = (line); (line)->entries.le_prev = &(&head)->lh_first ; } while (0); | |||
284 | } | |||
285 | line_count = input_lines; | |||
286 | } | |||
287 | ||||
288 | static void | |||
289 | free_lines(void) | |||
290 | { | |||
291 | struct ed_line *line; | |||
292 | ||||
293 | while (!LIST_EMPTY(&head)(((&head)->lh_first) == ((void *)0))) { | |||
294 | line = LIST_FIRST(&head)((&head)->lh_first); | |||
295 | LIST_REMOVE(line, entries)do { if ((line)->entries.le_next != ((void *)0)) (line)-> entries.le_next->entries.le_prev = (line)->entries.le_prev ; *(line)->entries.le_prev = (line)->entries.le_next; ; ; } while (0); | |||
296 | free(line); | |||
297 | } | |||
298 | } | |||
299 | ||||
300 | static struct ed_line * | |||
301 | get_line(LINENUM lineno) | |||
302 | { | |||
303 | struct ed_line *line; | |||
304 | LINENUM i; | |||
305 | ||||
306 | if (lineno == 0) | |||
307 | return NULL((void *)0); | |||
308 | ||||
309 | i = 0; | |||
310 | LIST_FOREACH(line, &head, entries)for((line) = ((&head)->lh_first); (line)!= ((void *)0) ; (line) = ((line)->entries.le_next)) | |||
311 | if (++i == lineno) | |||
312 | return line; | |||
313 | ||||
314 | return NULL((void *)0); | |||
315 | } | |||
316 | ||||
317 | static struct ed_line * | |||
318 | create_line(off_t seek) | |||
319 | { | |||
320 | struct ed_line *line; | |||
321 | ||||
322 | line = malloc(sizeof(*line)); | |||
323 | if (line == NULL((void *)0)) | |||
324 | fatal("cannot allocate memory"); | |||
325 | line->src = SRC_PCH2; | |||
326 | line->subst = 0; | |||
327 | line->pos.seek = seek; | |||
328 | ||||
329 | return line; | |||
330 | } | |||
331 | ||||
332 | static int | |||
333 | valid_addr(LINENUM lineno, LINENUM min) | |||
334 | { | |||
335 | return lineno >= min && lineno <= line_count; | |||
336 | } |
1 | /* $OpenBSD: stdio.h,v 1.54 2020/09/11 17:56:41 naddy Exp $ */ | |||
2 | /* $NetBSD: stdio.h,v 1.18 1996/04/25 18:29:21 jtc Exp $ */ | |||
3 | ||||
4 | /*- | |||
5 | * Copyright (c) 1990 The Regents of the University of California. | |||
6 | * All rights reserved. | |||
7 | * | |||
8 | * This code is derived from software contributed to Berkeley by | |||
9 | * Chris Torek. | |||
10 | * | |||
11 | * Redistribution and use in source and binary forms, with or without | |||
12 | * modification, are permitted provided that the following conditions | |||
13 | * are met: | |||
14 | * 1. Redistributions of source code must retain the above copyright | |||
15 | * notice, this list of conditions and the following disclaimer. | |||
16 | * 2. Redistributions in binary form must reproduce the above copyright | |||
17 | * notice, this list of conditions and the following disclaimer in the | |||
18 | * documentation and/or other materials provided with the distribution. | |||
19 | * 3. Neither the name of the University nor the names of its contributors | |||
20 | * may be used to endorse or promote products derived from this software | |||
21 | * without specific prior written permission. | |||
22 | * | |||
23 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | |||
24 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |||
25 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |||
26 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | |||
27 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |||
28 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | |||
29 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |||
30 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | |||
31 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | |||
32 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | |||
33 | * SUCH DAMAGE. | |||
34 | * | |||
35 | * @(#)stdio.h 5.17 (Berkeley) 6/3/91 | |||
36 | */ | |||
37 | ||||
38 | #ifndef _STDIO_H_ | |||
39 | #define _STDIO_H_ | |||
40 | ||||
41 | #include <sys/cdefs.h> | |||
42 | #include <sys/_null.h> | |||
43 | #include <sys/_types.h> | |||
44 | ||||
45 | #if __BSD_VISIBLE1 || __POSIX_VISIBLE200809 || __XPG_VISIBLE700 | |||
46 | #include <sys/types.h> /* XXX should be removed */ | |||
47 | #endif | |||
48 | ||||
49 | #ifndef _SIZE_T_DEFINED_ | |||
50 | #define _SIZE_T_DEFINED_ | |||
51 | typedef __size_t size_t; | |||
52 | #endif | |||
53 | ||||
54 | #ifndef _OFF_T_DEFINED_ | |||
55 | #define _OFF_T_DEFINED_ | |||
56 | typedef __off_t off_t; | |||
57 | #endif | |||
58 | ||||
59 | #define _FSTDIO /* Define for new stdio with functions. */ | |||
60 | ||||
61 | typedef off_t fpos_t; /* stdio file position type */ | |||
62 | ||||
63 | /* | |||
64 | * NB: to fit things in six character monocase externals, the stdio | |||
65 | * code uses the prefix `__s' for stdio objects, typically followed | |||
66 | * by a three-character attempt at a mnemonic. | |||
67 | */ | |||
68 | ||||
69 | /* stdio buffers */ | |||
70 | struct __sbuf { | |||
71 | unsigned char *_base; | |||
72 | int _size; | |||
73 | }; | |||
74 | ||||
75 | /* | |||
76 | * stdio state variables. | |||
77 | * | |||
78 | * The following always hold: | |||
79 | * | |||
80 | * if (_flags&(__SLBF|__SWR)) == (__SLBF|__SWR), | |||
81 | * _lbfsize is -_bf._size, else _lbfsize is 0 | |||
82 | * if _flags&__SRD, _w is 0 | |||
83 | * if _flags&__SWR, _r is 0 | |||
84 | * | |||
85 | * This ensures that the getc and putc macros (or inline functions) never | |||
86 | * try to write or read from a file that is in `read' or `write' mode. | |||
87 | * (Moreover, they can, and do, automatically switch from read mode to | |||
88 | * write mode, and back, on "r+" and "w+" files.) | |||
89 | * | |||
90 | * _lbfsize is used only to make the inline line-buffered output stream | |||
91 | * code as compact as possible. | |||
92 | * | |||
93 | * _ub, _up, and _ur are used when ungetc() pushes back more characters | |||
94 | * than fit in the current _bf, or when ungetc() pushes back a character | |||
95 | * that does not match the previous one in _bf. When this happens, | |||
96 | * _ub._base becomes non-nil (i.e., a stream has ungetc() data iff | |||
97 | * _ub._base!=NULL) and _up and _ur save the current values of _p and _r. | |||
98 | */ | |||
99 | typedef struct __sFILE { | |||
100 | unsigned char *_p; /* current position in (some) buffer */ | |||
101 | int _r; /* read space left for getc() */ | |||
102 | int _w; /* write space left for putc() */ | |||
103 | short _flags; /* flags, below; this FILE is free if 0 */ | |||
104 | short _file; /* fileno, if Unix descriptor, else -1 */ | |||
105 | struct __sbuf _bf; /* the buffer (at least 1 byte, if !NULL) */ | |||
106 | int _lbfsize; /* 0 or -_bf._size, for inline putc */ | |||
107 | ||||
108 | /* operations */ | |||
109 | void *_cookie; /* cookie passed to io functions */ | |||
110 | int (*_close)(void *); | |||
111 | int (*_read)(void *, char *, int); | |||
112 | fpos_t (*_seek)(void *, fpos_t, int); | |||
113 | int (*_write)(void *, const char *, int); | |||
114 | ||||
115 | /* extension data, to avoid further ABI breakage */ | |||
116 | struct __sbuf _ext; | |||
117 | /* data for long sequences of ungetc() */ | |||
118 | unsigned char *_up; /* saved _p when _p is doing ungetc data */ | |||
119 | int _ur; /* saved _r when _r is counting ungetc data */ | |||
120 | ||||
121 | /* tricks to meet minimum requirements even when malloc() fails */ | |||
122 | unsigned char _ubuf[3]; /* guarantee an ungetc() buffer */ | |||
123 | unsigned char _nbuf[1]; /* guarantee a getc() buffer */ | |||
124 | ||||
125 | /* separate buffer for fgetln() when line crosses buffer boundary */ | |||
126 | struct __sbuf _lb; /* buffer for fgetln() */ | |||
127 | ||||
128 | /* Unix stdio files get aligned to block boundaries on fseek() */ | |||
129 | int _blksize; /* stat.st_blksize (may be != _bf._size) */ | |||
130 | fpos_t _offset; /* current lseek offset */ | |||
131 | } FILE; | |||
132 | ||||
133 | __BEGIN_DECLS | |||
134 | extern FILE __sF[]; | |||
135 | __END_DECLS | |||
136 | ||||
137 | #define __SLBF0x0001 0x0001 /* line buffered */ | |||
138 | #define __SNBF0x0002 0x0002 /* unbuffered */ | |||
139 | #define __SRD0x0004 0x0004 /* OK to read */ | |||
140 | #define __SWR0x0008 0x0008 /* OK to write */ | |||
141 | /* RD and WR are never simultaneously asserted */ | |||
142 | #define __SRW0x0010 0x0010 /* open for reading & writing */ | |||
143 | #define __SEOF0x0020 0x0020 /* found EOF */ | |||
144 | #define __SERR0x0040 0x0040 /* found error */ | |||
145 | #define __SMBF0x0080 0x0080 /* _buf is from malloc */ | |||
146 | #define __SAPP0x0100 0x0100 /* fdopen()ed in append mode */ | |||
147 | #define __SSTR0x0200 0x0200 /* this is an sprintf/snprintf string */ | |||
148 | #define __SOPT0x0400 0x0400 /* do fseek() optimisation */ | |||
149 | #define __SNPT0x0800 0x0800 /* do not do fseek() optimisation */ | |||
150 | #define __SOFF0x1000 0x1000 /* set iff _offset is in fact correct */ | |||
151 | #define __SMOD0x2000 0x2000 /* true => fgetln modified _p text */ | |||
152 | #define __SALC0x4000 0x4000 /* allocate string space dynamically */ | |||
153 | #define __SIGN0x8000 0x8000 /* ignore this file in _fwalk */ | |||
154 | ||||
155 | /* | |||
156 | * The following three definitions are for ANSI C, which took them | |||
157 | * from System V, which brilliantly took internal interface macros and | |||
158 | * made them official arguments to setvbuf(), without renaming them. | |||
159 | * Hence, these ugly _IOxxx names are *supposed* to appear in user code. | |||
160 | * | |||
161 | * Although numbered as their counterparts above, the implementation | |||
162 | * does not rely on this. | |||
163 | */ | |||
164 | #define _IOFBF0 0 /* setvbuf should set fully buffered */ | |||
165 | #define _IOLBF1 1 /* setvbuf should set line buffered */ | |||
166 | #define _IONBF2 2 /* setvbuf should set unbuffered */ | |||
167 | ||||
168 | #define BUFSIZ1024 1024 /* size of buffer used by setbuf */ | |||
169 | ||||
170 | #define EOF(-1) (-1) | |||
171 | ||||
172 | /* | |||
173 | * FOPEN_MAX is a minimum maximum, and should be the number of descriptors | |||
174 | * that the kernel can provide without allocation of a resource that can | |||
175 | * fail without the process sleeping. Do not use this for anything. | |||
176 | */ | |||
177 | #define FOPEN_MAX20 20 /* must be <= OPEN_MAX <sys/syslimits.h> */ | |||
178 | #define FILENAME_MAX1024 1024 /* must be <= PATH_MAX <sys/syslimits.h> */ | |||
179 | ||||
180 | /* System V/ANSI C; this is the wrong way to do this, do *not* use these. */ | |||
181 | #if __BSD_VISIBLE1 || __XPG_VISIBLE700 | |||
182 | #define P_tmpdir"/tmp/" "/tmp/" | |||
183 | #endif | |||
184 | #define L_tmpnam1024 1024 /* XXX must be == PATH_MAX */ | |||
185 | #define TMP_MAX0x7fffffff 0x7fffffff /* more, but don't overflow int */ | |||
186 | ||||
187 | #ifndef SEEK_SET0 | |||
188 | #define SEEK_SET0 0 /* set file offset to offset */ | |||
189 | #endif | |||
190 | #ifndef SEEK_CUR1 | |||
191 | #define SEEK_CUR1 1 /* set file offset to current plus offset */ | |||
192 | #endif | |||
193 | #ifndef SEEK_END2 | |||
194 | #define SEEK_END2 2 /* set file offset to EOF plus offset */ | |||
195 | #endif | |||
196 | ||||
197 | #define stdin(&__sF[0]) (&__sF[0]) | |||
198 | #define stdout(&__sF[1]) (&__sF[1]) | |||
199 | #define stderr(&__sF[2]) (&__sF[2]) | |||
200 | ||||
201 | /* | |||
202 | * Functions defined in ANSI C standard. | |||
203 | */ | |||
204 | __BEGIN_DECLS | |||
205 | void clearerr(FILE *)(!__isthreaded ? ((void)((FILE *)->_flags &= ~(0x0040| 0x0020))) : (clearerr)(FILE *)); | |||
206 | #if __POSIX_VISIBLE200809 >= 200809 | |||
207 | int dprintf(int, const char * __restrict, ...) | |||
208 | __attribute__((__format__ (printf, 2, 3))) | |||
209 | __attribute__((__nonnull__ (2))); | |||
210 | #endif | |||
211 | int fclose(FILE *); | |||
212 | int feof(FILE *)(!__isthreaded ? (((FILE *)->_flags & 0x0020) != 0) : ( feof)(FILE *)); | |||
213 | int ferror(FILE *)(!__isthreaded ? (((FILE *)->_flags & 0x0040) != 0) : ( ferror)(FILE *)); | |||
214 | int fflush(FILE *); | |||
215 | int fgetc(FILE *); | |||
216 | int fgetpos(FILE *, fpos_t *); | |||
217 | char *fgets(char *, int, FILE *) | |||
218 | __attribute__((__bounded__ (__string__,1,2))); | |||
219 | FILE *fopen(const char *, const char *); | |||
220 | int fprintf(FILE *, const char *, ...); | |||
221 | int fputc(int, FILE *); | |||
222 | int fputs(const char *, FILE *); | |||
223 | size_t fread(void *, size_t, size_t, FILE *) | |||
224 | __attribute__((__bounded__ (__size__,1,3,2))); | |||
225 | FILE *freopen(const char *, const char *, FILE *); | |||
226 | int fscanf(FILE *, const char *, ...); | |||
227 | int fseek(FILE *, long, int); | |||
228 | int fseeko(FILE *, off_t, int); | |||
229 | int fsetpos(FILE *, const fpos_t *); | |||
230 | long ftell(FILE *); | |||
231 | off_t ftello(FILE *); | |||
232 | size_t fwrite(const void *, size_t, size_t, FILE *) | |||
233 | __attribute__((__bounded__ (__size__,1,3,2))); | |||
234 | int getc(FILE *)(!__isthreaded ? (--(FILE *)->_r < 0 ? __srget(FILE *) : (int)(*(FILE *)->_p++)) : (getc)(FILE *)); | |||
235 | int getchar(void); | |||
236 | #if __POSIX_VISIBLE200809 >= 200809 | |||
237 | ssize_t getdelim(char ** __restrict, size_t * __restrict, int, | |||
238 | FILE * __restrict); | |||
239 | ssize_t getline(char ** __restrict, size_t * __restrict, | |||
240 | FILE * __restrict); | |||
241 | #endif | |||
242 | #if __BSD_VISIBLE1 && !defined(__SYS_ERRLIST) | |||
243 | #define __SYS_ERRLIST | |||
244 | ||||
245 | extern int sys_nerr; /* perror(3) external variables */ | |||
246 | extern char *sys_errlist[]; | |||
247 | #endif | |||
248 | void perror(const char *); | |||
249 | int printf(const char *, ...); | |||
250 | int putc(int, FILE *)(!__isthreaded ? __sputc(int, FILE *) : (putc)(int, FILE *)); | |||
251 | int putchar(int)(!__isthreaded ? __sputc(int, (&__sF[1])) : (putc)(int, ( &__sF[1]))); | |||
252 | int puts(const char *); | |||
253 | int remove(const char *); | |||
254 | int rename(const char *, const char *); | |||
255 | #if __POSIX_VISIBLE200809 >= 200809 | |||
256 | int renameat(int, const char *, int, const char *); | |||
257 | #endif | |||
258 | void rewind(FILE *); | |||
259 | int scanf(const char *, ...); | |||
260 | void setbuf(FILE *, char *); | |||
261 | int setvbuf(FILE *, char *, int, size_t); | |||
262 | int sprintf(char *, const char *, ...); | |||
263 | int sscanf(const char *, const char *, ...); | |||
264 | FILE *tmpfile(void); | |||
265 | char *tmpnam(char *); | |||
266 | int ungetc(int, FILE *); | |||
267 | int vfprintf(FILE *, const char *, __va_list); | |||
268 | int vprintf(const char *, __va_list); | |||
269 | int vsprintf(char *, const char *, __va_list); | |||
270 | #if __POSIX_VISIBLE200809 >= 200809 | |||
271 | int vdprintf(int, const char * __restrict, __va_list) | |||
272 | __attribute__((__format__ (printf, 2, 0))) | |||
273 | __attribute__((__nonnull__ (2))); | |||
274 | #endif | |||
275 | ||||
276 | #if __ISO_C_VISIBLE2011 >= 1999 || __XPG_VISIBLE700 >= 500 || __BSD_VISIBLE1 | |||
277 | int snprintf(char *, size_t, const char *, ...) | |||
278 | __attribute__((__format__ (printf, 3, 4))) | |||
279 | __attribute__((__nonnull__ (3))) | |||
280 | __attribute__((__bounded__ (__string__,1,2))); | |||
281 | int vsnprintf(char *, size_t, const char *, __va_list) | |||
282 | __attribute__((__format__ (printf, 3, 0))) | |||
283 | __attribute__((__nonnull__ (3))) | |||
284 | __attribute__((__bounded__(__string__,1,2))); | |||
285 | #endif /* __ISO_C_VISIBLE >= 1999 || __XPG_VISIBLE >= 500 || __BSD_VISIBLE */ | |||
286 | ||||
287 | #if __ISO_C_VISIBLE2011 >= 1999 || __BSD_VISIBLE1 | |||
288 | int vfscanf(FILE *, const char *, __va_list) | |||
289 | __attribute__((__format__ (scanf, 2, 0))) | |||
290 | __attribute__((__nonnull__ (2))); | |||
291 | int vscanf(const char *, __va_list) | |||
292 | __attribute__((__format__ (scanf, 1, 0))) | |||
293 | __attribute__((__nonnull__ (1))); | |||
294 | int vsscanf(const char *, const char *, __va_list) | |||
295 | __attribute__((__format__ (scanf, 2, 0))) | |||
296 | __attribute__((__nonnull__ (2))); | |||
297 | #endif /* __ISO_C_VISIBLE >= 1999 || __BSD_VISIBLE */ | |||
298 | ||||
299 | __END_DECLS | |||
300 | ||||
301 | ||||
302 | /* | |||
303 | * Functions defined in POSIX 1003.1. | |||
304 | */ | |||
305 | #if __BSD_VISIBLE1 || __POSIX_VISIBLE200809 || __XPG_VISIBLE700 | |||
306 | #define L_ctermid1024 1024 /* size for ctermid(); PATH_MAX */ | |||
307 | ||||
308 | __BEGIN_DECLS | |||
309 | char *ctermid(char *); | |||
310 | FILE *fdopen(int, const char *); | |||
311 | int fileno(FILE *)(!__isthreaded ? ((FILE *)->_file) : (fileno)(FILE *)); | |||
312 | ||||
313 | #if __POSIX_VISIBLE200809 >= 199209 | |||
314 | int pclose(FILE *); | |||
315 | FILE *popen(const char *, const char *); | |||
316 | #endif | |||
317 | ||||
318 | #if __POSIX_VISIBLE200809 >= 199506 | |||
319 | void flockfile(FILE *); | |||
320 | int ftrylockfile(FILE *); | |||
321 | void funlockfile(FILE *); | |||
322 | ||||
323 | /* | |||
324 | * These are normally used through macros as defined below, but POSIX | |||
325 | * requires functions as well. | |||
326 | */ | |||
327 | int getc_unlocked(FILE *)(--(FILE *)->_r < 0 ? __srget(FILE *) : (int)(*(FILE *) ->_p++)); | |||
328 | int getchar_unlocked(void); | |||
329 | int putc_unlocked(int, FILE *)__sputc(int, FILE *); | |||
330 | int putchar_unlocked(int)__sputc(int, (&__sF[1])); | |||
331 | #endif /* __POSIX_VISIBLE >= 199506 */ | |||
332 | ||||
333 | #if __POSIX_VISIBLE200809 >= 200809 | |||
334 | FILE *fmemopen(void *, size_t, const char *); | |||
335 | FILE *open_memstream(char **, size_t *); | |||
336 | #endif /* __POSIX_VISIBLE >= 200809 */ | |||
337 | ||||
338 | #if __XPG_VISIBLE700 | |||
339 | char *tempnam(const char *, const char *); | |||
340 | #endif | |||
341 | __END_DECLS | |||
342 | ||||
343 | #endif /* __BSD_VISIBLE || __POSIX_VISIBLE || __XPG_VISIBLE */ | |||
344 | ||||
345 | /* | |||
346 | * Routines that are purely local. | |||
347 | */ | |||
348 | #if __BSD_VISIBLE1 | |||
349 | __BEGIN_DECLS | |||
350 | int asprintf(char **, const char *, ...) | |||
351 | __attribute__((__format__ (printf, 2, 3))) | |||
352 | __attribute__((__nonnull__ (2))); | |||
353 | char *fgetln(FILE *, size_t *); | |||
354 | int fpurge(FILE *); | |||
355 | int getw(FILE *); | |||
356 | int putw(int, FILE *); | |||
357 | void setbuffer(FILE *, char *, int); | |||
358 | int setlinebuf(FILE *); | |||
359 | int vasprintf(char **, const char *, __va_list) | |||
360 | __attribute__((__format__ (printf, 2, 0))) | |||
361 | __attribute__((__nonnull__ (2))); | |||
362 | __END_DECLS | |||
363 | ||||
364 | /* | |||
365 | * Stdio function-access interface. | |||
366 | */ | |||
367 | __BEGIN_DECLS | |||
368 | FILE *funopen(const void *, | |||
369 | int (*)(void *, char *, int), | |||
370 | int (*)(void *, const char *, int), | |||
371 | fpos_t (*)(void *, fpos_t, int), | |||
372 | int (*)(void *)); | |||
373 | __END_DECLS | |||
374 | #define fropen(cookie, fn)funopen(cookie, fn, 0, 0, 0) funopen(cookie, fn, 0, 0, 0) | |||
375 | #define fwopen(cookie, fn)funopen(cookie, 0, fn, 0, 0) funopen(cookie, 0, fn, 0, 0) | |||
376 | #endif /* __BSD_VISIBLE */ | |||
377 | ||||
378 | /* | |||
379 | * Functions internal to the implementation. | |||
380 | */ | |||
381 | __BEGIN_DECLS | |||
382 | int __srget(FILE *); | |||
383 | int __swbuf(int, FILE *); | |||
384 | __END_DECLS | |||
385 | ||||
386 | /* | |||
387 | * The __sfoo macros are here so that we can | |||
388 | * define function versions in the C library. | |||
389 | */ | |||
390 | #define __sgetc(p)(--(p)->_r < 0 ? __srget(p) : (int)(*(p)->_p++)) (--(p)->_r < 0 ? __srget(p) : (int)(*(p)->_p++)) | |||
391 | static __inline int __sputc(int _c, FILE *_p) { | |||
392 | if (--_p->_w >= 0 || (_p->_w >= _p->_lbfsize && (char)_c != '\n')) | |||
| ||||
393 | return (*_p->_p++ = _c); | |||
394 | else | |||
395 | return (__swbuf(_c, _p)); | |||
396 | } | |||
397 | ||||
398 | #define __sfeof(p)(((p)->_flags & 0x0020) != 0) (((p)->_flags & __SEOF0x0020) != 0) | |||
399 | #define __sferror(p)(((p)->_flags & 0x0040) != 0) (((p)->_flags & __SERR0x0040) != 0) | |||
400 | #define __sclearerr(p)((void)((p)->_flags &= ~(0x0040|0x0020))) ((void)((p)->_flags &= ~(__SERR0x0040|__SEOF0x0020))) | |||
401 | #define __sfileno(p)((p)->_file) ((p)->_file) | |||
402 | ||||
403 | extern int __isthreaded; | |||
404 | ||||
405 | #define feof(p)(!__isthreaded ? (((p)->_flags & 0x0020) != 0) : (feof )(p)) (!__isthreaded ? __sfeof(p)(((p)->_flags & 0x0020) != 0) : (feof)(p)) | |||
406 | #define ferror(p)(!__isthreaded ? (((p)->_flags & 0x0040) != 0) : (ferror )(p)) (!__isthreaded ? __sferror(p)(((p)->_flags & 0x0040) != 0) : (ferror)(p)) | |||
407 | #define clearerr(p)(!__isthreaded ? ((void)((p)->_flags &= ~(0x0040|0x0020 ))) : (clearerr)(p)) (!__isthreaded ? __sclearerr(p)((void)((p)->_flags &= ~(0x0040|0x0020))) : (clearerr)(p)) | |||
408 | ||||
409 | #if __POSIX_VISIBLE200809 | |||
410 | #define fileno(p)(!__isthreaded ? ((p)->_file) : (fileno)(p)) (!__isthreaded ? __sfileno(p)((p)->_file) : (fileno)(p)) | |||
411 | #endif | |||
412 | ||||
413 | #define getc(fp)(!__isthreaded ? (--(fp)->_r < 0 ? __srget(fp) : (int)( *(fp)->_p++)) : (getc)(fp)) (!__isthreaded ? __sgetc(fp)(--(fp)->_r < 0 ? __srget(fp) : (int)(*(fp)->_p++)) : (getc)(fp)) | |||
414 | ||||
415 | #if __BSD_VISIBLE1 | |||
416 | /* | |||
417 | * The macro implementations of putc and putc_unlocked are not | |||
418 | * fully POSIX compliant; they do not set errno on failure | |||
419 | */ | |||
420 | #define putc(x, fp)(!__isthreaded ? __sputc(x, fp) : (putc)(x, fp)) (!__isthreaded ? __sputc(x, fp) : (putc)(x, fp)) | |||
421 | #endif /* __BSD_VISIBLE */ | |||
422 | ||||
423 | #if __POSIX_VISIBLE200809 >= 199506 | |||
424 | #define getc_unlocked(fp)(--(fp)->_r < 0 ? __srget(fp) : (int)(*(fp)->_p++)) __sgetc(fp)(--(fp)->_r < 0 ? __srget(fp) : (int)(*(fp)->_p++)) | |||
425 | /* | |||
426 | * The macro implementations of putc and putc_unlocked are not | |||
427 | * fully POSIX compliant; they do not set errno on failure | |||
428 | */ | |||
429 | #if __BSD_VISIBLE1 | |||
430 | #define putc_unlocked(x, fp)__sputc(x, fp) __sputc(x, fp) | |||
431 | #endif /* __BSD_VISIBLE */ | |||
432 | #endif /* __POSIX_VISIBLE >= 199506 */ | |||
433 | ||||
434 | #define getchar()(!__isthreaded ? (--((&__sF[0]))->_r < 0 ? __srget( (&__sF[0])) : (int)(*((&__sF[0]))->_p++)) : (getc) ((&__sF[0]))) getc(stdin)(!__isthreaded ? (--((&__sF[0]))->_r < 0 ? __srget( (&__sF[0])) : (int)(*((&__sF[0]))->_p++)) : (getc) ((&__sF[0]))) | |||
435 | #define putchar(x)(!__isthreaded ? __sputc(x, (&__sF[1])) : (putc)(x, (& __sF[1]))) putc(x, stdout)(!__isthreaded ? __sputc(x, (&__sF[1])) : (putc)(x, (& __sF[1]))) | |||
436 | #define getchar_unlocked()(--((&__sF[0]))->_r < 0 ? __srget((&__sF[0])) : (int)(*((&__sF[0]))->_p++)) getc_unlocked(stdin)(--((&__sF[0]))->_r < 0 ? __srget((&__sF[0])) : (int)(*((&__sF[0]))->_p++)) | |||
437 | #define putchar_unlocked(c)__sputc(c, (&__sF[1])) putc_unlocked(c, stdout)__sputc(c, (&__sF[1])) | |||
438 | ||||
439 | #endif /* _STDIO_H_ */ |