cscope.out

cscope 15 $HOME/Desktop/linux_source/linux-0.11 -q 0000006350 0000649183
	@fs/bitmap.c

8 
	~<¡ršg.h
>

10 
	~<lšux/sched.h
>

11 
	~<lšux/k”Ãl.h
>

13 
	#þ—r_block
(
addr
) \

14 
	`__asm__
("cld\n\t" \

17 ::"a" (0),"c" (
BLOCK_SIZE
/4),"D" ((è(
addr
)):"cx","di")

	)

19 
	#£t_b™
(
Ä
,
addr
) ({\

20 
»s
 
	`__asm__
("ax"); \

21 
__asm__
 
	`__vÞ©že__
("btsl %2,%3\n\tsetb %%al": \

22 "÷" (
»s
):"0" (0),"r" (
Ä
),"m" (*(
addr
))); \

23 
»s
;})

	)

25 
	#þ—r_b™
(
Ä
,
addr
) ({\

26 
»s
 
	`__asm__
("ax"); \

27 
__asm__
 
	`__vÞ©že__
("btrl %2,%3\n\tsetnb %%al": \

28 "÷" (
»s
):"0" (0),"r" (
Ä
),"m" (*(
addr
))); \

29 
»s
;})

	)

31 
	#fšd_fœ¡_z”o
(
addr
) ({ \

32 
__»s
; \

33 
	`__asm__
("cld\n" \

44 :"=c" (
__»s
):"c" (0),"S" (
addr
):"ax","dx","si"); \

45 
__»s
;})

	)

47 
	$ä“_block
(
dev
, 
block
)

49 
su³r_block
 * 
sb
;

50 
bufãr_h—d
 * 
bh
;

52 ià(!(
sb
 = 
	`g‘_su³r
(
dev
)))

53 
	`·nic
("tryingo free block on‚onexistent device");

54 ià(
block
 < 
sb
->
s_fœ¡d©azÚe
 || block >ðsb->
s_nzÚes
)

55 
	`·nic
("tryingo free block‚ot in datazone");

56 
bh
 = 
	`g‘_hash_bË
(
dev
,
block
);

57 ià(
bh
) {

58 ià(
bh
->
b_couÁ
 != 1) {

59 
	`´štk
("tryingo free block (%04x:%d), count=%d\n",

60 
dev
,
block
,
bh
->
b_couÁ
);

63 
bh
->
b_dœt
=0;

64 
bh
->
b_u±od©e
=0;

65 
	`b»l£
(
bh
);

67 
block
 -ð
sb
->
s_fœ¡d©azÚe
 - 1 ;

68 ià(
	`þ—r_b™
(
block
&8191,
sb
->
s_zm­
[block/8192]->
b_d©a
)) {

69 
	`´štk
("block (%04x:%dè",
dev
,
block
+
sb
->
s_fœ¡d©azÚe
-1);

70 
	`·nic
("free_block: bit‡lready cleared");

72 
sb
->
s_zm­
[
block
/8192]->
b_dœt
 = 1;

73 
	}
}

75 
	$Ãw_block
(
dev
)

77 
bufãr_h—d
 * 
bh
;

78 
su³r_block
 * 
sb
;

79 
i
,
j
;

81 ià(!(
sb
 = 
	`g‘_su³r
(
dev
)))

82 
	`·nic
("tryingo get‚ew block from‚onexistant device");

83 
j
 = 8192;

84 
i
=0 ; i<8 ; i++)

85 ià(
bh
=
sb
->
s_zm­
[
i
])

86 ià((
j
=
	`fšd_fœ¡_z”o
(
bh
->
b_d©a
))<8192)

88 ià(
i
>=8 || !
bh
 || 
j
>=8192)

90 ià(
	`£t_b™
(
j
,
bh
->
b_d©a
))

91 
	`·nic
("new_block: bit‡lready set");

92 
bh
->
b_dœt
 = 1;

93 
j
 +ð
i
*8192 + 
sb
->
s_fœ¡d©azÚe
-1;

94 ià(
j
 >ð
sb
->
s_nzÚes
)

96 ià(!(
bh
=
	`g‘blk
(
dev
,
j
)))

97 
	`·nic
("new_block: cannot get block");

98 ià(
bh
->
b_couÁ
 != 1)

99 
	`·nic
("new block: count is != 1");

100 
	`þ—r_block
(
bh
->
b_d©a
);

101 
bh
->
b_u±od©e
 = 1;

102 
bh
->
b_dœt
 = 1;

103 
	`b»l£
(
bh
);

104  
j
;

105 
	}
}

107 
	$ä“_šode
(
m_šode
 * 
šode
)

109 
su³r_block
 * 
sb
;

110 
bufãr_h—d
 * 
bh
;

112 ià(!
šode
)

114 ià(!
šode
->
i_dev
) {

115 
	`mem£t
(
šode
,0,(*inode));

118 ià(
šode
->
i_couÁ
>1) {

119 
	`´štk
("ŒyšgØä“ inodw™h couÁ=%d\n",
šode
->
i_couÁ
);

120 
	`·nic
("free_inode");

122 ià(
šode
->
i_Æšks
)

123 
	`·nic
("tryingo free inode with†inks");

124 ià(!(
sb
 = 
	`g‘_su³r
(
šode
->
i_dev
)))

125 
	`·nic
("tryingo free inode on‚onexistent device");

126 ià(
šode
->
i_num
 < 1 || inode->i_num > 
sb
->
s_nšodes
)

127 
	`·nic
("tryingo free inode 0 or‚onexistant inode");

128 ià(!(
bh
=
sb
->
s_im­
[
šode
->
i_num
>>13]))

129 
	`·nic
("nonexistent imap in superblock");

130 ià(
	`þ—r_b™
(
šode
->
i_num
&8191,
bh
->
b_d©a
))

131 
	`´štk
("free_inode: bit‡lready cleared.\n\r");

132 
bh
->
b_dœt
 = 1;

133 
	`mem£t
(
šode
,0,(*inode));

134 
	}
}

136 
m_šode
 * 
	$Ãw_šode
(
dev
)

138 
m_šode
 * 
šode
;

139 
su³r_block
 * 
sb
;

140 
bufãr_h—d
 * 
bh
;

141 
i
,
j
;

143 ià(!(
šode
=
	`g‘_em±y_šode
()))

144  
NULL
;

145 ià(!(
sb
 = 
	`g‘_su³r
(
dev
)))

146 
	`·nic
("new_inode with unknown device");

147 
j
 = 8192;

148 
i
=0 ; i<8 ; i++)

149 ià(
bh
=
sb
->
s_im­
[
i
])

150 ià((
j
=
	`fšd_fœ¡_z”o
(
bh
->
b_d©a
))<8192)

152 ià(!
bh
 || 
j
 >ð8192 || j+
i
*8192 > 
sb
->
s_nšodes
) {

153 
	`ut
(
šode
);

154  
NULL
;

156 ià(
	`£t_b™
(
j
,
bh
->
b_d©a
))

157 
	`·nic
("new_inode: bit‡lready set");

158 
bh
->
b_dœt
 = 1;

159 
šode
->
i_couÁ
=1;

160 
šode
->
i_Æšks
=1;

161 
šode
->
i_dev
=
dev
;

162 
šode
->
i_uid
=
cu¼’t
->
euid
;

163 
šode
->
i_gid
=
cu¼’t
->
egid
;

164 
šode
->
i_dœt
=1;

165 
šode
->
i_num
 = 
j
 + 
i
*8192;

166 
šode
->
i_mtime
 = inode->
i_©ime
 = inode->
i_ùime
 = 
CURRENT_TIME
;

167  
šode
;

168 
	}
}

	@fs/block_dev.c

7 
	~<”ºo.h
>

9 
	~<lšux/sched.h
>

10 
	~<lšux/k”Ãl.h
>

11 
	~<asm/£gm’t.h
>

12 
	~<asm/sy¡em.h
>

14 
	$block_wr™e
(
dev
, * 
pos
, * 
buf
, 
couÁ
)

16 
block
 = *
pos
 >> 
BLOCK_SIZE_BITS
;

17 
off£t
 = *
pos
 & (
BLOCK_SIZE
-1);

18 
ch¬s
;

19 
wr™‹n
 = 0;

20 
bufãr_h—d
 * 
bh
;

21 * 
p
;

23 
couÁ
>0) {

24 
ch¬s
 = 
BLOCK_SIZE
 - 
off£t
;

25 ià(
ch¬s
 > 
couÁ
)

26 
ch¬s
=
couÁ
;

27 ià(
ch¬s
 =ð
BLOCK_SIZE
)

28 
bh
 = 
	`g‘blk
(
dev
,
block
);

30 
bh
 = 
	`b»ada
(
dev
,
block
,block+1,block+2,-1);

31 
block
++;

32 ià(!
bh
)

33  
wr™‹n
?wr™‹n:-
EIO
;

34 
p
 = 
off£t
 + 
bh
->
b_d©a
;

35 
off£t
 = 0;

36 *
pos
 +ð
ch¬s
;

37 
wr™‹n
 +ð
ch¬s
;

38 
couÁ
 -ð
ch¬s
;

39 
ch¬s
-->0)

40 *(
p
++èð
	`g‘_fs_by‹
(
buf
++);

41 
bh
->
b_dœt
 = 1;

42 
	`b»l£
(
bh
);

44  
wr™‹n
;

45 
	}
}

47 
	$block_»ad
(
dev
, * 
pos
, * 
buf
, 
couÁ
)

49 
block
 = *
pos
 >> 
BLOCK_SIZE_BITS
;

50 
off£t
 = *
pos
 & (
BLOCK_SIZE
-1);

51 
ch¬s
;

52 
»ad
 = 0;

53 
bufãr_h—d
 * 
bh
;

54 * 
p
;

56 
couÁ
>0) {

57 
ch¬s
 = 
BLOCK_SIZE
-
off£t
;

58 ià(
ch¬s
 > 
couÁ
)

59 
ch¬s
 = 
couÁ
;

60 ià(!(
bh
 = 
	`b»ada
(
dev
,
block
,block+1,block+2,-1)))

61  
»ad
?»ad:-
EIO
;

62 
block
++;

63 
p
 = 
off£t
 + 
bh
->
b_d©a
;

64 
off£t
 = 0;

65 *
pos
 +ð
ch¬s
;

66 
»ad
 +ð
ch¬s
;

67 
couÁ
 -ð
ch¬s
;

68 
ch¬s
-->0)

69 
	`put_fs_by‹
(*(
p
++),
buf
++);

70 
	`b»l£
(
bh
);

72  
»ad
;

73 
	}
}

	@fs/buffer.c

21 
	~<¡d¬g.h
>

23 
	~<lšux/cÚfig.h
>

24 
	~<lšux/sched.h
>

25 
	~<lšux/k”Ãl.h
>

26 
	~<asm/sy¡em.h
>

27 
	~<asm/io.h
>

29 
’d
;

30 
bufãr_h—d
 * 
	g¡¬t_bufãr
 = (bufãr_h—d *è&
’d
;

31 
bufãr_h—d
 * 
	ghash_bË
[
NR_HASH
];

32 
bufãr_h—d
 * 
	gä“_li¡
;

33 
sk_¡ruù
 * 
	gbufãr_wa™
 = 
NULL
;

34 
	gNR_BUFFERS
 = 0;

36 
šlše
 
	$wa™_Ú_bufãr
(
bufãr_h—d
 * 
bh
)

38 
	`þi
();

39 
bh
->
b_lock
)

40 
	`¦“p_Ú
(&
bh
->
b_wa™
);

41 
	`¡i
();

42 
	}
}

44 
	$sys_sync
()

46 
i
;

47 
bufãr_h—d
 * 
bh
;

49 
	`sync_šodes
();

50 
bh
 = 
¡¬t_bufãr
;

51 
i
=0 ; i<
NR_BUFFERS
 ; i++,
bh
++) {

52 
	`wa™_Ú_bufãr
(
bh
);

53 ià(
bh
->
b_dœt
)

54 
	`Î_rw_block
(
WRITE
,
bh
);

57 
	}
}

59 
	$sync_dev
(
dev
)

61 
i
;

62 
bufãr_h—d
 * 
bh
;

64 
bh
 = 
¡¬t_bufãr
;

65 
i
=0 ; i<
NR_BUFFERS
 ; i++,
bh
++) {

66 ià(
bh
->
b_dev
 !ð
dev
)

68 
	`wa™_Ú_bufãr
(
bh
);

69 ià(
bh
->
b_dev
 =ð
dev
 && bh->
b_dœt
)

70 
	`Î_rw_block
(
WRITE
,
bh
);

72 
	`sync_šodes
();

73 
bh
 = 
¡¬t_bufãr
;

74 
i
=0 ; i<
NR_BUFFERS
 ; i++,
bh
++) {

75 ià(
bh
->
b_dev
 !ð
dev
)

77 
	`wa™_Ú_bufãr
(
bh
);

78 ià(
bh
->
b_dev
 =ð
dev
 && bh->
b_dœt
)

79 
	`Î_rw_block
(
WRITE
,
bh
);

82 
	}
}

84 
šlše
 
	$šv®id©e_bufãrs
(
dev
)

86 
i
;

87 
bufãr_h—d
 * 
bh
;

89 
bh
 = 
¡¬t_bufãr
;

90 
i
=0 ; i<
NR_BUFFERS
 ; i++,
bh
++) {

91 ià(
bh
->
b_dev
 !ð
dev
)

93 
	`wa™_Ú_bufãr
(
bh
);

94 ià(
bh
->
b_dev
 =ð
dev
)

95 
bh
->
b_u±od©e
 = bh->
b_dœt
 = 0;

97 
	}
}

113 
	$check_disk_chªge
(
dev
)

115 
i
;

117 ià(
	`MAJOR
(
dev
) != 2)

119 ià(!
	`æÝpy_chªge
(
dev
 & 0x03))

121 
i
=0 ; i<
NR_SUPER
 ; i++)

122 ià(
su³r_block
[
i
].
s_dev
 =ð
dev
)

123 
	`put_su³r
(
su³r_block
[
i
].
s_dev
);

124 
	`šv®id©e_šodes
(
dev
);

125 
	`šv®id©e_bufãrs
(
dev
);

126 
	}
}

128 
	#_hashâ
(
dev
,
block
è((()(dev^block))%
NR_HASH
)

	)

129 
	#hash
(
dev
,
block
è
hash_bË
[
	`_hashâ
(dev,block)]

	)

131 
šlše
 
	$»move_äom_queues
(
bufãr_h—d
 * 
bh
)

134 ià(
bh
->
b_Ãxt
)

135 
bh
->
b_Ãxt
->
b_´ev
 = bh->b_prev;

136 ià(
bh
->
b_´ev
)

137 
bh
->
b_´ev
->
b_Ãxt
 = bh->b_next;

138 ià(
	`hash
(
bh
->
b_dev
,bh->
b_blockÄ
) == bh)

139 
	`hash
(
bh
->
b_dev
,bh->
b_blockÄ
èðbh->
b_Ãxt
;

141 ià(!(
bh
->
b_´ev_ä“
è|| !(bh->
b_Ãxt_ä“
))

142 
	`·nic
("Free block†ist corrupted");

143 
bh
->
b_´ev_ä“
->
b_Ãxt_ä“
 = bh->b_next_free;

144 
bh
->
b_Ãxt_ä“
->
b_´ev_ä“
 = bh->b_prev_free;

145 ià(
ä“_li¡
 =ð
bh
)

146 
ä“_li¡
 = 
bh
->
b_Ãxt_ä“
;

147 
	}
}

149 
šlše
 
	$š£¹_što_queues
(
bufãr_h—d
 * 
bh
)

152 
bh
->
b_Ãxt_ä“
 = 
ä“_li¡
;

153 
bh
->
b_´ev_ä“
 = 
ä“_li¡
->b_prev_free;

154 
ä“_li¡
->
b_´ev_ä“
->
b_Ãxt_ä“
 = 
bh
;

155 
ä“_li¡
->
b_´ev_ä“
 = 
bh
;

157 
bh
->
b_´ev
 = 
NULL
;

158 
bh
->
b_Ãxt
 = 
NULL
;

159 ià(!
bh
->
b_dev
)

161 
bh
->
b_Ãxt
 = 
	`hash
(bh->
b_dev
,bh->
b_blockÄ
);

162 
	`hash
(
bh
->
b_dev
,bh->
b_blockÄ
) = bh;

163 
bh
->
b_Ãxt
->
b_´ev
 = bh;

164 
	}
}

166 
bufãr_h—d
 * 
	$fšd_bufãr
(
dev
, 
block
)

168 
bufãr_h—d
 * 
tmp
;

170 
tmp
 = 
	`hash
(
dev
,
block
è;m°!ð
NULL
 ;m°ðtmp->
b_Ãxt
)

171 ià(
tmp
->
b_dev
==
dev
 &&mp->
b_blockÄ
==
block
)

172  
tmp
;

173  
NULL
;

174 
	}
}

183 
bufãr_h—d
 * 
	$g‘_hash_bË
(
dev
, 
block
)

185 
bufãr_h—d
 * 
bh
;

188 ià(!(
bh
=
	`fšd_bufãr
(
dev
,
block
)))

189  
NULL
;

190 
bh
->
b_couÁ
++;

191 
	`wa™_Ú_bufãr
(
bh
);

192 ià(
bh
->
b_dev
 =ð
dev
 && bh->
b_blockÄ
 =ð
block
)

193  
bh
;

194 
bh
->
b_couÁ
--;

196 
	}
}

205 
	#BADNESS
(
bh
è(((bh)->
b_dœt
<<1)+(bh)->
b_lock
)

	)

206 
bufãr_h—d
 * 
	$g‘blk
(
dev
,
block
)

208 
bufãr_h—d
 * 
tmp
, * 
bh
;

210 
»³©
:

211 ià(
bh
 = 
	`g‘_hash_bË
(
dev
,
block
))

212  
bh
;

213 
tmp
 = 
ä“_li¡
;

215 ià(
tmp
->
b_couÁ
)

217 ià(!
bh
 || 
	`BADNESS
(
tmp
)<BADNESS(bh)) {

218 
bh
 = 
tmp
;

219 ià(!
	`BADNESS
(
tmp
))

223 } (
tmp
 =mp->
b_Ãxt_ä“
è!ð
ä“_li¡
);

224 ià(!
bh
) {

225 
	`¦“p_Ú
(&
bufãr_wa™
);

226 
»³©
;

228 
	`wa™_Ú_bufãr
(
bh
);

229 ià(
bh
->
b_couÁ
)

230 
»³©
;

231 
bh
->
b_dœt
) {

232 
	`sync_dev
(
bh
->
b_dev
);

233 
	`wa™_Ú_bufãr
(
bh
);

234 ià(
bh
->
b_couÁ
)

235 
»³©
;

239 ià(
	`fšd_bufãr
(
dev
,
block
))

240 
»³©
;

243 
bh
->
b_couÁ
=1;

244 
bh
->
b_dœt
=0;

245 
bh
->
b_u±od©e
=0;

246 
	`»move_äom_queues
(
bh
);

247 
bh
->
b_dev
=
dev
;

248 
bh
->
b_blockÄ
=
block
;

249 
	`š£¹_što_queues
(
bh
);

250  
bh
;

251 
	}
}

253 
	$b»l£
(
bufãr_h—d
 * 
buf
)

255 ià(!
buf
)

257 
	`wa™_Ú_bufãr
(
buf
);

258 ià(!(
buf
->
b_couÁ
--))

259 
	`·nic
("Tryingo free free buffer");

260 
	`wake_up
(&
bufãr_wa™
);

261 
	}
}

267 
bufãr_h—d
 * 
	$b»ad
(
dev
,
block
)

269 
bufãr_h—d
 * 
bh
;

271 ià(!(
bh
=
	`g‘blk
(
dev
,
block
)))

272 
	`·nic
("bread: getblk„eturned NULL\n");

273 ià(
bh
->
b_u±od©e
)

274  
bh
;

275 
	`Î_rw_block
(
READ
,
bh
);

276 
	`wa™_Ú_bufãr
(
bh
);

277 ià(
bh
->
b_u±od©e
)

278  
bh
;

279 
	`b»l£
(
bh
);

280  
NULL
;

281 
	}
}

283 
	#COPYBLK
(
äom
,
to
) \

284 
	`__asm__
("cld\n\t" \

287 ::"c" (
BLOCK_SIZE
/4),"S" (
äom
),"D" (
to
) \

288 :"cx","di","si")

	)

296 
	$b»ad_·ge
(
add»ss
,
dev
,
b
[4])

298 
bufãr_h—d
 * 
bh
[4];

299 
i
;

301 
i
=0 ; i<4 ; i++)

302 ià(
b
[
i
]) {

303 ià(
bh
[
i
] = 
	`g‘blk
(
dev
,
b
[i]))

304 ià(!
bh
[
i
]->
b_u±od©e
)

305 
	`Î_rw_block
(
READ
,
bh
[
i
]);

307 
bh
[
i
] = 
NULL
;

308 
i
=0 ; i<4 ; i++,
add»ss
 +ð
BLOCK_SIZE
)

309 ià(
bh
[
i
]) {

310 
	`wa™_Ú_bufãr
(
bh
[
i
]);

311 ià(
bh
[
i
]->
b_u±od©e
)

312 
	`COPYBLK
((è
bh
[
i
]->
b_d©a
,
add»ss
);

313 
	`b»l£
(
bh
[
i
]);

315 
	}
}

322 
bufãr_h—d
 * 
	$b»ada
(
dev
,
fœ¡
, ...)

324 
va_li¡
 
¬gs
;

325 
bufãr_h—d
 * 
bh
, *
tmp
;

327 
	`va_¡¬t
(
¬gs
,
fœ¡
);

328 ià(!(
bh
=
	`g‘blk
(
dev
,
fœ¡
)))

329 
	`·nic
("bread: getblk„eturned NULL\n");

330 ià(!
bh
->
b_u±od©e
)

331 
	`Î_rw_block
(
READ
,
bh
);

332 (
fœ¡
=
	`va_¬g
(
¬gs
,))>=0) {

333 
tmp
=
	`g‘blk
(
dev
,
fœ¡
);

334 ià(
tmp
) {

335 ià(!
tmp
->
b_u±od©e
)

336 
	`Î_rw_block
(
READA
,
bh
);

337 
tmp
->
b_couÁ
--;

340 
	`va_’d
(
¬gs
);

341 
	`wa™_Ú_bufãr
(
bh
);

342 ià(
bh
->
b_u±od©e
)

343  
bh
;

344 
	`b»l£
(
bh
);

345  (
NULL
);

346 
	}
}

348 
	$bufãr_š™
(
bufãr_’d
)

350 
bufãr_h—d
 * 
h
 = 
¡¬t_bufãr
;

351 * 
b
;

352 
i
;

354 ià(
bufãr_’d
 == 1<<20)

355 
b
 = (*) (640*1024);

357 
b
 = (*è
bufãr_’d
;

358  (
b
 -ð
BLOCK_SIZE
è>ð((*è(
h
+1)) ) {

359 
h
->
b_dev
 = 0;

360 
h
->
b_dœt
 = 0;

361 
h
->
b_couÁ
 = 0;

362 
h
->
b_lock
 = 0;

363 
h
->
b_u±od©e
 = 0;

364 
h
->
b_wa™
 = 
NULL
;

365 
h
->
b_Ãxt
 = 
NULL
;

366 
h
->
b_´ev
 = 
NULL
;

367 
h
->
b_d©a
 = (*è
b
;

368 
h
->
b_´ev_ä“
 = h-1;

369 
h
->
b_Ãxt_ä“
 = h+1;

370 
h
++;

371 
NR_BUFFERS
++;

372 ià(
b
 == (*) 0x100000)

373 
b
 = (*) 0xA0000;

375 
h
--;

376 
ä“_li¡
 = 
¡¬t_bufãr
;

377 
ä“_li¡
->
b_´ev_ä“
 = 
h
;

378 
h
->
b_Ãxt_ä“
 = 
ä“_li¡
;

379 
i
=0;i<
NR_HASH
;i++)

380 
hash_bË
[
i
]=
NULL
;

381 
	}
}

	@fs/char_dev.c

7 
	~<”ºo.h
>

8 
	~<sys/ty³s.h
>

10 
	~<lšux/sched.h
>

11 
	~<lšux/k”Ãl.h
>

13 
	~<asm/£gm’t.h
>

14 
	~<asm/io.h
>

16 
‰y_»ad
(
mšÜ
,* 
buf
,
couÁ
);

17 
‰y_wr™e
(
mšÜ
,* 
buf
,
couÁ
);

19 (*
üw_±r
)(
	trw
,
	tmšÜ
,* 
	tbuf
,
	tcouÁ
,
	toff_t
 * 
	tpos
);

21 
	$rw_‰yx
(
rw
,
mšÜ
,* 
buf
,
couÁ
,
off_t
 * 
pos
)

23  ((
rw
==
READ
)?
	`‰y_»ad
(
mšÜ
,
buf
,
couÁ
):

24 
	`‰y_wr™e
(
mšÜ
,
buf
,
couÁ
));

25 
	}
}

27 
	$rw_‰y
(
rw
,
mšÜ
,* 
buf
,
couÁ
, 
off_t
 * 
pos
)

29 ià(
cu¼’t
->
‰y
<0)

30  -
EPERM
;

31  
	`rw_‰yx
(
rw
,
cu¼’t
->
‰y
,
buf
,
couÁ
,
pos
);

32 
	}
}

34 
	$rw_¿m
(
rw
,* 
buf
, 
couÁ
, 
off_t
 *
pos
)

36  -
EIO
;

37 
	}
}

39 
	$rw_mem
(
rw
,* 
buf
, 
couÁ
, 
off_t
 * 
pos
)

41  -
EIO
;

42 
	}
}

44 
	$rw_kmem
(
rw
,* 
buf
, 
couÁ
, 
off_t
 * 
pos
)

46  -
EIO
;

47 
	}
}

49 
	$rw_pÜt
(
rw
,* 
buf
, 
couÁ
, 
off_t
 * 
pos
)

51 
i
=*
pos
;

53 
couÁ
-->0 && 
i
<65536) {

54 ià(
rw
==
READ
)

55 
	`put_fs_by‹
(
	`šb
(
i
),
buf
++);

57 
	`outb
(
	`g‘_fs_by‹
(
buf
++),
i
);

58 
i
++;

60 
i
 -ð*
pos
;

61 *
pos
 +ð
i
;

62  
i
;

63 
	}
}

65 
	$rw_memÜy
(
rw
, 
mšÜ
, * 
buf
, 
couÁ
, 
off_t
 * 
pos
)

67 
mšÜ
) {

69  
	`rw_¿m
(
rw
,
buf
,
couÁ
,
pos
);

71  
	`rw_mem
(
rw
,
buf
,
couÁ
,
pos
);

73  
	`rw_kmem
(
rw
,
buf
,
couÁ
,
pos
);

75  (
rw
==
READ
)?0:
couÁ
;

77  
	`rw_pÜt
(
rw
,
buf
,
couÁ
,
pos
);

79  -
EIO
;

81 
	}
}

83 
	#NRDEVS
 (( (
üw_bË
))/( (
üw_±r
)))

	)

85 
üw_±r
 
	güw_bË
[]={

86 
NULL
,

87 
rw_memÜy
,

88 
NULL
,

89 
NULL
,

90 
rw_‰yx
,

91 
rw_‰y
,

92 
NULL
,

93 
NULL
};

95 
	$rw_ch¬
(
rw
,
dev
, * 
buf
, 
couÁ
, 
off_t
 * 
pos
)

97 
üw_±r
 
ÿÎ_addr
;

99 ià(
	`MAJOR
(
dev
)>=
NRDEVS
)

100  -
ENODEV
;

101 ià(!(
ÿÎ_addr
=
üw_bË
[
	`MAJOR
(
dev
)]))

102  -
ENODEV
;

103  
	`ÿÎ_addr
(
rw
,
	`MINOR
(
dev
),
buf
,
couÁ
,
pos
);

104 
	}
}

	@fs/exec.c

20 
	~<”ºo.h
>

21 
	~<¡ršg.h
>

22 
	~<sys/¡©.h
>

23 
	~<a.out.h
>

25 
	~<lšux/fs.h
>

26 
	~<lšux/sched.h
>

27 
	~<lšux/k”Ãl.h
>

28 
	~<lšux/mm.h
>

29 
	~<asm/£gm’t.h
>

31 
sys_ex™
(
ex™_code
);

32 
sys_þo£
(
fd
);

39 
	#MAX_ARG_PAGES
 32

	)

46 * 
	$ü—‹_bËs
(* 
p
,
¬gc
,
’vc
)

48 *
¬gv
,*
’vp
;

49 * 
¥
;

51 
¥
 = (*è(0xfffffffø& (è
p
);

52 
¥
 -ð
’vc
+1;

53 
’vp
 = 
¥
;

54 
¥
 -ð
¬gc
+1;

55 
¬gv
 = 
¥
;

56 
	`put_fs_lÚg
(()
’vp
,--
¥
);

57 
	`put_fs_lÚg
(()
¬gv
,--
¥
);

58 
	`put_fs_lÚg
(()
¬gc
,--
¥
);

59 
¬gc
-->0) {

60 
	`put_fs_lÚg
((è
p
,
¬gv
++);

61 
	`g‘_fs_by‹
(
p
++)) ;

63 
	`put_fs_lÚg
(0,
¬gv
);

64 
’vc
-->0) {

65 
	`put_fs_lÚg
((è
p
,
’vp
++);

66 
	`g‘_fs_by‹
(
p
++)) ;

68 
	`put_fs_lÚg
(0,
’vp
);

69  
¥
;

70 
	}
}

75 
	$couÁ
(** 
¬gv
)

77 
i
=0;

78 ** 
tmp
;

80 ià(
tmp
 = 
¬gv
)

81 
	`g‘_fs_lÚg
((*è(
tmp
++)))

82 
i
++;

84  
i
;

85 
	}
}

104 
	$cÝy_¡ršgs
(
¬gc
,** 
¬gv
,*
·ge
,

105 
p
, 
äom_kmem
)

107 *
tmp
, *
·g
;

108 
Ën
, 
off£t
 = 0;

109 
Þd_fs
, 
Ãw_fs
;

111 ià(!
p
)

113 
Ãw_fs
 = 
	`g‘_ds
();

114 
Þd_fs
 = 
	`g‘_fs
();

115 ià(
äom_kmem
==2)

116 
	`£t_fs
(
Ãw_fs
);

117 
¬gc
-- > 0) {

118 ià(
äom_kmem
 == 1)

119 
	`£t_fs
(
Ãw_fs
);

120 ià(!(
tmp
 = (*)
	`g‘_fs_lÚg
(((*)
¬gv
)+
¬gc
)))

121 
	`·nic
("argc is wrong");

122 ià(
äom_kmem
 == 1)

123 
	`£t_fs
(
Þd_fs
);

124 
Ën
=0;

126 
Ën
++;

127 } 
	`g‘_fs_by‹
(
tmp
++));

128 ià(
p
-
Ën
 < 0) {

129 
	`£t_fs
(
Þd_fs
);

132 
Ën
) {

133 --
p
; --
tmp
; --
Ën
;

134 ià(--
off£t
 < 0) {

135 
off£t
 = 
p
 % 
PAGE_SIZE
;

136 ià(
äom_kmem
==2)

137 
	`£t_fs
(
Þd_fs
);

138 ià(!(
·g
 = (*è
·ge
[
p
/
PAGE_SIZE
]) &&

139 !(
·g
 = (*è
·ge
[
p
/
PAGE_SIZE
] =

140 (*è
	`g‘_ä“_·ge
()))

142 ià(
äom_kmem
==2)

143 
	`£t_fs
(
Ãw_fs
);

146 *(
·g
 + 
off£t
èð
	`g‘_fs_by‹
(
tmp
);

149 ià(
äom_kmem
==2)

150 
	`£t_fs
(
Þd_fs
);

151  
p
;

152 
	}
}

154 
	$chªge_ldt
(
‹xt_size
,* 
·ge
)

156 
code_lim™
,
d©a_lim™
,
code_ba£
,
d©a_ba£
;

157 
i
;

159 
code_lim™
 = 
‹xt_size
+
PAGE_SIZE
 -1;

160 
code_lim™
 &= 0xFFFFF000;

161 
d©a_lim™
 = 0x4000000;

162 
code_ba£
 = 
	`g‘_ba£
(
cu¼’t
->
ldt
[1]);

163 
d©a_ba£
 = 
code_ba£
;

164 
	`£t_ba£
(
cu¼’t
->
ldt
[1],
code_ba£
);

165 
	`£t_lim™
(
cu¼’t
->
ldt
[1],
code_lim™
);

166 
	`£t_ba£
(
cu¼’t
->
ldt
[2],
d©a_ba£
);

167 
	`£t_lim™
(
cu¼’t
->
ldt
[2],
d©a_lim™
);

169 
	`__asm__
("pushl $0x17\n\tpop %%fs"::);

170 
d©a_ba£
 +ð
d©a_lim™
;

171 
i
=
MAX_ARG_PAGES
-1 ; i>=0 ; i--) {

172 
d©a_ba£
 -ð
PAGE_SIZE
;

173 ià(
·ge
[
i
])

174 
	`put_·ge
(
·ge
[
i
],
d©a_ba£
);

176  
d©a_lim™
;

177 
	}
}

182 
	$do_execve
(* 
e
,
tmp
,* 
fž’ame
,

183 ** 
¬gv
, ** 
’vp
)

185 
m_šode
 * 
šode
;

186 
bufãr_h—d
 * 
bh
;

187 
exec
 
ex
;

188 
·ge
[
MAX_ARG_PAGES
];

189 
i
,
¬gc
,
’vc
;

190 
e_uid
, 
e_gid
;

191 
»tv®
;

192 
sh_bªg
 = 0;

193 
p
=
PAGE_SIZE
*
MAX_ARG_PAGES
-4;

195 ià((0xfffà& 
e
[1]) != 0x000f)

196 
	`·nic
("execve called from supervisor mode");

197 
i
=0 ; i<
MAX_ARG_PAGES
 ; i++)

198 
·ge
[
i
]=0;

199 ià(!(
šode
=
	`Çmei
(
fž’ame
)))

200  -
ENOENT
;

201 
¬gc
 = 
	`couÁ
(
¬gv
);

202 
’vc
 = 
	`couÁ
(
’vp
);

204 
»¡¬t_š‹½
:

205 ià(!
	`S_ISREG
(
šode
->
i_mode
)) {

206 
»tv®
 = -
EACCES
;

207 
exec_”rÜ2
;

209 
i
 = 
šode
->
i_mode
;

210 
e_uid
 = (
i
 & 
S_ISUID
è? 
šode
->
i_uid
 : 
cu¼’t
->
euid
;

211 
e_gid
 = (
i
 & 
S_ISGID
è? 
šode
->
i_gid
 : 
cu¼’t
->
egid
;

212 ià(
cu¼’t
->
euid
 =ð
šode
->
i_uid
)

213 
i
 >>= 6;

214 ià(
cu¼’t
->
egid
 =ð
šode
->
i_gid
)

215 
i
 >>= 3;

216 ià(!(
i
 & 1) &&

217 !((
šode
->
i_mode
 & 0111è&& 
	`su£r
())) {

218 
»tv®
 = -
ENOEXEC
;

219 
exec_”rÜ2
;

221 ià(!(
bh
 = 
	`b»ad
(
šode
->
i_dev
,šode->
i_zÚe
[0]))) {

222 
»tv®
 = -
EACCES
;

223 
exec_”rÜ2
;

225 
ex
 = *((
exec
 *è
bh
->
b_d©a
);

226 ià((
bh
->
b_d©a
[0] =ð'#'è&& (bh->b_d©a[1] =ð'!'è&& (!
sh_bªg
)) {

232 
buf
[1023], *
ý
, *
š‹½
, *
i_Çme
, *
i_¬g
;

233 
Þd_fs
;

235 
	`¡ºýy
(
buf
, 
bh
->
b_d©a
+2, 1022);

236 
	`b»l£
(
bh
);

237 
	`ut
(
šode
);

238 
buf
[1022] = '\0';

239 ià(
ý
 = 
	`¡rchr
(
buf
, '\n')) {

240 *
ý
 = '\0';

241 
ý
 = 
buf
; (*cp == ' ') || (*cp == '\t'); cp++);

243 ià(!
ý
 || *cp == '\0') {

244 
»tv®
 = -
ENOEXEC
;

245 
exec_”rÜ1
;

247 
š‹½
 = 
i_Çme
 = 
ý
;

248 
i_¬g
 = 0;

249  ; *
ý
 && (*cp != ' ') && (*cp != '\t'); cp++) {

250 ià(*
ý
 == '/')

251 
i_Çme
 = 
ý
+1;

253 ià(*
ý
) {

254 *
ý
++ = '\0';

255 
i_¬g
 = 
ý
;

261 ià(
sh_bªg
++ == 0) {

262 
p
 = 
	`cÝy_¡ršgs
(
’vc
, 
’vp
, 
·ge
,…, 0);

263 
p
 = 
	`cÝy_¡ršgs
(--
¬gc
, 
¬gv
+1, 
·ge
,…, 0);

273 
p
 = 
	`cÝy_¡ršgs
(1, &
fž’ame
, 
·ge
,…, 1);

274 
¬gc
++;

275 ià(
i_¬g
) {

276 
p
 = 
	`cÝy_¡ršgs
(1, &
i_¬g
, 
·ge
,…, 2);

277 
¬gc
++;

279 
p
 = 
	`cÝy_¡ršgs
(1, &
i_Çme
, 
·ge
,…, 2);

280 
¬gc
++;

281 ià(!
p
) {

282 
»tv®
 = -
ENOMEM
;

283 
exec_”rÜ1
;

288 
Þd_fs
 = 
	`g‘_fs
();

289 
	`£t_fs
(
	`g‘_ds
());

290 ià(!(
šode
=
	`Çmei
(
š‹½
))) {

291 
	`£t_fs
(
Þd_fs
);

292 
»tv®
 = -
ENOENT
;

293 
exec_”rÜ1
;

295 
	`£t_fs
(
Þd_fs
);

296 
»¡¬t_š‹½
;

298 
	`b»l£
(
bh
);

299 ià(
	`N_MAGIC
(
ex
è!ð
ZMAGIC
 ||ƒx.
a_Œsize
 ||ƒx.
a_drsize
 ||

300 
ex
.
a_‹xt
+ex.
a_d©a
+ex.
a_bss
>0x3000000 ||

301 
šode
->
i_size
 < 
ex
.
a_‹xt
+ex.
a_d©a
+ex.
a_syms
+
	`N_TXTOFF
(ex)) {

302 
»tv®
 = -
ENOEXEC
;

303 
exec_”rÜ2
;

305 ià(
	`N_TXTOFF
(
ex
è!ð
BLOCK_SIZE
) {

306 
	`´štk
("%s: N_TXTOFF !ðBLOCK_SIZE. S“‡.out.h.", 
fž’ame
);

307 
»tv®
 = -
ENOEXEC
;

308 
exec_”rÜ2
;

310 ià(!
sh_bªg
) {

311 
p
 = 
	`cÝy_¡ršgs
(
’vc
,
’vp
,
·ge
,p,0);

312 
p
 = 
	`cÝy_¡ršgs
(
¬gc
,
¬gv
,
·ge
,p,0);

313 ià(!
p
) {

314 
»tv®
 = -
ENOMEM
;

315 
exec_”rÜ2
;

319 ià(
cu¼’t
->
execubË
)

320 
	`ut
(
cu¼’t
->
execubË
);

321 
cu¼’t
->
execubË
 = 
šode
;

322 
i
=0 ; i<32 ; i++)

323 
cu¼’t
->
sigaùiÚ
[
i
].
§_hªdËr
 = 
NULL
;

324 
i
=0 ; i<
NR_OPEN
 ; i++)

325 ià((
cu¼’t
->
þo£_Ú_exec
>>
i
)&1)

326 
	`sys_þo£
(
i
);

327 
cu¼’t
->
þo£_Ú_exec
 = 0;

328 
	`ä“_·ge_bËs
(
	`g‘_ba£
(
cu¼’t
->
ldt
[1]),
	`g‘_lim™
(0x0f));

329 
	`ä“_·ge_bËs
(
	`g‘_ba£
(
cu¼’t
->
ldt
[2]),
	`g‘_lim™
(0x17));

330 ià(
Ï¡_sk_u£d_m©h
 =ð
cu¼’t
)

331 
Ï¡_sk_u£d_m©h
 = 
NULL
;

332 
cu¼’t
->
u£d_m©h
 = 0;

333 
p
 +ð
	`chªge_ldt
(
ex
.
a_‹xt
,
·ge
)-
MAX_ARG_PAGES
*
PAGE_SIZE
;

334 
p
 = (è
	`ü—‹_bËs
((*í,
¬gc
,
’vc
);

335 
cu¼’t
->
brk
 = 
ex
.
a_bss
 +

336 (
cu¼’t
->
’d_d©a
 = 
ex
.
a_d©a
 +

337 (
cu¼’t
->
’d_code
 = 
ex
.
a_‹xt
));

338 
cu¼’t
->
¡¬t_¡ack
 = 
p
 & 0xfffff000;

339 
cu¼’t
->
euid
 = 
e_uid
;

340 
cu¼’t
->
egid
 = 
e_gid
;

341 
i
 = 
ex
.
a_‹xt
+ex.
a_d©a
;

342 
i
&0xfff)

343 
	`put_fs_by‹
(0,(*è(
i
++));

344 
e
[0] = 
ex
.
a_’Œy
;

345 
e
[3] = 
p
;

347 
exec_”rÜ2
:

348 
	`ut
(
šode
);

349 
exec_”rÜ1
:

350 
i
=0 ; i<
MAX_ARG_PAGES
 ; i++)

351 
	`ä“_·ge
(
·ge
[
i
]);

352 (
»tv®
);

353 
	}
}

	@fs/fcntl.c

7 
	~<¡ršg.h
>

8 
	~<”ºo.h
>

9 
	~<lšux/sched.h
>

10 
	~<lšux/k”Ãl.h
>

11 
	~<asm/£gm’t.h
>

13 
	~<fúŽ.h
>

14 
	~<sys/¡©.h
>

16 
sys_þo£
(
fd
);

18 
	$dupfd
(
fd
, 
¬g
)

20 ià(
fd
 >ð
NR_OPEN
 || !
cu¼’t
->
fžp
[fd])

21  -
EBADF
;

22 ià(
¬g
 >ð
NR_OPEN
)

23  -
EINVAL
;

24 
¬g
 < 
NR_OPEN
)

25 ià(
cu¼’t
->
fžp
[
¬g
])

26 
¬g
++;

29 ià(
¬g
 >ð
NR_OPEN
)

30  -
EMFILE
;

31 
cu¼’t
->
þo£_Ú_exec
 &ð~(1<<
¬g
);

32 (
cu¼’t
->
fžp
[
¬g
] = cu¼’t->fžp[
fd
])->
f_couÁ
++;

33  
¬g
;

34 
	}
}

36 
	$sys_dup2
(
Þdfd
, 
Ãwfd
)

38 
	`sys_þo£
(
Ãwfd
);

39  
	`dupfd
(
Þdfd
,
Ãwfd
);

40 
	}
}

42 
	$sys_dup
(
fždes
)

44  
	`dupfd
(
fždes
,0);

45 
	}
}

47 
	$sys_fúŽ
(
fd
, 
cmd
, 
¬g
)

49 
fže
 * 
fžp
;

51 ià(
fd
 >ð
NR_OPEN
 || !(
fžp
 = 
cu¼’t
->filp[fd]))

52  -
EBADF
;

53 
cmd
) {

54 
F_DUPFD
:

55  
	`dupfd
(
fd
,
¬g
);

56 
F_GETFD
:

57  (
cu¼’t
->
þo£_Ú_exec
>>
fd
)&1;

58 
F_SETFD
:

59 ià(
¬g
&1)

60 
cu¼’t
->
þo£_Ú_exec
 |ð(1<<
fd
);

62 
cu¼’t
->
þo£_Ú_exec
 &ð~(1<<
fd
);

64 
F_GETFL
:

65  
fžp
->
f_æags
;

66 
F_SETFL
:

67 
fžp
->
f_æags
 &ð~(
O_APPEND
 | 
O_NONBLOCK
);

68 
fžp
->
f_æags
 |ð
¬g
 & (
O_APPEND
 | 
O_NONBLOCK
);

70 
F_GETLK
: 
F_SETLK
: 
F_SETLKW
:

75 
	}
}

	@fs/file_dev.c

7 
	~<”ºo.h
>

8 
	~<fúŽ.h
>

10 
	~<lšux/sched.h
>

11 
	~<lšux/k”Ãl.h
>

12 
	~<asm/£gm’t.h
>

14 
	#MIN
(
a
,
b
è((×)<(b))?×):(b))

	)

15 
	#MAX
(
a
,
b
è((×)>(b))?×):(b))

	)

17 
	$fže_»ad
(
m_šode
 * 
šode
, 
fže
 * 
fžp
, * 
buf
, 
couÁ
)

19 
Ëá
,
ch¬s
,
Ä
;

20 
bufãr_h—d
 * 
bh
;

22 ià((
Ëá
=
couÁ
)<=0)

24 
Ëá
) {

25 ià(
Ä
 = 
	`bm­
(
šode
,(
fžp
->
f_pos
)/
BLOCK_SIZE
)) {

26 ià(!(
bh
=
	`b»ad
(
šode
->
i_dev
,
Ä
)))

29 
bh
 = 
NULL
;

30 
Ä
 = 
fžp
->
f_pos
 % 
BLOCK_SIZE
;

31 
ch¬s
 = 
	`MIN
Ð
BLOCK_SIZE
-
Ä
 , 
Ëá
 );

32 
fžp
->
f_pos
 +ð
ch¬s
;

33 
Ëá
 -ð
ch¬s
;

34 ià(
bh
) {

35 * 
p
 = 
Ä
 + 
bh
->
b_d©a
;

36 
ch¬s
-->0)

37 
	`put_fs_by‹
(*(
p
++),
buf
++);

38 
	`b»l£
(
bh
);

40 
ch¬s
-->0)

41 
	`put_fs_by‹
(0,
buf
++);

44 
šode
->
i_©ime
 = 
CURRENT_TIME
;

45  (
couÁ
-
Ëá
)?(couÁ-Ëá):-
ERROR
;

46 
	}
}

48 
	$fže_wr™e
(
m_šode
 * 
šode
, 
fže
 * 
fžp
, * 
buf
, 
couÁ
)

50 
off_t
 
pos
;

51 
block
,
c
;

52 
bufãr_h—d
 * 
bh
;

53 * 
p
;

54 
i
=0;

60 ià(
fžp
->
f_æags
 & 
O_APPEND
)

61 
pos
 = 
šode
->
i_size
;

63 
pos
 = 
fžp
->
f_pos
;

64 
i
<
couÁ
) {

65 ià(!(
block
 = 
	`ü—‹_block
(
šode
,
pos
/
BLOCK_SIZE
)))

67 ià(!(
bh
=
	`b»ad
(
šode
->
i_dev
,
block
)))

69 
c
 = 
pos
 % 
BLOCK_SIZE
;

70 
p
 = 
c
 + 
bh
->
b_d©a
;

71 
bh
->
b_dœt
 = 1;

72 
c
 = 
BLOCK_SIZE
-c;

73 ià(
c
 > 
couÁ
-
i
) c = count-i;

74 
pos
 +ð
c
;

75 ià(
pos
 > 
šode
->
i_size
) {

76 
šode
->
i_size
 = 
pos
;

77 
šode
->
i_dœt
 = 1;

79 
i
 +ð
c
;

80 
c
-->0)

81 *(
p
++èð
	`g‘_fs_by‹
(
buf
++);

82 
	`b»l£
(
bh
);

84 
šode
->
i_mtime
 = 
CURRENT_TIME
;

85 ià(!(
fžp
->
f_æags
 & 
O_APPEND
)) {

86 
fžp
->
f_pos
 = 
pos
;

87 
šode
->
i_ùime
 = 
CURRENT_TIME
;

89  (
i
?i:-1);

90 
	}
}

	@fs/file_table.c

7 
	~<lšux/fs.h
>

9 
fže
 
	gfže_bË
[
NR_FILE
];

	@fs/inode.c

7 
	~<¡ršg.h
>

8 
	~<sys/¡©.h
>

10 
	~<lšux/sched.h
>

11 
	~<lšux/k”Ãl.h
>

12 
	~<lšux/mm.h
>

13 
	~<asm/sy¡em.h
>

15 
m_šode
 
	gšode_bË
[
NR_INODE
]={{0,},};

17 
»ad_šode
(
m_šode
 * 
šode
);

18 
wr™e_šode
(
m_šode
 * 
šode
);

20 
šlše
 
	$wa™_Ú_šode
(
m_šode
 * 
šode
)

22 
	`þi
();

23 
šode
->
i_lock
)

24 
	`¦“p_Ú
(&
šode
->
i_wa™
);

25 
	`¡i
();

26 
	}
}

28 
šlše
 
	$lock_šode
(
m_šode
 * 
šode
)

30 
	`þi
();

31 
šode
->
i_lock
)

32 
	`¦“p_Ú
(&
šode
->
i_wa™
);

33 
šode
->
i_lock
=1;

34 
	`¡i
();

35 
	}
}

37 
šlše
 
	$uÆock_šode
(
m_šode
 * 
šode
)

39 
šode
->
i_lock
=0;

40 
	`wake_up
(&
šode
->
i_wa™
);

41 
	}
}

43 
	$šv®id©e_šodes
(
dev
)

45 
i
;

46 
m_šode
 * 
šode
;

48 
šode
 = 0+
šode_bË
;

49 
i
=0 ; i<
NR_INODE
 ; i++,
šode
++) {

50 
	`wa™_Ú_šode
(
šode
);

51 ià(
šode
->
i_dev
 =ð
dev
) {

52 ià(
šode
->
i_couÁ
)

53 
	`´štk
("inode in use on„emoved disk\n\r");

54 
šode
->
i_dev
 = inode->
i_dœt
 = 0;

57 
	}
}

59 
	$sync_šodes
()

61 
i
;

62 
m_šode
 * 
šode
;

64 
šode
 = 0+
šode_bË
;

65 
i
=0 ; i<
NR_INODE
 ; i++,
šode
++) {

66 
	`wa™_Ú_šode
(
šode
);

67 ià(
šode
->
i_dœt
 && !šode->
i_pe
)

68 
	`wr™e_šode
(
šode
);

70 
	}
}

72 
	$_bm­
(
m_šode
 * 
šode
,
block
,
ü—‹
)

74 
bufãr_h—d
 * 
bh
;

75 
i
;

77 ià(
block
<0)

78 
	`·nic
("_bmap: block<0");

79 ià(
block
 >= 7+512+512*512)

80 
	`·nic
("_bmap: block>big");

81 ià(
block
<7) {

82 ià(
ü—‹
 && !
šode
->
i_zÚe
[
block
])

83 ià(
šode
->
i_zÚe
[
block
]=
	`Ãw_block
(šode->
i_dev
)) {

84 
šode
->
i_ùime
=
CURRENT_TIME
;

85 
šode
->
i_dœt
=1;

87  
šode
->
i_zÚe
[
block
];

89 
block
 -= 7;

90 ià(
block
<512) {

91 ià(
ü—‹
 && !
šode
->
i_zÚe
[7])

92 ià(
šode
->
i_zÚe
[7]=
	`Ãw_block
(šode->
i_dev
)) {

93 
šode
->
i_dœt
=1;

94 
šode
->
i_ùime
=
CURRENT_TIME
;

96 ià(!
šode
->
i_zÚe
[7])

98 ià(!(
bh
 = 
	`b»ad
(
šode
->
i_dev
,šode->
i_zÚe
[7])))

100 
i
 = ((*è(
bh
->
b_d©a
))[
block
];

101 ià(
ü—‹
 && !
i
)

102 ià(
i
=
	`Ãw_block
(
šode
->
i_dev
)) {

103 ((*è(
bh
->
b_d©a
))[
block
]=
i
;

104 
bh
->
b_dœt
=1;

106 
	`b»l£
(
bh
);

107  
i
;

109 
block
 -= 512;

110 ià(
ü—‹
 && !
šode
->
i_zÚe
[8])

111 ià(
šode
->
i_zÚe
[8]=
	`Ãw_block
(šode->
i_dev
)) {

112 
šode
->
i_dœt
=1;

113 
šode
->
i_ùime
=
CURRENT_TIME
;

115 ià(!
šode
->
i_zÚe
[8])

117 ià(!(
bh
=
	`b»ad
(
šode
->
i_dev
,šode->
i_zÚe
[8])))

119 
i
 = ((*)
bh
->
b_d©a
)[
block
>>9];

120 ià(
ü—‹
 && !
i
)

121 ià(
i
=
	`Ãw_block
(
šode
->
i_dev
)) {

122 ((*è(
bh
->
b_d©a
))[
block
>>9]=
i
;

123 
bh
->
b_dœt
=1;

125 
	`b»l£
(
bh
);

126 ià(!
i
)

128 ià(!(
bh
=
	`b»ad
(
šode
->
i_dev
,
i
)))

130 
i
 = ((*)
bh
->
b_d©a
)[
block
&511];

131 ià(
ü—‹
 && !
i
)

132 ià(
i
=
	`Ãw_block
(
šode
->
i_dev
)) {

133 ((*è(
bh
->
b_d©a
))[
block
&511]=
i
;

134 
bh
->
b_dœt
=1;

136 
	`b»l£
(
bh
);

137  
i
;

138 
	}
}

140 
	$bm­
(
m_šode
 * 
šode
,
block
)

142  
	`_bm­
(
šode
,
block
,0);

143 
	}
}

145 
	$ü—‹_block
(
m_šode
 * 
šode
, 
block
)

147  
	`_bm­
(
šode
,
block
,1);

148 
	}
}

150 
	$ut
(
m_šode
 * 
šode
)

152 ià(!
šode
)

154 
	`wa™_Ú_šode
(
šode
);

155 ià(!
šode
->
i_couÁ
)

156 
	`·nic
("iput:ryingo free free inode");

157 ià(
šode
->
i_pe
) {

158 
	`wake_up
(&
šode
->
i_wa™
);

159 ià(--
šode
->
i_couÁ
)

161 
	`ä“_·ge
(
šode
->
i_size
);

162 
šode
->
i_couÁ
=0;

163 
šode
->
i_dœt
=0;

164 
šode
->
i_pe
=0;

167 ià(!
šode
->
i_dev
) {

168 
šode
->
i_couÁ
--;

171 ià(
	`S_ISBLK
(
šode
->
i_mode
)) {

172 
	`sync_dev
(
šode
->
i_zÚe
[0]);

173 
	`wa™_Ú_šode
(
šode
);

175 
»³©
:

176 ià(
šode
->
i_couÁ
>1) {

177 
šode
->
i_couÁ
--;

180 ià(!
šode
->
i_Æšks
) {

181 
	`Œunÿ‹
(
šode
);

182 
	`ä“_šode
(
šode
);

185 ià(
šode
->
i_dœt
) {

186 
	`wr™e_šode
(
šode
);

187 
	`wa™_Ú_šode
(
šode
);

188 
»³©
;

190 
šode
->
i_couÁ
--;

192 
	}
}

194 
m_šode
 * 
	$g‘_em±y_šode
()

196 
m_šode
 * 
šode
;

197 
m_šode
 * 
Ï¡_šode
 = 
šode_bË
;

198 
i
;

201 
šode
 = 
NULL
;

202 
i
 = 
NR_INODE
; i ; i--) {

203 ià(++
Ï¡_šode
 >ð
šode_bË
 + 
NR_INODE
)

204 
Ï¡_šode
 = 
šode_bË
;

205 ià(!
Ï¡_šode
->
i_couÁ
) {

206 
šode
 = 
Ï¡_šode
;

207 ià(!
šode
->
i_dœt
 && !šode->
i_lock
)

211 ià(!
šode
) {

212 
i
=0 ; i<
NR_INODE
 ; i++)

213 
	`´štk
("%04x: %6d\t",
šode_bË
[
i
].
i_dev
,

214 
šode_bË
[
i
].
i_num
);

215 
	`·nic
("No free inodes in mem");

217 
	`wa™_Ú_šode
(
šode
);

218 
šode
->
i_dœt
) {

219 
	`wr™e_šode
(
šode
);

220 
	`wa™_Ú_šode
(
šode
);

222 } 
šode
->
i_couÁ
);

223 
	`mem£t
(
šode
,0,(*inode));

224 
šode
->
i_couÁ
 = 1;

225  
šode
;

226 
	}
}

228 
m_šode
 * 
	$g‘_pe_šode
()

230 
m_šode
 * 
šode
;

232 ià(!(
šode
 = 
	`g‘_em±y_šode
()))

233  
NULL
;

234 ià(!(
šode
->
i_size
=
	`g‘_ä“_·ge
())) {

235 
šode
->
i_couÁ
 = 0;

236  
NULL
;

238 
šode
->
i_couÁ
 = 2;

239 
	`PIPE_HEAD
(*
šode
èð
	`PIPE_TAIL
(*inode) = 0;

240 
šode
->
i_pe
 = 1;

241  
šode
;

242 
	}
}

244 
m_šode
 * 
	$ig‘
(
dev
,
Ä
)

246 
m_šode
 * 
šode
, * 
em±y
;

248 ià(!
dev
)

249 
	`·nic
("iget with dev==0");

250 
em±y
 = 
	`g‘_em±y_šode
();

251 
šode
 = 
šode_bË
;

252 
šode
 < 
NR_INODE
+
šode_bË
) {

253 ià(
šode
->
i_dev
 !ð
dev
 || inode->
i_num
 !ð
Ä
) {

254 
šode
++;

257 
	`wa™_Ú_šode
(
šode
);

258 ià(
šode
->
i_dev
 !ð
dev
 || inode->
i_num
 !ð
Ä
) {

259 
šode
 = 
šode_bË
;

262 
šode
->
i_couÁ
++;

263 ià(
šode
->
i_mouÁ
) {

264 
i
;

266 
i
 = 0 ; i<
NR_SUPER
 ; i++)

267 ià(
su³r_block
[
i
].
s_imouÁ
==
šode
)

269 ià(
i
 >ð
NR_SUPER
) {

270 
	`´štk
("Mounted inode hasn't got sb\n");

271 ià(
em±y
)

272 
	`ut
(
em±y
);

273  
šode
;

275 
	`ut
(
šode
);

276 
dev
 = 
su³r_block
[
i
].
s_dev
;

277 
Ä
 = 
ROOT_INO
;

278 
šode
 = 
šode_bË
;

281 ià(
em±y
)

282 
	`ut
(
em±y
);

283  
šode
;

285 ià(!
em±y
)

286  (
NULL
);

287 
šode
=
em±y
;

288 
šode
->
i_dev
 = 
dev
;

289 
šode
->
i_num
 = 
Ä
;

290 
	`»ad_šode
(
šode
);

291  
šode
;

292 
	}
}

294 
	$»ad_šode
(
m_šode
 * 
šode
)

296 
su³r_block
 * 
sb
;

297 
bufãr_h—d
 * 
bh
;

298 
block
;

300 
	`lock_šode
(
šode
);

301 ià(!(
sb
=
	`g‘_su³r
(
šode
->
i_dev
)))

302 
	`·nic
("tryingo„ead inode without dev");

303 
block
 = 2 + 
sb
->
s_im­_blocks
 + sb->
s_zm­_blocks
 +

304 (
šode
->
i_num
-1)/
INODES_PER_BLOCK
;

305 ià(!(
bh
=
	`b»ad
(
šode
->
i_dev
,
block
)))

306 
	`·nic
("unableo„ead i-node block");

307 *(
d_šode
 *)
šode
 =

308 ((
d_šode
 *)
bh
->
b_d©a
)

309 [(
šode
->
i_num
-1)%
INODES_PER_BLOCK
];

310 
	`b»l£
(
bh
);

311 
	`uÆock_šode
(
šode
);

312 
	}
}

314 
	$wr™e_šode
(
m_šode
 * 
šode
)

316 
su³r_block
 * 
sb
;

317 
bufãr_h—d
 * 
bh
;

318 
block
;

320 
	`lock_šode
(
šode
);

321 ià(!
šode
->
i_dœt
 || !šode->
i_dev
) {

322 
	`uÆock_šode
(
šode
);

325 ià(!(
sb
=
	`g‘_su³r
(
šode
->
i_dev
)))

326 
	`·nic
("tryingo write inode without device");

327 
block
 = 2 + 
sb
->
s_im­_blocks
 + sb->
s_zm­_blocks
 +

328 (
šode
->
i_num
-1)/
INODES_PER_BLOCK
;

329 ià(!(
bh
=
	`b»ad
(
šode
->
i_dev
,
block
)))

330 
	`·nic
("unableo„ead i-node block");

331 ((
d_šode
 *)
bh
->
b_d©a
)

332 [(
šode
->
i_num
-1)%
INODES_PER_BLOCK
] =

333 *(
d_šode
 *)
šode
;

334 
bh
->
b_dœt
=1;

335 
šode
->
i_dœt
=0;

336 
	`b»l£
(
bh
);

337 
	`uÆock_šode
(
šode
);

338 
	}
}

	@fs/ioctl.c

7 
	~<¡ršg.h
>

8 
	~<”ºo.h
>

9 
	~<sys/¡©.h
>

11 
	~<lšux/sched.h
>

13 
‰y_ioùl
(
dev
, 
cmd
, 
¬g
);

15 (*
	tioùl_±r
)(
	tdev
,
	tcmd
,
	t¬g
);

17 
	#NRDEVS
 (( (
ioùl_bË
))/( (
ioùl_±r
)))

	)

19 
ioùl_±r
 
ioùl_bË
[]={

20 
NULL
,

21 
NULL
,

22 
NULL
,

23 
NULL
,

24 
‰y_ioùl
,

25 
‰y_ioùl
,

26 
NULL
,

27 
NULL
};

30 
	$sys_ioùl
(
fd
, 
cmd
, 
¬g
)

32 
fže
 * 
fžp
;

33 
dev
,
mode
;

35 ià(
fd
 >ð
NR_OPEN
 || !(
fžp
 = 
cu¼’t
->filp[fd]))

36  -
EBADF
;

37 
mode
=
fžp
->
f_šode
->
i_mode
;

38 ià(!
	`S_ISCHR
(
mode
è&& !
	`S_ISBLK
(mode))

39  -
EINVAL
;

40 
dev
 = 
fžp
->
f_šode
->
i_zÚe
[0];

41 ià(
	`MAJOR
(
dev
è>ð
NRDEVS
)

42  -
ENODEV
;

43 ià(!
ioùl_bË
[
	`MAJOR
(
dev
)])

44  -
ENOTTY
;

45  
ioùl_bË
[
	`MAJOR
(
dev
)](dev,
cmd
,
¬g
);

46 
	}
}

	@fs/namei.c

11 
	~<lšux/sched.h
>

12 
	~<lšux/k”Ãl.h
>

13 
	~<asm/£gm’t.h
>

15 
	~<¡ršg.h
>

16 
	~<fúŽ.h
>

17 
	~<”ºo.h
>

18 
	~<cÚ¡.h
>

19 
	~<sys/¡©.h
>

21 
	#ACC_MODE
(
x
è("\004\002\006\377"[(x)&
O_ACCMODE
])

	)

29 
	#MAY_EXEC
 1

	)

30 
	#MAY_WRITE
 2

	)

31 
	#MAY_READ
 4

	)

40 
	$³rmissiÚ
(
m_šode
 * 
šode
,
mask
)

42 
mode
 = 
šode
->
i_mode
;

45 ià(
šode
->
i_dev
 && !šode->
i_Æšks
)

47 ià(
cu¼’t
->
euid
==
šode
->
i_uid
)

48 
mode
 >>= 6;

49 ià(
cu¼’t
->
egid
==
šode
->
i_gid
)

50 
mode
 >>= 3;

51 ià(((
mode
 & 
mask
 & 0007è=ðmaskè|| 
	`su£r
())

54 
	}
}

63 
	$m©ch
(
Ën
,cÚ¡ * 
Çme
,
dœ_’Œy
 * 
de
)

65 
§me
 
	`__asm__
("ax");

67 ià(!
de
 || !de->
šode
 || 
Ën
 > 
NAME_LEN
)

69 ià(
Ën
 < 
NAME_LEN
 && 
de
->
Çme
[len])

71 
	`__asm__
("cld\n\t"

74 :"÷" (
§me
)

75 :"0" (0),"S" ((è
Çme
),"D" ((è
de
->Çme),"c" (
Ën
)

77  
§me
;

78 
	}
}

91 
bufãr_h—d
 * 
	$fšd_’Œy
(
m_šode
 ** 
dœ
,

92 cÚ¡ * 
Çme
, 
Çm–’
, 
dœ_’Œy
 ** 
»s_dœ
)

94 
’Œ›s
;

95 
block
,
i
;

96 
bufãr_h—d
 * 
bh
;

97 
dœ_’Œy
 * 
de
;

98 
su³r_block
 * 
sb
;

100 #ifdeà
NO_TRUNCATE


101 ià(
Çm–’
 > 
NAME_LEN
)

102  
NULL
;

104 ià(
Çm–’
 > 
NAME_LEN
)

105 
Çm–’
 = 
NAME_LEN
;

107 
’Œ›s
 = (*
dœ
)->
i_size
 / ( (
dœ_’Œy
));

108 *
»s_dœ
 = 
NULL
;

109 ià(!
Çm–’
)

110  
NULL
;

112 ià(
Çm–’
==2 && 
	`g‘_fs_by‹
(
Çme
)=='.' && get_fs_byte(name+1)=='.') {

114 ià((*
dœ
è=ð
cu¼’t
->
roÙ
)

115 
Çm–’
=1;

116 ià((*
dœ
)->
i_num
 =ð
ROOT_INO
) {

119 
sb
=
	`g‘_su³r
((*
dœ
)->
i_dev
);

120 ià(
sb
->
s_imouÁ
) {

121 
	`ut
(*
dœ
);

122 (*
dœ
)=
sb
->
s_imouÁ
;

123 (*
dœ
)->
i_couÁ
++;

127 ià(!(
block
 = (*
dœ
)->
i_zÚe
[0]))

128  
NULL
;

129 ià(!(
bh
 = 
	`b»ad
((*
dœ
)->
i_dev
,
block
)))

130  
NULL
;

131 
i
 = 0;

132 
de
 = (
dœ_’Œy
 *è
bh
->
b_d©a
;

133 
i
 < 
’Œ›s
) {

134 ià((*)
de
 >ð
BLOCK_SIZE
+
bh
->
b_d©a
) {

135 
	`b»l£
(
bh
);

136 
bh
 = 
NULL
;

137 ià(!(
block
 = 
	`bm­
(*
dœ
,
i
/
DIR_ENTRIES_PER_BLOCK
)) ||

138 !(
bh
 = 
	`b»ad
((*
dœ
)->
i_dev
,
block
))) {

139 
i
 +ð
DIR_ENTRIES_PER_BLOCK
;

142 
de
 = (
dœ_’Œy
 *è
bh
->
b_d©a
;

144 ià(
	`m©ch
(
Çm–’
,
Çme
,
de
)) {

145 *
»s_dœ
 = 
de
;

146  
bh
;

148 
de
++;

149 
i
++;

151 
	`b»l£
(
bh
);

152  
NULL
;

153 
	}
}

165 
bufãr_h—d
 * 
	$add_’Œy
(
m_šode
 * 
dœ
,

166 cÚ¡ * 
Çme
, 
Çm–’
, 
dœ_’Œy
 ** 
»s_dœ
)

168 
block
,
i
;

169 
bufãr_h—d
 * 
bh
;

170 
dœ_’Œy
 * 
de
;

172 *
»s_dœ
 = 
NULL
;

173 #ifdeà
NO_TRUNCATE


174 ià(
Çm–’
 > 
NAME_LEN
)

175  
NULL
;

177 ià(
Çm–’
 > 
NAME_LEN
)

178 
Çm–’
 = 
NAME_LEN
;

180 ià(!
Çm–’
)

181  
NULL
;

182 ià(!(
block
 = 
dœ
->
i_zÚe
[0]))

183  
NULL
;

184 ià(!(
bh
 = 
	`b»ad
(
dœ
->
i_dev
,
block
)))

185  
NULL
;

186 
i
 = 0;

187 
de
 = (
dœ_’Œy
 *è
bh
->
b_d©a
;

189 ià((*)
de
 >ð
BLOCK_SIZE
+
bh
->
b_d©a
) {

190 
	`b»l£
(
bh
);

191 
bh
 = 
NULL
;

192 
block
 = 
	`ü—‹_block
(
dœ
,
i
/
DIR_ENTRIES_PER_BLOCK
);

193 ià(!
block
)

194  
NULL
;

195 ià(!(
bh
 = 
	`b»ad
(
dœ
->
i_dev
,
block
))) {

196 
i
 +ð
DIR_ENTRIES_PER_BLOCK
;

199 
de
 = (
dœ_’Œy
 *è
bh
->
b_d©a
;

201 ià(
i
*(
dœ_’Œy
è>ð
dœ
->
i_size
) {

202 
de
->
šode
=0;

203 
dœ
->
i_size
 = (
i
+1)*(
dœ_’Œy
);

204 
dœ
->
i_dœt
 = 1;

205 
dœ
->
i_ùime
 = 
CURRENT_TIME
;

207 ià(!
de
->
šode
) {

208 
dœ
->
i_mtime
 = 
CURRENT_TIME
;

209 
i
=0; i < 
NAME_LEN
 ; i++)

210 
de
->
Çme
[
i
]=(i<
Çm–’
)?
	`g‘_fs_by‹
(name+i):0;

211 
bh
->
b_dœt
 = 1;

212 *
»s_dœ
 = 
de
;

213  
bh
;

215 
de
++;

216 
i
++;

218 
	`b»l£
(
bh
);

219  
NULL
;

220 
	}
}

228 
m_šode
 * 
	$g‘_dœ
(cÚ¡ * 
·thÇme
)

230 
c
;

231 cÚ¡ * 
thi¢ame
;

232 
m_šode
 * 
šode
;

233 
bufãr_h—d
 * 
bh
;

234 
Çm–’
,
šr
,
idev
;

235 
dœ_’Œy
 * 
de
;

237 ià(!
cu¼’t
->
roÙ
 || !cu¼’t->roÙ->
i_couÁ
)

238 
	`·nic
("No„oot inode");

239 ià(!
cu¼’t
->
pwd
 || !cu¼’t->pwd->
i_couÁ
)

240 
	`·nic
("No cwd inode");

241 ià((
c
=
	`g‘_fs_by‹
(
·thÇme
))=='/') {

242 
šode
 = 
cu¼’t
->
roÙ
;

243 
·thÇme
++;

244 } ià(
c
)

245 
šode
 = 
cu¼’t
->
pwd
;

247  
NULL
;

248 
šode
->
i_couÁ
++;

250 
thi¢ame
 = 
·thÇme
;

251 ià(!
	`S_ISDIR
(
šode
->
i_mode
è|| !
	`³rmissiÚ
(šode,
MAY_EXEC
)) {

252 
	`ut
(
šode
);

253  
NULL
;

255 
Çm–’
=0;(
c
=
	`g‘_fs_by‹
(
·thÇme
++))&&(c!='/');namelen++)

257 ià(!
c
)

258  
šode
;

259 ià(!(
bh
 = 
	`fšd_’Œy
(&
šode
,
thi¢ame
,
Çm–’
,&
de
))) {

260 
	`ut
(
šode
);

261  
NULL
;

263 
šr
 = 
de
->
šode
;

264 
idev
 = 
šode
->
i_dev
;

265 
	`b»l£
(
bh
);

266 
	`ut
(
šode
);

267 ià(!(
šode
 = 
	`ig‘
(
idev
,
šr
)))

268  
NULL
;

270 
	}
}

278 
m_šode
 * 
	$dœ_Çmei
(cÚ¡ * 
·thÇme
,

279 * 
Çm–’
, cÚ¡ ** 
Çme
)

281 
c
;

282 cÚ¡ * 
ba£Çme
;

283 
m_šode
 * 
dœ
;

285 ià(!(
dœ
 = 
	`g‘_dœ
(
·thÇme
)))

286  
NULL
;

287 
ba£Çme
 = 
·thÇme
;

288 
c
=
	`g‘_fs_by‹
(
·thÇme
++))

289 ià(
c
=='/')

290 
ba£Çme
=
·thÇme
;

291 *
Çm–’
 = 
·thÇme
-
ba£Çme
-1;

292 *
Çme
 = 
ba£Çme
;

293  
dœ
;

294 
	}
}

303 
m_šode
 * 
	$Çmei
(cÚ¡ * 
·thÇme
)

305 cÚ¡ * 
ba£Çme
;

306 
šr
,
dev
,
Çm–’
;

307 
m_šode
 * 
dœ
;

308 
bufãr_h—d
 * 
bh
;

309 
dœ_’Œy
 * 
de
;

311 ià(!(
dœ
 = 
	`dœ_Çmei
(
·thÇme
,&
Çm–’
,&
ba£Çme
)))

312  
NULL
;

313 ià(!
Çm–’
)

314  
dœ
;

315 
bh
 = 
	`fšd_’Œy
(&
dœ
,
ba£Çme
,
Çm–’
,&
de
);

316 ià(!
bh
) {

317 
	`ut
(
dœ
);

318  
NULL
;

320 
šr
 = 
de
->
šode
;

321 
dev
 = 
dœ
->
i_dev
;

322 
	`b»l£
(
bh
);

323 
	`ut
(
dœ
);

324 
dœ
=
	`ig‘
(
dev
,
šr
);

325 ià(
dœ
) {

326 
dœ
->
i_©ime
=
CURRENT_TIME
;

327 
dœ
->
i_dœt
=1;

329  
dœ
;

330 
	}
}

337 
	$Ý’_Çmei
(cÚ¡ * 
·thÇme
, 
æag
, 
mode
,

338 
m_šode
 ** 
»s_šode
)

340 cÚ¡ * 
ba£Çme
;

341 
šr
,
dev
,
Çm–’
;

342 
m_šode
 * 
dœ
, *
šode
;

343 
bufãr_h—d
 * 
bh
;

344 
dœ_’Œy
 * 
de
;

346 ià((
æag
 & 
O_TRUNC
è&& !(æag & 
O_ACCMODE
))

347 
æag
 |ð
O_WRONLY
;

348 
mode
 &ð0777 & ~
cu¼’t
->
umask
;

349 
mode
 |ð
I_REGULAR
;

350 ià(!(
dœ
 = 
	`dœ_Çmei
(
·thÇme
,&
Çm–’
,&
ba£Çme
)))

351  -
ENOENT
;

352 ià(!
Çm–’
) {

353 ià(!(
æag
 & (
O_ACCMODE
|
O_CREAT
|
O_TRUNC
))) {

354 *
»s_šode
=
dœ
;

357 
	`ut
(
dœ
);

358  -
EISDIR
;

360 
bh
 = 
	`fšd_’Œy
(&
dœ
,
ba£Çme
,
Çm–’
,&
de
);

361 ià(!
bh
) {

362 ià(!(
æag
 & 
O_CREAT
)) {

363 
	`ut
(
dœ
);

364  -
ENOENT
;

366 ià(!
	`³rmissiÚ
(
dœ
,
MAY_WRITE
)) {

367 
	`ut
(
dœ
);

368  -
EACCES
;

370 
šode
 = 
	`Ãw_šode
(
dœ
->
i_dev
);

371 ià(!
šode
) {

372 
	`ut
(
dœ
);

373  -
ENOSPC
;

375 
šode
->
i_uid
 = 
cu¼’t
->
euid
;

376 
šode
->
i_mode
 = 
mode
;

377 
šode
->
i_dœt
 = 1;

378 
bh
 = 
	`add_’Œy
(
dœ
,
ba£Çme
,
Çm–’
,&
de
);

379 ià(!
bh
) {

380 
šode
->
i_Æšks
--;

381 
	`ut
(
šode
);

382 
	`ut
(
dœ
);

383  -
ENOSPC
;

385 
de
->
šode
 = inode->
i_num
;

386 
bh
->
b_dœt
 = 1;

387 
	`b»l£
(
bh
);

388 
	`ut
(
dœ
);

389 *
»s_šode
 = 
šode
;

392 
šr
 = 
de
->
šode
;

393 
dev
 = 
dœ
->
i_dev
;

394 
	`b»l£
(
bh
);

395 
	`ut
(
dœ
);

396 ià(
æag
 & 
O_EXCL
)

397  -
EEXIST
;

398 ià(!(
šode
=
	`ig‘
(
dev
,
šr
)))

399  -
EACCES
;

400 ià((
	`S_ISDIR
(
šode
->
i_mode
è&& (
æag
 & 
O_ACCMODE
)) ||

401 !
	`³rmissiÚ
(
šode
,
	`ACC_MODE
(
æag
))) {

402 
	`ut
(
šode
);

403  -
EPERM
;

405 
šode
->
i_©ime
 = 
CURRENT_TIME
;

406 ià(
æag
 & 
O_TRUNC
)

407 
	`Œunÿ‹
(
šode
);

408 *
»s_šode
 = 
šode
;

410 
	}
}

412 
	$sys_mknod
(cÚ¡ * 
fž’ame
, 
mode
, 
dev
)

414 cÚ¡ * 
ba£Çme
;

415 
Çm–’
;

416 
m_šode
 * 
dœ
, * 
šode
;

417 
bufãr_h—d
 * 
bh
;

418 
dœ_’Œy
 * 
de
;

420 ià(!
	`su£r
())

421  -
EPERM
;

422 ià(!(
dœ
 = 
	`dœ_Çmei
(
fž’ame
,&
Çm–’
,&
ba£Çme
)))

423  -
ENOENT
;

424 ià(!
Çm–’
) {

425 
	`ut
(
dœ
);

426  -
ENOENT
;

428 ià(!
	`³rmissiÚ
(
dœ
,
MAY_WRITE
)) {

429 
	`ut
(
dœ
);

430  -
EPERM
;

432 
bh
 = 
	`fšd_’Œy
(&
dœ
,
ba£Çme
,
Çm–’
,&
de
);

433 ià(
bh
) {

434 
	`b»l£
(
bh
);

435 
	`ut
(
dœ
);

436  -
EEXIST
;

438 
šode
 = 
	`Ãw_šode
(
dœ
->
i_dev
);

439 ià(!
šode
) {

440 
	`ut
(
dœ
);

441  -
ENOSPC
;

443 
šode
->
i_mode
 = 
mode
;

444 ià(
	`S_ISBLK
(
mode
è|| 
	`S_ISCHR
(mode))

445 
šode
->
i_zÚe
[0] = 
dev
;

446 
šode
->
i_mtime
 = inode->
i_©ime
 = 
CURRENT_TIME
;

447 
šode
->
i_dœt
 = 1;

448 
bh
 = 
	`add_’Œy
(
dœ
,
ba£Çme
,
Çm–’
,&
de
);

449 ià(!
bh
) {

450 
	`ut
(
dœ
);

451 
šode
->
i_Æšks
=0;

452 
	`ut
(
šode
);

453  -
ENOSPC
;

455 
de
->
šode
 = inode->
i_num
;

456 
bh
->
b_dœt
 = 1;

457 
	`ut
(
dœ
);

458 
	`ut
(
šode
);

459 
	`b»l£
(
bh
);

461 
	}
}

463 
	$sys_mkdœ
(cÚ¡ * 
·thÇme
, 
mode
)

465 cÚ¡ * 
ba£Çme
;

466 
Çm–’
;

467 
m_šode
 * 
dœ
, * 
šode
;

468 
bufãr_h—d
 * 
bh
, *
dœ_block
;

469 
dœ_’Œy
 * 
de
;

471 ià(!
	`su£r
())

472  -
EPERM
;

473 ià(!(
dœ
 = 
	`dœ_Çmei
(
·thÇme
,&
Çm–’
,&
ba£Çme
)))

474  -
ENOENT
;

475 ià(!
Çm–’
) {

476 
	`ut
(
dœ
);

477  -
ENOENT
;

479 ià(!
	`³rmissiÚ
(
dœ
,
MAY_WRITE
)) {

480 
	`ut
(
dœ
);

481  -
EPERM
;

483 
bh
 = 
	`fšd_’Œy
(&
dœ
,
ba£Çme
,
Çm–’
,&
de
);

484 ià(
bh
) {

485 
	`b»l£
(
bh
);

486 
	`ut
(
dœ
);

487  -
EEXIST
;

489 
šode
 = 
	`Ãw_šode
(
dœ
->
i_dev
);

490 ià(!
šode
) {

491 
	`ut
(
dœ
);

492  -
ENOSPC
;

494 
šode
->
i_size
 = 32;

495 
šode
->
i_dœt
 = 1;

496 
šode
->
i_mtime
 = inode->
i_©ime
 = 
CURRENT_TIME
;

497 ià(!(
šode
->
i_zÚe
[0]=
	`Ãw_block
(šode->
i_dev
))) {

498 
	`ut
(
dœ
);

499 
šode
->
i_Æšks
--;

500 
	`ut
(
šode
);

501  -
ENOSPC
;

503 
šode
->
i_dœt
 = 1;

504 ià(!(
dœ_block
=
	`b»ad
(
šode
->
i_dev
,šode->
i_zÚe
[0]))) {

505 
	`ut
(
dœ
);

506 
	`ä“_block
(
šode
->
i_dev
,šode->
i_zÚe
[0]);

507 
šode
->
i_Æšks
--;

508 
	`ut
(
šode
);

509  -
ERROR
;

511 
de
 = (
dœ_’Œy
 *è
dœ_block
->
b_d©a
;

512 
de
->
šode
=šode->
i_num
;

513 
	`¡rýy
(
de
->
Çme
,".");

514 
de
++;

515 
de
->
šode
 = 
dœ
->
i_num
;

516 
	`¡rýy
(
de
->
Çme
,"..");

517 
šode
->
i_Æšks
 = 2;

518 
dœ_block
->
b_dœt
 = 1;

519 
	`b»l£
(
dœ_block
);

520 
šode
->
i_mode
 = 
I_DIRECTORY
 | (
mode
 & 0777 & ~
cu¼’t
->
umask
);

521 
šode
->
i_dœt
 = 1;

522 
bh
 = 
	`add_’Œy
(
dœ
,
ba£Çme
,
Çm–’
,&
de
);

523 ià(!
bh
) {

524 
	`ut
(
dœ
);

525 
	`ä“_block
(
šode
->
i_dev
,šode->
i_zÚe
[0]);

526 
šode
->
i_Æšks
=0;

527 
	`ut
(
šode
);

528  -
ENOSPC
;

530 
de
->
šode
 = inode->
i_num
;

531 
bh
->
b_dœt
 = 1;

532 
dœ
->
i_Æšks
++;

533 
dœ
->
i_dœt
 = 1;

534 
	`ut
(
dœ
);

535 
	`ut
(
šode
);

536 
	`b»l£
(
bh
);

538 
	}
}

543 
	$em±y_dœ
(
m_šode
 * 
šode
)

545 
Ä
,
block
;

546 
Ën
;

547 
bufãr_h—d
 * 
bh
;

548 
dœ_’Œy
 * 
de
;

550 
Ën
 = 
šode
->
i_size
 /  (
dœ_’Œy
);

551 ià(
Ën
<2 || !
šode
->
i_zÚe
[0] ||

552 !(
bh
=
	`b»ad
(
šode
->
i_dev
,šode->
i_zÚe
[0]))) {

553 
	`´štk
("w¬nšg - bad dœeùÜy oÀdev %04x\n",
šode
->
i_dev
);

556 
de
 = (
dœ_’Œy
 *è
bh
->
b_d©a
;

557 ià(
de
[0].
šode
 !ðšode->
i_num
 || !de[1].inode ||

558 
	`¡rcmp
(".",
de
[0].
Çme
) || strcmp("..",de[1].name)) {

559 
	`´štk
("w¬nšg - bad dœeùÜy oÀdev %04x\n",
šode
->
i_dev
);

562 
Ä
 = 2;

563 
de
 += 2;

564 
Ä
<
Ën
) {

565 ià((*è
de
 >ð(*è(
bh
->
b_d©a
+
BLOCK_SIZE
)) {

566 
	`b»l£
(
bh
);

567 
block
=
	`bm­
(
šode
,
Ä
/
DIR_ENTRIES_PER_BLOCK
);

568 ià(!
block
) {

569 
Ä
 +ð
DIR_ENTRIES_PER_BLOCK
;

572 ià(!(
bh
=
	`b»ad
(
šode
->
i_dev
,
block
)))

574 
de
 = (
dœ_’Œy
 *è
bh
->
b_d©a
;

576 ià(
de
->
šode
) {

577 
	`b»l£
(
bh
);

580 
de
++;

581 
Ä
++;

583 
	`b»l£
(
bh
);

585 
	}
}

587 
	$sys_rmdœ
(cÚ¡ * 
Çme
)

589 cÚ¡ * 
ba£Çme
;

590 
Çm–’
;

591 
m_šode
 * 
dœ
, * 
šode
;

592 
bufãr_h—d
 * 
bh
;

593 
dœ_’Œy
 * 
de
;

595 ià(!
	`su£r
())

596  -
EPERM
;

597 ià(!(
dœ
 = 
	`dœ_Çmei
(
Çme
,&
Çm–’
,&
ba£Çme
)))

598  -
ENOENT
;

599 ià(!
Çm–’
) {

600 
	`ut
(
dœ
);

601  -
ENOENT
;

603 ià(!
	`³rmissiÚ
(
dœ
,
MAY_WRITE
)) {

604 
	`ut
(
dœ
);

605  -
EPERM
;

607 
bh
 = 
	`fšd_’Œy
(&
dœ
,
ba£Çme
,
Çm–’
,&
de
);

608 ià(!
bh
) {

609 
	`ut
(
dœ
);

610  -
ENOENT
;

612 ià(!(
šode
 = 
	`ig‘
(
dœ
->
i_dev
, 
de
->inode))) {

613 
	`ut
(
dœ
);

614 
	`b»l£
(
bh
);

615  -
EPERM
;

617 ià((
dœ
->
i_mode
 & 
S_ISVTX
è&& 
cu¼’t
->
euid
 &&

618 
šode
->
i_uid
 !ð
cu¼’t
->
euid
) {

619 
	`ut
(
dœ
);

620 
	`ut
(
šode
);

621 
	`b»l£
(
bh
);

622  -
EPERM
;

624 ià(
šode
->
i_dev
 !ð
dœ
->i_dev || inode->
i_couÁ
>1) {

625 
	`ut
(
dœ
);

626 
	`ut
(
šode
);

627 
	`b»l£
(
bh
);

628  -
EPERM
;

630 ià(
šode
 =ð
dœ
) {

631 
	`ut
(
šode
);

632 
	`ut
(
dœ
);

633 
	`b»l£
(
bh
);

634  -
EPERM
;

636 ià(!
	`S_ISDIR
(
šode
->
i_mode
)) {

637 
	`ut
(
šode
);

638 
	`ut
(
dœ
);

639 
	`b»l£
(
bh
);

640  -
ENOTDIR
;

642 ià(!
	`em±y_dœ
(
šode
)) {

643 
	`ut
(
šode
);

644 
	`ut
(
dœ
);

645 
	`b»l£
(
bh
);

646  -
ENOTEMPTY
;

648 ià(
šode
->
i_Æšks
 != 2)

649 
	`´štk
("em±y dœeùÜy ha Æšk!=2 (%d)",
šode
->
i_Æšks
);

650 
de
->
šode
 = 0;

651 
bh
->
b_dœt
 = 1;

652 
	`b»l£
(
bh
);

653 
šode
->
i_Æšks
=0;

654 
šode
->
i_dœt
=1;

655 
dœ
->
i_Æšks
--;

656 
dœ
->
i_ùime
 = dœ->
i_mtime
 = 
CURRENT_TIME
;

657 
dœ
->
i_dœt
=1;

658 
	`ut
(
dœ
);

659 
	`ut
(
šode
);

661 
	}
}

663 
	$sys_uÆšk
(cÚ¡ * 
Çme
)

665 cÚ¡ * 
ba£Çme
;

666 
Çm–’
;

667 
m_šode
 * 
dœ
, * 
šode
;

668 
bufãr_h—d
 * 
bh
;

669 
dœ_’Œy
 * 
de
;

671 ià(!(
dœ
 = 
	`dœ_Çmei
(
Çme
,&
Çm–’
,&
ba£Çme
)))

672  -
ENOENT
;

673 ià(!
Çm–’
) {

674 
	`ut
(
dœ
);

675  -
ENOENT
;

677 ià(!
	`³rmissiÚ
(
dœ
,
MAY_WRITE
)) {

678 
	`ut
(
dœ
);

679  -
EPERM
;

681 
bh
 = 
	`fšd_’Œy
(&
dœ
,
ba£Çme
,
Çm–’
,&
de
);

682 ià(!
bh
) {

683 
	`ut
(
dœ
);

684  -
ENOENT
;

686 ià(!(
šode
 = 
	`ig‘
(
dœ
->
i_dev
, 
de
->inode))) {

687 
	`ut
(
dœ
);

688 
	`b»l£
(
bh
);

689  -
ENOENT
;

691 ià((
dœ
->
i_mode
 & 
S_ISVTX
è&& !
	`su£r
() &&

692 
cu¼’t
->
euid
 !ð
šode
->
i_uid
 &&

693 
cu¼’t
->
euid
 !ð
dœ
->
i_uid
) {

694 
	`ut
(
dœ
);

695 
	`ut
(
šode
);

696 
	`b»l£
(
bh
);

697  -
EPERM
;

699 ià(
	`S_ISDIR
(
šode
->
i_mode
)) {

700 
	`ut
(
šode
);

701 
	`ut
(
dœ
);

702 
	`b»l£
(
bh
);

703  -
EPERM
;

705 ià(!
šode
->
i_Æšks
) {

706 
	`´štk
("Deleting‚onexistent file (%04x:%d), %d\n",

707 
šode
->
i_dev
,šode->
i_num
,šode->
i_Æšks
);

708 
šode
->
i_Æšks
=1;

710 
de
->
šode
 = 0;

711 
bh
->
b_dœt
 = 1;

712 
	`b»l£
(
bh
);

713 
šode
->
i_Æšks
--;

714 
šode
->
i_dœt
 = 1;

715 
šode
->
i_ùime
 = 
CURRENT_TIME
;

716 
	`ut
(
šode
);

717 
	`ut
(
dœ
);

719 
	}
}

721 
	$sys_lšk
(cÚ¡ * 
ÞdÇme
, cÚ¡ * 
ÃwÇme
)

723 
dœ_’Œy
 * 
de
;

724 
m_šode
 * 
Þdšode
, * 
dœ
;

725 
bufãr_h—d
 * 
bh
;

726 cÚ¡ * 
ba£Çme
;

727 
Çm–’
;

729 
Þdšode
=
	`Çmei
(
ÞdÇme
);

730 ià(!
Þdšode
)

731  -
ENOENT
;

732 ià(
	`S_ISDIR
(
Þdšode
->
i_mode
)) {

733 
	`ut
(
Þdšode
);

734  -
EPERM
;

736 
dœ
 = 
	`dœ_Çmei
(
ÃwÇme
,&
Çm–’
,&
ba£Çme
);

737 ià(!
dœ
) {

738 
	`ut
(
Þdšode
);

739  -
EACCES
;

741 ià(!
Çm–’
) {

742 
	`ut
(
Þdšode
);

743 
	`ut
(
dœ
);

744  -
EPERM
;

746 ià(
dœ
->
i_dev
 !ð
Þdšode
->i_dev) {

747 
	`ut
(
dœ
);

748 
	`ut
(
Þdšode
);

749  -
EXDEV
;

751 ià(!
	`³rmissiÚ
(
dœ
,
MAY_WRITE
)) {

752 
	`ut
(
dœ
);

753 
	`ut
(
Þdšode
);

754  -
EACCES
;

756 
bh
 = 
	`fšd_’Œy
(&
dœ
,
ba£Çme
,
Çm–’
,&
de
);

757 ià(
bh
) {

758 
	`b»l£
(
bh
);

759 
	`ut
(
dœ
);

760 
	`ut
(
Þdšode
);

761  -
EEXIST
;

763 
bh
 = 
	`add_’Œy
(
dœ
,
ba£Çme
,
Çm–’
,&
de
);

764 ià(!
bh
) {

765 
	`ut
(
dœ
);

766 
	`ut
(
Þdšode
);

767  -
ENOSPC
;

769 
de
->
šode
 = 
Þdšode
->
i_num
;

770 
bh
->
b_dœt
 = 1;

771 
	`b»l£
(
bh
);

772 
	`ut
(
dœ
);

773 
Þdšode
->
i_Æšks
++;

774 
Þdšode
->
i_ùime
 = 
CURRENT_TIME
;

775 
Þdšode
->
i_dœt
 = 1;

776 
	`ut
(
Þdšode
);

778 
	}
}

	@fs/open.c

7 
	~<¡ršg.h
>

8 
	~<”ºo.h
>

9 
	~<fúŽ.h
>

10 
	~<sys/ty³s.h
>

11 
	~<utime.h
>

12 
	~<sys/¡©.h
>

14 
	~<lšux/sched.h
>

15 
	~<lšux/‰y.h
>

16 
	~<lšux/k”Ãl.h
>

17 
	~<asm/£gm’t.h
>

19 
	$sys_u¡©
(
dev
, 
u¡©
 * 
ubuf
)

21  -
ENOSYS
;

22 
	}
}

24 
	$sys_utime
(* 
fž’ame
, 
utimbuf
 * 
times
)

26 
m_šode
 * 
šode
;

27 
aùime
,
modtime
;

29 ià(!(
šode
=
	`Çmei
(
fž’ame
)))

30  -
ENOENT
;

31 ià(
times
) {

32 
aùime
 = 
	`g‘_fs_lÚg
((*è&
times
->actime);

33 
modtime
 = 
	`g‘_fs_lÚg
((*è&
times
->modtime);

35 
aùime
 = 
modtime
 = 
CURRENT_TIME
;

36 
šode
->
i_©ime
 = 
aùime
;

37 
šode
->
i_mtime
 = 
modtime
;

38 
šode
->
i_dœt
 = 1;

39 
	`ut
(
šode
);

41 
	}
}

47 
	$sys_acûss
(cÚ¡ * 
fž’ame
,
mode
)

49 
m_šode
 * 
šode
;

50 
»s
, 
i_mode
;

52 
mode
 &= 0007;

53 ià(!(
šode
=
	`Çmei
(
fž’ame
)))

54  -
EACCES
;

55 
i_mode
 = 
»s
 = 
šode
->i_mode & 0777;

56 
	`ut
(
šode
);

57 ià(
cu¼’t
->
uid
 =ð
šode
->
i_uid
)

58 
»s
 >>= 6;

59 ià(
cu¼’t
->
gid
 =ð
šode
->
i_gid
)

60 
»s
 >>= 6;

61 ià((
»s
 & 0007 & 
mode
) == mode)

69 ià((!
cu¼’t
->
uid
) &&

70 (!(
mode
 & 1è|| (
i_mode
 & 0111)))

72  -
EACCES
;

73 
	}
}

75 
	$sys_chdœ
(cÚ¡ * 
fž’ame
)

77 
m_šode
 * 
šode
;

79 ià(!(
šode
 = 
	`Çmei
(
fž’ame
)))

80  -
ENOENT
;

81 ià(!
	`S_ISDIR
(
šode
->
i_mode
)) {

82 
	`ut
(
šode
);

83  -
ENOTDIR
;

85 
	`ut
(
cu¼’t
->
pwd
);

86 
cu¼’t
->
pwd
 = 
šode
;

88 
	}
}

90 
	$sys_chroÙ
(cÚ¡ * 
fž’ame
)

92 
m_šode
 * 
šode
;

94 ià(!(
šode
=
	`Çmei
(
fž’ame
)))

95  -
ENOENT
;

96 ià(!
	`S_ISDIR
(
šode
->
i_mode
)) {

97 
	`ut
(
šode
);

98  -
ENOTDIR
;

100 
	`ut
(
cu¼’t
->
roÙ
);

101 
cu¼’t
->
roÙ
 = 
šode
;

103 
	}
}

105 
	$sys_chmod
(cÚ¡ * 
fž’ame
,
mode
)

107 
m_šode
 * 
šode
;

109 ià(!(
šode
=
	`Çmei
(
fž’ame
)))

110  -
ENOENT
;

111 ià((
cu¼’t
->
euid
 !ð
šode
->
i_uid
è&& !
	`su£r
()) {

112 
	`ut
(
šode
);

113  -
EACCES
;

115 
šode
->
i_mode
 = (
mode
 & 07777) | (inode->i_mode & ~07777);

116 
šode
->
i_dœt
 = 1;

117 
	`ut
(
šode
);

119 
	}
}

121 
	$sys_chown
(cÚ¡ * 
fž’ame
,
uid
,
gid
)

123 
m_šode
 * 
šode
;

125 ià(!(
šode
=
	`Çmei
(
fž’ame
)))

126  -
ENOENT
;

127 ià(!
	`su£r
()) {

128 
	`ut
(
šode
);

129  -
EACCES
;

131 
šode
->
i_uid
=
uid
;

132 
šode
->
i_gid
=
gid
;

133 
šode
->
i_dœt
=1;

134 
	`ut
(
šode
);

136 
	}
}

138 
	$sys_Ý’
(cÚ¡ * 
fž’ame
,
æag
,
mode
)

140 
m_šode
 * 
šode
;

141 
fže
 * 
f
;

142 
i
,
fd
;

144 
mode
 &ð0777 & ~
cu¼’t
->
umask
;

145 
fd
=0 ; fd<
NR_OPEN
 ; fd++)

146 ià(!
cu¼’t
->
fžp
[
fd
])

148 ià(
fd
>=
NR_OPEN
)

149  -
EINVAL
;

150 
cu¼’t
->
þo£_Ú_exec
 &ð~(1<<
fd
);

151 
f
=0+
fže_bË
;

152 
i
=0 ; i<
NR_FILE
 ; i++,
f
++)

153 ià(!
f
->
f_couÁ
) ;

154 ià(
i
>=
NR_FILE
)

155  -
EINVAL
;

156 (
cu¼’t
->
fžp
[
fd
]=
f
)->
f_couÁ
++;

157 ià((
i
=
	`Ý’_Çmei
(
fž’ame
,
æag
,
mode
,&
šode
))<0) {

158 
cu¼’t
->
fžp
[
fd
]=
NULL
;

159 
f
->
f_couÁ
=0;

160  
i
;

163 ià(
	`S_ISCHR
(
šode
->
i_mode
))

164 ià(
	`MAJOR
(
šode
->
i_zÚe
[0])==4) {

165 ià(
cu¼’t
->
Ëad”
 && cu¼’t->
‰y
<0) {

166 
cu¼’t
->
‰y
 = 
	`MINOR
(
šode
->
i_zÚe
[0]);

167 
‰y_bË
[
cu¼’t
->
‰y
].
pg½
 = current->pgrp;

169 } ià(
	`MAJOR
(
šode
->
i_zÚe
[0])==5)

170 ià(
cu¼’t
->
‰y
<0) {

171 
	`ut
(
šode
);

172 
cu¼’t
->
fžp
[
fd
]=
NULL
;

173 
f
->
f_couÁ
=0;

174  -
EPERM
;

177 ià(
	`S_ISBLK
(
šode
->
i_mode
))

178 
	`check_disk_chªge
(
šode
->
i_zÚe
[0]);

179 
f
->
f_mode
 = 
šode
->
i_mode
;

180 
f
->
f_æags
 = 
æag
;

181 
f
->
f_couÁ
 = 1;

182 
f
->
f_šode
 = 
šode
;

183 
f
->
f_pos
 = 0;

184  (
fd
);

185 
	}
}

187 
	$sys_ü—t
(cÚ¡ * 
·thÇme
, 
mode
)

189  
	`sys_Ý’
(
·thÇme
, 
O_CREAT
 | 
O_TRUNC
, 
mode
);

190 
	}
}

192 
	$sys_þo£
(
fd
)

194 
fže
 * 
fžp
;

196 ià(
fd
 >ð
NR_OPEN
)

197  -
EINVAL
;

198 
cu¼’t
->
þo£_Ú_exec
 &ð~(1<<
fd
);

199 ià(!(
fžp
 = 
cu¼’t
->fžp[
fd
]))

200  -
EINVAL
;

201 
cu¼’t
->
fžp
[
fd
] = 
NULL
;

202 ià(
fžp
->
f_couÁ
 == 0)

203 
	`·nic
("Close: file count is 0");

204 ià(--
fžp
->
f_couÁ
)

206 
	`ut
(
fžp
->
f_šode
);

208 
	}
}

	@fs/pipe.c

7 
	~<sigÇl.h
>

9 
	~<lšux/sched.h
>

10 
	~<lšux/mm.h
>

11 
	~<asm/£gm’t.h
>

13 
	$»ad_pe
(
m_šode
 * 
šode
, * 
buf
, 
couÁ
)

15 
ch¬s
, 
size
, 
»ad
 = 0;

17 
couÁ
>0) {

18 !(
size
=
	`PIPE_SIZE
(*
šode
))) {

19 
	`wake_up
(&
šode
->
i_wa™
);

20 ià(
šode
->
i_couÁ
 != 2)

21  
»ad
;

22 
	`¦“p_Ú
(&
šode
->
i_wa™
);

24 
ch¬s
 = 
PAGE_SIZE
-
	`PIPE_TAIL
(*
šode
);

25 ià(
ch¬s
 > 
couÁ
)

26 
ch¬s
 = 
couÁ
;

27 ià(
ch¬s
 > 
size
)

28 
ch¬s
 = 
size
;

29 
couÁ
 -ð
ch¬s
;

30 
»ad
 +ð
ch¬s
;

31 
size
 = 
	`PIPE_TAIL
(*
šode
);

32 
	`PIPE_TAIL
(*
šode
è+ð
ch¬s
;

33 
	`PIPE_TAIL
(*
šode
è&ð(
PAGE_SIZE
-1);

34 
ch¬s
-->0)

35 
	`put_fs_by‹
(((*)
šode
->
i_size
)[
size
++],
buf
++);

37 
	`wake_up
(&
šode
->
i_wa™
);

38  
»ad
;

39 
	}
}

41 
	$wr™e_pe
(
m_šode
 * 
šode
, * 
buf
, 
couÁ
)

43 
ch¬s
, 
size
, 
wr™‹n
 = 0;

45 
couÁ
>0) {

46 !(
size
=(
PAGE_SIZE
-1)-
	`PIPE_SIZE
(*
šode
))) {

47 
	`wake_up
(&
šode
->
i_wa™
);

48 ià(
šode
->
i_couÁ
 != 2) {

49 
cu¼’t
->
sigÇl
 |ð(1<<(
SIGPIPE
-1));

50  
wr™‹n
?written:-1;

52 
	`¦“p_Ú
(&
šode
->
i_wa™
);

54 
ch¬s
 = 
PAGE_SIZE
-
	`PIPE_HEAD
(*
šode
);

55 ià(
ch¬s
 > 
couÁ
)

56 
ch¬s
 = 
couÁ
;

57 ià(
ch¬s
 > 
size
)

58 
ch¬s
 = 
size
;

59 
couÁ
 -ð
ch¬s
;

60 
wr™‹n
 +ð
ch¬s
;

61 
size
 = 
	`PIPE_HEAD
(*
šode
);

62 
	`PIPE_HEAD
(*
šode
è+ð
ch¬s
;

63 
	`PIPE_HEAD
(*
šode
è&ð(
PAGE_SIZE
-1);

64 
ch¬s
-->0)

65 ((*)
šode
->
i_size
)[
size
++]=
	`g‘_fs_by‹
(
buf
++);

67 
	`wake_up
(&
šode
->
i_wa™
);

68  
wr™‹n
;

69 
	}
}

71 
	$sys_pe
(* 
fždes
)

73 
m_šode
 * 
šode
;

74 
fže
 * 
f
[2];

75 
fd
[2];

76 
i
,
j
;

78 
j
=0;

79 
i
=0;
j
<2 && i<
NR_FILE
;i++)

80 ià(!
fže_bË
[
i
].
f_couÁ
)

81 (
f
[
j
++]=
i
+
fže_bË
)->
f_couÁ
++;

82 ià(
j
==1)

83 
f
[0]->
f_couÁ
=0;

84 ià(
j
<2)

86 
j
=0;

87 
i
=0;
j
<2 && i<
NR_OPEN
;i++)

88 ià(!
cu¼’t
->
fžp
[
i
]) {

89 
cu¼’t
->
fžp
[ 
fd
[
j
]=
i
 ] = 
f
[j];

90 
j
++;

92 ià(
j
==1)

93 
cu¼’t
->
fžp
[
fd
[0]]=
NULL
;

94 ià(
j
<2) {

95 
f
[0]->
f_couÁ
=f[1]->f_count=0;

98 ià(!(
šode
=
	`g‘_pe_šode
())) {

99 
cu¼’t
->
fžp
[
fd
[0]] =

100 
cu¼’t
->
fžp
[
fd
[1]] = 
NULL
;

101 
f
[0]->
f_couÁ
 = f[1]->f_count = 0;

104 
f
[0]->
f_šode
 = f[1]->f_šodð
šode
;

105 
f
[0]->
f_pos
 = f[1]->f_pos = 0;

106 
f
[0]->
f_mode
 = 1;

107 
f
[1]->
f_mode
 = 2;

108 
	`put_fs_lÚg
(
fd
[0],0+
fždes
);

109 
	`put_fs_lÚg
(
fd
[1],1+
fždes
);

111 
	}
}

	@fs/read_write.c

7 
	~<sys/¡©.h
>

8 
	~<”ºo.h
>

9 
	~<sys/ty³s.h
>

11 
	~<lšux/k”Ãl.h
>

12 
	~<lšux/sched.h
>

13 
	~<asm/£gm’t.h
>

15 
rw_ch¬
(
rw
,
dev
, * 
buf
, 
couÁ
, 
off_t
 * 
pos
);

16 
»ad_pe
(
m_šode
 * 
šode
, * 
buf
, 
couÁ
);

17 
wr™e_pe
(
m_šode
 * 
šode
, * 
buf
, 
couÁ
);

18 
block_»ad
(
dev
, 
off_t
 * 
pos
, * 
buf
, 
couÁ
);

19 
block_wr™e
(
dev
, 
off_t
 * 
pos
, * 
buf
, 
couÁ
);

20 
fže_»ad
(
m_šode
 * 
šode
, 
fže
 * 
fžp
,

21 * 
buf
, 
couÁ
);

22 
fže_wr™e
(
m_šode
 * 
šode
, 
fže
 * 
fžp
,

23 * 
buf
, 
couÁ
);

25 
	$sys_l£ek
(
fd
,
off_t
 
off£t
, 
Üigš
)

27 
fže
 * file;

28 
tmp
;

30 ià(
fd
 >ð
NR_OPEN
 || !(
fže
=
cu¼’t
->
fžp
[fd]è|| !(fže->
f_šode
)

31 || !
	`IS_SEEKABLE
(
	`MAJOR
(
fže
->
f_šode
->
i_dev
)))

32  -
EBADF
;

33 ià(
fže
->
f_šode
->
i_pe
)

34  -
ESPIPE
;

35 
Üigš
) {

37 ià(
off£t
<0è -
EINVAL
;

38 
fže
->
f_pos
=
off£t
;

41 ià(
fže
->
f_pos
+
off£t
<0è -
EINVAL
;

42 
fže
->
f_pos
 +ð
off£t
;

45 ià((
tmp
=
fže
->
f_šode
->
i_size
+
off£t
) < 0)

46  -
EINVAL
;

47 
fže
->
f_pos
 = 
tmp
;

50  -
EINVAL
;

52  
fže
->
f_pos
;

53 
	}
}

55 
	$sys_»ad
(
fd
,* 
buf
,
couÁ
)

57 
fže
 * file;

58 
m_šode
 * 
šode
;

60 ià(
fd
>=
NR_OPEN
 || 
couÁ
<0 || !(
fže
=
cu¼’t
->
fžp
[fd]))

61  -
EINVAL
;

62 ià(!
couÁ
)

64 
	`v”ify_¬—
(
buf
,
couÁ
);

65 
šode
 = 
fže
->
f_šode
;

66 ià(
šode
->
i_pe
)

67  (
fže
->
f_mode
&1)?
	`»ad_pe
(
šode
,
buf
,
couÁ
):-
EIO
;

68 ià(
	`S_ISCHR
(
šode
->
i_mode
))

69  
	`rw_ch¬
(
READ
,
šode
->
i_zÚe
[0],
buf
,
couÁ
,&
fže
->
f_pos
);

70 ià(
	`S_ISBLK
(
šode
->
i_mode
))

71  
	`block_»ad
(
šode
->
i_zÚe
[0],&
fže
->
f_pos
,
buf
,
couÁ
);

72 ià(
	`S_ISDIR
(
šode
->
i_mode
è|| 
	`S_ISREG
(inode->i_mode)) {

73 ià(
couÁ
+
fže
->
f_pos
 > 
šode
->
i_size
)

74 
couÁ
 = 
šode
->
i_size
 - 
fže
->
f_pos
;

75 ià(
couÁ
<=0)

77  
	`fže_»ad
(
šode
,
fže
,
buf
,
couÁ
);

79 
	`´štk
("(R—d)šode->i_mode=%06o\n\r",
šode
->
i_mode
);

80  -
EINVAL
;

81 
	}
}

83 
	$sys_wr™e
(
fd
,* 
buf
,
couÁ
)

85 
fže
 * file;

86 
m_šode
 * 
šode
;

88 ià(
fd
>=
NR_OPEN
 || 
couÁ
 <0 || !(
fže
=
cu¼’t
->
fžp
[fd]))

89  -
EINVAL
;

90 ià(!
couÁ
)

92 
šode
=
fže
->
f_šode
;

93 ià(
šode
->
i_pe
)

94  (
fže
->
f_mode
&2)?
	`wr™e_pe
(
šode
,
buf
,
couÁ
):-
EIO
;

95 ià(
	`S_ISCHR
(
šode
->
i_mode
))

96  
	`rw_ch¬
(
WRITE
,
šode
->
i_zÚe
[0],
buf
,
couÁ
,&
fže
->
f_pos
);

97 ià(
	`S_ISBLK
(
šode
->
i_mode
))

98  
	`block_wr™e
(
šode
->
i_zÚe
[0],&
fže
->
f_pos
,
buf
,
couÁ
);

99 ià(
	`S_ISREG
(
šode
->
i_mode
))

100  
	`fže_wr™e
(
šode
,
fže
,
buf
,
couÁ
);

101 
	`´štk
("(Wr™e)šode->i_mode=%06o\n\r",
šode
->
i_mode
);

102  -
EINVAL
;

103 
	}
}

	@fs/stat.c

7 
	~<”ºo.h
>

8 
	~<sys/¡©.h
>

10 
	~<lšux/fs.h
>

11 
	~<lšux/sched.h
>

12 
	~<lšux/k”Ãl.h
>

13 
	~<asm/£gm’t.h
>

15 
	$ý_¡©
(
m_šode
 * 
šode
, 
¡©
 * 
¡©buf
)

17 
¡©
 
tmp
;

18 
i
;

20 
	`v”ify_¬—
(
¡©buf
, (* statbuf));

21 
tmp
.
¡_dev
 = 
šode
->
i_dev
;

22 
tmp
.
¡_šo
 = 
šode
->
i_num
;

23 
tmp
.
¡_mode
 = 
šode
->
i_mode
;

24 
tmp
.
¡_Æšk
 = 
šode
->
i_Æšks
;

25 
tmp
.
¡_uid
 = 
šode
->
i_uid
;

26 
tmp
.
¡_gid
 = 
šode
->
i_gid
;

27 
tmp
.
¡_rdev
 = 
šode
->
i_zÚe
[0];

28 
tmp
.
¡_size
 = 
šode
->
i_size
;

29 
tmp
.
¡_©ime
 = 
šode
->
i_©ime
;

30 
tmp
.
¡_mtime
 = 
šode
->
i_mtime
;

31 
tmp
.
¡_ùime
 = 
šode
->
i_ùime
;

32 
i
=0 ; i< (
tmp
) ; i++)

33 
	`put_fs_by‹
(((*è&
tmp
)[
i
],&((*è
¡©buf
)[i]);

34 
	}
}

36 
	$sys_¡©
(* 
fž’ame
, 
¡©
 * 
¡©buf
)

38 
m_šode
 * 
šode
;

40 ià(!(
šode
=
	`Çmei
(
fž’ame
)))

41  -
ENOENT
;

42 
	`ý_¡©
(
šode
,
¡©buf
);

43 
	`ut
(
šode
);

45 
	}
}

47 
	$sys_f¡©
(
fd
, 
¡©
 * 
¡©buf
)

49 
fže
 * 
f
;

50 
m_šode
 * 
šode
;

52 ià(
fd
 >ð
NR_OPEN
 || !(
f
=
cu¼’t
->
fžp
[fd]è|| !(
šode
=f->
f_šode
))

53  -
EBADF
;

54 
	`ý_¡©
(
šode
,
¡©buf
);

56 
	}
}

	@fs/super.c

10 
	~<lšux/cÚfig.h
>

11 
	~<lšux/sched.h
>

12 
	~<lšux/k”Ãl.h
>

13 
	~<asm/sy¡em.h
>

15 
	~<”ºo.h
>

16 
	~<sys/¡©.h
>

18 
sync_dev
(
dev
);

19 
wa™_fÜ_key´ess
();

22 
	#£t_b™
(
b™Ä
,
addr
) ({ \

23 
__»s
 
	`__asm__
("ax"); \

24 
	`__asm__
("bˆ%2,%3;£tb %%®":"÷" (
__»s
):"a" (0),"r" (
b™Ä
),"m" (*(
addr
))); \

25 
__»s
; })

	)

27 
su³r_block
 
	gsu³r_block
[
NR_SUPER
];

29 
	gROOT_DEV
 = 0;

31 
	$lock_su³r
(
su³r_block
 * 
sb
)

33 
	`þi
();

34 
sb
->
s_lock
)

35 
	`¦“p_Ú
(&(
sb
->
s_wa™
));

36 
sb
->
s_lock
 = 1;

37 
	`¡i
();

38 
	}
}

40 
	$ä“_su³r
(
su³r_block
 * 
sb
)

42 
	`þi
();

43 
sb
->
s_lock
 = 0;

44 
	`wake_up
(&(
sb
->
s_wa™
));

45 
	`¡i
();

46 
	}
}

48 
	$wa™_Ú_su³r
(
su³r_block
 * 
sb
)

50 
	`þi
();

51 
sb
->
s_lock
)

52 
	`¦“p_Ú
(&(
sb
->
s_wa™
));

53 
	`¡i
();

54 
	}
}

56 
su³r_block
 * 
	$g‘_su³r
(
dev
)

58 
su³r_block
 * 
s
;

60 ià(!
dev
)

61  
NULL
;

62 
s
 = 0+
su³r_block
;

63 
s
 < 
NR_SUPER
+
su³r_block
)

64 ià(
s
->
s_dev
 =ð
dev
) {

65 
	`wa™_Ú_su³r
(
s
);

66 ià(
s
->
s_dev
 =ð
dev
)

67  
s
;

68 
s
 = 0+
su³r_block
;

70 
s
++;

71  
NULL
;

72 
	}
}

74 
	$put_su³r
(
dev
)

76 
su³r_block
 * 
sb
;

77 
m_šode
 * 
šode
;

78 
i
;

80 ià(
dev
 =ð
ROOT_DEV
) {

81 
	`´štk
("root diskette changed:…repare for‡rmageddon\n\r");

84 ià(!(
sb
 = 
	`g‘_su³r
(
dev
)))

86 ià(
sb
->
s_imouÁ
) {

87 
	`´štk
("Mounted disk changed -ssk,ssk\n\r");

90 
	`lock_su³r
(
sb
);

91 
sb
->
s_dev
 = 0;

92 
i
=0;i<
I_MAP_SLOTS
;i++)

93 
	`b»l£
(
sb
->
s_im­
[
i
]);

94 
i
=0;i<
Z_MAP_SLOTS
;i++)

95 
	`b»l£
(
sb
->
s_zm­
[
i
]);

96 
	`ä“_su³r
(
sb
);

98 
	}
}

100 
su³r_block
 * 
	$»ad_su³r
(
dev
)

102 
su³r_block
 * 
s
;

103 
bufãr_h—d
 * 
bh
;

104 
i
,
block
;

106 ià(!
dev
)

107  
NULL
;

108 
	`check_disk_chªge
(
dev
);

109 ià(
s
 = 
	`g‘_su³r
(
dev
))

110  
s
;

111 
s
 = 0+
su³r_block
 ;; s++) {

112 ià(
s
 >ð
NR_SUPER
+
su³r_block
)

113  
NULL
;

114 ià(!
s
->
s_dev
)

117 
s
->
s_dev
 = 
dev
;

118 
s
->
s_isup
 = 
NULL
;

119 
s
->
s_imouÁ
 = 
NULL
;

120 
s
->
s_time
 = 0;

121 
s
->
s_rd_Úly
 = 0;

122 
s
->
s_dœt
 = 0;

123 
	`lock_su³r
(
s
);

124 ià(!(
bh
 = 
	`b»ad
(
dev
,1))) {

125 
s
->
s_dev
=0;

126 
	`ä“_su³r
(
s
);

127  
NULL
;

129 *((
d_su³r_block
 *è
s
) =

130 *((
d_su³r_block
 *è
bh
->
b_d©a
);

131 
	`b»l£
(
bh
);

132 ià(
s
->
s_magic
 !ð
SUPER_MAGIC
) {

133 
s
->
s_dev
 = 0;

134 
	`ä“_su³r
(
s
);

135  
NULL
;

137 
i
=0;i<
I_MAP_SLOTS
;i++)

138 
s
->
s_im­
[
i
] = 
NULL
;

139 
i
=0;i<
Z_MAP_SLOTS
;i++)

140 
s
->
s_zm­
[
i
] = 
NULL
;

141 
block
=2;

142 
i
=0 ; i < 
s
->
s_im­_blocks
 ; i++)

143 ià(
s
->
s_im­
[
i
]=
	`b»ad
(
dev
,
block
))

144 
block
++;

147 
i
=0 ; i < 
s
->
s_zm­_blocks
 ; i++)

148 ià(
s
->
s_zm­
[
i
]=
	`b»ad
(
dev
,
block
))

149 
block
++;

152 ià(
block
 !ð2+
s
->
s_im­_blocks
+s->
s_zm­_blocks
) {

153 
i
=0;i<
I_MAP_SLOTS
;i++)

154 
	`b»l£
(
s
->
s_im­
[
i
]);

155 
i
=0;i<
Z_MAP_SLOTS
;i++)

156 
	`b»l£
(
s
->
s_zm­
[
i
]);

157 
s
->
s_dev
=0;

158 
	`ä“_su³r
(
s
);

159  
NULL
;

161 
s
->
s_im­
[0]->
b_d©a
[0] |= 1;

162 
s
->
s_zm­
[0]->
b_d©a
[0] |= 1;

163 
	`ä“_su³r
(
s
);

164  
s
;

165 
	}
}

167 
	$sys_umouÁ
(* 
dev_Çme
)

169 
m_šode
 * 
šode
;

170 
su³r_block
 * 
sb
;

171 
dev
;

173 ià(!(
šode
=
	`Çmei
(
dev_Çme
)))

174  -
ENOENT
;

175 
dev
 = 
šode
->
i_zÚe
[0];

176 ià(!
	`S_ISBLK
(
šode
->
i_mode
)) {

177 
	`ut
(
šode
);

178  -
ENOTBLK
;

180 
	`ut
(
šode
);

181 ià(
dev
==
ROOT_DEV
)

182  -
EBUSY
;

183 ià(!(
sb
=
	`g‘_su³r
(
dev
)è|| !(sb->
s_imouÁ
))

184  -
ENOENT
;

185 ià(!
sb
->
s_imouÁ
->
i_mouÁ
)

186 
	`´štk
("Mounted inode has i_mount=0\n");

187 
šode
=
šode_bË
+0 ; inode<šode_bË+
NR_INODE
 ; inode++)

188 ià(
šode
->
i_dev
==
dev
 && inode->
i_couÁ
)

189  -
EBUSY
;

190 
sb
->
s_imouÁ
->
i_mouÁ
=0;

191 
	`ut
(
sb
->
s_imouÁ
);

192 
sb
->
s_imouÁ
 = 
NULL
;

193 
	`ut
(
sb
->
s_isup
);

194 
sb
->
s_isup
 = 
NULL
;

195 
	`put_su³r
(
dev
);

196 
	`sync_dev
(
dev
);

198 
	}
}

200 
	$sys_mouÁ
(* 
dev_Çme
, * 
dœ_Çme
, 
rw_æag
)

202 
m_šode
 * 
dev_i
, * 
dœ_i
;

203 
su³r_block
 * 
sb
;

204 
dev
;

206 ià(!(
dev_i
=
	`Çmei
(
dev_Çme
)))

207  -
ENOENT
;

208 
dev
 = 
dev_i
->
i_zÚe
[0];

209 ià(!
	`S_ISBLK
(
dev_i
->
i_mode
)) {

210 
	`ut
(
dev_i
);

211  -
EPERM
;

213 
	`ut
(
dev_i
);

214 ià(!(
dœ_i
=
	`Çmei
(
dœ_Çme
)))

215  -
ENOENT
;

216 ià(
dœ_i
->
i_couÁ
 !ð1 || dœ_i->
i_num
 =ð
ROOT_INO
) {

217 
	`ut
(
dœ_i
);

218  -
EBUSY
;

220 ià(!
	`S_ISDIR
(
dœ_i
->
i_mode
)) {

221 
	`ut
(
dœ_i
);

222  -
EPERM
;

224 ià(!(
sb
=
	`»ad_su³r
(
dev
))) {

225 
	`ut
(
dœ_i
);

226  -
EBUSY
;

228 ià(
sb
->
s_imouÁ
) {

229 
	`ut
(
dœ_i
);

230  -
EBUSY
;

232 ià(
dœ_i
->
i_mouÁ
) {

233 
	`ut
(
dœ_i
);

234  -
EPERM
;

236 
sb
->
s_imouÁ
=
dœ_i
;

237 
dœ_i
->
i_mouÁ
=1;

238 
dœ_i
->
i_dœt
=1;

240 
	}
}

242 
	$mouÁ_roÙ
()

244 
i
,
ä“
;

245 
su³r_block
 * 
p
;

246 
m_šode
 * 
mi
;

248 ià(32 !ð (
d_šode
))

249 
	`·nic
("bad i-node size");

250 
i
=0;i<
NR_FILE
;i++)

251 
fže_bË
[
i
].
f_couÁ
=0;

252 ià(
	`MAJOR
(
ROOT_DEV
) == 2) {

253 
	`´štk
("Insert„oot floppy‡nd…ress ENTER");

254 
	`wa™_fÜ_key´ess
();

256 
p
 = &
su³r_block
[0] ;… < &su³r_block[
NR_SUPER
] ;…++) {

257 
p
->
s_dev
 = 0;

258 
p
->
s_lock
 = 0;

259 
p
->
s_wa™
 = 
NULL
;

261 ià(!(
p
=
	`»ad_su³r
(
ROOT_DEV
)))

262 
	`·nic
("Unableo mount„oot");

263 ià(!(
mi
=
	`ig‘
(
ROOT_DEV
,
ROOT_INO
)))

264 
	`·nic
("Unableo„ead„oot i-node");

265 
mi
->
i_couÁ
 += 3 ;

266 
p
->
s_isup
 =…->
s_imouÁ
 = 
mi
;

267 
cu¼’t
->
pwd
 = 
mi
;

268 
cu¼’t
->
roÙ
 = 
mi
;

269 
ä“
=0;

270 
i
=
p
->
s_nzÚes
;

271 -- 
i
 >= 0)

272 ià(!
	`£t_b™
(
i
&8191,
p
->
s_zm­
[i>>13]->
b_d©a
))

273 
ä“
++;

274 
	`´štk
("%d/%d f»blocks\n\r",
ä“
,
p
->
s_nzÚes
);

275 
ä“
=0;

276 
i
=
p
->
s_nšodes
+1;

277 -- 
i
 >= 0)

278 ià(!
	`£t_b™
(
i
&8191,
p
->
s_im­
[i>>13]->
b_d©a
))

279 
ä“
++;

280 
	`´štk
("%d/%d f»šodes\n\r",
ä“
,
p
->
s_nšodes
);

281 
	}
}

	@fs/truncate.c

7 
	~<lšux/sched.h
>

9 
	~<sys/¡©.h
>

11 
	$ä“_šd
(
dev
,
block
)

13 
bufãr_h—d
 * 
bh
;

14 * 
p
;

15 
i
;

17 ià(!
block
)

19 ià(
bh
=
	`b»ad
(
dev
,
block
)) {

20 
p
 = (*è
bh
->
b_d©a
;

21 
i
=0;i<512;i++,
p
++)

22 ià(*
p
)

23 
	`ä“_block
(
dev
,*
p
);

24 
	`b»l£
(
bh
);

26 
	`ä“_block
(
dev
,
block
);

27 
	}
}

29 
	$ä“_dšd
(
dev
,
block
)

31 
bufãr_h—d
 * 
bh
;

32 * 
p
;

33 
i
;

35 ià(!
block
)

37 ià(
bh
=
	`b»ad
(
dev
,
block
)) {

38 
p
 = (*è
bh
->
b_d©a
;

39 
i
=0;i<512;i++,
p
++)

40 ià(*
p
)

41 
	`ä“_šd
(
dev
,*
p
);

42 
	`b»l£
(
bh
);

44 
	`ä“_block
(
dev
,
block
);

45 
	}
}

47 
	$Œunÿ‹
(
m_šode
 * 
šode
)

49 
i
;

51 ià(!(
	`S_ISREG
(
šode
->
i_mode
è|| 
	`S_ISDIR
(inode->i_mode)))

53 
i
=0;i<7;i++)

54 ià(
šode
->
i_zÚe
[
i
]) {

55 
	`ä“_block
(
šode
->
i_dev
,šode->
i_zÚe
[
i
]);

56 
šode
->
i_zÚe
[
i
]=0;

58 
	`ä“_šd
(
šode
->
i_dev
,šode->
i_zÚe
[7]);

59 
	`ä“_dšd
(
šode
->
i_dev
,šode->
i_zÚe
[8]);

60 
šode
->
i_zÚe
[7] = inode->i_zone[8] = 0;

61 
šode
->
i_size
 = 0;

62 
šode
->
i_dœt
 = 1;

63 
šode
->
i_mtime
 = inode->
i_ùime
 = 
CURRENT_TIME
;

64 
	}
}

	@include/a.out.h

1 #iâdeà
_A_OUT_H


2 
	#_A_OUT_H


	)

4 
	#__GNU_EXEC_MACROS__


	)

6 
	sexec
 {

7 
	ma_magic
;

8 
	ma_‹xt
;

9 
	ma_d©a
;

10 
	ma_bss
;

11 
	ma_syms
;

12 
	ma_’Œy
;

13 
	ma_Œsize
;

14 
	ma_drsize
;

17 #iâdeà
N_MAGIC


18 
	#N_MAGIC
(
exec
è(Óxec).
a_magic
)

	)

21 #iâdeà
OMAGIC


23 
	#OMAGIC
 0407

	)

25 
	#NMAGIC
 0410

	)

27 
	#ZMAGIC
 0413

	)

30 #iâdeà
N_BADMAG


31 
	#N_BADMAG
(
x
) \

32 (
	`N_MAGIC
(
x
è!ð
OMAGIC
 && N_MAGIC(xè!ð
NMAGIC
 \

33 && 
	`N_MAGIC
(
x
è!ð
ZMAGIC
)

	)

36 
	#_N_BADMAG
(
x
) \

37 (
	`N_MAGIC
(
x
è!ð
OMAGIC
 && N_MAGIC(xè!ð
NMAGIC
 \

38 && 
	`N_MAGIC
(
x
è!ð
ZMAGIC
)

	)

40 
	#_N_HDROFF
(
x
è(
SEGMENT_SIZE
 -  (
exec
))

	)

42 #iâdeà
N_TXTOFF


43 
	#N_TXTOFF
(
x
) \

44 (
	`N_MAGIC
(
x
è=ð
ZMAGIC
 ? 
	`_N_HDROFF
((x)è+  (
exec
è:  (exec))

	)

47 #iâdeà
N_DATOFF


48 
	#N_DATOFF
(
x
è(
	`N_TXTOFF
(xè+ (x).
a_‹xt
)

	)

51 #iâdeà
N_TRELOFF


52 
	#N_TRELOFF
(
x
è(
	`N_DATOFF
(xè+ (x).
a_d©a
)

	)

55 #iâdeà
N_DRELOFF


56 
	#N_DRELOFF
(
x
è(
	`N_TRELOFF
(xè+ (x).
a_Œsize
)

	)

59 #iâdeà
N_SYMOFF


60 
	#N_SYMOFF
(
x
è(
	`N_DRELOFF
(xè+ (x).
a_drsize
)

	)

63 #iâdeà
N_STROFF


64 
	#N_STROFF
(
x
è(
	`N_SYMOFF
(xè+ (x).
a_syms
)

	)

68 #iâdeà
N_TXTADDR


69 
	#N_TXTADDR
(
x
è0

	)

75 #ià
defšed
(
vax
è|| defšed(
hp300
è|| defšed(
pyr
)

76 
	#SEGMENT_SIZE
 
PAGE_SIZE


	)

78 #ifdef 
hp300


79 
	#PAGE_SIZE
 4096

	)

81 #ifdef 
sÚy


82 
	#SEGMENT_SIZE
 0x2000

	)

84 #ifdeà
is68k


85 
	#SEGMENT_SIZE
 0x20000

	)

87 #ià
defšed
(
m68k
è&& defšed(
PORTAR
)

88 
	#PAGE_SIZE
 0x400

	)

89 
	#SEGMENT_SIZE
 
PAGE_SIZE


	)

92 
	#PAGE_SIZE
 4096

	)

93 
	#SEGMENT_SIZE
 1024

	)

95 
	#_N_SEGMENT_ROUND
(
x
è(((xè+ 
SEGMENT_SIZE
 - 1è& ~(SEGMENT_SIZE - 1))

	)

97 
	#_N_TXTENDADDR
(
x
è(
	`N_TXTADDR
(x)+(x).
a_‹xt
)

	)

99 #iâdeà
N_DATADDR


100 
	#N_DATADDR
(
x
) \

101 (
	`N_MAGIC
(
x
)==
OMAGIC
? (
	`_N_TXTENDADDR
(x)) \

102 : (
	`_N_SEGMENT_ROUND
 (
	`_N_TXTENDADDR
(
x
))))

	)

106 #iâdeà
N_BSSADDR


107 
	#N_BSSADDR
(
x
è(
	`N_DATADDR
(xè+ (x).
a_d©a
)

	)

110 #iâdeà
N_NLIST_DECLARED


111 
	sÆi¡
 {

113 *
	mn_Çme
;

114 
Æi¡
 *
	mn_Ãxt
;

115 
	mn_¡rx
;

116 } 
	mn_un
;

117 
	mn_ty³
;

118 
	mn_Ùh”
;

119 
	mn_desc
;

120 
	mn_v®ue
;

124 #iâdeà
N_UNDF


125 
	#N_UNDF
 0

	)

127 #iâdeà
N_ABS


128 
	#N_ABS
 2

	)

130 #iâdeà
N_TEXT


131 
	#N_TEXT
 4

	)

133 #iâdeà
N_DATA


134 
	#N_DATA
 6

	)

136 #iâdeà
N_BSS


137 
	#N_BSS
 8

	)

139 #iâdeà
N_COMM


140 
	#N_COMM
 18

	)

142 #iâdeà
N_FN


143 
	#N_FN
 15

	)

146 #iâdeà
N_EXT


147 
	#N_EXT
 1

	)

149 #iâdeà
N_TYPE


150 
	#N_TYPE
 036

	)

152 #iâdeà
N_STAB


153 
	#N_STAB
 0340

	)

164 
	#N_INDR
 0xa

	)

178 
	#N_SETA
 0x14

	)

179 
	#N_SETT
 0x16

	)

180 
	#N_SETD
 0x18

	)

181 
	#N_SETB
 0x1A

	)

184 
	#N_SETV
 0x1C

	)

186 #iâdeà
N_RELOCATION_INFO_DECLARED


193 
	s»loÿtiÚ_šfo


196 
	mr_add»ss
;

198 
	mr_symbÞnum
:24;

202 
	mr_pü–
:1;

205 
	mr_Ëngth
:2;

212 
	mr_ex‹º
:1;

215 
	mr_·d
:4;

	@include/asm/io.h

1 
	#outb
(
v®ue
,
pÜt
) \

2 
	`__asm__
 ("outb %%®,%%dx"::"a" (
v®ue
),"d" (
pÜt
))

	)

5 
	#šb
(
pÜt
) ({ \

6 
_v
; \

7 
__asm__
 vÞ©ž("šb %%dx,%%®":"÷" (
_v
):"d" (
pÜt
)); \

8 
_v
; \

9 })

	)

11 
	#outb_p
(
v®ue
,
pÜt
) \

12 
	`__asm__
 ("outb %%al,%%dx\n" \

15 "1:"::"a" (
v®ue
),"d" (
pÜt
))

	)

17 
	#šb_p
(
pÜt
) ({ \

18 
_v
; \

19 
__asm__
 volatile ("inb %%dx,%%al\n" \

22 "1:":"÷" (
_v
):"d" (
pÜt
)); \

23 
_v
; \

24 })

	)

	@include/asm/memory.h

8 
	#memýy
(
de¡
,
¤c
,
n
) ({ \

9 * 
_»s
 = 
de¡
; \

10 
	`__asm__
 ("cld;rep;movsb" \

11 ::"D" (()(
_»s
)),"S" (()(
¤c
)),"c" ((è(
n
)) \

13 
_»s
; \

14 })

	)

	@include/asm/segment.h

1 
šlše
 
	$g‘_fs_by‹
(cÚ¡ * 
addr
)

3 
_v
;

5 
	`__asm__
 ("movb %%fs:%1,%0":"ô" (
_v
):"m" (*
addr
));

6  
_v
;

7 
	}
}

9 
šlše
 
	$g‘_fs_wÜd
(cÚ¡ *
addr
)

11 
_v
;

13 
	`__asm__
 ("movw %%fs:%1,%0":"ô" (
_v
):"m" (*
addr
));

14  
_v
;

15 
	}
}

17 
šlše
 
	$g‘_fs_lÚg
(cÚ¡ *
addr
)

19 
_v
;

21 
	`__asm__
 ("movÈ%%fs:%1,%0":"ô" (
_v
):"m" (*
addr
)); \

22  
_v
;

23 
	}
}

25 
šlše
 
	$put_fs_by‹
(
v®
,*
addr
)

27 
	`__asm__
 ("movb %0,%%fs:%1"::"r" (
v®
),"m" (*
addr
));

28 
	}
}

30 
šlše
 
	$put_fs_wÜd
(
v®
,* 
addr
)

32 
	`__asm__
 ("movw %0,%%fs:%1"::"r" (
v®
),"m" (*
addr
));

33 
	}
}

35 
šlše
 
	$put_fs_lÚg
(
v®
,* 
addr
)

37 
	`__asm__
 ("movÈ%0,%%fs:%1"::"r" (
v®
),"m" (*
addr
));

38 
	}
}

47 
šlše
 
	$g‘_fs
()

49 
_v
;

50 
	`__asm__
("mov %%fs,%%ax":"÷" (
_v
):);

51  
_v
;

52 
	}
}

54 
šlše
 
	$g‘_ds
()

56 
_v
;

57 
	`__asm__
("mov %%ds,%%ax":"÷" (
_v
):);

58  
_v
;

59 
	}
}

61 
šlše
 
	$£t_fs
(
v®
)

63 
	`__asm__
("mov %0,%%fs"::"a" ((è
v®
));

64 
	}
}

	@include/asm/system.h

1 
	#move_to_u£r_mode
() \

2 
	`__asm__
 ("movl %%esp,%%eax\n\t" \

14 :::"ax")

	)

16 
	#¡i
(è
	`__asm__
 ("¡i"::)

	)

17 
	#þi
(è
	`__asm__
 ("þi"::)

	)

18 
	#nÝ
(è
	`__asm__
 ("nÝ"::)

	)

20 
	#œ‘
(è
	`__asm__
 ("œ‘"::)

	)

22 
	#_£t_g©e
(
g©e_addr
,
ty³
,
d¶
,
addr
) \

23 
	`__asm__
 ("movw %%dx,%%ax\n\t" \

28 : "i" ((è(0x8000+(
d¶
<<13)+(
ty³
<<8))), \

29 "o" (*((*è(
g©e_addr
))), \

30 "o" (*(4+(*è(
g©e_addr
))), \

31 "d" ((*è(
addr
)),"a" (0x00080000))

	)

33 
	#£t_šŒ_g©e
(
n
,
addr
) \

34 
	`_£t_g©e
(&
idt
[
n
],14,0,
addr
)

	)

36 
	#£t_Œ­_g©e
(
n
,
addr
) \

37 
	`_£t_g©e
(&
idt
[
n
],15,0,
addr
)

	)

39 
	#£t_sy¡em_g©e
(
n
,
addr
) \

40 
	`_£t_g©e
(&
idt
[
n
],15,3,
addr
)

	)

42 
	#_£t_£g_desc
(
g©e_addr
,
ty³
,
d¶
,
ba£
,
lim™
) {\

43 *(
g©e_addr
èð((
ba£
) & 0xff000000) | \

44 (((
ba£
) & 0x00ff0000)>>16) | \

45 ((
lim™
) & 0xf0000) | \

46 ((
d¶
)<<13) | \

48 ((
ty³
)<<8); \

49 *((
g©e_addr
)+1èð(((
ba£
) & 0x0000ffff)<<16) | \

50 ((
lim™
è& 0x0ffff); }

	)

52 
	#_£t_ts¦dt_desc
(
n
,
addr
,
ty³
) \

53 
	`__asm__
 ("movw $104,%1\n\t" \

57 "movb $" 
ty³
 ",%4\n\t" \

61 ::"a" (
addr
), "m" (*(
n
)), "m" (*(n+2)), "m" (*(n+4)), \

62 "m" (*(
n
+5)), "m" (*(n+6)), "m" (*(n+7)) \

63 )

	)

65 
	#£t_tss_desc
(
n
,
addr
è
	`_£t_ts¦dt_desc
(((*èÒ)),addr,"0x89")

	)

66 
	#£t_ldt_desc
(
n
,
addr
è
	`_£t_ts¦dt_desc
(((*èÒ)),addr,"0x82")

	)

	@include/const.h

1 #iâdeà
_CONST_H


2 
	#_CONST_H


	)

4 
	#BUFFER_END
 0x200000

	)

6 
	#I_TYPE
 0170000

	)

7 
	#I_DIRECTORY
 0040000

	)

8 
	#I_REGULAR
 0100000

	)

9 
	#I_BLOCK_SPECIAL
 0060000

	)

10 
	#I_CHAR_SPECIAL
 0020000

	)

11 
	#I_NAMED_PIPE
 0010000

	)

12 
	#I_SET_UID_BIT
 0004000

	)

13 
	#I_SET_GID_BIT
 0002000

	)

	@include/ctype.h

1 #iâdeà
_CTYPE_H


2 
	#_CTYPE_H


	)

4 
	#_U
 0x01

	)

5 
	#_L
 0x02

	)

6 
	#_D
 0x04

	)

7 
	#_C
 0x08

	)

8 
	#_P
 0x10

	)

9 
	#_S
 0x20

	)

10 
	#_X
 0x40

	)

11 
	#_SP
 0x80

	)

13 
_ùy³
[];

14 
_ùmp
;

16 
	#i§Êum
(
c
è((
_ùy³
+1)[c]&(
_U
|
_L
|
_D
))

	)

17 
	#i§Íha
(
c
è((
_ùy³
+1)[c]&(
_U
|
_L
))

	)

18 
	#isúŒl
(
c
è((
_ùy³
+1)[c]&(
_C
))

	)

19 
	#isdig™
(
c
è((
_ùy³
+1)[c]&(
_D
))

	)

20 
	#isg¿ph
(
c
è((
_ùy³
+1)[c]&(
_P
|
_U
|
_L
|
_D
))

	)

21 
	#i¦ow”
(
c
è((
_ùy³
+1)[c]&(
_L
))

	)

22 
	#i¥ršt
(
c
è((
_ùy³
+1)[c]&(
_P
|
_U
|
_L
|
_D
|
_SP
))

	)

23 
	#i¥unù
(
c
è((
_ùy³
+1)[c]&(
_P
))

	)

24 
	#is¥aû
(
c
è((
_ùy³
+1)[c]&(
_S
))

	)

25 
	#isuµ”
(
c
è((
_ùy³
+1)[c]&(
_U
))

	)

26 
	#isxdig™
(
c
è((
_ùy³
+1)[c]&(
_D
|
_X
))

	)

28 
	#i§scii
(
c
è(((èc)<=0x7f)

	)

29 
	#tßscii
(
c
è(((èc)&0x7f)

	)

31 
	#tÞow”
(
c
è(
_ùmp
=c,
	`isuµ”
(_ùmp)?_ùmp-('A'-'a'):_ùmp)

	)

32 
	#touµ”
(
c
è(
_ùmp
=c,
	`i¦ow”
(_ùmp)?_ùmp-('a'-'A'):_ùmp)

	)

	@include/errno.h

1 #iâdeà
_ERRNO_H


2 
	#_ERRNO_H


	)

17 
”ºo
;

19 
	#ERROR
 99

	)

20 
	#EPERM
 1

	)

21 
	#ENOENT
 2

	)

22 
	#ESRCH
 3

	)

23 
	#EINTR
 4

	)

24 
	#EIO
 5

	)

25 
	#ENXIO
 6

	)

26 
	#E2BIG
 7

	)

27 
	#ENOEXEC
 8

	)

28 
	#EBADF
 9

	)

29 
	#ECHILD
 10

	)

30 
	#EAGAIN
 11

	)

31 
	#ENOMEM
 12

	)

32 
	#EACCES
 13

	)

33 
	#EFAULT
 14

	)

34 
	#ENOTBLK
 15

	)

35 
	#EBUSY
 16

	)

36 
	#EEXIST
 17

	)

37 
	#EXDEV
 18

	)

38 
	#ENODEV
 19

	)

39 
	#ENOTDIR
 20

	)

40 
	#EISDIR
 21

	)

41 
	#EINVAL
 22

	)

42 
	#ENFILE
 23

	)

43 
	#EMFILE
 24

	)

44 
	#ENOTTY
 25

	)

45 
	#ETXTBSY
 26

	)

46 
	#EFBIG
 27

	)

47 
	#ENOSPC
 28

	)

48 
	#ESPIPE
 29

	)

49 
	#EROFS
 30

	)

50 
	#EMLINK
 31

	)

51 
	#EPIPE
 32

	)

52 
	#EDOM
 33

	)

53 
	#ERANGE
 34

	)

54 
	#EDEADLK
 35

	)

55 
	#ENAMETOOLONG
 36

	)

56 
	#ENOLCK
 37

	)

57 
	#ENOSYS
 38

	)

58 
	#ENOTEMPTY
 39

	)

	@include/fcntl.h

1 #iâdeà
_FCNTL_H


2 
	#_FCNTL_H


	)

4 
	~<sys/ty³s.h
>

7 
	#O_ACCMODE
 00003

	)

8 
	#O_RDONLY
 00

	)

9 
	#O_WRONLY
 01

	)

10 
	#O_RDWR
 02

	)

11 
	#O_CREAT
 00100

	)

12 
	#O_EXCL
 00200

	)

13 
	#O_NOCTTY
 00400

	)

14 
	#O_TRUNC
 01000

	)

15 
	#O_APPEND
 02000

	)

16 
	#O_NONBLOCK
 04000

	)

17 
	#O_NDELAY
 
O_NONBLOCK


	)

23 
	#F_DUPFD
 0

	)

24 
	#F_GETFD
 1

	)

25 
	#F_SETFD
 2

	)

26 
	#F_GETFL
 3

	)

27 
	#F_SETFL
 4

	)

28 
	#F_GETLK
 5

	)

29 
	#F_SETLK
 6

	)

30 
	#F_SETLKW
 7

	)

33 
	#FD_CLOEXEC
 1

	)

38 
	#F_RDLCK
 0

	)

39 
	#F_WRLCK
 1

	)

40 
	#F_UNLCK
 2

	)

43 
	sæock
 {

44 
	ml_ty³
;

45 
	ml_wh’û
;

46 
off_t
 
	ml_¡¬t
;

47 
off_t
 
	ml_Ën
;

48 
pid_t
 
	ml_pid
;

51 
ü—t
(cÚ¡ * 
fž’ame
,
mode_t
 
mode
);

52 
fúŽ
(
fždes
,
cmd
, ...);

53 
Ý’
(cÚ¡ * 
fž’ame
, 
æags
, ...);

	@include/linux/config.h

1 #iâdeà
_CONFIG_H


2 
	#_CONFIG_H


	)

19 
	#KBD_FINNISH


	)

	@include/linux/fdreg.h

6 #iâdeà
_FDREG_H


7 
	#_FDREG_H


	)

9 
ticks_to_æÝpy_Ú
(
Ä
);

10 
æÝpy_Ú
(
Ä
);

11 
æÝpy_off
(
Ä
);

12 
æÝpy_£Ëù
(
Ä
);

13 
æÝpy_de£Ëù
(
Ä
);

16 
	#FD_STATUS
 0x3f4

	)

17 
	#FD_DATA
 0x3f5

	)

18 
	#FD_DOR
 0x3f2

	)

19 
	#FD_DIR
 0x3f7

	)

20 
	#FD_DCR
 0x3f7

	)

23 
	#STATUS_BUSYMASK
 0x0F

	)

24 
	#STATUS_BUSY
 0x10

	)

25 
	#STATUS_DMA
 0x20

	)

26 
	#STATUS_DIR
 0x40

	)

27 
	#STATUS_READY
 0x80

	)

30 
	#ST0_DS
 0x03

	)

31 
	#ST0_HA
 0x04

	)

32 
	#ST0_NR
 0x08

	)

33 
	#ST0_ECE
 0x10

	)

34 
	#ST0_SE
 0x20

	)

35 
	#ST0_INTR
 0xC0

	)

38 
	#ST1_MAM
 0x01

	)

39 
	#ST1_WP
 0x02

	)

40 
	#ST1_ND
 0x04

	)

41 
	#ST1_OR
 0x10

	)

42 
	#ST1_CRC
 0x20

	)

43 
	#ST1_EOC
 0x80

	)

46 
	#ST2_MAM
 0x01

	)

47 
	#ST2_BC
 0x02

	)

48 
	#ST2_SNS
 0x04

	)

49 
	#ST2_SEH
 0x08

	)

50 
	#ST2_WC
 0x10

	)

51 
	#ST2_CRC
 0x20

	)

52 
	#ST2_CM
 0x40

	)

55 
	#ST3_HA
 0x04

	)

56 
	#ST3_TZ
 0x10

	)

57 
	#ST3_WP
 0x40

	)

60 
	#FD_RECALIBRATE
 0x07

	)

61 
	#FD_SEEK
 0x0F

	)

62 
	#FD_READ
 0xE6

	)

63 
	#FD_WRITE
 0xC5

	)

64 
	#FD_SENSEI
 0x08

	)

65 
	#FD_SPECIFY
 0x03

	)

68 
	#DMA_READ
 0x46

	)

69 
	#DMA_WRITE
 0x4A

	)

	@include/linux/fs.h

6 #iâdeà
_FS_H


7 
	#_FS_H


	)

9 
	~<sys/ty³s.h
>

24 
	#IS_SEEKABLE
(
x
è((x)>=1 && (x)<=3)

	)

26 
	#READ
 0

	)

27 
	#WRITE
 1

	)

28 
	#READA
 2

	)

29 
	#WRITEA
 3

	)

31 
bufãr_š™
(
bufãr_’d
);

33 
	#MAJOR
(
a
è((()×))>>8)

	)

34 
	#MINOR
(
a
è(×)&0xff)

	)

36 
	#NAME_LEN
 14

	)

37 
	#ROOT_INO
 1

	)

39 
	#I_MAP_SLOTS
 8

	)

40 
	#Z_MAP_SLOTS
 8

	)

41 
	#SUPER_MAGIC
 0x137F

	)

43 
	#NR_OPEN
 20

	)

44 
	#NR_INODE
 32

	)

45 
	#NR_FILE
 64

	)

46 
	#NR_SUPER
 8

	)

47 
	#NR_HASH
 307

	)

48 
	#NR_BUFFERS
 
Ä_bufãrs


	)

49 
	#BLOCK_SIZE
 1024

	)

50 
	#BLOCK_SIZE_BITS
 10

	)

51 #iâdeà
NULL


52 
	#NULL
 ((*è0)

	)

55 
	#INODES_PER_BLOCK
 ((
BLOCK_SIZE
)/( (
d_šode
)))

	)

56 
	#DIR_ENTRIES_PER_BLOCK
 ((
BLOCK_SIZE
)/( (
dœ_’Œy
)))

	)

58 
	#PIPE_HEAD
(
šode
è((šode).
i_zÚe
[0])

	)

59 
	#PIPE_TAIL
(
šode
è((šode).
i_zÚe
[1])

	)

60 
	#PIPE_SIZE
(
šode
è((
	`PIPE_HEAD
(šode)-
	`PIPE_TAIL
(šode))&(
PAGE_SIZE
-1))

	)

61 
	#PIPE_EMPTY
(
šode
è(
	`PIPE_HEAD
(šode)==
	`PIPE_TAIL
(šode))

	)

62 
	#PIPE_FULL
(
šode
è(
	`PIPE_SIZE
(šode)==(
PAGE_SIZE
-1))

	)

63 
	#INC_PIPE
(
h—d
) \

64 
	`__asm__
("šþ %0\n\ndÈ$4095,%0"::"m" (
h—d
))

	)

66 
	tbufãr_block
[
BLOCK_SIZE
];

68 
	sbufãr_h—d
 {

69 * 
	mb_d©a
;

70 
	mb_blockÄ
;

71 
	mb_dev
;

72 
	mb_u±od©e
;

73 
	mb_dœt
;

74 
	mb_couÁ
;

75 
	mb_lock
;

76 
sk_¡ruù
 * 
	mb_wa™
;

77 
bufãr_h—d
 * 
	mb_´ev
;

78 
bufãr_h—d
 * 
	mb_Ãxt
;

79 
bufãr_h—d
 * 
	mb_´ev_ä“
;

80 
bufãr_h—d
 * 
	mb_Ãxt_ä“
;

83 
	sd_šode
 {

84 
	mi_mode
;

85 
	mi_uid
;

86 
	mi_size
;

87 
	mi_time
;

88 
	mi_gid
;

89 
	mi_Æšks
;

90 
	mi_zÚe
[9];

93 
	sm_šode
 {

94 
	mi_mode
;

95 
	mi_uid
;

96 
	mi_size
;

97 
	mi_mtime
;

98 
	mi_gid
;

99 
	mi_Æšks
;

100 
	mi_zÚe
[9];

102 
sk_¡ruù
 * 
	mi_wa™
;

103 
	mi_©ime
;

104 
	mi_ùime
;

105 
	mi_dev
;

106 
	mi_num
;

107 
	mi_couÁ
;

108 
	mi_lock
;

109 
	mi_dœt
;

110 
	mi_pe
;

111 
	mi_mouÁ
;

112 
	mi_£ek
;

113 
	mi_upd©e
;

116 
	sfže
 {

117 
	mf_mode
;

118 
	mf_æags
;

119 
	mf_couÁ
;

120 
m_šode
 * 
	mf_šode
;

121 
off_t
 
	mf_pos
;

124 
	ssu³r_block
 {

125 
	ms_nšodes
;

126 
	ms_nzÚes
;

127 
	ms_im­_blocks
;

128 
	ms_zm­_blocks
;

129 
	ms_fœ¡d©azÚe
;

130 
	ms_log_zÚe_size
;

131 
	ms_max_size
;

132 
	ms_magic
;

134 
bufãr_h—d
 * 
	ms_im­
[8];

135 
bufãr_h—d
 * 
	ms_zm­
[8];

136 
	ms_dev
;

137 
m_šode
 * 
	ms_isup
;

138 
m_šode
 * 
	ms_imouÁ
;

139 
	ms_time
;

140 
sk_¡ruù
 * 
	ms_wa™
;

141 
	ms_lock
;

142 
	ms_rd_Úly
;

143 
	ms_dœt
;

146 
	sd_su³r_block
 {

147 
	ms_nšodes
;

148 
	ms_nzÚes
;

149 
	ms_im­_blocks
;

150 
	ms_zm­_blocks
;

151 
	ms_fœ¡d©azÚe
;

152 
	ms_log_zÚe_size
;

153 
	ms_max_size
;

154 
	ms_magic
;

157 
	sdœ_’Œy
 {

158 
	mšode
;

159 
	mÇme
[
NAME_LEN
];

162 
m_šode
 
šode_bË
[
NR_INODE
];

163 
fže
 
fže_bË
[
NR_FILE
];

164 
su³r_block
 su³r_block[
NR_SUPER
];

165 
bufãr_h—d
 * 
¡¬t_bufãr
;

166 
Ä_bufãrs
;

168 
check_disk_chªge
(
dev
);

169 
æÝpy_chªge
(
Ä
);

170 
ticks_to_æÝpy_Ú
(
dev
);

171 
æÝpy_Ú
(
dev
);

172 
æÝpy_off
(
dev
);

173 
Œunÿ‹
(
m_šode
 * 
šode
);

174 
sync_šodes
();

175 
wa™_Ú
(
m_šode
 * 
šode
);

176 
bm­
(
m_šode
 * 
šode
,
block
);

177 
ü—‹_block
(
m_šode
 * 
šode
,
block
);

178 
m_šode
 * 
Çmei
(cÚ¡ * 
·thÇme
);

179 
Ý’_Çmei
(cÚ¡ * 
·thÇme
, 
æag
, 
mode
,

180 
m_šode
 ** 
»s_šode
);

181 
ut
(
m_šode
 * 
šode
);

182 
m_šode
 * 
ig‘
(
dev
,
Ä
);

183 
m_šode
 * 
g‘_em±y_šode
();

184 
m_šode
 * 
g‘_pe_šode
();

185 
bufãr_h—d
 * 
g‘_hash_bË
(
dev
, 
block
);

186 
bufãr_h—d
 * 
g‘blk
(
dev
, 
block
);

187 
Î_rw_block
(
rw
, 
bufãr_h—d
 * 
bh
);

188 
b»l£
(
bufãr_h—d
 * 
buf
);

189 
bufãr_h—d
 * 
b»ad
(
dev
,
block
);

190 
b»ad_·ge
(
addr
,
dev
,
b
[4]);

191 
bufãr_h—d
 * 
b»ada
(
dev
,
block
,...);

192 
Ãw_block
(
dev
);

193 
ä“_block
(
dev
, 
block
);

194 
m_šode
 * 
Ãw_šode
(
dev
);

195 
ä“_šode
(
m_šode
 * 
šode
);

196 
sync_dev
(
dev
);

197 
su³r_block
 * 
g‘_su³r
(
dev
);

198 
ROOT_DEV
;

200 
mouÁ_roÙ
();

	@include/linux/hdreg.h

6 #iâdeà
_HDREG_H


7 
	#_HDREG_H


	)

10 
	#HD_DATA
 0x1f0

	)

11 
	#HD_ERROR
 0x1f1

	)

12 
	#HD_NSECTOR
 0x1f2

	)

13 
	#HD_SECTOR
 0x1f3

	)

14 
	#HD_LCYL
 0x1f4

	)

15 
	#HD_HCYL
 0x1f5

	)

16 
	#HD_CURRENT
 0x1f6

	)

17 
	#HD_STATUS
 0x1f7

	)

18 
	#HD_PRECOMP
 
HD_ERROR


	)

19 
	#HD_COMMAND
 
HD_STATUS


	)

21 
	#HD_CMD
 0x3f6

	)

24 
	#ERR_STAT
 0x01

	)

25 
	#INDEX_STAT
 0x02

	)

26 
	#ECC_STAT
 0x04

	)

27 
	#DRQ_STAT
 0x08

	)

28 
	#SEEK_STAT
 0x10

	)

29 
	#WRERR_STAT
 0x20

	)

30 
	#READY_STAT
 0x40

	)

31 
	#BUSY_STAT
 0x80

	)

34 
	#WIN_RESTORE
 0x10

	)

35 
	#WIN_READ
 0x20

	)

36 
	#WIN_WRITE
 0x30

	)

37 
	#WIN_VERIFY
 0x40

	)

38 
	#WIN_FORMAT
 0x50

	)

39 
	#WIN_INIT
 0x60

	)

40 
	#WIN_SEEK
 0x70

	)

41 
	#WIN_DIAGNOSE
 0x90

	)

42 
	#WIN_SPECIFY
 0x91

	)

45 
	#MARK_ERR
 0x01

	)

46 
	#TRK0_ERR
 0x02

	)

47 
	#ABRT_ERR
 0x04

	)

48 
	#ID_ERR
 0x10

	)

49 
	#ECC_ERR
 0x40

	)

50 
	#BBD_ERR
 0x80

	)

52 
	s·¹™iÚ
 {

53 
	mboÙ_šd
;

54 
	mh—d
;

55 
	m£ùÜ
;

56 
	mcyl
;

57 
	msys_šd
;

58 
	m’d_h—d
;

59 
	m’d_£ùÜ
;

60 
	m’d_cyl
;

61 
	m¡¬t_£ù
;

62 
	mÄ_£ùs
;

	@include/linux/head.h

1 #iâdeà
_HEAD_H


2 
	#_HEAD_H


	)

4 
	sdesc_¡ruù
 {

5 
	ma
,
	mb
;

6 } 
	tdesc_bË
[256];

8 
pg_dœ
[1024];

9 
desc_bË
 
idt
,
gdt
;

11 
	#GDT_NUL
 0

	)

12 
	#GDT_CODE
 1

	)

13 
	#GDT_DATA
 2

	)

14 
	#GDT_TMP
 3

	)

16 
	#LDT_NUL
 0

	)

17 
	#LDT_CODE
 1

	)

18 
	#LDT_DATA
 2

	)

	@include/linux/kernel.h

4 
v”ify_¬—
(* 
addr
,
couÁ
);

5 vÞ©ž
·nic
(cÚ¡ * 
¡r
);

6 
´štf
(cÚ¡ * 
fmt
, ...);

7 
´štk
(cÚ¡ * 
fmt
, ...);

8 
‰y_wr™e
(
ch
,* 
buf
,
couÁ
);

9 * 
m®loc
(
size
);

10 
ä“_s
(* 
obj
, 
size
);

12 
	#ä“
(
x
è
	`ä“_s
((x), 0)

	)

21 
	#su£r
(è(
cu¼’t
->
euid
 =ð0)

	)

	@include/linux/mm.h

1 #iâdeà
_MM_H


2 
	#_MM_H


	)

4 
	#PAGE_SIZE
 4096

	)

6 
g‘_ä“_·ge
();

7 
put_·ge
(
·ge
,
add»ss
);

8 
ä“_·ge
(
addr
);

	@include/linux/sched.h

1 #iâdeà
_SCHED_H


2 
	#_SCHED_H


	)

4 
	#NR_TASKS
 64

	)

5 
	#HZ
 100

	)

7 
	#FIRST_TASK
 
sk
[0]

	)

8 
	#LAST_TASK
 
sk
[
NR_TASKS
-1]

	)

10 
	~<lšux/h—d.h
>

11 
	~<lšux/fs.h
>

12 
	~<lšux/mm.h
>

13 
	~<sigÇl.h
>

15 #ià(
NR_OPEN
 > 32)

19 
	#TASK_RUNNING
 0

	)

20 
	#TASK_INTERRUPTIBLE
 1

	)

21 
	#TASK_UNINTERRUPTIBLE
 2

	)

22 
	#TASK_ZOMBIE
 3

	)

23 
	#TASK_STOPPED
 4

	)

25 #iâdeà
NULL


26 
	#NULL
 ((*è0)

	)

29 
cÝy_·ge_bËs
(
äom
, 
to
, 
size
);

30 
ä“_·ge_bËs
(
äom
, 
size
);

32 
sched_š™
();

33 
scheduË
();

34 
Œ­_š™
();

35 
·nic
(cÚ¡ * 
¡r
);

36 
‰y_wr™e
(
mšÜ
,* 
buf
,
couÁ
);

38 (*
	gâ_±r
)();

40 
	si387_¡ruù
 {

41 
	mcwd
;

42 
	mswd
;

43 
	mtwd
;

44 
	mf
;

45 
	mfcs
;

46 
	mfoo
;

47 
	mfos
;

48 
	m¡_¥aû
[20];

51 
	stss_¡ruù
 {

52 
	mback_lšk
;

53 
	me¥0
;

54 
	mss0
;

55 
	me¥1
;

56 
	mss1
;

57 
	me¥2
;

58 
	mss2
;

59 
	mü3
;

60 
	me
;

61 
	meæags
;

62 
	m—x
,
	mecx
,
	medx
,
	mebx
;

63 
	me¥
;

64 
	mebp
;

65 
	mesi
;

66 
	medi
;

67 
	mes
;

68 
	mcs
;

69 
	mss
;

70 
	mds
;

71 
	mfs
;

72 
	mgs
;

73 
	mldt
;

74 
	mŒaû_b™m­
;

75 
i387_¡ruù
 
	mi387
;

78 
	ssk_¡ruù
 {

80 
	m¡©e
;

81 
	mcouÁ”
;

82 
	m´iÜ™y
;

83 
	msigÇl
;

84 
sigaùiÚ
 
	msigaùiÚ
[32];

85 
	mblocked
;

87 
	mex™_code
;

88 
	m¡¬t_code
,
	m’d_code
,
	m’d_d©a
,
	mbrk
,
	m¡¬t_¡ack
;

89 
	mpid
,
	mçth”
,
	mpg½
,
	m£ssiÚ
,
	mËad”
;

90 
	muid
,
	meuid
,
	msuid
;

91 
	mgid
,
	megid
,
	msgid
;

92 
	m®¬m
;

93 
	mutime
,
	m¡ime
,
	mcutime
,
	mc¡ime
,
	m¡¬t_time
;

94 
	mu£d_m©h
;

96 
	m‰y
;

97 
	mumask
;

98 
m_šode
 * 
	mpwd
;

99 
m_šode
 * 
	mroÙ
;

100 
m_šode
 * 
	mexecubË
;

101 
	mþo£_Ú_exec
;

102 
fže
 * 
	mfžp
[
NR_OPEN
];

104 
desc_¡ruù
 
	mldt
[3];

106 
tss_¡ruù
 
	mtss
;

113 
	#INIT_TASK
 \

121  -1,0022,
NULL
,NULL,NULL,0, \

122  {
NULL
,}, \

128  {0,
PAGE_SIZE
+()&
š™_sk
,0x10,0,0,0,0,()&
pg_dœ
,\

131 
	`_LDT
(0),0x80000000, \

134 }

	)

136 
sk_¡ruù
 *
sk
[
NR_TASKS
];

137 
sk_¡ruù
 *
Ï¡_sk_u£d_m©h
;

138 
sk_¡ruù
 *
cu¼’t
;

139 vÞ©ž
jiff›s
;

140 
¡¬tup_time
;

142 
	#CURRENT_TIME
 (
¡¬tup_time
+
jiff›s
/
HZ
)

	)

144 
add_tim”
(
jiff›s
, (*
â
)());

145 
	`¦“p_Ú
(
sk_¡ruù
 ** 
p
);

146 
	`š‹¼u±ibË_¦“p_Ú
(
sk_¡ruù
 ** 
p
);

147 
	`wake_up
(
sk_¡ruù
 ** 
p
);

153 
	#FIRST_TSS_ENTRY
 4

	)

154 
	#FIRST_LDT_ENTRY
 (
FIRST_TSS_ENTRY
+1)

	)

155 
	#_TSS
(
n
è((((èn)<<4)+(
FIRST_TSS_ENTRY
<<3))

	)

156 
	#_LDT
(
n
è((((èn)<<4)+(
FIRST_LDT_ENTRY
<<3))

	)

157 
	#Ér
(
n
è
	`__asm__
("É¸%%ax"::"a" (
	`_TSS
Ò)))

	)

158 
	#Îdt
(
n
è
	`__asm__
("Îdˆ%%ax"::"a" (
	`_LDT
Ò)))

	)

159 
	#¡r
(
n
) \

160 
	`__asm__
("str %%ax\n\t" \

163 :"÷" (
n
) \

164 :"a" (0),"i" (
FIRST_TSS_ENTRY
<<3))

	)

171 
	#sw™ch_to
(
n
) {\

172 ¡ruù {
a
,
b
;} 
__tmp
; \

173 
	`__asm__
("cmpl %%ecx,_current\n\t" \

182 ::"m" (*&
__tmp
.
a
),"m" (*&__tmp.
b
), \

183 "d" (
	`_TSS
(
n
)),"c" ((è
sk
[n])); \

184 
	}

	)
}

186 
	#PAGE_ALIGN
(
n
è((Ò)+0xfff)&0xfffff000)

	)

188 
	#_£t_ba£
(
addr
,
ba£
) \

189 
	`__asm__
("movw %%dx,%0\n\t" \

193 ::"m" (*((
addr
)+2)), \

194 "m" (*((
addr
)+4)), \

195 "m" (*((
addr
)+7)), \

196 "d" (
ba£
) \

197 :"dx")

	)

199 
	#_£t_lim™
(
addr
,
lim™
) \

200 
	`__asm__
("movw %%dx,%0\n\t" \

206 ::"m" (*(
addr
)), \

207 "m" (*((
addr
)+6)), \

208 "d" (
lim™
) \

209 :"dx")

	)

211 
	#£t_ba£
(
ldt
,
ba£
è
	`_£t_ba£
Ð((*)&Ödt)è, ba£ )

	)

212 
	#£t_lim™
(
ldt
,
lim™
è
	`_£t_lim™
Ð((*)&Ödt)è, (lim™-1)>>12 )

	)

214 
	#_g‘_ba£
(
addr
) ({\

215 
__ba£
; \

216 
	`__asm__
("movb %3,%%dh\n\t" \

220 :"=d" (
__ba£
) \

221 :"m" (*((
addr
)+2)), \

222 "m" (*((
addr
)+4)), \

223 "m" (*((
addr
)+7))); \

224 
__ba£
;})

	)

226 
	#g‘_ba£
(
ldt
è
	`_g‘_ba£
Ð((*)&Ödt)è)

	)

228 
	#g‘_lim™
(
£gm’t
) ({ \

229 
__lim™
; \

230 
	`__asm__
("l¦È%1,%0\n\tšþ %0":"ô" (
__lim™
):"r" (
£gm’t
)); \

231 
__lim™
;})

	)

	@include/linux/sys.h

1 
sys_£tup
();

2 
sys_ex™
();

3 
sys_fÜk
();

4 
sys_»ad
();

5 
sys_wr™e
();

6 
sys_Ý’
();

7 
sys_þo£
();

8 
sys_wa™pid
();

9 
sys_ü—t
();

10 
sys_lšk
();

11 
sys_uÆšk
();

12 
sys_execve
();

13 
sys_chdœ
();

14 
sys_time
();

15 
sys_mknod
();

16 
sys_chmod
();

17 
sys_chown
();

18 
sys_b»ak
();

19 
sys_¡©
();

20 
sys_l£ek
();

21 
sys_g‘pid
();

22 
sys_mouÁ
();

23 
sys_umouÁ
();

24 
sys_£tuid
();

25 
sys_g‘uid
();

26 
sys_¡ime
();

27 
sys_±¿û
();

28 
sys_®¬m
();

29 
sys_f¡©
();

30 
sys_·u£
();

31 
sys_utime
();

32 
sys_¡ty
();

33 
sys_g‰y
();

34 
sys_acûss
();

35 
sys_niû
();

36 
sys_áime
();

37 
sys_sync
();

38 
sys_kžl
();

39 
sys_»Çme
();

40 
sys_mkdœ
();

41 
sys_rmdœ
();

42 
sys_dup
();

43 
sys_pe
();

44 
sys_times
();

45 
sys_´of
();

46 
sys_brk
();

47 
sys_£tgid
();

48 
sys_g‘gid
();

49 
sys_sigÇl
();

50 
sys_g‘euid
();

51 
sys_g‘egid
();

52 
sys_acù
();

53 
sys_phys
();

54 
sys_lock
();

55 
sys_ioùl
();

56 
sys_fúŽ
();

57 
sys_mpx
();

58 
sys_£gid
();

59 
sys_ulim™
();

60 
sys_uÇme
();

61 
sys_umask
();

62 
sys_chroÙ
();

63 
sys_u¡©
();

64 
sys_dup2
();

65 
sys_g‘µid
();

66 
sys_g‘pg½
();

67 
sys_£tsid
();

68 
sys_sigaùiÚ
();

69 
sys_sg‘mask
();

70 
sys_s£tmask
();

71 
sys_£Œeuid
();

72 
sys_£Œegid
();

74 
â_±r
 
	gsys_ÿÎ_bË
[] = { 
sys_£tup
, 
sys_ex™
, 
sys_fÜk
, 
sys_»ad
,

75 
sys_wr™e
, 
sys_Ý’
, 
sys_þo£
, 
sys_wa™pid
, 
sys_ü—t
, 
sys_lšk
,

76 
sys_uÆšk
, 
sys_execve
, 
sys_chdœ
, 
sys_time
, 
sys_mknod
, 
sys_chmod
,

77 
sys_chown
, 
sys_b»ak
, 
sys_¡©
, 
sys_l£ek
, 
sys_g‘pid
, 
sys_mouÁ
,

78 
sys_umouÁ
, 
sys_£tuid
, 
sys_g‘uid
, 
sys_¡ime
, 
sys_±¿û
, 
sys_®¬m
,

79 
sys_f¡©
, 
sys_·u£
, 
sys_utime
, 
sys_¡ty
, 
sys_g‰y
, 
sys_acûss
,

80 
sys_niû
, 
sys_áime
, 
sys_sync
, 
sys_kžl
, 
sys_»Çme
, 
sys_mkdœ
,

81 
sys_rmdœ
, 
sys_dup
, 
sys_pe
, 
sys_times
, 
sys_´of
, 
sys_brk
, 
sys_£tgid
,

82 
sys_g‘gid
, 
sys_sigÇl
, 
sys_g‘euid
, 
sys_g‘egid
, 
sys_acù
, 
sys_phys
,

83 
sys_lock
, 
sys_ioùl
, 
sys_fúŽ
, 
sys_mpx
, 
sys_£gid
, 
sys_ulim™
,

84 
sys_uÇme
, 
sys_umask
, 
sys_chroÙ
, 
sys_u¡©
, 
sys_dup2
, 
sys_g‘µid
,

85 
sys_g‘pg½
, 
sys_£tsid
, 
sys_sigaùiÚ
, 
sys_sg‘mask
, 
sys_s£tmask
,

86 
sys_£Œeuid
,
sys_£Œegid
 };

	@include/linux/tty.h

9 #iâdeà
_TTY_H


10 
	#_TTY_H


	)

12 
	~<‹rmios.h
>

14 
	#TTY_BUF_SIZE
 1024

	)

16 
	s‰y_queue
 {

17 
	md©a
;

18 
	mh—d
;

19 
	mž
;

20 
sk_¡ruù
 * 
	m´oc_li¡
;

21 
	mbuf
[
TTY_BUF_SIZE
];

24 
	#INC
(
a
è(×èð(×)+1è& (
TTY_BUF_SIZE
-1))

	)

25 
	#DEC
(
a
è(×èð(×)-1è& (
TTY_BUF_SIZE
-1))

	)

26 
	#EMPTY
(
a
è(×).
h—d
 =ð×).
ž
)

	)

27 
	#LEFT
(
a
è((×).
ž
-×).
h—d
-1)&(
TTY_BUF_SIZE
-1))

	)

28 
	#LAST
(
a
è(×).
buf
[(
TTY_BUF_SIZE
-1)&(×).
h—d
-1)])

	)

29 
	#FULL
(
a
è(!
	`LEFT
×))

	)

30 
	#CHARS
(
a
è((×).
h—d
-×).
ž
)&(
TTY_BUF_SIZE
-1))

	)

31 
	#GETCH
(
queue
,
c
) \

32 ()({
c
=(
queue
).
buf
[(queue).
ž
];
	`INC
((queue).ž);})

	)

33 
	#PUTCH
(
c
,
queue
) \

34 ()({(
queue
).
buf
[(queue).
h—d
]=(
c
);
	`INC
((queue).h—d);})

	)

36 
	#INTR_CHAR
(
‰y
è(Ñty)->
‹rmios
.
c_cc
[
VINTR
])

	)

37 
	#QUIT_CHAR
(
‰y
è(Ñty)->
‹rmios
.
c_cc
[
VQUIT
])

	)

38 
	#ERASE_CHAR
(
‰y
è(Ñty)->
‹rmios
.
c_cc
[
VERASE
])

	)

39 
	#KILL_CHAR
(
‰y
è(Ñty)->
‹rmios
.
c_cc
[
VKILL
])

	)

40 
	#EOF_CHAR
(
‰y
è(Ñty)->
‹rmios
.
c_cc
[
VEOF
])

	)

41 
	#START_CHAR
(
‰y
è(Ñty)->
‹rmios
.
c_cc
[
VSTART
])

	)

42 
	#STOP_CHAR
(
‰y
è(Ñty)->
‹rmios
.
c_cc
[
VSTOP
])

	)

43 
	#SUSPEND_CHAR
(
‰y
è(Ñty)->
‹rmios
.
c_cc
[
VSUSP
])

	)

45 
	s‰y_¡ruù
 {

46 
‹rmios
 
	m‹rmios
;

47 
	mpg½
;

48 
	m¡Ý³d
;

49 (*
	mwr™e
)(
‰y_¡ruù
 * 
	m‰y
);

50 
‰y_queue
 
	m»ad_q
;

51 
‰y_queue
 
	mwr™e_q
;

52 
‰y_queue
 
	m£cÚd¬y
;

55 
‰y_¡ruù
 
‰y_bË
[];

63 
	#INIT_C_CC
 "\003\034\177\025\004\0\1\0\021\023\032\0\022\017\027\026\0"

	)

65 
rs_š™
();

66 
cÚ_š™
();

67 
‰y_š™
();

69 
‰y_»ad
(
c
, * 
buf
, 
n
);

70 
‰y_wr™e
(
c
, * 
buf
, 
n
);

72 
rs_wr™e
(
‰y_¡ruù
 * 
‰y
);

73 
cÚ_wr™e
(
‰y_¡ruù
 * 
‰y
);

75 
cÝy_to_cooked
(
‰y_¡ruù
 * 
‰y
);

	@include/signal.h

1 #iâdeà
_SIGNAL_H


2 
	#_SIGNAL_H


	)

4 
	~<sys/ty³s.h
>

6 
	tsig_©omic_t
;

7 
	tsig£t_t
;

9 
	#_NSIG
 32

	)

10 
	#NSIG
 
_NSIG


	)

12 
	#SIGHUP
 1

	)

13 
	#SIGINT
 2

	)

14 
	#SIGQUIT
 3

	)

15 
	#SIGILL
 4

	)

16 
	#SIGTRAP
 5

	)

17 
	#SIGABRT
 6

	)

18 
	#SIGIOT
 6

	)

19 
	#SIGUNUSED
 7

	)

20 
	#SIGFPE
 8

	)

21 
	#SIGKILL
 9

	)

22 
	#SIGUSR1
 10

	)

23 
	#SIGSEGV
 11

	)

24 
	#SIGUSR2
 12

	)

25 
	#SIGPIPE
 13

	)

26 
	#SIGALRM
 14

	)

27 
	#SIGTERM
 15

	)

28 
	#SIGSTKFLT
 16

	)

29 
	#SIGCHLD
 17

	)

30 
	#SIGCONT
 18

	)

31 
	#SIGSTOP
 19

	)

32 
	#SIGTSTP
 20

	)

33 
	#SIGTTIN
 21

	)

34 
	#SIGTTOU
 22

	)

37 
	#SA_NOCLDSTOP
 1

	)

38 
	#SA_NOMASK
 0x40000000

	)

39 
	#SA_ONESHOT
 0x80000000

	)

41 
	#SIG_BLOCK
 0

	)

42 
	#SIG_UNBLOCK
 1

	)

43 
	#SIG_SETMASK
 2

	)

45 
	#SIG_DFL
 (((*)())0è

	)

46 
	#SIG_IGN
 (((*)())1è

	)

48 
	ssigaùiÚ
 {

49 (*
	m§_hªdËr
)();

50 
sig£t_t
 
	m§_mask
;

51 
	m§_æags
;

52 (*
	m§_»¡Ü”
)();

55 (*
	$sigÇl
(
_sig
, (*
_func
)()))();

56 
	`¿i£
(
sig
);

57 
	`kžl
(
pid_t
 
pid
, 
sig
);

58 
	`sigadd£t
(
sig£t_t
 *
mask
, 
signo
);

59 
	`sigd–£t
(
sig£t_t
 *
mask
, 
signo
);

60 
	`sigem±y£t
(
sig£t_t
 *
mask
);

61 
	`sigfžl£t
(
sig£t_t
 *
mask
);

62 
	`sigismemb”
(
sig£t_t
 *
mask
, 
signo
);

63 
	`sig³ndšg
(
sig£t_t
 *
£t
);

64 
	`sig´ocmask
(
how
, 
sig£t_t
 *
£t
, sig£t_ˆ*
Þd£t
);

65 
	`sigsu¥’d
(
sig£t_t
 *
sigmask
);

66 
	`sigaùiÚ
(
sig
, 
sigaùiÚ
 *
aù
, sigaùiÚ *
Þdaù
);

	@include/stdarg.h

1 #iâdeà
_STDARG_H


2 
	#_STDARG_H


	)

4 *
	tva_li¡
;

9 
	#__va_rounded_size
(
TYPE
) \

10 ((( (
TYPE
è+  (è- 1è/  ()è*  ())

	)

12 #iâdeà
__¥¬c__


13 
	#va_¡¬t
(
AP
, 
LASTARG
) \

14 (
AP
 = ((*è&(
LASTARG
è+ 
	`__va_rounded_size
 (LASTARG)))

	)

16 
	#va_¡¬t
(
AP
, 
LASTARG
) \

17 (
	`__bužtš_§v”egs
 (), \

18 
AP
 = ((*è&(
LASTARG
è+ 
	`__va_rounded_size
 (LASTARG)))

	)

21 
va_’d
 (
va_li¡
);

22 
	#va_’d
(
AP
)

	)

24 
	#va_¬g
(
AP
, 
TYPE
) \

25 (
AP
 +ð
	`__va_rounded_size
 (
TYPE
), \

26 *((
TYPE
 *è(
AP
 - 
	`__va_rounded_size
 (TYPE))))

	)

	@include/stddef.h

1 #iâdeà
_STDDEF_H


2 
	#_STDDEF_H


	)

4 #iâdeà
_PTRDIFF_T


5 
	#_PTRDIFF_T


	)

6 
	t±rdiff_t
;

9 #iâdeà
_SIZE_T


10 
	#_SIZE_T


	)

11 
	tsize_t
;

14 #undeà
NULL


15 
	#NULL
 ((*)0)

	)

17 
	#off£tof
(
TYPE
, 
MEMBER
è((
size_t
è&((TYPE *)0)->MEMBER)

	)

	@include/string.h

1 #iâdeà
_STRING_H_


2 
	#_STRING_H_


	)

4 #iâdeà
NULL


5 
	#NULL
 ((*è0)

	)

8 #iâdeà
_SIZE_T


9 
	#_SIZE_T


	)

10 
	tsize_t
;

13 * 
¡»¼Ü
(
”ºo
);

27 
šlše
 * 
	$¡rýy
(* 
de¡
,cÚ¡ *
¤c
)

29 
	`__asm__
("cld\n"

34 ::"S" (
¤c
),"D" (
de¡
):"si","di","ax");

35  
de¡
;

36 
	}
}

38 
šlše
 * 
	$¡ºýy
(* 
de¡
,cÚ¡ *
¤c
,
couÁ
)

40 
	`__asm__
("cld\n"

50 ::"S" (
¤c
),"D" (
de¡
),"c" (
couÁ
):"si","di","ax","cx");

51  
de¡
;

52 
	}
}

54 
šlše
 * 
	$¡rÿt
(* 
de¡
,cÚ¡ * 
¤c
)

56 
	`__asm__
("cld\n\t"

64 ::"S" (
¤c
),"D" (
de¡
),"a" (0),"c" (0xffffffff):"si","di","ax","cx");

65  
de¡
;

66 
	}
}

68 
šlše
 * 
	$¡ºÿt
(* 
de¡
,cÚ¡ * 
¤c
,
couÁ
)

70 
	`__asm__
("cld\n\t"

83 ::"S" (
¤c
),"D" (
de¡
),"a" (0),"c" (0xffffffff),"g" (
couÁ
)

85  
de¡
;

86 
	}
}

88 
šlše
 
	$¡rcmp
(cÚ¡ * 
cs
,cÚ¡ * 
ù
)

90 
__»s
 
	`__asm__
("ax");

91 
	`__asm__
("cld\n"

103 :"÷" (
__»s
):"D" (
cs
),"S" (
ù
):"si","di");

104  
__»s
;

105 
	}
}

107 
šlše
 
	$¡ºcmp
(cÚ¡ * 
cs
,cÚ¡ * 
ù
,
couÁ
)

109 
__»s
 
	`__asm__
("ax");

110 
	`__asm__
("cld\n"

124 :"÷" (
__»s
):"D" (
cs
),"S" (
ù
),"c" (
couÁ
):"si","di","cx");

125  
__»s
;

126 
	}
}

128 
šlše
 * 
	$¡rchr
(cÚ¡ * 
s
,
c
)

130 * 
__»s
 
	`__asm__
("ax");

131 
	`__asm__
("cld\n\t"

141 :"÷" (
__»s
):"S" (
s
),"0" (
c
):"si");

142  
__»s
;

143 
	}
}

145 
šlše
 * 
	$¡¼chr
(cÚ¡ * 
s
,
c
)

147 * 
__»s
 
	`__asm__
("dx");

148 
	`__asm__
("cld\n\t"

157 :"=d" (
__»s
):"0" (0),"S" (
s
),"a" (
c
):"ax","si");

158  
__»s
;

159 
	}
}

161 
šlše
 
	$¡r¥n
(cÚ¡ * 
cs
, cÚ¡ * 
ù
)

163 * 
__»s
 
	`__asm__
("si");

164 
	`__asm__
("cld\n\t"

180 :"=S" (
__»s
):"a" (0),"c" (0xffffffff),"0" (
cs
),"g" (
ù
)

182  
__»s
-
cs
;

183 
	}
}

185 
šlše
 
	$¡rc¥n
(cÚ¡ * 
cs
, cÚ¡ * 
ù
)

187 * 
__»s
 
	`__asm__
("si");

188 
	`__asm__
("cld\n\t"

204 :"=S" (
__»s
):"a" (0),"c" (0xffffffff),"0" (
cs
),"g" (
ù
)

206  
__»s
-
cs
;

207 
	}
}

209 
šlše
 * 
	$¡½brk
(cÚ¡ * 
cs
,cÚ¡ * 
ù
)

211 * 
__»s
 
	`__asm__
("si");

212 
	`__asm__
("cld\n\t"

231 :"=S" (
__»s
):"a" (0),"c" (0xffffffff),"0" (
cs
),"g" (
ù
)

233  
__»s
;

234 
	}
}

236 
šlše
 * 
	$¡r¡r
(cÚ¡ * 
cs
,cÚ¡ * 
ù
)

238 * 
__»s
 
	`__asm__
("ax");

239 
	`__asm__
("cld\n\t" \

258 :"÷" (
__»s
):"0" (0),"c" (0xffffffff),"S" (
cs
),"g" (
ù
)

260  
__»s
;

261 
	}
}

263 
šlše
 
	$¡¾’
(cÚ¡ * 
s
)

265 
__»s
 
	`__asm__
("cx");

266 
	`__asm__
("cld\n\t"

271 :"=c" (
__»s
):"D" (
s
),"a" (0),"0" (0xffffffff):"di");

272  
__»s
;

273 
	}
}

275 * 
___¡¹ok
;

277 
šlše
 * 
	$¡¹ok
(* 
s
,cÚ¡ * 
ù
)

279 * 
__»s
 
	`__asm__
("si");

280 
	`__asm__
("testl %1,%1\n\t"

330 :"=b" (
__»s
),"=S" (
___¡¹ok
)

331 :"0" (
___¡¹ok
),"1" (
s
),"g" (
ù
)

333  
__»s
;

334 
	}
}

336 
šlše
 * 
	$memýy
(* 
de¡
,cÚ¡ * 
¤c
, 
n
)

338 
	`__asm__
("cld\n\t"

341 ::"c" (
n
),"S" (
¤c
),"D" (
de¡
)

343  
de¡
;

344 
	}
}

346 
šlše
 * 
	$memmove
(* 
de¡
,cÚ¡ * 
¤c
, 
n
)

348 ià(
de¡
<
¤c
)

349 
	`__asm__
("cld\n\t"

352 ::"c" (
n
),"S" (
¤c
),"D" (
de¡
)

355 
	`__asm__
("std\n\t"

358 ::"c" (
n
),"S" (
¤c
+n-1),"D" (
de¡
+n-1)

360  
de¡
;

361 
	}
}

363 
šlše
 
	$memcmp
(cÚ¡ * 
cs
,cÚ¡ * 
ù
,
couÁ
)

365 
__»s
 
	`__asm__
("ax");

366 
	`__asm__
("cld\n\t"

374 :"÷" (
__»s
):"0" (0),"D" (
cs
),"S" (
ù
),"c" (
couÁ
)

376  
__»s
;

377 
	}
}

379 
šlše
 * 
	$memchr
(cÚ¡ * 
cs
,
c
,
couÁ
)

381 * 
__»s
 
	`__asm__
("di");

382 ià(!
couÁ
)

383  
NULL
;

384 
	`__asm__
("cld\n\t"

390 :"=D" (
__»s
):"a" (
c
),"D" (
cs
),"c" (
couÁ
)

392  
__»s
;

393 
	}
}

395 
šlše
 * 
	$mem£t
(* 
s
,
c
,
couÁ
)

397 
	`__asm__
("cld\n\t"

400 ::"a" (
c
),"D" (
s
),"c" (
couÁ
)

402  
s
;

403 
	}
}

	@include/sys/stat.h

1 #iâdeà
_SYS_STAT_H


2 
	#_SYS_STAT_H


	)

4 
	~<sys/ty³s.h
>

6 
	s¡©
 {

7 
dev_t
 
	m¡_dev
;

8 
šo_t
 
	m¡_šo
;

9 
umode_t
 
	m¡_mode
;

10 
Æšk_t
 
	m¡_Æšk
;

11 
uid_t
 
	m¡_uid
;

12 
gid_t
 
	m¡_gid
;

13 
dev_t
 
	m¡_rdev
;

14 
off_t
 
	m¡_size
;

15 
time_t
 
	m¡_©ime
;

16 
time_t
 
	m¡_mtime
;

17 
time_t
 
	m¡_ùime
;

20 
	#S_IFMT
 00170000

	)

21 
	#S_IFREG
 0100000

	)

22 
	#S_IFBLK
 0060000

	)

23 
	#S_IFDIR
 0040000

	)

24 
	#S_IFCHR
 0020000

	)

25 
	#S_IFIFO
 0010000

	)

26 
	#S_ISUID
 0004000

	)

27 
	#S_ISGID
 0002000

	)

28 
	#S_ISVTX
 0001000

	)

30 
	#S_ISREG
(
m
è(((mè& 
S_IFMT
è=ð
S_IFREG
)

	)

31 
	#S_ISDIR
(
m
è(((mè& 
S_IFMT
è=ð
S_IFDIR
)

	)

32 
	#S_ISCHR
(
m
è(((mè& 
S_IFMT
è=ð
S_IFCHR
)

	)

33 
	#S_ISBLK
(
m
è(((mè& 
S_IFMT
è=ð
S_IFBLK
)

	)

34 
	#S_ISFIFO
(
m
è(((mè& 
S_IFMT
è=ð
S_IFIFO
)

	)

36 
	#S_IRWXU
 00700

	)

37 
	#S_IRUSR
 00400

	)

38 
	#S_IWUSR
 00200

	)

39 
	#S_IXUSR
 00100

	)

41 
	#S_IRWXG
 00070

	)

42 
	#S_IRGRP
 00040

	)

43 
	#S_IWGRP
 00020

	)

44 
	#S_IXGRP
 00010

	)

46 
	#S_IRWXO
 00007

	)

47 
	#S_IROTH
 00004

	)

48 
	#S_IWOTH
 00002

	)

49 
	#S_IXOTH
 00001

	)

51 
chmod
(cÚ¡ *
_·th
, 
mode_t
 
mode
);

52 
f¡©
(
fždes
, 
¡©
 *
¡©_buf
);

53 
mkdœ
(cÚ¡ *
_·th
, 
mode_t
 
mode
);

54 
mkfifo
(cÚ¡ *
_·th
, 
mode_t
 
mode
);

55 
¡©
(cÚ¡ *
fž’ame
, ¡© *
¡©_buf
);

56 
mode_t
 
umask
(mode_ˆ
mask
);

	@include/sys/times.h

1 #iâdeà
_TIMES_H


2 
	#_TIMES_H


	)

4 
	~<sys/ty³s.h
>

6 
	stms
 {

7 
time_t
 
	mtms_utime
;

8 
time_t
 
	mtms_¡ime
;

9 
time_t
 
	mtms_cutime
;

10 
time_t
 
	mtms_c¡ime
;

13 
time_t
 
times
(
tms
 * 

);

	@include/sys/types.h

1 #iâdeà
_SYS_TYPES_H


2 
	#_SYS_TYPES_H


	)

4 #iâdeà
_SIZE_T


5 
	#_SIZE_T


	)

6 
	tsize_t
;

9 #iâdeà
_TIME_T


10 
	#_TIME_T


	)

11 
	ttime_t
;

14 #iâdeà
_PTRDIFF_T


15 
	#_PTRDIFF_T


	)

16 
	t±rdiff_t
;

19 #iâdeà
NULL


20 
	#NULL
 ((*è0)

	)

23 
	tpid_t
;

24 
	tuid_t
;

25 
	tgid_t
;

26 
	tdev_t
;

27 
	tšo_t
;

28 
	tmode_t
;

29 
	tumode_t
;

30 
	tÆšk_t
;

31 
	tdaddr_t
;

32 
	toff_t
;

33 
	tu_ch¬
;

34 
	tushÜt
;

36 ¡ruù { 
	mquÙ
,
	m»m
; } 
	tdiv_t
;

37 ¡ruù { 
	mquÙ
,
	m»m
; } 
	tldiv_t
;

39 
	su¡©
 {

40 
daddr_t
 
	mf_tä“
;

41 
šo_t
 
	mf_tšode
;

42 
	mf_âame
[6];

43 
	mf_åack
[6];

	@include/sys/utsname.h

1 #iâdeà
_SYS_UTSNAME_H


2 
	#_SYS_UTSNAME_H


	)

4 
	~<sys/ty³s.h
>

6 
	sut¢ame
 {

7 
	msy¢ame
[9];

8 
	mnod’ame
[9];

9 
	m»Ëa£
[9];

10 
	mv”siÚ
[9];

11 
	mmachše
[9];

14 
uÇme
(
ut¢ame
 * 
utsbuf
);

	@include/sys/wait.h

1 #iâdeà
_SYS_WAIT_H


2 
	#_SYS_WAIT_H


	)

4 
	~<sys/ty³s.h
>

6 
	#_LOW
(
v
èÐ(vè& 0377)

	)

7 
	#_HIGH
(
v
èÐ((vè>> 8è& 0377)

	)

10 
	#WNOHANG
 1

	)

11 
	#WUNTRACED
 2

	)

13 
	#WIFEXITED
(
s
è(!((s)&0xFF)

	)

14 
	#WIFSTOPPED
(
s
è(((s)&0xFF)==0x7F)

	)

15 
	#WEXITSTATUS
(
s
è(((s)>>8)&0xFF)

	)

16 
	#WTERMSIG
(
s
è((s)&0x7F)

	)

17 
	#WSTOPSIG
(
s
è(((s)>>8)&0xFF)

	)

18 
	#WIFSIGNALED
(
s
è((()(s)-1 & 0xFFFFè< 0xFF)

	)

20 
pid_t
 
wa™
(*
¡©_loc
);

21 
pid_t
 
wa™pid
Õid_ˆ
pid
, *
¡©_loc
, 
ÝtiÚs
);

	@include/termios.h

1 #iâdeà
_TERMIOS_H


2 
	#_TERMIOS_H


	)

4 
	#TTY_BUF_SIZE
 1024

	)

8 
	#TCGETS
 0x5401

	)

9 
	#TCSETS
 0x5402

	)

10 
	#TCSETSW
 0x5403

	)

11 
	#TCSETSF
 0x5404

	)

12 
	#TCGETA
 0x5405

	)

13 
	#TCSETA
 0x5406

	)

14 
	#TCSETAW
 0x5407

	)

15 
	#TCSETAF
 0x5408

	)

16 
	#TCSBRK
 0x5409

	)

17 
	#TCXONC
 0x540A

	)

18 
	#TCFLSH
 0x540B

	)

19 
	#TIOCEXCL
 0x540C

	)

20 
	#TIOCNXCL
 0x540D

	)

21 
	#TIOCSCTTY
 0x540E

	)

22 
	#TIOCGPGRP
 0x540F

	)

23 
	#TIOCSPGRP
 0x5410

	)

24 
	#TIOCOUTQ
 0x5411

	)

25 
	#TIOCSTI
 0x5412

	)

26 
	#TIOCGWINSZ
 0x5413

	)

27 
	#TIOCSWINSZ
 0x5414

	)

28 
	#TIOCMGET
 0x5415

	)

29 
	#TIOCMBIS
 0x5416

	)

30 
	#TIOCMBIC
 0x5417

	)

31 
	#TIOCMSET
 0x5418

	)

32 
	#TIOCGSOFTCAR
 0x5419

	)

33 
	#TIOCSSOFTCAR
 0x541A

	)

34 
	#TIOCINQ
 0x541B

	)

36 
	swšsize
 {

37 
	mws_row
;

38 
	mws_cÞ
;

39 
	mws_xpix–
;

40 
	mws_ypix–
;

43 
	#NCC
 8

	)

44 
	s‹rmio
 {

45 
	mc_iæag
;

46 
	mc_oæag
;

47 
	mc_cæag
;

48 
	mc_læag
;

49 
	mc_lše
;

50 
	mc_cc
[
NCC
];

53 
	#NCCS
 17

	)

54 
	s‹rmios
 {

55 
	mc_iæag
;

56 
	mc_oæag
;

57 
	mc_cæag
;

58 
	mc_læag
;

59 
	mc_lše
;

60 
	mc_cc
[
NCCS
];

64 
	#VINTR
 0

	)

65 
	#VQUIT
 1

	)

66 
	#VERASE
 2

	)

67 
	#VKILL
 3

	)

68 
	#VEOF
 4

	)

69 
	#VTIME
 5

	)

70 
	#VMIN
 6

	)

71 
	#VSWTC
 7

	)

72 
	#VSTART
 8

	)

73 
	#VSTOP
 9

	)

74 
	#VSUSP
 10

	)

75 
	#VEOL
 11

	)

76 
	#VREPRINT
 12

	)

77 
	#VDISCARD
 13

	)

78 
	#VWERASE
 14

	)

79 
	#VLNEXT
 15

	)

80 
	#VEOL2
 16

	)

83 
	#IGNBRK
 0000001

	)

84 
	#BRKINT
 0000002

	)

85 
	#IGNPAR
 0000004

	)

86 
	#PARMRK
 0000010

	)

87 
	#INPCK
 0000020

	)

88 
	#ISTRIP
 0000040

	)

89 
	#INLCR
 0000100

	)

90 
	#IGNCR
 0000200

	)

91 
	#ICRNL
 0000400

	)

92 
	#IUCLC
 0001000

	)

93 
	#IXON
 0002000

	)

94 
	#IXANY
 0004000

	)

95 
	#IXOFF
 0010000

	)

96 
	#IMAXBEL
 0020000

	)

99 
	#OPOST
 0000001

	)

100 
	#OLCUC
 0000002

	)

101 
	#ONLCR
 0000004

	)

102 
	#OCRNL
 0000010

	)

103 
	#ONOCR
 0000020

	)

104 
	#ONLRET
 0000040

	)

105 
	#OFILL
 0000100

	)

106 
	#OFDEL
 0000200

	)

107 
	#NLDLY
 0000400

	)

108 
	#NL0
 0000000

	)

109 
	#NL1
 0000400

	)

110 
	#CRDLY
 0003000

	)

111 
	#CR0
 0000000

	)

112 
	#CR1
 0001000

	)

113 
	#CR2
 0002000

	)

114 
	#CR3
 0003000

	)

115 
	#TABDLY
 0014000

	)

116 
	#TAB0
 0000000

	)

117 
	#TAB1
 0004000

	)

118 
	#TAB2
 0010000

	)

119 
	#TAB3
 0014000

	)

120 
	#XTABS
 0014000

	)

121 
	#BSDLY
 0020000

	)

122 
	#BS0
 0000000

	)

123 
	#BS1
 0020000

	)

124 
	#VTDLY
 0040000

	)

125 
	#VT0
 0000000

	)

126 
	#VT1
 0040000

	)

127 
	#FFDLY
 0040000

	)

128 
	#FF0
 0000000

	)

129 
	#FF1
 0040000

	)

132 
	#CBAUD
 0000017

	)

133 
	#B0
 0000000

	)

134 
	#B50
 0000001

	)

135 
	#B75
 0000002

	)

136 
	#B110
 0000003

	)

137 
	#B134
 0000004

	)

138 
	#B150
 0000005

	)

139 
	#B200
 0000006

	)

140 
	#B300
 0000007

	)

141 
	#B600
 0000010

	)

142 
	#B1200
 0000011

	)

143 
	#B1800
 0000012

	)

144 
	#B2400
 0000013

	)

145 
	#B4800
 0000014

	)

146 
	#B9600
 0000015

	)

147 
	#B19200
 0000016

	)

148 
	#B38400
 0000017

	)

149 
	#EXTA
 
B19200


	)

150 
	#EXTB
 
B38400


	)

151 
	#CSIZE
 0000060

	)

152 
	#CS5
 0000000

	)

153 
	#CS6
 0000020

	)

154 
	#CS7
 0000040

	)

155 
	#CS8
 0000060

	)

156 
	#CSTOPB
 0000100

	)

157 
	#CREAD
 0000200

	)

158 
	#CPARENB
 0000400

	)

159 
	#CPARODD
 0001000

	)

160 
	#HUPCL
 0002000

	)

161 
	#CLOCAL
 0004000

	)

162 
	#CIBAUD
 03600000

	)

163 
	#CRTSCTS
 020000000000

	)

165 
	#PARENB
 
CPARENB


	)

166 
	#PARODD
 
CPARODD


	)

169 
	#ISIG
 0000001

	)

170 
	#ICANON
 0000002

	)

171 
	#XCASE
 0000004

	)

172 
	#ECHO
 0000010

	)

173 
	#ECHOE
 0000020

	)

174 
	#ECHOK
 0000040

	)

175 
	#ECHONL
 0000100

	)

176 
	#NOFLSH
 0000200

	)

177 
	#TOSTOP
 0000400

	)

178 
	#ECHOCTL
 0001000

	)

179 
	#ECHOPRT
 0002000

	)

180 
	#ECHOKE
 0004000

	)

181 
	#FLUSHO
 0010000

	)

182 
	#PENDIN
 0040000

	)

183 
	#IEXTEN
 0100000

	)

186 
	#TIOCM_LE
 0x001

	)

187 
	#TIOCM_DTR
 0x002

	)

188 
	#TIOCM_RTS
 0x004

	)

189 
	#TIOCM_ST
 0x008

	)

190 
	#TIOCM_SR
 0x010

	)

191 
	#TIOCM_CTS
 0x020

	)

192 
	#TIOCM_CAR
 0x040

	)

193 
	#TIOCM_RNG
 0x080

	)

194 
	#TIOCM_DSR
 0x100

	)

195 
	#TIOCM_CD
 
TIOCM_CAR


	)

196 
	#TIOCM_RI
 
TIOCM_RNG


	)

199 
	#TCOOFF
 0

	)

200 
	#TCOON
 1

	)

201 
	#TCIOFF
 2

	)

202 
	#TCION
 3

	)

205 
	#TCIFLUSH
 0

	)

206 
	#TCOFLUSH
 1

	)

207 
	#TCIOFLUSH
 2

	)

210 
	#TCSANOW
 0

	)

211 
	#TCSADRAIN
 1

	)

212 
	#TCSAFLUSH
 2

	)

214 
	t¥“d_t
;

216 
¥“d_t
 
cfg‘i¥“d
(
‹rmios
 *
‹rmios_p
);

217 
¥“d_t
 
cfg‘o¥“d
(
‹rmios
 *
‹rmios_p
);

218 
cf£ti¥“d
(
‹rmios
 *
‹rmios_p
, 
¥“d_t
 
¥“d
);

219 
cf£to¥“d
(
‹rmios
 *
‹rmios_p
, 
¥“d_t
 
¥“d
);

220 
tcd¿š
(
fždes
);

221 
tcæow
(
fždes
, 
aùiÚ
);

222 
tcæush
(
fždes
, 
queue_£ËùÜ
);

223 
tcg‘©Œ
(
fždes
, 
‹rmios
 *
‹rmios_p
);

224 
tc£ndb»ak
(
fždes
, 
du¿tiÚ
);

225 
tc£‰r
(
fždes
, 
ÝtiÚ®_aùiÚs
,

226 
‹rmios
 *
‹rmios_p
);

	@include/time.h

1 #iâdeà
_TIME_H


2 
	#_TIME_H


	)

4 #iâdeà
_TIME_T


5 
	#_TIME_T


	)

6 
	ttime_t
;

9 #iâdeà
_SIZE_T


10 
	#_SIZE_T


	)

11 
	tsize_t
;

14 
	#CLOCKS_PER_SEC
 100

	)

16 
	tþock_t
;

18 
	stm
 {

19 
	mtm_£c
;

20 
	mtm_mš
;

21 
	mtm_hour
;

22 
	mtm_mday
;

23 
	mtm_mÚ
;

24 
	mtm_y—r
;

25 
	mtm_wday
;

26 
	mtm_yday
;

27 
	mtm_isd¡
;

30 
þock_t
 
þock
();

31 
time_t
 
time
Ñime_ˆ* 

);

32 
difáime
(
time_t
 
time2
,ime_ˆ
time1
);

33 
time_t
 
mktime
(
tm
 * 

);

35 * 
asùime
(cÚ¡ 
tm
 * 

);

36 * 
ùime
(cÚ¡ 
time_t
 * 

);

37 
tm
 * 
gmtime
(cÚ¡ 
time_t
 *

);

38 
tm
 *
loÿÉime
(cÚ¡ 
time_t
 * 

);

39 
size_t
 
¡ráime
(* 
s
, size_ˆ
smax
, cÚ¡ * 
fmt
, cÚ¡ 
tm
 * 

);

40 
tz£t
();

	@include/unistd.h

1 #iâdeà
_UNISTD_H


2 
	#_UNISTD_H


	)

5 
	#_POSIX_VERSION
 198808L

	)

7 
	#_POSIX_CHOWN_RESTRICTED


	)

8 
	#_POSIX_NO_TRUNC


	)

9 
	#_POSIX_VDISABLE
 '\0'

	)

13 
	#STDIN_FILENO
 0

	)

14 
	#STDOUT_FILENO
 1

	)

15 
	#STDERR_FILENO
 2

	)

17 #iâdeà
NULL


18 
	#NULL
 ((*)0)

	)

22 
	#F_OK
 0

	)

23 
	#X_OK
 1

	)

24 
	#W_OK
 2

	)

25 
	#R_OK
 4

	)

28 
	#SEEK_SET
 0

	)

29 
	#SEEK_CUR
 1

	)

30 
	#SEEK_END
 2

	)

33 
	#_SC_ARG_MAX
 1

	)

34 
	#_SC_CHILD_MAX
 2

	)

35 
	#_SC_CLOCKS_PER_SEC
 3

	)

36 
	#_SC_NGROUPS_MAX
 4

	)

37 
	#_SC_OPEN_MAX
 5

	)

38 
	#_SC_JOB_CONTROL
 6

	)

39 
	#_SC_SAVED_IDS
 7

	)

40 
	#_SC_VERSION
 8

	)

43 
	#_PC_LINK_MAX
 1

	)

44 
	#_PC_MAX_CANON
 2

	)

45 
	#_PC_MAX_INPUT
 3

	)

46 
	#_PC_NAME_MAX
 4

	)

47 
	#_PC_PATH_MAX
 5

	)

48 
	#_PC_PIPE_BUF
 6

	)

49 
	#_PC_NO_TRUNC
 7

	)

50 
	#_PC_VDISABLE
 8

	)

51 
	#_PC_CHOWN_RESTRICTED
 9

	)

53 
	~<sys/¡©.h
>

54 
	~<sys/times.h
>

55 
	~<sys/ut¢ame.h
>

56 
	~<utime.h
>

58 #ifdeà
__LIBRARY__


60 
	#__NR_£tup
 0

	)

61 
	#__NR_ex™
 1

	)

62 
	#__NR_fÜk
 2

	)

63 
	#__NR_»ad
 3

	)

64 
	#__NR_wr™e
 4

	)

65 
	#__NR_Ý’
 5

	)

66 
	#__NR_þo£
 6

	)

67 
	#__NR_wa™pid
 7

	)

68 
	#__NR_ü—t
 8

	)

69 
	#__NR_lšk
 9

	)

70 
	#__NR_uÆšk
 10

	)

71 
	#__NR_execve
 11

	)

72 
	#__NR_chdœ
 12

	)

73 
	#__NR_time
 13

	)

74 
	#__NR_mknod
 14

	)

75 
	#__NR_chmod
 15

	)

76 
	#__NR_chown
 16

	)

77 
	#__NR_b»ak
 17

	)

78 
	#__NR_¡©
 18

	)

79 
	#__NR_l£ek
 19

	)

80 
	#__NR_g‘pid
 20

	)

81 
	#__NR_mouÁ
 21

	)

82 
	#__NR_umouÁ
 22

	)

83 
	#__NR_£tuid
 23

	)

84 
	#__NR_g‘uid
 24

	)

85 
	#__NR_¡ime
 25

	)

86 
	#__NR_±¿û
 26

	)

87 
	#__NR_®¬m
 27

	)

88 
	#__NR_f¡©
 28

	)

89 
	#__NR_·u£
 29

	)

90 
	#__NR_utime
 30

	)

91 
	#__NR_¡ty
 31

	)

92 
	#__NR_g‰y
 32

	)

93 
	#__NR_acûss
 33

	)

94 
	#__NR_niû
 34

	)

95 
	#__NR_áime
 35

	)

96 
	#__NR_sync
 36

	)

97 
	#__NR_kžl
 37

	)

98 
	#__NR_»Çme
 38

	)

99 
	#__NR_mkdœ
 39

	)

100 
	#__NR_rmdœ
 40

	)

101 
	#__NR_dup
 41

	)

102 
	#__NR_pe
 42

	)

103 
	#__NR_times
 43

	)

104 
	#__NR_´of
 44

	)

105 
	#__NR_brk
 45

	)

106 
	#__NR_£tgid
 46

	)

107 
	#__NR_g‘gid
 47

	)

108 
	#__NR_sigÇl
 48

	)

109 
	#__NR_g‘euid
 49

	)

110 
	#__NR_g‘egid
 50

	)

111 
	#__NR_acù
 51

	)

112 
	#__NR_phys
 52

	)

113 
	#__NR_lock
 53

	)

114 
	#__NR_ioùl
 54

	)

115 
	#__NR_fúŽ
 55

	)

116 
	#__NR_mpx
 56

	)

117 
	#__NR_£gid
 57

	)

118 
	#__NR_ulim™
 58

	)

119 
	#__NR_uÇme
 59

	)

120 
	#__NR_umask
 60

	)

121 
	#__NR_chroÙ
 61

	)

122 
	#__NR_u¡©
 62

	)

123 
	#__NR_dup2
 63

	)

124 
	#__NR_g‘µid
 64

	)

125 
	#__NR_g‘pg½
 65

	)

126 
	#__NR_£tsid
 66

	)

127 
	#__NR_sigaùiÚ
 67

	)

128 
	#__NR_sg‘mask
 68

	)

129 
	#__NR_s£tmask
 69

	)

130 
	#__NR_£Œeuid
 70

	)

131 
	#__NR_£Œegid
 71

	)

133 
	#_sysÿÎ0
(
ty³
,
Çme
) \

134 
ty³
 
	`Çme
() \

136 
__»s
; \

137 
__asm__
 volatile ("int $0x80" \

138 : "÷" (
__»s
) \

139 : "0" (
__NR_
##
Çme
)); \

140 ià(
__»s
 >= 0) \

141  (
ty³
è
__»s
; \

142 
”ºo
 = -
__»s
; \

144 }

	)

146 
	#_sysÿÎ1
(
ty³
,
Çme
,
©y³
,
a
) \

147 
ty³
 
	`Çme
(
©y³
 
a
) \

149 
__»s
; \

150 
__asm__
 volatile ("int $0x80" \

151 : "÷" (
__»s
) \

152 : "0" (
__NR_
##
Çme
),"b" (()(
a
))); \

153 ià(
__»s
 >= 0) \

154  (
ty³
è
__»s
; \

155 
”ºo
 = -
__»s
; \

157 }

	)

159 
	#_sysÿÎ2
(
ty³
,
Çme
,
©y³
,
a
,
bty³
,
b
) \

160 
ty³
 
	`Çme
(
©y³
 
a
,
bty³
 
b
) \

162 
__»s
; \

163 
__asm__
 volatile ("int $0x80" \

164 : "÷" (
__»s
) \

165 : "0" (
__NR_
##
Çme
),"b" (()(
a
)),"c" (()(
b
))); \

166 ià(
__»s
 >= 0) \

167  (
ty³
è
__»s
; \

168 
”ºo
 = -
__»s
; \

170 }

	)

172 
	#_sysÿÎ3
(
ty³
,
Çme
,
©y³
,
a
,
bty³
,
b
,
ùy³
,
c
) \

173 
ty³
 
	`Çme
(
©y³
 
a
,
bty³
 
b
,
ùy³
 
c
) \

175 
__»s
; \

176 
__asm__
 volatile ("int $0x80" \

177 : "÷" (
__»s
) \

178 : "0" (
__NR_
##
Çme
),"b" (()(
a
)),"c" (()(
b
)),"d" (()(
c
))); \

179 ià(
__»s
>=0) \

180  (
ty³
è
__»s
; \

181 
”ºo
=-
__»s
; \

183 }

	)

187 
”ºo
;

189 
acûss
(cÚ¡ * 
fž’ame
, 
mode_t
 
mode
);

190 
acù
(cÚ¡ * 
fž’ame
);

191 
®¬m
(
£c
);

192 
brk
(* 
’d_d©a_£gm’t
);

193 * 
sbrk
(
±rdiff_t
 
šüem’t
);

194 
chdœ
(cÚ¡ * 
fž’ame
);

195 
chmod
(cÚ¡ * 
fž’ame
, 
mode_t
 
mode
);

196 
chown
(cÚ¡ * 
fž’ame
, 
uid_t
 
owÃr
, 
gid_t
 
group
);

197 
chroÙ
(cÚ¡ * 
fž’ame
);

198 
þo£
(
fždes
);

199 
ü—t
(cÚ¡ * 
fž’ame
, 
mode_t
 
mode
);

200 
dup
(
fždes
);

201 
execve
(cÚ¡ * 
fž’ame
, ** 
¬gv
, ** 
’vp
);

202 
execv
(cÚ¡ * 
·thÇme
, ** 
¬gv
);

203 
execvp
(cÚ¡ * 
fže
, ** 
¬gv
);

204 
exeþ
(cÚ¡ * 
·thÇme
, * 
¬g0
, ...);

205 
exeþp
(cÚ¡ * 
fže
, * 
¬g0
, ...);

206 
exeþe
(cÚ¡ * 
·thÇme
, * 
¬g0
, ...);

207 vÞ©ž
ex™
(
¡©us
);

208 vÞ©ž
_ex™
(
¡©us
);

209 
fúŽ
(
fždes
, 
cmd
, ...);

210 
fÜk
();

211 
g‘pid
();

212 
g‘uid
();

213 
g‘euid
();

214 
g‘gid
();

215 
g‘egid
();

216 
ioùl
(
fždes
, 
cmd
, ...);

217 
kžl
(
pid_t
 
pid
, 
sigÇl
);

218 
lšk
(cÚ¡ * 
fž’ame1
, cÚ¡ * 
fž’ame2
);

219 
l£ek
(
fždes
, 
off_t
 
off£t
, 
Üigš
);

220 
mknod
(cÚ¡ * 
fž’ame
, 
mode_t
 
mode
, 
dev_t
 
dev
);

221 
mouÁ
(cÚ¡ * 
¥ecŸlfže
, cÚ¡ * 
dœ
, 
rwæag
);

222 
niû
(
v®
);

223 
Ý’
(cÚ¡ * 
fž’ame
, 
æag
, ...);

224 
·u£
();

225 
pe
(* 
fždes
);

226 
»ad
(
fždes
, * 
buf
, 
off_t
 
couÁ
);

227 
£g½
();

228 
£gid
(
pid_t
 
pid
,pid_ˆ
pgid
);

229 
£tuid
(
uid_t
 
uid
);

230 
£tgid
(
gid_t
 
gid
);

231 (*
	$sigÇl
(
sig
, (*
â
)()))();

232 
	`¡©
(cÚ¡ * 
fž’ame
, 
¡©
 * 
¡©_buf
);

233 
	`f¡©
(
fždes
, 
¡©
 * 
¡©_buf
);

234 
	`¡ime
(
time_t
 * 
Œ
);

235 
	`sync
();

236 
time_t
 
	`time
Ñime_ˆ* 
Žoc
);

237 
time_t
 
	`times
(
tms
 * 
tbuf
);

238 
	`ulim™
(
cmd
, 
lim™
);

239 
mode_t
 
	`umask
(mode_ˆ
mask
);

240 
	`umouÁ
(cÚ¡ * 
¥ecŸlfže
);

241 
	`uÇme
(
ut¢ame
 * 
Çme
);

242 
	`uÆšk
(cÚ¡ * 
fž’ame
);

243 
	`u¡©
(
dev_t
 
dev
, 
u¡©
 * 
ubuf
);

244 
	`utime
(cÚ¡ * 
fž’ame
, 
utimbuf
 * 
times
);

245 
pid_t
 
	`wa™pid
Õid_ˆ
pid
,* 
wa™_¡©
,
ÝtiÚs
);

246 
pid_t
 
	`wa™
(* 
wa™_¡©
);

247 
	`wr™e
(
fždes
, cÚ¡ * 
buf
, 
off_t
 
couÁ
);

248 
	`dup2
(
Þdfd
, 
Ãwfd
);

249 
	`g‘µid
();

250 
pid_t
 
	`g‘pg½
();

251 
pid_t
 
	`£tsid
();

	@include/utime.h

1 #iâdeà
_UTIME_H


2 
	#_UTIME_H


	)

4 
	~<sys/ty³s.h
>

6 
	sutimbuf
 {

7 
time_t
 
	maùime
;

8 
time_t
 
	mmodtime
;

11 
utime
(cÚ¡ *
fž’ame
, 
utimbuf
 *
times
);

	@init/main.c

7 
	#__LIBRARY__


	)

8 
	~<uni¡d.h
>

9 
	~<time.h
>

23 
šlše
 
	$_sysÿÎ0
(,
fÜk
)

24 
šlše
 
	$_sysÿÎ0
(,
·u£
)

25 
šlše
 
	$_sysÿÎ1
(,
£tup
,*,
BIOS
)

26 
šlše
 
	$_sysÿÎ0
(,
sync
)

28 
	~<lšux/‰y.h
>

29 
	~<lšux/sched.h
>

30 
	~<lšux/h—d.h
>

31 
	~<asm/sy¡em.h
>

32 
	~<asm/io.h
>

34 
	~<¡ddef.h
>

35 
	~<¡d¬g.h
>

36 
	~<uni¡d.h
>

37 
	~<fúŽ.h
>

38 
	~<sys/ty³s.h
>

40 
	~<lšux/fs.h
>

42 
´štbuf
[1024];

44 
	`v¥rštf
();

45 
	`š™
();

46 
	`blk_dev_š™
();

47 
	`chr_dev_š™
();

48 
	`hd_š™
();

49 
	`æÝpy_š™
();

50 
	`mem_š™
(
¡¬t
, 
’d
);

51 
	`rd_š™
(
mem_¡¬t
, 
Ëngth
);

52 
	`k”Ãl_mktime
(
tm
 *m);

53 
¡¬tup_time
;

58 
	#EXT_MEM_K
 (*(*)0x90002)

	)

59 
	#DRIVE_INFO
 (*(
drive_šfo
 *)0x90080)

	)

60 
	#ORIG_ROOT_DEV
 (*(*)0x901FC)

	)

69 
	#CMOS_READ
(
addr
) ({ \

70 
	`outb_p
(0x80|
addr
,0x70); \

71 
	`šb_p
(0x71); \

72 
	}
})

	)

74 
	#BCD_TO_BIN
(
v®
è((v®)=((v®)&15è+ ((v®)>>4)*10)

	)

76 
	$time_š™
()

78 
tm
 
time
;

81 
time
.
tm_£c
 = 
	`CMOS_READ
(0);

82 
time
.
tm_mš
 = 
	`CMOS_READ
(2);

83 
time
.
tm_hour
 = 
	`CMOS_READ
(4);

84 
time
.
tm_mday
 = 
	`CMOS_READ
(7);

85 
time
.
tm_mÚ
 = 
	`CMOS_READ
(8);

86 
time
.
tm_y—r
 = 
	`CMOS_READ
(9);

87 } 
time
.
tm_£c
 !ð
	`CMOS_READ
(0));

88 
	`BCD_TO_BIN
(
time
.
tm_£c
);

89 
	`BCD_TO_BIN
(
time
.
tm_mš
);

90 
	`BCD_TO_BIN
(
time
.
tm_hour
);

91 
	`BCD_TO_BIN
(
time
.
tm_mday
);

92 
	`BCD_TO_BIN
(
time
.
tm_mÚ
);

93 
	`BCD_TO_BIN
(
time
.
tm_y—r
);

94 
time
.
tm_mÚ
--;

95 
¡¬tup_time
 = 
	`k”Ãl_mktime
(&
time
);

96 
	}
}

98 
	gmemÜy_’d
 = 0;

99 
	gbufãr_memÜy_’d
 = 0;

100 
	gmaš_memÜy_¡¬t
 = 0;

102 
	sdrive_šfo
 { 
	mdummy
[32]; } 
	gdrive_šfo
;

104 
	$maš
()

110 
ROOT_DEV
 = 
ORIG_ROOT_DEV
;

111 
drive_šfo
 = 
DRIVE_INFO
;

112 
memÜy_’d
 = (1<<20è+ (
EXT_MEM_K
<<10);

113 
memÜy_’d
 &= 0xfffff000;

114 ià(
memÜy_’d
 > 16*1024*1024)

115 
memÜy_’d
 = 16*1024*1024;

116 ià(
memÜy_’d
 > 12*1024*1024)

117 
bufãr_memÜy_’d
 = 4*1024*1024;

118 ià(
memÜy_’d
 > 6*1024*1024)

119 
bufãr_memÜy_’d
 = 2*1024*1024;

121 
bufãr_memÜy_’d
 = 1*1024*1024;

122 
maš_memÜy_¡¬t
 = 
bufãr_memÜy_’d
;

123 #ifdeà
RAMDISK


124 
maš_memÜy_¡¬t
 +ð
	`rd_š™
(maš_memÜy_¡¬t, 
RAMDISK
*1024);

126 
	`mem_š™
(
maš_memÜy_¡¬t
,
memÜy_’d
);

127 
	`Œ­_š™
();

128 
	`blk_dev_š™
();

129 
	`chr_dev_š™
();

130 
	`‰y_š™
();

131 
	`time_š™
();

132 
	`sched_š™
();

133 
	`bufãr_š™
(
bufãr_memÜy_’d
);

134 
	`hd_š™
();

135 
	`æÝpy_š™
();

136 
	`¡i
();

137 
	`move_to_u£r_mode
();

138 ià(!
	`fÜk
()) {

139 
	`š™
();

148 ;;è
	`·u£
();

149 
	}
}

151 
	$´štf
(cÚ¡ *
fmt
, ...)

153 
va_li¡
 
¬gs
;

154 
i
;

156 
	`va_¡¬t
(
¬gs
, 
fmt
);

157 
	`wr™e
(1,
´štbuf
,
i
=
	`v¥rštf
Õrštbuf, 
fmt
, 
¬gs
));

158 
	`va_’d
(
¬gs
);

159  
i
;

160 
	}
}

162 * 
	g¬gv_rc
[] = { "/bš/sh", 
NULL
 };

163 * 
	g’vp_rc
[] = { "HOME=/", 
NULL
 };

165 * 
	g¬gv
[] = { "-/bš/sh",
NULL
 };

166 * 
	g’vp
[] = { "HOME=/u¤/roÙ", 
NULL
 };

168 
	$š™
()

170 
pid
,
i
;

172 
	`£tup
((*è&
drive_šfo
);

173 (è
	`Ý’
("/dev/‰y0",
O_RDWR
,0);

174 (è
	`dup
(0);

175 (è
	`dup
(0);

176 
	`´štf
("%d bufãr ð%d by‹ bufã¸¥aû\n\r",
NR_BUFFERS
,

177 
NR_BUFFERS
*
BLOCK_SIZE
);

178 
	`´štf
("F»mem: %d by‹s\n\r",
memÜy_’d
-
maš_memÜy_¡¬t
);

179 ià(!(
pid
=
	`fÜk
())) {

180 
	`þo£
(0);

181 ià(
	`Ý’
("/‘c/rc",
O_RDONLY
,0))

182 
	`_ex™
(1);

183 
	`execve
("/bš/sh",
¬gv_rc
,
’vp_rc
);

184 
	`_ex™
(2);

186 ià(
pid
>0)

187 
pid
 !ð
	`wa™
(&
i
))

190 ià((
pid
=
	`fÜk
())<0) {

191 
	`´štf
("Fork failed in init\r\n");

194 ià(!
pid
) {

195 
	`þo£
(0);close(1);close(2);

196 
	`£tsid
();

197 (è
	`Ý’
("/dev/‰y0",
O_RDWR
,0);

198 (è
	`dup
(0);

199 (è
	`dup
(0);

200 
	`_ex™
(
	`execve
("/bš/sh",
¬gv
,
’vp
));

203 ià(
pid
 =ð
	`wa™
(&
i
))

205 
	`´štf
("\n\rchžd %d d›d w™h cod%04x\n\r",
pid
,
i
);

206 
	`sync
();

211 
	`_ex™
(0);

212 
	}
}

	@kernel/blk_drv/blk.h

1 #iâdeà
_BLK_H


2 
	#_BLK_H


	)

4 
	#NR_BLK_DEV
 7

	)

15 
	#NR_REQUEST
 32

	)

23 
	s»que¡
 {

24 
	mdev
;

25 
	mcmd
;

26 
	m”rÜs
;

27 
	m£ùÜ
;

28 
	mÄ_£ùÜs
;

29 * 
	mbufãr
;

30 
sk_¡ruù
 * 
	mwa™šg
;

31 
bufãr_h—d
 * 
	mbh
;

32 
»que¡
 * 
	mÃxt
;

40 
	#IN_ORDER
(
s1
,
s2
) \

41 ((
s1
)->
cmd
<(
s2
)->cmd || (s1)->cmd==(s2)->cmd && \

42 ((
s1
)->
dev
 < (
s2
)->dev || ((s1)->dev == (s2)->dev && \

43 (
s1
)->
£ùÜ
 < (
s2
)->£ùÜ)))

	)

45 
	sblk_dev_¡ruù
 {

46 (*
	m»que¡_â
)();

47 
»que¡
 * 
	mcu¼’t_»que¡
;

50 
blk_dev_¡ruù
 
blk_dev
[
NR_BLK_DEV
];

51 
»que¡
„eque¡[
NR_REQUEST
];

52 
sk_¡ruù
 * 
wa™_fÜ_»que¡
;

54 #ifdeà
MAJOR_NR


61 #ià(
MAJOR_NR
 == 1)

63 
	#DEVICE_NAME
 "¿mdisk"

	)

64 
	#DEVICE_REQUEST
 
do_rd_»que¡


	)

65 
	#DEVICE_NR
(
deviû
è((deviûè& 7)

	)

66 
	#DEVICE_ON
(
deviû
)

	)

67 
	#DEVICE_OFF
(
deviû
)

	)

69 #–ià(
MAJOR_NR
 == 2)

71 
	#DEVICE_NAME
 "æÝpy"

	)

72 
	#DEVICE_INTR
 
do_æÝpy


	)

73 
	#DEVICE_REQUEST
 
do_fd_»que¡


	)

74 
	#DEVICE_NR
(
deviû
è((deviûè& 3)

	)

75 
	#DEVICE_ON
(
deviû
è
	`æÝpy_Ú
(
	`DEVICE_NR
(deviû))

	)

76 
	#DEVICE_OFF
(
deviû
è
	`æÝpy_off
(
	`DEVICE_NR
(deviû))

	)

78 #–ià(
MAJOR_NR
 == 3)

80 
	#DEVICE_NAME
 "h¬ddisk"

	)

81 
	#DEVICE_INTR
 
do_hd


	)

82 
	#DEVICE_REQUEST
 
do_hd_»que¡


	)

83 
	#DEVICE_NR
(
deviû
è(
	`MINOR
(deviû)/5)

	)

84 
	#DEVICE_ON
(
deviû
)

	)

85 
	#DEVICE_OFF
(
deviû
)

	)

93 
	#CURRENT
 (
blk_dev
[
MAJOR_NR
].
cu¼’t_»que¡
)

	)

94 
	#CURRENT_DEV
 
	`DEVICE_NR
(
CURRENT
->
dev
)

	)

96 #ifdeà
DEVICE_INTR


97 (*
DEVICE_INTR
)(èð
NULL
;

99 (
DEVICE_REQUEST
)();

101 
šlše
 
	$uÆock_bufãr
(
bufãr_h—d
 * 
bh
)

103 ià(!
bh
->
b_lock
)

104 
	`´štk
(
DEVICE_NAME
 ": free buffer being unlocked\n");

105 
bh
->
b_lock
=0;

106 
	`wake_up
(&
bh
->
b_wa™
);

107 
	}
}

109 
šlše
 
	$’d_»que¡
(
u±od©e
)

111 
	`DEVICE_OFF
(
CURRENT
->
dev
);

112 ià(
CURRENT
->
bh
) {

113 
CURRENT
->
bh
->
b_u±od©e
 = 
u±od©e
;

114 
	`uÆock_bufãr
(
CURRENT
->
bh
);

116 ià(!
u±od©e
) {

117 
	`´štk
(
DEVICE_NAME
 " I/Oƒrror\n\r");

118 
	`´štk
("dev %04x, block %d\n\r",
CURRENT
->
dev
,

119 
CURRENT
->
bh
->
b_blockÄ
);

121 
	`wake_up
(&
CURRENT
->
wa™šg
);

122 
	`wake_up
(&
wa™_fÜ_»que¡
);

123 
CURRENT
->
dev
 = -1;

124 
CURRENT
 = CURRENT->
Ãxt
;

125 
	}
}

127 
	#INIT_REQUEST
 \

128 
»³©
: \

129 ià(!
CURRENT
) \

131 ià(
	`MAJOR
(
CURRENT
->
dev
è!ð
MAJOR_NR
) \

132 
	`·nic
(
DEVICE_NAME
 ":„equest†ist destroyed"); \

133 ià(
CURRENT
->
bh
) { \

134 ià(!
CURRENT
->
bh
->
b_lock
) \

135 
	`·nic
(
DEVICE_NAME
 ": block‚ot†ocked"); \

136 }

	)

	@kernel/blk_drv/floppy.c

33 
	~<lšux/sched.h
>

34 
	~<lšux/fs.h
>

35 
	~<lšux/k”Ãl.h
>

36 
	~<lšux/fd»g.h
>

37 
	~<asm/sy¡em.h
>

38 
	~<asm/io.h
>

39 
	~<asm/£gm’t.h
>

41 
	#MAJOR_NR
 2

	)

42 
	~"blk.h
"

44 
	g»ÿlib¿‹
 = 0;

45 
	g»£t
 = 0;

46 
	g£ek
 = 0;

48 
cu¼’t_DOR
;

50 
	#immoutb_p
(
v®
,
pÜt
) \

51 
	`__asm__
("outb %0,%1\n\tjm°1f\n1:\tjm°1f\n1:"::"a" ((è(
v®
)),"i" (
pÜt
))

	)

53 
	#TYPE
(
x
è((x)>>2)

	)

54 
	#DRIVE
(
x
è((x)&0x03)

	)

60 
	#MAX_ERRORS
 8

	)

65 
	#MAX_REPLIES
 7

	)

66 
	g»¶y_bufãr
[
MAX_REPLIES
];

67 
	#ST0
 (
»¶y_bufãr
[0])

	)

68 
	#ST1
 (
»¶y_bufãr
[1])

	)

69 
	#ST2
 (
»¶y_bufãr
[2])

	)

70 
	#ST3
 (
»¶y_bufãr
[3])

	)

82 
	sæÝpy_¡ruù
 {

83 
	msize
, 
	m£ù
, 
	mh—d
, 
	mŒack
, 
	m¡»tch
;

84 
	mg­
,
	m¿‹
,
	m¥ec1
;

85 } 
	gæÝpy_ty³
[] = {

104 
æÝpy_š‹¼u±
();

105 
tmp_æÝpy_¬—
[1024];

112 
	gcur_¥ec1
 = -1;

113 
	gcur_¿‹
 = -1;

114 
æÝpy_¡ruù
 * 
	gæÝpy
 = 
æÝpy_ty³
;

115 
	gcu¼’t_drive
 = 0;

116 
	g£ùÜ
 = 0;

117 
	gh—d
 = 0;

118 
	gŒack
 = 0;

119 
	g£ek_Œack
 = 0;

120 
	gcu¼’t_Œack
 = 255;

121 
	gcommªd
 = 0;

122 
	g£Ëùed
 = 0;

123 
sk_¡ruù
 * 
	gwa™_Ú_æÝpy_£Ëù
 = 
NULL
;

125 
	$æÝpy_de£Ëù
(
Ä
)

127 ià(
Ä
 !ð(
cu¼’t_DOR
 & 3))

128 
	`´štk
("floppy_deselect: drive‚ot selected\n\r");

129 
£Ëùed
 = 0;

130 
	`wake_up
(&
wa™_Ú_æÝpy_£Ëù
);

131 
	}
}

139 
	$æÝpy_chªge
(
Ä
)

141 
»³©
:

142 
	`æÝpy_Ú
(
Ä
);

143 (
cu¼’t_DOR
 & 3è!ð
Ä
 && 
£Ëùed
)

144 
	`š‹¼u±ibË_¦“p_Ú
(&
wa™_Ú_æÝpy_£Ëù
);

145 ià((
cu¼’t_DOR
 & 3è!ð
Ä
)

146 
»³©
;

147 ià(
	`šb
(
FD_DIR
) & 0x80) {

148 
	`æÝpy_off
(
Ä
);

151 
	`æÝpy_off
(
Ä
);

153 
	}
}

155 
	#cÝy_bufãr
(
äom
,
to
) \

156 
	`__asm__
("cld ;„ep ; movsl" \

157 ::"c" (
BLOCK_SIZE
/4),"S" (()(
äom
)),"D" (()(
to
)) \

158 :"cx","di","si")

	)

160 
	$£tup_DMA
()

162 
addr
 = (è
CURRENT
->
bufãr
;

164 
	`þi
();

165 ià(
addr
 >= 0x100000) {

166 
addr
 = (è
tmp_æÝpy_¬—
;

167 ià(
commªd
 =ð
FD_WRITE
)

168 
	`cÝy_bufãr
(
CURRENT
->
bufãr
,
tmp_æÝpy_¬—
);

171 
	`immoutb_p
(4|2,10);

174 
	`__asm__
("outb %%al,$12\n\tjmp 1f\n1:\tjmp 1f\n1:\t"

176 "a" ((è((
commªd
 =ð
FD_READ
)?
DMA_READ
:
DMA_WRITE
)));

178 
	`immoutb_p
(
addr
,4);

179 
addr
 >>= 8;

181 
	`immoutb_p
(
addr
,4);

182 
addr
 >>= 8;

184 
	`immoutb_p
(
addr
,0x81);

186 
	`immoutb_p
(0xff,5);

188 
	`immoutb_p
(3,5);

190 
	`immoutb_p
(0|2,10);

191 
	`¡i
();

192 
	}
}

194 
	$ouut_by‹
(
by‹
)

196 
couÁ”
;

197 
¡©us
;

199 ià(
»£t
)

201 
couÁ”
 = 0 ; counter < 10000 ; counter++) {

202 
¡©us
 = 
	`šb_p
(
FD_STATUS
è& (
STATUS_READY
 | 
STATUS_DIR
);

203 ià(
¡©us
 =ð
STATUS_READY
) {

204 
	`outb
(
by‹
,
FD_DATA
);

208 
»£t
 = 1;

209 
	`´štk
("Unableo send byteo FDC\n\r");

210 
	}
}

212 
	$»suÉ
()

214 
i
 = 0, 
couÁ”
, 
¡©us
;

216 ià(
»£t
)

218 
couÁ”
 = 0 ; counter < 10000 ; counter++) {

219 
¡©us
 = 
	`šb_p
(
FD_STATUS
)&(
STATUS_DIR
|
STATUS_READY
|
STATUS_BUSY
);

220 ià(
¡©us
 =ð
STATUS_READY
)

221  
i
;

222 ià(
¡©us
 =ð(
STATUS_DIR
|
STATUS_READY
|
STATUS_BUSY
)) {

223 ià(
i
 >ð
MAX_REPLIES
)

225 
»¶y_bufãr
[
i
++] = 
	`šb_p
(
FD_DATA
);

228 
»£t
 = 1;

229 
	`´štk
("Getstatusimes out\n\r");

231 
	}
}

233 
	$bad_æp_šŒ
()

235 
CURRENT
->
”rÜs
++;

236 ià(
CURRENT
->
”rÜs
 > 
MAX_ERRORS
) {

237 
	`æÝpy_de£Ëù
(
cu¼’t_drive
);

238 
	`’d_»que¡
(0);

240 ià(
CURRENT
->
”rÜs
 > 
MAX_ERRORS
/2)

241 
»£t
 = 1;

243 
»ÿlib¿‹
 = 1;

244 
	}
}

250 
	$rw_š‹¼u±
()

252 ià(
	`»suÉ
(è!ð7 || (
ST0
 & 0xf8è|| (
ST1
 & 0xbfè|| (
ST2
 & 0x73)) {

253 ià(
ST1
 & 0x02) {

254 
	`´štk
("Driv%d i wr™´Ùeùed\n\r",
cu¼’t_drive
);

255 
	`æÝpy_de£Ëù
(
cu¼’t_drive
);

256 
	`’d_»que¡
(0);

258 
	`bad_æp_šŒ
();

259 
	`do_fd_»que¡
();

262 ià(
commªd
 =ð
FD_READ
 && ()(
CURRENT
->
bufãr
) >= 0x100000)

263 
	`cÝy_bufãr
(
tmp_æÝpy_¬—
,
CURRENT
->
bufãr
);

264 
	`æÝpy_de£Ëù
(
cu¼’t_drive
);

265 
	`’d_»que¡
(1);

266 
	`do_fd_»que¡
();

267 
	}
}

269 
šlše
 
	$£tup_rw_æÝpy
()

271 
	`£tup_DMA
();

272 
do_æÝpy
 = 
rw_š‹¼u±
;

273 
	`ouut_by‹
(
commªd
);

274 
	`ouut_by‹
(
h—d
<<2 | 
cu¼’t_drive
);

275 
	`ouut_by‹
(
Œack
);

276 
	`ouut_by‹
(
h—d
);

277 
	`ouut_by‹
(
£ùÜ
);

278 
	`ouut_by‹
(2);

279 
	`ouut_by‹
(
æÝpy
->
£ù
);

280 
	`ouut_by‹
(
æÝpy
->
g­
);

281 
	`ouut_by‹
(0xFF);

282 ià(
»£t
)

283 
	`do_fd_»que¡
();

284 
	}
}

291 
	$£ek_š‹¼u±
()

294 
	`ouut_by‹
(
FD_SENSEI
);

295 ià(
	`»suÉ
(è!ð2 || (
ST0
 & 0xF8è!ð0x20 || 
ST1
 !ð
£ek_Œack
) {

296 
	`bad_æp_šŒ
();

297 
	`do_fd_»que¡
();

300 
cu¼’t_Œack
 = 
ST1
;

301 
	`£tup_rw_æÝpy
();

302 
	}
}

309 
	$Œªsãr
()

311 ià(
cur_¥ec1
 !ð
æÝpy
->
¥ec1
) {

312 
cur_¥ec1
 = 
æÝpy
->
¥ec1
;

313 
	`ouut_by‹
(
FD_SPECIFY
);

314 
	`ouut_by‹
(
cur_¥ec1
);

315 
	`ouut_by‹
(6);

317 ià(
cur_¿‹
 !ð
æÝpy
->
¿‹
)

318 
	`outb_p
(
cur_¿‹
 = 
æÝpy
->
¿‹
,
FD_DCR
);

319 ià(
»£t
) {

320 
	`do_fd_»que¡
();

323 ià(!
£ek
) {

324 
	`£tup_rw_æÝpy
();

327 
do_æÝpy
 = 
£ek_š‹¼u±
;

328 ià(
£ek_Œack
) {

329 
	`ouut_by‹
(
FD_SEEK
);

330 
	`ouut_by‹
(
h—d
<<2 | 
cu¼’t_drive
);

331 
	`ouut_by‹
(
£ek_Œack
);

333 
	`ouut_by‹
(
FD_RECALIBRATE
);

334 
	`ouut_by‹
(
h—d
<<2 | 
cu¼’t_drive
);

336 ià(
»£t
)

337 
	`do_fd_»que¡
();

338 
	}
}

343 
	$»ÿl_š‹¼u±
()

345 
	`ouut_by‹
(
FD_SENSEI
);

346 ià(
	`»suÉ
()!=2 || (
ST0
 & 0xE0) == 0x60)

347 
»£t
 = 1;

349 
»ÿlib¿‹
 = 0;

350 
	`do_fd_»que¡
();

351 
	}
}

353 
	$uÃx³ùed_æÝpy_š‹¼u±
()

355 
	`ouut_by‹
(
FD_SENSEI
);

356 ià(
	`»suÉ
()!=2 || (
ST0
 & 0xE0) == 0x60)

357 
»£t
 = 1;

359 
»ÿlib¿‹
 = 1;

360 
	}
}

362 
	$»ÿlib¿‹_æÝpy
()

364 
»ÿlib¿‹
 = 0;

365 
cu¼’t_Œack
 = 0;

366 
do_æÝpy
 = 
»ÿl_š‹¼u±
;

367 
	`ouut_by‹
(
FD_RECALIBRATE
);

368 
	`ouut_by‹
(
h—d
<<2 | 
cu¼’t_drive
);

369 ià(
»£t
)

370 
	`do_fd_»que¡
();

371 
	}
}

373 
	$»£t_š‹¼u±
()

375 
	`ouut_by‹
(
FD_SENSEI
);

376 (è
	`»suÉ
();

377 
	`ouut_by‹
(
FD_SPECIFY
);

378 
	`ouut_by‹
(
cur_¥ec1
);

379 
	`ouut_by‹
(6);

380 
	`do_fd_»que¡
();

381 
	}
}

386 
	$»£t_æÝpy
()

388 
i
;

390 
»£t
 = 0;

391 
cur_¥ec1
 = -1;

392 
cur_¿‹
 = -1;

393 
»ÿlib¿‹
 = 1;

394 
	`´štk
("Reset-floppy called\n\r");

395 
	`þi
();

396 
do_æÝpy
 = 
»£t_š‹¼u±
;

397 
	`outb_p
(
cu¼’t_DOR
 & ~0x04,
FD_DOR
);

398 
i
=0 ; i<100 ; i++)

399 
	`__asm__
("nop");

400 
	`outb
(
cu¼’t_DOR
,
FD_DOR
);

401 
	`¡i
();

402 
	}
}

404 
	$æÝpy_Ú_š‹¼u±
()

407 
£Ëùed
 = 1;

408 ià(
cu¼’t_drive
 !ð(
cu¼’t_DOR
 & 3)) {

409 
cu¼’t_DOR
 &= 0xFC;

410 
cu¼’t_DOR
 |ð
cu¼’t_drive
;

411 
	`outb
(
cu¼’t_DOR
,
FD_DOR
);

412 
	`add_tim”
(2,&
Œªsãr
);

414 
	`Œªsãr
();

415 
	}
}

417 
	$do_fd_»que¡
()

419 
block
;

421 
£ek
 = 0;

422 ià(
»£t
) {

423 
	`»£t_æÝpy
();

426 ià(
»ÿlib¿‹
) {

427 
	`»ÿlib¿‹_æÝpy
();

430 
INIT_REQUEST
;

431 
æÝpy
 = (
	`MINOR
(
CURRENT
->
dev
)>>2è+ 
æÝpy_ty³
;

432 ià(
cu¼’t_drive
 !ð
CURRENT_DEV
)

433 
£ek
 = 1;

434 
cu¼’t_drive
 = 
CURRENT_DEV
;

435 
block
 = 
CURRENT
->
£ùÜ
;

436 ià(
block
+2 > 
æÝpy
->
size
) {

437 
	`’d_»que¡
(0);

438 
»³©
;

440 
£ùÜ
 = 
block
 % 
æÝpy
->
£ù
;

441 
block
 /ð
æÝpy
->
£ù
;

442 
h—d
 = 
block
 % 
æÝpy
->head;

443 
Œack
 = 
block
 / 
æÝpy
->
h—d
;

444 
£ek_Œack
 = 
Œack
 << 
æÝpy
->
¡»tch
;

445 ià(
£ek_Œack
 !ð
cu¼’t_Œack
)

446 
£ek
 = 1;

447 
£ùÜ
++;

448 ià(
CURRENT
->
cmd
 =ð
READ
)

449 
commªd
 = 
FD_READ
;

450 ià(
CURRENT
->
cmd
 =ð
WRITE
)

451 
commªd
 = 
FD_WRITE
;

453 
	`·nic
("do_fd_request: unknown command");

454 
	`add_tim”
(
	`ticks_to_æÝpy_Ú
(
cu¼’t_drive
),&
æÝpy_Ú_š‹¼u±
);

455 
	}
}

457 
	$æÝpy_š™
()

459 
blk_dev
[
MAJOR_NR
].
»que¡_â
 = 
DEVICE_REQUEST
;

460 
	`£t_Œ­_g©e
(0x26,&
æÝpy_š‹¼u±
);

461 
	`outb
(
	`šb_p
(0x21)&~0x40,0x21);

462 
	}
}

	@kernel/blk_drv/hd.c

16 
	~<lšux/cÚfig.h
>

17 
	~<lšux/sched.h
>

18 
	~<lšux/fs.h
>

19 
	~<lšux/k”Ãl.h
>

20 
	~<lšux/hd»g.h
>

21 
	~<asm/sy¡em.h
>

22 
	~<asm/io.h
>

23 
	~<asm/£gm’t.h
>

25 
	#MAJOR_NR
 3

	)

26 
	~"blk.h
"

28 
	#CMOS_READ
(
addr
) ({ \

29 
	`outb_p
(0x80|
addr
,0x70); \

30 
	`šb_p
(0x71); \

31 })

	)

34 
	#MAX_ERRORS
 7

	)

35 
	#MAX_HD
 2

	)

37 
»ÿl_šŒ
();

39 
	g»ÿlib¿‹
 = 1;

40 
	g»£t
 = 1;

45 
	shd_i_¡ruù
 {

46 
	mh—d
,
	m£ù
,
	mcyl
,
	mwpcom
,
	mlzÚe
,
	mùl
;

48 #ifdeà
HD_TYPE


49 
hd_i_¡ruù
 
	ghd_šfo
[] = { 
HD_TYPE
 };

50 
	#NR_HD
 (( (
hd_šfo
))/( (
hd_i_¡ruù
)))

	)

52 
hd_i_¡ruù
 
	ghd_šfo
[] = { {0,0,0,0,0,0},{0,0,0,0,0,0} };

53 
	gNR_HD
 = 0;

56 
	shd_¡ruù
 {

57 
	m¡¬t_£ù
;

58 
	mÄ_£ùs
;

59 } 
	ghd
[5*
MAX_HD
]={{0,0},};

61 
	#pÜt_»ad
(
pÜt
,
buf
,
Ä
) \

62 
	`__asm__
("þd;»p;šsw"::"d" (
pÜt
),"D" (
buf
),"c" (
Ä
):"cx","di")

	)

64 
	#pÜt_wr™e
(
pÜt
,
buf
,
Ä
) \

65 
	`__asm__
("þd;»p;outsw"::"d" (
pÜt
),"S" (
buf
),"c" (
Ä
):"cx","si")

	)

67 
hd_š‹¼u±
();

68 
rd_lßd
();

71 
	$sys_£tup
(* 
BIOS
)

73 
ÿÎabË
 = 1;

74 
i
,
drive
;

75 
cmos_disks
;

76 
·¹™iÚ
 *
p
;

77 
bufãr_h—d
 * 
bh
;

79 ià(!
ÿÎabË
)

81 
ÿÎabË
 = 0;

82 #iâdeà
HD_TYPE


83 
drive
=0 ; drive<2 ; drive++) {

84 
hd_šfo
[
drive
].
cyl
 = *(*è
BIOS
;

85 
hd_šfo
[
drive
].
h—d
 = *(*è(2+
BIOS
);

86 
hd_šfo
[
drive
].
wpcom
 = *(*è(5+
BIOS
);

87 
hd_šfo
[
drive
].
ùl
 = *(*è(8+
BIOS
);

88 
hd_šfo
[
drive
].
lzÚe
 = *(*è(12+
BIOS
);

89 
hd_šfo
[
drive
].
£ù
 = *(*è(14+
BIOS
);

90 
BIOS
 += 16;

92 ià(
hd_šfo
[1].
cyl
)

93 
NR_HD
=2;

95 
NR_HD
=1;

97 
i
=0 ; i<
NR_HD
 ; i++) {

98 
hd
[
i
*5].
¡¬t_£ù
 = 0;

99 
hd
[
i
*5].
Ä_£ùs
 = 
hd_šfo
[i].
h—d
*

100 
hd_šfo
[
i
].
£ù
*hd_šfo[i].
cyl
;

125 ià((
cmos_disks
 = 
	`CMOS_READ
(0x12)) & 0xf0)

126 ià(
cmos_disks
 & 0x0f)

127 
NR_HD
 = 2;

129 
NR_HD
 = 1;

131 
NR_HD
 = 0;

132 
i
 = 
NR_HD
 ; i < 2 ; i++) {

133 
hd
[
i
*5].
¡¬t_£ù
 = 0;

134 
hd
[
i
*5].
Ä_£ùs
 = 0;

136 
drive
=0 ; drive<
NR_HD
 ; drive++) {

137 ià(!(
bh
 = 
	`b»ad
(0x300 + 
drive
*5,0))) {

138 
	`´štk
("Unableo„ead…artitionable of drive %d\n\r",

139 
drive
);

140 
	`·nic
("");

142 ià(
bh
->
b_d©a
[510] != 0x55 || ()

143 
bh
->
b_d©a
[511] != 0xAA) {

144 
	`´štk
("Bad…¬t™iÚabË oÀdriv%d\n\r",
drive
);

145 
	`·nic
("");

147 
p
 = 0x1BE + (*)
bh
->
b_d©a
;

148 
i
=1;i<5;i++,
p
++) {

149 
hd
[
i
+5*
drive
].
¡¬t_£ù
 = 
p
->start_sect;

150 
hd
[
i
+5*
drive
].
Ä_£ùs
 = 
p
->nr_sects;

152 
	`b»l£
(
bh
);

154 ià(
NR_HD
)

155 
	`´štk
("P¬t™iÚabË% ok.\n\r",(
NR_HD
>1)?"s":"");

156 
	`rd_lßd
();

157 
	`mouÁ_roÙ
();

159 
	}
}

161 
	$cÚŒÞËr_»ady
()

163 
»Œ›s
=10000;

165 --
»Œ›s
 && (
	`šb_p
(
HD_STATUS
)&0xc0)!=0x40);

166  (
»Œ›s
);

167 
	}
}

169 
	$wš_»suÉ
()

171 
i
=
	`šb_p
(
HD_STATUS
);

173 ià((
i
 & (
BUSY_STAT
 | 
READY_STAT
 | 
WRERR_STAT
 | 
SEEK_STAT
 | 
ERR_STAT
))

174 =ð(
READY_STAT
 | 
SEEK_STAT
))

176 ià(
i
&1èi=
	`šb
(
HD_ERROR
);

178 
	}
}

180 
	$hd_out
(
drive
,
n£ù
,
£ù
,

181 
h—d
,
cyl
,
cmd
,

182 (*
šŒ_addr
)())

184 
pÜt
 
	`asm
("dx");

186 ià(
drive
>1 || 
h—d
>15)

187 
	`·nic
("Tryingo write bad sector");

188 ià(!
	`cÚŒÞËr_»ady
())

189 
	`·nic
("HD controller‚ot„eady");

190 
do_hd
 = 
šŒ_addr
;

191 
	`outb_p
(
hd_šfo
[
drive
].
ùl
,
HD_CMD
);

192 
pÜt
=
HD_DATA
;

193 
	`outb_p
(
hd_šfo
[
drive
].
wpcom
>>2,++
pÜt
);

194 
	`outb_p
(
n£ù
,++
pÜt
);

195 
	`outb_p
(
£ù
,++
pÜt
);

196 
	`outb_p
(
cyl
,++
pÜt
);

197 
	`outb_p
(
cyl
>>8,++
pÜt
);

198 
	`outb_p
(0xA0|(
drive
<<4)|
h—d
,++
pÜt
);

199 
	`outb
(
cmd
,++
pÜt
);

200 
	}
}

202 
	$drive_busy
()

204 
i
;

206 
i
 = 0; i < 10000; i++)

207 ià(
READY_STAT
 =ð(
	`šb_p
(
HD_STATUS
è& (
BUSY_STAT
|READY_STAT)))

209 
i
 = 
	`šb
(
HD_STATUS
);

210 
i
 &ð
BUSY_STAT
 | 
READY_STAT
 | 
SEEK_STAT
;

211 ià(
i
 =ð
READY_STAT
 | 
SEEK_STAT
)

213 
	`´štk
("HD controllerimes out\n\r");

215 
	}
}

217 
	$»£t_cÚŒÞËr
()

219 
i
;

221 
	`outb
(4,
HD_CMD
);

222 
i
 = 0; i < 100; i++è
	`nÝ
();

223 
	`outb
(
hd_šfo
[0].
ùl
 & 0x0à,
HD_CMD
);

224 ià(
	`drive_busy
())

225 
	`´štk
("HD-controller still busy\n\r");

226 ià((
i
 = 
	`šb
(
HD_ERROR
)) != 1)

227 
	`´štk
("HD-cÚŒÞË¸»£ˆçžed: %02x\n\r",
i
);

228 
	}
}

230 
	$»£t_hd
(
Ä
)

232 
	`»£t_cÚŒÞËr
();

233 
	`hd_out
(
Ä
,
hd_šfo
[Ä].
£ù
,hd_šfo[Ä].£ù,hd_šfo[Ä].
h—d
-1,

234 
hd_šfo
[
Ä
].
cyl
,
WIN_SPECIFY
,&
»ÿl_šŒ
);

235 
	}
}

237 
	$uÃx³ùed_hd_š‹¼u±
()

239 
	`´štk
("Unexpected HD interrupt\n\r");

240 
	}
}

242 
	$bad_rw_šŒ
()

244 ià(++
CURRENT
->
”rÜs
 >ð
MAX_ERRORS
)

245 
	`’d_»que¡
(0);

246 ià(
CURRENT
->
”rÜs
 > 
MAX_ERRORS
/2)

247 
»£t
 = 1;

248 
	}
}

250 
	$»ad_šŒ
()

252 ià(
	`wš_»suÉ
()) {

253 
	`bad_rw_šŒ
();

254 
	`do_hd_»que¡
();

257 
	`pÜt_»ad
(
HD_DATA
,
CURRENT
->
bufãr
,256);

258 
CURRENT
->
”rÜs
 = 0;

259 
CURRENT
->
bufãr
 += 512;

260 
CURRENT
->
£ùÜ
++;

261 ià(--
CURRENT
->
Ä_£ùÜs
) {

262 
do_hd
 = &
»ad_šŒ
;

265 
	`’d_»que¡
(1);

266 
	`do_hd_»que¡
();

267 
	}
}

269 
	$wr™e_šŒ
()

271 ià(
	`wš_»suÉ
()) {

272 
	`bad_rw_šŒ
();

273 
	`do_hd_»que¡
();

276 ià(--
CURRENT
->
Ä_£ùÜs
) {

277 
CURRENT
->
£ùÜ
++;

278 
CURRENT
->
bufãr
 += 512;

279 
do_hd
 = &
wr™e_šŒ
;

280 
	`pÜt_wr™e
(
HD_DATA
,
CURRENT
->
bufãr
,256);

283 
	`’d_»que¡
(1);

284 
	`do_hd_»que¡
();

285 
	}
}

287 
	$»ÿl_šŒ
()

289 ià(
	`wš_»suÉ
())

290 
	`bad_rw_šŒ
();

291 
	`do_hd_»que¡
();

292 
	}
}

294 
	$do_hd_»que¡
()

296 
i
,
r
;

297 
block
,
dev
;

298 
£c
,
h—d
,
cyl
;

299 
n£ù
;

301 
INIT_REQUEST
;

302 
dev
 = 
	`MINOR
(
CURRENT
->dev);

303 
block
 = 
CURRENT
->
£ùÜ
;

304 ià(
dev
 >ð5*
NR_HD
 || 
block
+2 > 
hd
[dev].
Ä_£ùs
) {

305 
	`’d_»que¡
(0);

306 
»³©
;

308 
block
 +ð
hd
[
dev
].
¡¬t_£ù
;

309 
dev
 /= 5;

310 
	`__asm__
("divÈ%4":"÷" (
block
),"=d" (
£c
):"0" (block),"1" (0),

311 "r" (
hd_šfo
[
dev
].
£ù
));

312 
	`__asm__
("divÈ%4":"÷" (
cyl
),"=d" (
h—d
):"0" (
block
),"1" (0),

313 "r" (
hd_šfo
[
dev
].
h—d
));

314 
£c
++;

315 
n£ù
 = 
CURRENT
->
Ä_£ùÜs
;

316 ià(
»£t
) {

317 
»£t
 = 0;

318 
»ÿlib¿‹
 = 1;

319 
	`»£t_hd
(
CURRENT_DEV
);

322 ià(
»ÿlib¿‹
) {

323 
»ÿlib¿‹
 = 0;

324 
	`hd_out
(
dev
,
hd_šfo
[
CURRENT_DEV
].
£ù
,0,0,0,

325 
WIN_RESTORE
,&
»ÿl_šŒ
);

328 ià(
CURRENT
->
cmd
 =ð
WRITE
) {

329 
	`hd_out
(
dev
,
n£ù
,
£c
,
h—d
,
cyl
,
WIN_WRITE
,&
wr™e_šŒ
);

330 
i
=0 ; i<3000 && !(
r
=
	`šb_p
(
HD_STATUS
)&
DRQ_STAT
) ; i++)

332 ià(!
r
) {

333 
	`bad_rw_šŒ
();

334 
»³©
;

336 
	`pÜt_wr™e
(
HD_DATA
,
CURRENT
->
bufãr
,256);

337 } ià(
CURRENT
->
cmd
 =ð
READ
) {

338 
	`hd_out
(
dev
,
n£ù
,
£c
,
h—d
,
cyl
,
WIN_READ
,&
»ad_šŒ
);

340 
	`·nic
("unknown hd-command");

341 
	}
}

343 
	$hd_š™
()

345 
blk_dev
[
MAJOR_NR
].
»que¡_â
 = 
DEVICE_REQUEST
;

346 
	`£t_šŒ_g©e
(0x2E,&
hd_š‹¼u±
);

347 
	`outb_p
(
	`šb_p
(0x21)&0xfb,0x21);

348 
	`outb
(
	`šb_p
(0xA1)&0xbf,0xA1);

349 
	}
}

	@kernel/blk_drv/ll_rw_blk.c

10 
	~<”ºo.h
>

11 
	~<lšux/sched.h
>

12 
	~<lšux/k”Ãl.h
>

13 
	~<asm/sy¡em.h
>

15 
	~"blk.h
"

21 
»que¡
 
	g»que¡
[
NR_REQUEST
];

26 
sk_¡ruù
 * 
	gwa™_fÜ_»que¡
 = 
NULL
;

32 
blk_dev_¡ruù
 
	gblk_dev
[
NR_BLK_DEV
] = {

33 { 
NULL
, NULL },

34 { 
NULL
, NULL },

35 { 
NULL
, NULL },

36 { 
NULL
, NULL },

37 { 
NULL
, NULL },

38 { 
NULL
, NULL },

39 { 
NULL
, NULL }

42 
šlše
 
	$lock_bufãr
(
bufãr_h—d
 * 
bh
)

44 
	`þi
();

45 
bh
->
b_lock
)

46 
	`¦“p_Ú
(&
bh
->
b_wa™
);

47 
bh
->
b_lock
=1;

48 
	`¡i
();

49 
	}
}

51 
šlše
 
	$uÆock_bufãr
(
bufãr_h—d
 * 
bh
)

53 ià(!
bh
->
b_lock
)

54 
	`´štk
("ll_rw_block.c: buffer‚ot†ocked\n\r");

55 
bh
->
b_lock
 = 0;

56 
	`wake_up
(&
bh
->
b_wa™
);

57 
	}
}

64 
	$add_»que¡
(
blk_dev_¡ruù
 * 
dev
, 
»que¡
 * 
»q
)

66 
»que¡
 * 
tmp
;

68 
»q
->
Ãxt
 = 
NULL
;

69 
	`þi
();

70 ià(
»q
->
bh
)

71 
»q
->
bh
->
b_dœt
 = 0;

72 ià(!(
tmp
 = 
dev
->
cu¼’t_»que¡
)) {

73 
dev
->
cu¼’t_»que¡
 = 
»q
;

74 
	`¡i
();

75 (
dev
->
»que¡_â
)();

78  ; 
tmp
->
Ãxt
 ;mp=tmp->next)

79 ià((
	`IN_ORDER
(
tmp
,
»q
) ||

80 !
	`IN_ORDER
(
tmp
,tmp->
Ãxt
)) &&

81 
	`IN_ORDER
(
»q
,
tmp
->
Ãxt
))

83 
»q
->
Ãxt
=
tmp
->next;

84 
tmp
->
Ãxt
=
»q
;

85 
	`¡i
();

86 
	}
}

88 
	$make_»que¡
(
majÜ
,
rw
, 
bufãr_h—d
 * 
bh
)

90 
»que¡
 * 
»q
;

91 
rw_ah—d
;

95 ià(
rw_ah—d
 = (
rw
 =ð
READA
 ||„w =ð
WRITEA
)) {

96 ià(
bh
->
b_lock
)

98 ià(
rw
 =ð
READA
)

99 
rw
 = 
READ
;

101 
rw
 = 
WRITE
;

103 ià(
rw
!=
READ
 &&„w!=
WRITE
)

104 
	`·nic
("Bad block dev command, must be R/W/RA/WA");

105 
	`lock_bufãr
(
bh
);

106 ià((
rw
 =ð
WRITE
 && !
bh
->
b_dœt
è|| (rw =ð
READ
 && bh->
b_u±od©e
)) {

107 
	`uÆock_bufãr
(
bh
);

110 
»³©
:

115 ià(
rw
 =ð
READ
)

116 
»q
 = 
»que¡
+
NR_REQUEST
;

118 
»q
 = 
»que¡
+((
NR_REQUEST
*2)/3);

120 --
»q
 >ð
»que¡
)

121 ià(
»q
->
dev
<0)

124 ià(
»q
 < 
»que¡
) {

125 ià(
rw_ah—d
) {

126 
	`uÆock_bufãr
(
bh
);

129 
	`¦“p_Ú
(&
wa™_fÜ_»que¡
);

130 
»³©
;

133 
»q
->
dev
 = 
bh
->
b_dev
;

134 
»q
->
cmd
 = 
rw
;

135 
»q
->
”rÜs
=0;

136 
»q
->
£ùÜ
 = 
bh
->
b_blockÄ
<<1;

137 
»q
->
Ä_£ùÜs
 = 2;

138 
»q
->
bufãr
 = 
bh
->
b_d©a
;

139 
»q
->
wa™šg
 = 
NULL
;

140 
»q
->
bh
 = bh;

141 
»q
->
Ãxt
 = 
NULL
;

142 
	`add_»que¡
(
majÜ
+
blk_dev
,
»q
);

143 
	}
}

145 
	$Î_rw_block
(
rw
, 
bufãr_h—d
 * 
bh
)

147 
majÜ
;

149 ià((
majÜ
=
	`MAJOR
(
bh
->
b_dev
)è>ð
NR_BLK_DEV
 ||

150 !(
blk_dev
[
majÜ
].
»que¡_â
)) {

151 
	`´štk
("Tryingo„ead‚onexistent block-device\n\r");

154 
	`make_»que¡
(
majÜ
,
rw
,
bh
);

155 
	}
}

157 
	$blk_dev_š™
()

159 
i
;

161 
i
=0 ; i<
NR_REQUEST
 ; i++) {

162 
»que¡
[
i
].
dev
 = -1;

163 
»que¡
[
i
].
Ãxt
 = 
NULL
;

165 
	}
}

	@kernel/blk_drv/ramdisk.c

7 
	~<¡ršg.h
>

9 
	~<lšux/cÚfig.h
>

10 
	~<lšux/sched.h
>

11 
	~<lšux/fs.h
>

12 
	~<lšux/k”Ãl.h
>

13 
	~<asm/sy¡em.h
>

14 
	~<asm/£gm’t.h
>

15 
	~<asm/memÜy.h
>

17 
	#MAJOR_NR
 1

	)

18 
	~"blk.h
"

20 *
	grd_¡¬t
;

21 
	grd_Ëngth
 = 0;

23 
	$do_rd_»que¡
()

25 
Ën
;

26 *
addr
;

28 
INIT_REQUEST
;

29 
addr
 = 
rd_¡¬t
 + (
CURRENT
->
£ùÜ
 << 9);

30 
Ën
 = 
CURRENT
->
Ä_£ùÜs
 << 9;

31 ià((
	`MINOR
(
CURRENT
->
dev
è!ð1è|| (
addr
+
Ën
 > 
rd_¡¬t
+
rd_Ëngth
)) {

32 
	`’d_»que¡
(0);

33 
»³©
;

35 ià(
CURRENT
-> 
cmd
 =ð
WRITE
) {

36 (è
	`memýy
(
addr
,

37 
CURRENT
->
bufãr
,

38 
Ën
);

39 } ià(
CURRENT
->
cmd
 =ð
READ
) {

40 (è
	`memýy
(
CURRENT
->
bufãr
,

41 
addr
,

42 
Ën
);

44 
	`·nic
("unknown„amdisk-command");

45 
	`’d_»que¡
(1);

46 
»³©
;

47 
	}
}

52 
	$rd_š™
(
mem_¡¬t
, 
Ëngth
)

54 
i
;

55 *
ý
;

57 
blk_dev
[
MAJOR_NR
].
»que¡_â
 = 
DEVICE_REQUEST
;

58 
rd_¡¬t
 = (*è
mem_¡¬t
;

59 
rd_Ëngth
 = 
Ëngth
;

60 
ý
 = 
rd_¡¬t
;

61 
i
=0; i < 
Ëngth
; i++)

62 *
ý
++ = '\0';

63 (
Ëngth
);

64 
	}
}

71 
	$rd_lßd
()

73 
bufãr_h—d
 *
bh
;

74 
su³r_block
 
s
;

75 
block
 = 256;

76 
i
 = 1;

77 
nblocks
;

78 *
ý
;

80 ià(!
rd_Ëngth
)

82 
	`´štk
("Ram disk: %d by‹s, s¹šg‡ˆ0x%x\n", 
rd_Ëngth
,

83 (è
rd_¡¬t
);

84 ià(
	`MAJOR
(
ROOT_DEV
) != 2)

86 
bh
 = 
	`b»ada
(
ROOT_DEV
,
block
+1,block,block+2,-1);

87 ià(!
bh
) {

88 
	`´štk
("Diskƒrror while†ooking for„amdisk!\n");

91 *((
d_su³r_block
 *è&
s
èð*((d_su³r_block *è
bh
->
b_d©a
);

92 
	`b»l£
(
bh
);

93 ià(
s
.
s_magic
 !ð
SUPER_MAGIC
)

96 
nblocks
 = 
s
.
s_nzÚes
 << s.
s_log_zÚe_size
;

97 ià(
nblocks
 > (
rd_Ëngth
 >> 
BLOCK_SIZE_BITS
)) {

98 
	`´štk
("Ram disk imageoo big! (%d blocks, %d‡vail)\n",

99 
nblocks
, 
rd_Ëngth
 >> 
BLOCK_SIZE_BITS
);

102 
	`´štk
("Loading %d bytes into„am disk... 0000k",

103 
nblocks
 << 
BLOCK_SIZE_BITS
);

104 
ý
 = 
rd_¡¬t
;

105 
nblocks
) {

106 ià(
nblocks
 > 2)

107 
bh
 = 
	`b»ada
(
ROOT_DEV
, 
block
, block+1, block+2, -1);

109 
bh
 = 
	`b»ad
(
ROOT_DEV
, 
block
);

110 ià(!
bh
) {

111 
	`´štk
("I/Oƒrror on block %d,‡borting†oad\n",

112 
block
);

115 (è
	`memýy
(
ý
, 
bh
->
b_d©a
, 
BLOCK_SIZE
);

116 
	`b»l£
(
bh
);

117 
	`´štk
("\010\010\010\010\010%4dk",
i
);

118 
ý
 +ð
BLOCK_SIZE
;

119 
block
++;

120 
nblocks
--;

121 
i
++;

123 
	`´štk
("\010\010\010\010\010done \n");

124 
ROOT_DEV
=0x0101;

125 
	}
}

	@kernel/chr_drv/console.c

30 
	~<lšux/sched.h
>

31 
	~<lšux/‰y.h
>

32 
	~<asm/io.h
>

33 
	~<asm/sy¡em.h
>

39 
	#ORIG_X
 (*(*)0x90000)

	)

40 
	#ORIG_Y
 (*(*)0x90001)

	)

41 
	#ORIG_VIDEO_PAGE
 (*(*)0x90004)

	)

42 
	#ORIG_VIDEO_MODE
 ((*(*)0x90006è& 0xff)

	)

43 
	#ORIG_VIDEO_COLS
 (((*(*)0x90006è& 0xff00è>> 8)

	)

44 
	#ORIG_VIDEO_LINES
 (25)

	)

45 
	#ORIG_VIDEO_EGA_AX
 (*(*)0x90008)

	)

46 
	#ORIG_VIDEO_EGA_BX
 (*(*)0x9000a)

	)

47 
	#ORIG_VIDEO_EGA_CX
 (*(*)0x9000c)

	)

49 
	#VIDEO_TYPE_MDA
 0x10

	)

50 
	#VIDEO_TYPE_CGA
 0x11

	)

51 
	#VIDEO_TYPE_EGAM
 0x20

	)

52 
	#VIDEO_TYPE_EGAC
 0x21

	)

54 
	#NPAR
 16

	)

56 
keybßrd_š‹¼u±
();

58 
	gvideo_ty³
;

59 
	gvideo_num_cÞumns
;

60 
	gvideo_size_row
;

61 
	gvideo_num_lšes
;

62 
	gvideo_·ge
;

63 
	gvideo_mem_¡¬t
;

64 
	gvideo_mem_’d
;

65 
	gvideo_pÜt_»g
;

66 
	gvideo_pÜt_v®
;

67 
	gvideo_”a£_ch¬
;

69 
	gÜigš
;

70 
	gsü_’d
;

71 
	gpos
;

72 
	gx
,
	gy
;

73 
	gtÝ
,
	gbÙtom
;

74 
	g¡©e
=0;

75 
	gÅ¬
,
	g·r
[
NPAR
];

76 
	gques
=0;

77 
	g©Œ
=0x07;

79 
sysb“p
();

85 
	#RESPONSE
 "\033[?1;2c"

	)

88 
šlše
 
	$gÙoxy
(
Ãw_x
,
Ãw_y
)

90 ià(
Ãw_x
 > 
video_num_cÞumns
 || 
Ãw_y
 >ð
video_num_lšes
)

92 
x
=
Ãw_x
;

93 
y
=
Ãw_y
;

94 
pos
=
Üigš
 + 
y
*
video_size_row
 + (
x
<<1);

95 
	}
}

97 
šlše
 
	$£t_Üigš
()

99 
	`þi
();

100 
	`outb_p
(12, 
video_pÜt_»g
);

101 
	`outb_p
(0xff&((
Üigš
-
video_mem_¡¬t
)>>9), 
video_pÜt_v®
);

102 
	`outb_p
(13, 
video_pÜt_»g
);

103 
	`outb_p
(0xff&((
Üigš
-
video_mem_¡¬t
)>>1), 
video_pÜt_v®
);

104 
	`¡i
();

105 
	}
}

107 
	$süup
()

109 ià(
video_ty³
 =ð
VIDEO_TYPE_EGAC
 || video_ty³ =ð
VIDEO_TYPE_EGAM
)

111 ià(!
tÝ
 && 
bÙtom
 =ð
video_num_lšes
) {

112 
Üigš
 +ð
video_size_row
;

113 
pos
 +ð
video_size_row
;

114 
sü_’d
 +ð
video_size_row
;

115 ià(
sü_’d
 > 
video_mem_’d
) {

116 
	`__asm__
("cld\n\t"

122 ::"a" (
video_”a£_ch¬
),

123 "c" ((
video_num_lšes
-1)*
video_num_cÞumns
>>1),

124 "D" (
video_mem_¡¬t
),

125 "S" (
Üigš
)

127 
sü_’d
 -ð
Üigš
-
video_mem_¡¬t
;

128 
pos
 -ð
Üigš
-
video_mem_¡¬t
;

129 
Üigš
 = 
video_mem_¡¬t
;

131 
	`__asm__
("cld\n\t"

134 ::"a" (
video_”a£_ch¬
),

135 "c" (
video_num_cÞumns
),

136 "D" (
sü_’d
-
video_size_row
)

139 
	`£t_Üigš
();

141 
	`__asm__
("cld\n\t"

147 ::"a" (
video_”a£_ch¬
),

148 "c" ((
bÙtom
-
tÝ
-1)*
video_num_cÞumns
>>1),

149 "D" (
Üigš
+
video_size_row
*
tÝ
),

150 "S" (
Üigš
+
video_size_row
*(
tÝ
+1))

156 
	`__asm__
("cld\n\t"

162 ::"a" (
video_”a£_ch¬
),

163 "c" ((
bÙtom
-
tÝ
-1)*
video_num_cÞumns
>>1),

164 "D" (
Üigš
+
video_size_row
*
tÝ
),

165 "S" (
Üigš
+
video_size_row
*(
tÝ
+1))

168 
	}
}

170 
	$südown
()

172 ià(
video_ty³
 =ð
VIDEO_TYPE_EGAC
 || video_ty³ =ð
VIDEO_TYPE_EGAM
)

174 
	`__asm__
("std\n\t"

181 ::"a" (
video_”a£_ch¬
),

182 "c" ((
bÙtom
-
tÝ
-1)*
video_num_cÞumns
>>1),

183 "D" (
Üigš
+
video_size_row
*
bÙtom
-4),

184 "S" (
Üigš
+
video_size_row
*(
bÙtom
-1)-4)

189 
	`__asm__
("std\n\t"

196 ::"a" (
video_”a£_ch¬
),

197 "c" ((
bÙtom
-
tÝ
-1)*
video_num_cÞumns
>>1),

198 "D" (
Üigš
+
video_size_row
*
bÙtom
-4),

199 "S" (
Üigš
+
video_size_row
*(
bÙtom
-1)-4)

202 
	}
}

204 
	$lf
()

206 ià(
y
+1<
bÙtom
) {

207 
y
++;

208 
pos
 +ð
video_size_row
;

211 
	`süup
();

212 
	}
}

214 
	$ri
()

216 ià(
y
>
tÝ
) {

217 
y
--;

218 
pos
 -ð
video_size_row
;

221 
	`südown
();

222 
	}
}

224 
	$ü
()

226 
pos
 -ð
x
<<1;

227 
x
=0;

228 
	}
}

230 
	$d–
()

232 ià(
x
) {

233 
pos
 -= 2;

234 
x
--;

235 *(*)
pos
 = 
video_”a£_ch¬
;

237 
	}
}

239 
	$csi_J
(
·r
)

241 
couÁ
 
	`__asm__
("cx");

242 
¡¬t
 
	`__asm__
("di");

244 
·r
) {

246 
couÁ
 = (
sü_’d
-
pos
)>>1;

247 
¡¬t
 = 
pos
;

250 
couÁ
 = (
pos
-
Üigš
)>>1;

251 
¡¬t
 = 
Üigš
;

254 
couÁ
 = 
video_num_cÞumns
 * 
video_num_lšes
;

255 
¡¬t
 = 
Üigš
;

260 
	`__asm__
("cld\n\t"

263 ::"c" (
couÁ
),

264 "D" (
¡¬t
),"a" (
video_”a£_ch¬
)

266 
	}
}

268 
	$csi_K
(
·r
)

270 
couÁ
 
	`__asm__
("cx");

271 
¡¬t
 
	`__asm__
("di");

273 
·r
) {

275 ià(
x
>=
video_num_cÞumns
)

277 
couÁ
 = 
video_num_cÞumns
-
x
;

278 
¡¬t
 = 
pos
;

281 
¡¬t
 = 
pos
 - (
x
<<1);

282 
couÁ
 = (
x
<
video_num_cÞumns
)?x:video_num_columns;

285 
¡¬t
 = 
pos
 - (
x
<<1);

286 
couÁ
 = 
video_num_cÞumns
;

291 
	`__asm__
("cld\n\t"

294 ::"c" (
couÁ
),

295 "D" (
¡¬t
),"a" (
video_”a£_ch¬
)

297 
	}
}

299 
	$csi_m
()

301 
i
;

303 
i
=0;i<=
Å¬
;i++)

304 
·r
[
i
]) {

305 0:
©Œ
=0x07;;

306 1:
©Œ
=0x0f;;

307 4:
©Œ
=0x0f;;

308 7:
©Œ
=0x70;;

309 27:
©Œ
=0x07;;

311 
	}
}

313 
šlše
 
	$£t_cursÜ
()

315 
	`þi
();

316 
	`outb_p
(14, 
video_pÜt_»g
);

317 
	`outb_p
(0xff&((
pos
-
video_mem_¡¬t
)>>9), 
video_pÜt_v®
);

318 
	`outb_p
(15, 
video_pÜt_»g
);

319 
	`outb_p
(0xff&((
pos
-
video_mem_¡¬t
)>>1), 
video_pÜt_v®
);

320 
	`¡i
();

321 
	}
}

323 
	$»¥Úd
(
‰y_¡ruù
 * 
‰y
)

325 * 
p
 = 
RESPONSE
;

327 
	`þi
();

328 *
p
) {

329 
	`PUTCH
(*
p
,
‰y
->
»ad_q
);

330 
p
++;

332 
	`¡i
();

333 
	`cÝy_to_cooked
(
‰y
);

334 
	}
}

336 
	$š£¹_ch¬
()

338 
i
=
x
;

339 
tmp
, 
Þd
 = 
video_”a£_ch¬
;

340 * 
p
 = (*è
pos
;

342 
i
++<
video_num_cÞumns
) {

343 
tmp
=*
p
;

344 *
p
=
Þd
;

345 
Þd
=
tmp
;

346 
p
++;

348 
	}
}

350 
	$š£¹_lše
()

352 
ÞdtÝ
,
ÞdbÙtom
;

354 
ÞdtÝ
=
tÝ
;

355 
ÞdbÙtom
=
bÙtom
;

356 
tÝ
=
y
;

357 
bÙtom
 = 
video_num_lšes
;

358 
	`südown
();

359 
tÝ
=
ÞdtÝ
;

360 
bÙtom
=
ÞdbÙtom
;

361 
	}
}

363 
	$d–‘e_ch¬
()

365 
i
;

366 * 
p
 = (*è
pos
;

368 ià(
x
>=
video_num_cÞumns
)

370 
i
 = 
x
;

371 ++
i
 < 
video_num_cÞumns
) {

372 *
p
 = *(p+1);

373 
p
++;

375 *
p
 = 
video_”a£_ch¬
;

376 
	}
}

378 
	$d–‘e_lše
()

380 
ÞdtÝ
,
ÞdbÙtom
;

382 
ÞdtÝ
=
tÝ
;

383 
ÞdbÙtom
=
bÙtom
;

384 
tÝ
=
y
;

385 
bÙtom
 = 
video_num_lšes
;

386 
	`süup
();

387 
tÝ
=
ÞdtÝ
;

388 
bÙtom
=
ÞdbÙtom
;

389 
	}
}

391 
	$csi_©
(
Ä
)

393 ià(
Ä
 > 
video_num_cÞumns
)

394 
Ä
 = 
video_num_cÞumns
;

395 ià(!
Ä
)

396 
Ä
 = 1;

397 
Ä
--)

398 
	`š£¹_ch¬
();

399 
	}
}

401 
	$csi_L
(
Ä
)

403 ià(
Ä
 > 
video_num_lšes
)

404 
Ä
 = 
video_num_lšes
;

405 ià(!
Ä
)

406 
Ä
 = 1;

407 
Ä
--)

408 
	`š£¹_lše
();

409 
	}
}

411 
	$csi_P
(
Ä
)

413 ià(
Ä
 > 
video_num_cÞumns
)

414 
Ä
 = 
video_num_cÞumns
;

415 ià(!
Ä
)

416 
Ä
 = 1;

417 
Ä
--)

418 
	`d–‘e_ch¬
();

419 
	}
}

421 
	$csi_M
(
Ä
)

423 ià(
Ä
 > 
video_num_lšes
)

424 
Ä
 = 
video_num_lšes
;

425 ià(!
Ä
)

426 
Ä
=1;

427 
Ä
--)

428 
	`d–‘e_lše
();

429 
	}
}

431 
	g§ved_x
=0;

432 
	g§ved_y
=0;

434 
	$§ve_cur
()

436 
§ved_x
=
x
;

437 
§ved_y
=
y
;

438 
	}
}

440 
	$»¡Üe_cur
()

442 
	`gÙoxy
(
§ved_x
, 
§ved_y
);

443 
	}
}

445 
	$cÚ_wr™e
(
‰y_¡ruù
 * 
‰y
)

447 
Ä
;

448 
c
;

450 
Ä
 = 
	`CHARS
(
‰y
->
wr™e_q
);

451 
Ä
--) {

452 
	`GETCH
(
‰y
->
wr™e_q
,
c
);

453 
¡©e
) {

455 ià(
c
>31 && c<127) {

456 ià(
x
>=
video_num_cÞumns
) {

457 
x
 -ð
video_num_cÞumns
;

458 
pos
 -ð
video_size_row
;

459 
	`lf
();

461 
	`__asm__
("movb _attr,%%ah\n\t"

463 ::"a" (
c
),"m" (*(*)
pos
)

465 
pos
 += 2;

466 
x
++;

467 } ià(
c
==27)

468 
¡©e
=1;

469 ià(
c
==10 || c==11 || c==12)

470 
	`lf
();

471 ià(
c
==13)

472 
	`ü
();

473 ià(
c
==
	`ERASE_CHAR
(
‰y
))

474 
	`d–
();

475 ià(
c
==8) {

476 ià(
x
) {

477 
x
--;

478 
pos
 -= 2;

480 } ià(
c
==9) {

481 
c
=8-(
x
&7);

482 
x
 +ð
c
;

483 
pos
 +ð
c
<<1;

484 ià(
x
>
video_num_cÞumns
) {

485 
x
 -ð
video_num_cÞumns
;

486 
pos
 -ð
video_size_row
;

487 
	`lf
();

489 
c
=9;

490 } ià(
c
==7)

491 
	`sysb“p
();

494 
¡©e
=0;

495 ià(
c
=='[')

496 
¡©e
=2;

497 ià(
c
=='E')

498 
	`gÙoxy
(0,
y
+1);

499 ià(
c
=='M')

500 
	`ri
();

501 ià(
c
=='D')

502 
	`lf
();

503 ià(
c
=='Z')

504 
	`»¥Úd
(
‰y
);

505 ià(
x
=='7')

506 
	`§ve_cur
();

507 ià(
x
=='8')

508 
	`»¡Üe_cur
();

511 
Å¬
=0;Å¬<
NPAR
;npar++)

512 
·r
[
Å¬
]=0;

513 
Å¬
=0;

514 
¡©e
=3;

515 ià(
ques
=(
c
=='?'))

518 ià(
c
==';' && 
Å¬
<
NPAR
-1) {

519 
Å¬
++;

521 } ià(
c
>='0' && c<='9') {

522 
·r
[
Å¬
]=10*·r[Å¬]+
c
-'0';

524 } 
¡©e
=4;

526 
¡©e
=0;

527 
c
) {

529 ià(
·r
[0])…ar[0]--;

530 
	`gÙoxy
(
·r
[0],
y
);

533 ià(!
·r
[0])…ar[0]++;

534 
	`gÙoxy
(
x
,
y
-
·r
[0]);

537 ià(!
·r
[0])…ar[0]++;

538 
	`gÙoxy
(
x
,
y
+
·r
[0]);

541 ià(!
·r
[0])…ar[0]++;

542 
	`gÙoxy
(
x
+
·r
[0],
y
);

545 ià(!
·r
[0])…ar[0]++;

546 
	`gÙoxy
(
x
-
·r
[0],
y
);

549 ià(!
·r
[0])…ar[0]++;

550 
	`gÙoxy
(0,
y
+
·r
[0]);

553 ià(!
·r
[0])…ar[0]++;

554 
	`gÙoxy
(0,
y
-
·r
[0]);

557 ià(
·r
[0])…ar[0]--;

558 
	`gÙoxy
(
x
,
·r
[0]);

561 ià(
·r
[0])…ar[0]--;

562 ià(
·r
[1])…ar[1]--;

563 
	`gÙoxy
(
·r
[1],par[0]);

566 
	`csi_J
(
·r
[0]);

569 
	`csi_K
(
·r
[0]);

572 
	`csi_L
(
·r
[0]);

575 
	`csi_M
(
·r
[0]);

578 
	`csi_P
(
·r
[0]);

581 
	`csi_©
(
·r
[0]);

584 
	`csi_m
();

587 ià(
·r
[0])…ar[0]--;

588 ià(!
·r
[1]è·r[1] = 
video_num_lšes
;

589 ià(
·r
[0] <…ar[1] &&

590 
·r
[1] <ð
video_num_lšes
) {

591 
tÝ
=
·r
[0];

592 
bÙtom
=
·r
[1];

596 
	`§ve_cur
();

599 
	`»¡Üe_cur
();

604 
	`£t_cursÜ
();

605 
	}
}

617 
	$cÚ_š™
()

619 
a
;

620 *
di¥Ïy_desc
 = "????";

621 *
di¥Ïy_±r
;

623 
video_num_cÞumns
 = 
ORIG_VIDEO_COLS
;

624 
video_size_row
 = 
video_num_cÞumns
 * 2;

625 
video_num_lšes
 = 
ORIG_VIDEO_LINES
;

626 
video_·ge
 = 
ORIG_VIDEO_PAGE
;

627 
video_”a£_ch¬
 = 0x0720;

629 ià(
ORIG_VIDEO_MODE
 == 7)

631 
video_mem_¡¬t
 = 0xb0000;

632 
video_pÜt_»g
 = 0x3b4;

633 
video_pÜt_v®
 = 0x3b5;

634 ià((
ORIG_VIDEO_EGA_BX
 & 0xff) != 0x10)

636 
video_ty³
 = 
VIDEO_TYPE_EGAM
;

637 
video_mem_’d
 = 0xb8000;

638 
di¥Ïy_desc
 = "EGAm";

642 
video_ty³
 = 
VIDEO_TYPE_MDA
;

643 
video_mem_’d
 = 0xb2000;

644 
di¥Ïy_desc
 = "*MDA";

649 
video_mem_¡¬t
 = 0xb8000;

650 
video_pÜt_»g
 = 0x3d4;

651 
video_pÜt_v®
 = 0x3d5;

652 ià((
ORIG_VIDEO_EGA_BX
 & 0xff) != 0x10)

654 
video_ty³
 = 
VIDEO_TYPE_EGAC
;

655 
video_mem_’d
 = 0xbc000;

656 
di¥Ïy_desc
 = "EGAc";

660 
video_ty³
 = 
VIDEO_TYPE_CGA
;

661 
video_mem_’d
 = 0xba000;

662 
di¥Ïy_desc
 = "*CGA";

668 
di¥Ïy_±r
 = ((*)
video_mem_¡¬t
è+ 
video_size_row
 - 8;

669 *
di¥Ïy_desc
)

671 *
di¥Ïy_±r
++ = *
di¥Ïy_desc
++;

672 
di¥Ïy_±r
++;

677 
Üigš
 = 
video_mem_¡¬t
;

678 
sü_’d
 = 
video_mem_¡¬t
 + 
video_num_lšes
 * 
video_size_row
;

679 
tÝ
 = 0;

680 
bÙtom
 = 
video_num_lšes
;

682 
	`gÙoxy
(
ORIG_X
,
ORIG_Y
);

683 
	`£t_Œ­_g©e
(0x21,&
keybßrd_š‹¼u±
);

684 
	`outb_p
(
	`šb_p
(0x21)&0xfd,0x21);

685 
a
=
	`šb_p
(0x61);

686 
	`outb_p
(
a
|0x80,0x61);

687 
	`outb
(
a
,0x61);

688 
	}
}

691 
	$sysb“p¡Ý
()

694 
	`outb
(
	`šb_p
(0x61)&0xFC, 0x61);

695 
	}
}

697 
	gb“pcouÁ
 = 0;

699 
	$sysb“p
()

702 
	`outb_p
(
	`šb_p
(0x61)|3, 0x61);

704 
	`outb_p
(0xB6, 0x43);

706 
	`outb_p
(0x37, 0x42);

707 
	`outb
(0x06, 0x42);

709 
b“pcouÁ
 = 
HZ
/8;

710 
	}
}

	@kernel/chr_drv/serial.c

16 
	~<lšux/‰y.h
>

17 
	~<lšux/sched.h
>

18 
	~<asm/sy¡em.h
>

19 
	~<asm/io.h
>

21 
	#WAKEUP_CHARS
 (
TTY_BUF_SIZE
/4)

	)

23 
rs1_š‹¼u±
();

24 
rs2_š‹¼u±
();

26 
	$š™
(
pÜt
)

28 
	`outb_p
(0x80,
pÜt
+3);

29 
	`outb_p
(0x30,
pÜt
);

30 
	`outb_p
(0x00,
pÜt
+1);

31 
	`outb_p
(0x03,
pÜt
+3);

32 
	`outb_p
(0x0b,
pÜt
+4);

33 
	`outb_p
(0x0d,
pÜt
+1);

34 ()
	`šb
(
pÜt
);

35 
	}
}

37 
	$rs_š™
()

39 
	`£t_šŒ_g©e
(0x24,
rs1_š‹¼u±
);

40 
	`£t_šŒ_g©e
(0x23,
rs2_š‹¼u±
);

41 
	`š™
(
‰y_bË
[1].
»ad_q
.
d©a
);

42 
	`š™
(
‰y_bË
[2].
»ad_q
.
d©a
);

43 
	`outb
(
	`šb_p
(0x21)&0xE7,0x21);

44 
	}
}

53 
	$rs_wr™e
(
‰y_¡ruù
 * 
‰y
)

55 
	`þi
();

56 ià(!
	`EMPTY
(
‰y
->
wr™e_q
))

57 
	`outb
(
	`šb_p
(
‰y
->
wr™e_q
.
d©a
+1)|0x02,tty->write_q.data+1);

58 
	`¡i
();

59 
	}
}

	@kernel/chr_drv/tty_io.c

13 
	~<ùy³.h
>

14 
	~<”ºo.h
>

15 
	~<sigÇl.h
>

17 
	#ALRMMASK
 (1<<(
SIGALRM
-1))

	)

18 
	#KILLMASK
 (1<<(
SIGKILL
-1))

	)

19 
	#INTMASK
 (1<<(
SIGINT
-1))

	)

20 
	#QUITMASK
 (1<<(
SIGQUIT
-1))

	)

21 
	#TSTPMASK
 (1<<(
SIGTSTP
-1))

	)

23 
	~<lšux/sched.h
>

24 
	~<lšux/‰y.h
>

25 
	~<asm/£gm’t.h
>

26 
	~<asm/sy¡em.h
>

28 
	#_L_FLAG
(
‰y
,
f
è(Ñty)->
‹rmios
.
c_læag
 & f)

	)

29 
	#_I_FLAG
(
‰y
,
f
è(Ñty)->
‹rmios
.
c_iæag
 & f)

	)

30 
	#_O_FLAG
(
‰y
,
f
è(Ñty)->
‹rmios
.
c_oæag
 & f)

	)

32 
	#L_CANON
(
‰y
è
	`_L_FLAG
(Ñty),
ICANON
)

	)

33 
	#L_ISIG
(
‰y
è
	`_L_FLAG
(Ñty),
ISIG
)

	)

34 
	#L_ECHO
(
‰y
è
	`_L_FLAG
(Ñty),
ECHO
)

	)

35 
	#L_ECHOE
(
‰y
è
	`_L_FLAG
(Ñty),
ECHOE
)

	)

36 
	#L_ECHOK
(
‰y
è
	`_L_FLAG
(Ñty),
ECHOK
)

	)

37 
	#L_ECHOCTL
(
‰y
è
	`_L_FLAG
(Ñty),
ECHOCTL
)

	)

38 
	#L_ECHOKE
(
‰y
è
	`_L_FLAG
(Ñty),
ECHOKE
)

	)

40 
	#I_UCLC
(
‰y
è
	`_I_FLAG
(Ñty),
IUCLC
)

	)

41 
	#I_NLCR
(
‰y
è
	`_I_FLAG
(Ñty),
INLCR
)

	)

42 
	#I_CRNL
(
‰y
è
	`_I_FLAG
(Ñty),
ICRNL
)

	)

43 
	#I_NOCR
(
‰y
è
	`_I_FLAG
(Ñty),
IGNCR
)

	)

45 
	#O_POST
(
‰y
è
	`_O_FLAG
(Ñty),
OPOST
)

	)

46 
	#O_NLCR
(
‰y
è
	`_O_FLAG
(Ñty),
ONLCR
)

	)

47 
	#O_CRNL
(
‰y
è
	`_O_FLAG
(Ñty),
OCRNL
)

	)

48 
	#O_NLRET
(
‰y
è
	`_O_FLAG
(Ñty),
ONLRET
)

	)

49 
	#O_LCUC
(
‰y
è
	`_O_FLAG
(Ñty),
OLCUC
)

	)

51 
‰y_¡ruù
 
	g‰y_bË
[] = {

53 {
ICRNL
,

54 
OPOST
|
ONLCR
,

56 
ISIG
 | 
ICANON
 | 
ECHO
 | 
ECHOCTL
 | 
ECHOKE
,

58 
INIT_C_CC
},

61 
cÚ_wr™e
,

68 
B2400
 | 
CS8
,

71 
INIT_C_CC
},

74 
rs_wr™e
,

81 
B2400
 | 
CS8
,

84 
INIT_C_CC
},

87 
rs_wr™e
,

99 
‰y_queue
 * 
	gbË_li¡
[]={

100 &
‰y_bË
[0].
»ad_q
, &‰y_bË[0].
wr™e_q
,

101 &
‰y_bË
[1].
»ad_q
, &‰y_bË[1].
wr™e_q
,

102 &
‰y_bË
[2].
»ad_q
, &‰y_bË[2].
wr™e_q


105 
	$‰y_š™
()

107 
	`rs_š™
();

108 
	`cÚ_š™
();

109 
	}
}

111 
	$‰y_šŒ
(
‰y_¡ruù
 * 
‰y
, 
mask
)

113 
i
;

115 ià(
‰y
->
pg½
 <= 0)

117 
i
=0;i<
NR_TASKS
;i++)

118 ià(
sk
[
i
] &&ask[i]->
pg½
==
‰y
->pgrp)

119 
sk
[
i
]->
sigÇl
 |ð
mask
;

120 
	}
}

122 
	$¦“p_if_em±y
(
‰y_queue
 * 
queue
)

124 
	`þi
();

125 !
cu¼’t
->
sigÇl
 && 
	`EMPTY
(*
queue
))

126 
	`š‹¼u±ibË_¦“p_Ú
(&
queue
->
´oc_li¡
);

127 
	`¡i
();

128 
	}
}

130 
	$¦“p_if_fuÎ
(
‰y_queue
 * 
queue
)

132 ià(!
	`FULL
(*
queue
))

134 
	`þi
();

135 !
cu¼’t
->
sigÇl
 && 
	`LEFT
(*
queue
)<128)

136 
	`š‹¼u±ibË_¦“p_Ú
(&
queue
->
´oc_li¡
);

137 
	`¡i
();

138 
	}
}

140 
	$wa™_fÜ_key´ess
()

142 
	`¦“p_if_em±y
(&
‰y_bË
[0].
£cÚd¬y
);

143 
	}
}

145 
	$cÝy_to_cooked
(
‰y_¡ruù
 * 
‰y
)

147 sigÃd 
c
;

149 !
	`EMPTY
(
‰y
->
»ad_q
è&& !
	`FULL
Ñty->
£cÚd¬y
)) {

150 
	`GETCH
(
‰y
->
»ad_q
,
c
);

151 ià(
c
==13)

152 ià(
	`I_CRNL
(
‰y
))

153 
c
=10;

154 ià(
	`I_NOCR
(
‰y
))

157 ià(
c
==10 && 
	`I_NLCR
(
‰y
))

158 
c
=13;

159 ià(
	`I_UCLC
(
‰y
))

160 
c
=
	`tÞow”
(c);

161 ià(
	`L_CANON
(
‰y
)) {

162 ià(
c
==
	`KILL_CHAR
(
‰y
)) {

164 !(
	`EMPTY
(
‰y
->
£cÚd¬y
) ||

165 (
c
=
	`LAST
(
‰y
->
£cÚd¬y
))==10 ||

166 
c
==
	`EOF_CHAR
(
‰y
))) {

167 ià(
	`L_ECHO
(
‰y
)) {

168 ià(
c
<32)

169 
	`PUTCH
(127,
‰y
->
wr™e_q
);

170 
	`PUTCH
(127,
‰y
->
wr™e_q
);

171 
‰y
->
	`wr™e
(tty);

173 
	`DEC
(
‰y
->
£cÚd¬y
.
h—d
);

177 ià(
c
==
	`ERASE_CHAR
(
‰y
)) {

178 ià(
	`EMPTY
(
‰y
->
£cÚd¬y
) ||

179 (
c
=
	`LAST
(
‰y
->
£cÚd¬y
))==10 ||

180 
c
==
	`EOF_CHAR
(
‰y
))

182 ià(
	`L_ECHO
(
‰y
)) {

183 ià(
c
<32)

184 
	`PUTCH
(127,
‰y
->
wr™e_q
);

185 
	`PUTCH
(127,
‰y
->
wr™e_q
);

186 
‰y
->
	`wr™e
(tty);

188 
	`DEC
(
‰y
->
£cÚd¬y
.
h—d
);

191 ià(
c
==
	`STOP_CHAR
(
‰y
)) {

192 
‰y
->
¡Ý³d
=1;

195 ià(
c
==
	`START_CHAR
(
‰y
)) {

196 
‰y
->
¡Ý³d
=0;

200 ià(
	`L_ISIG
(
‰y
)) {

201 ià(
c
==
	`INTR_CHAR
(
‰y
)) {

202 
	`‰y_šŒ
(
‰y
,
INTMASK
);

205 ià(
c
==
	`QUIT_CHAR
(
‰y
)) {

206 
	`‰y_šŒ
(
‰y
,
QUITMASK
);

210 ià(
c
==10 || c==
	`EOF_CHAR
(
‰y
))

211 
‰y
->
£cÚd¬y
.
d©a
++;

212 ià(
	`L_ECHO
(
‰y
)) {

213 ià(
c
==10) {

214 
	`PUTCH
(10,
‰y
->
wr™e_q
);

215 
	`PUTCH
(13,
‰y
->
wr™e_q
);

216 } ià(
c
<32) {

217 ià(
	`L_ECHOCTL
(
‰y
)) {

218 
	`PUTCH
('^',
‰y
->
wr™e_q
);

219 
	`PUTCH
(
c
+64,
‰y
->
wr™e_q
);

222 
	`PUTCH
(
c
,
‰y
->
wr™e_q
);

223 
‰y
->
	`wr™e
(tty);

225 
	`PUTCH
(
c
,
‰y
->
£cÚd¬y
);

227 
	`wake_up
(&
‰y
->
£cÚd¬y
.
´oc_li¡
);

228 
	}
}

230 
	$‰y_»ad
(
chªÃl
, * 
buf
, 
Ä
)

232 
‰y_¡ruù
 * 
‰y
;

233 
c
, * 
b
=
buf
;

234 
mšimum
,
time
,
æag
=0;

235 
Þd®¬m
;

237 ià(
chªÃl
>2 || 
Ä
<0)  -1;

238 
‰y
 = &
‰y_bË
[
chªÃl
];

239 
Þd®¬m
 = 
cu¼’t
->
®¬m
;

240 
time
 = 10L*
‰y
->
‹rmios
.
c_cc
[
VTIME
];

241 
mšimum
 = 
‰y
->
‹rmios
.
c_cc
[
VMIN
];

242 ià(
time
 && !
mšimum
) {

243 
mšimum
=1;

244 ià(
æag
=(!
Þd®¬m
 || 
time
+
jiff›s
<oldalarm))

245 
cu¼’t
->
®¬m
 = 
time
+
jiff›s
;

247 ià(
mšimum
>
Ä
)

248 
mšimum
=
Ä
;

249 
Ä
>0) {

250 ià(
æag
 && (
cu¼’t
->
sigÇl
 & 
ALRMMASK
)) {

251 
cu¼’t
->
sigÇl
 &ð~
ALRMMASK
;

254 ià(
cu¼’t
->
sigÇl
)

256 ià(
	`EMPTY
(
‰y
->
£cÚd¬y
è|| (
	`L_CANON
(tty) &&

257 !
‰y
->
£cÚd¬y
.
d©a
 && 
	`LEFT
(tty->secondary)>20)) {

258 
	`¦“p_if_em±y
(&
‰y
->
£cÚd¬y
);

262 
	`GETCH
(
‰y
->
£cÚd¬y
,
c
);

263 ià(
c
==
	`EOF_CHAR
(
‰y
) || c==10)

264 
‰y
->
£cÚd¬y
.
d©a
--;

265 ià(
c
==
	`EOF_CHAR
(
‰y
è&& 
	`L_CANON
(tty))

266  (
b
-
buf
);

268 
	`put_fs_by‹
(
c
,
b
++);

269 ià(!--
Ä
)

272 } 
Ä
>0 && !
	`EMPTY
(
‰y
->
£cÚd¬y
));

273 ià(
time
 && !
	`L_CANON
(
‰y
))

274 ià(
æag
=(!
Þd®¬m
 || 
time
+
jiff›s
<oldalarm))

275 
cu¼’t
->
®¬m
 = 
time
+
jiff›s
;

277 
cu¼’t
->
®¬m
 = 
Þd®¬m
;

278 ià(
	`L_CANON
(
‰y
)) {

279 ià(
b
-
buf
)

281 } ià(
b
-
buf
 >ð
mšimum
)

284 
cu¼’t
->
®¬m
 = 
Þd®¬m
;

285 ià(
cu¼’t
->
sigÇl
 && !(
b
-
buf
))

286  -
EINTR
;

287  (
b
-
buf
);

288 
	}
}

290 
	$‰y_wr™e
(
chªÃl
, * 
buf
, 
Ä
)

292 
ü_æag
=0;

293 
‰y_¡ruù
 * 
‰y
;

294 
c
, *
b
=
buf
;

296 ià(
chªÃl
>2 || 
Ä
<0)  -1;

297 
‰y
 = 
chªÃl
 + 
‰y_bË
;

298 
Ä
>0) {

299 
	`¦“p_if_fuÎ
(&
‰y
->
wr™e_q
);

300 ià(
cu¼’t
->
sigÇl
)

302 
Ä
>0 && !
	`FULL
(
‰y
->
wr™e_q
)) {

303 
c
=
	`g‘_fs_by‹
(
b
);

304 ià(
	`O_POST
(
‰y
)) {

305 ià(
c
=='\r' && 
	`O_CRNL
(
‰y
))

306 
c
='\n';

307 ià(
c
=='\n' && 
	`O_NLRET
(
‰y
))

308 
c
='\r';

309 ià(
c
=='\n' && !
ü_æag
 && 
	`O_NLCR
(
‰y
)) {

310 
ü_æag
 = 1;

311 
	`PUTCH
(13,
‰y
->
wr™e_q
);

314 ià(
	`O_LCUC
(
‰y
))

315 
c
=
	`touµ”
(c);

317 
b
++; 
Ä
--;

318 
ü_æag
 = 0;

319 
	`PUTCH
(
c
,
‰y
->
wr™e_q
);

321 
‰y
->
	`wr™e
(tty);

322 ià(
Ä
>0)

323 
	`scheduË
();

325  (
b
-
buf
);

326 
	}
}

342 
	$do_‰y_š‹¼u±
(
‰y
)

344 
	`cÝy_to_cooked
(
‰y_bË
+
‰y
);

345 
	}
}

347 
	$chr_dev_š™
()

349 
	}
}

	@kernel/chr_drv/tty_ioctl.c

7 
	~<”ºo.h
>

8 
	~<‹rmios.h
>

10 
	~<lšux/sched.h
>

11 
	~<lšux/k”Ãl.h
>

12 
	~<lšux/‰y.h
>

14 
	~<asm/io.h
>

15 
	~<asm/£gm’t.h
>

16 
	~<asm/sy¡em.h
>

18 
	gquÙ›Á
[] = {

24 
	$chªge_¥“d
(
‰y_¡ruù
 * 
‰y
)

26 
pÜt
,
quÙ
;

28 ià(!(
pÜt
 = 
‰y
->
»ad_q
.
d©a
))

30 
quÙ
 = 
quÙ›Á
[
‰y
->
‹rmios
.
c_cæag
 & 
CBAUD
];

31 
	`þi
();

32 
	`outb_p
(0x80,
pÜt
+3);

33 
	`outb_p
(
quÙ
 & 0xff,
pÜt
);

34 
	`outb_p
(
quÙ
 >> 8,
pÜt
+1);

35 
	`outb
(0x03,
pÜt
+3);

36 
	`¡i
();

37 
	}
}

39 
	$æush
(
‰y_queue
 * 
queue
)

41 
	`þi
();

42 
queue
->
h—d
 = queue->
ž
;

43 
	`¡i
();

44 
	}
}

46 
	$wa™_uÁž_£Á
(
‰y_¡ruù
 * 
‰y
)

49 
	}
}

51 
	$£nd_b»ak
(
‰y_¡ruù
 * 
‰y
)

54 
	}
}

56 
	$g‘_‹rmios
(
‰y_¡ruù
 * 
‰y
, 
‹rmios
 *ermios)

58 
i
;

60 
	`v”ify_¬—
(
‹rmios
,  (*termios));

61 
i
=0 ; i< ( (*
‹rmios
)) ; i++)

62 
	`put_fs_by‹
Ð((*)&
‰y
->
‹rmios
)[
i
] , i+(*)termios );

64 
	}
}

66 
	$£t_‹rmios
(
‰y_¡ruù
 * 
‰y
, 
‹rmios
 *ermios)

68 
i
;

70 
i
=0 ; i< ( (*
‹rmios
)) ; i++)

71 ((*)&
‰y
->
‹rmios
)[
i
]=
	`g‘_fs_by‹
(i+(*)termios);

72 
	`chªge_¥“d
(
‰y
);

74 
	}
}

76 
	$g‘_‹rmio
(
‰y_¡ruù
 * 
‰y
, 
‹rmio
 *ermio)

78 
i
;

79 
‹rmio
 
tmp_‹rmio
;

81 
	`v”ify_¬—
(
‹rmio
,  (*termio));

82 
tmp_‹rmio
.
c_iæag
 = 
‰y
->
‹rmios
.c_iflag;

83 
tmp_‹rmio
.
c_oæag
 = 
‰y
->
‹rmios
.c_oflag;

84 
tmp_‹rmio
.
c_cæag
 = 
‰y
->
‹rmios
.c_cflag;

85 
tmp_‹rmio
.
c_læag
 = 
‰y
->
‹rmios
.c_lflag;

86 
tmp_‹rmio
.
c_lše
 = 
‰y
->
‹rmios
.c_line;

87 
i
=0 ; i < 
NCC
 ; i++)

88 
tmp_‹rmio
.
c_cc
[
i
] = 
‰y
->
‹rmios
.c_cc[i];

89 
i
=0 ; i< ( (*
‹rmio
)) ; i++)

90 
	`put_fs_by‹
Ð((*)&
tmp_‹rmio
)[
i
] , i+(*)
‹rmio
 );

92 
	}
}

97 
	$£t_‹rmio
(
‰y_¡ruù
 * 
‰y
, 
‹rmio
 *ermio)

99 
i
;

100 
‹rmio
 
tmp_‹rmio
;

102 
i
=0 ; i< ( (*
‹rmio
)) ; i++)

103 ((*)&
tmp_‹rmio
)[
i
]=
	`g‘_fs_by‹
(i+(*)
‹rmio
);

104 *(*)&
‰y
->
‹rmios
.
c_iæag
 = 
tmp_‹rmio
.c_iflag;

105 *(*)&
‰y
->
‹rmios
.
c_oæag
 = 
tmp_‹rmio
.c_oflag;

106 *(*)&
‰y
->
‹rmios
.
c_cæag
 = 
tmp_‹rmio
.c_cflag;

107 *(*)&
‰y
->
‹rmios
.
c_læag
 = 
tmp_‹rmio
.c_lflag;

108 
‰y
->
‹rmios
.
c_lše
 = 
tmp_‹rmio
.c_line;

109 
i
=0 ; i < 
NCC
 ; i++)

110 
‰y
->
‹rmios
.
c_cc
[
i
] = 
tmp_‹rmio
.c_cc[i];

111 
	`chªge_¥“d
(
‰y
);

113 
	}
}

115 
	$‰y_ioùl
(
dev
, 
cmd
, 
¬g
)

117 
‰y_¡ruù
 * 
‰y
;

118 ià(
	`MAJOR
(
dev
) == 5) {

119 
dev
=
cu¼’t
->
‰y
;

120 ià(
dev
<0)

121 
	`·nic
("tty_ioctl: dev<0");

123 
dev
=
	`MINOR
(dev);

124 
‰y
 = 
dev
 + 
‰y_bË
;

125 
cmd
) {

126 
TCGETS
:

127  
	`g‘_‹rmios
(
‰y
,(
‹rmios
 *è
¬g
);

128 
TCSETSF
:

129 
	`æush
(&
‰y
->
»ad_q
);

130 
TCSETSW
:

131 
	`wa™_uÁž_£Á
(
‰y
);

132 
TCSETS
:

133  
	`£t_‹rmios
(
‰y
,(
‹rmios
 *è
¬g
);

134 
TCGETA
:

135  
	`g‘_‹rmio
(
‰y
,(
‹rmio
 *è
¬g
);

136 
TCSETAF
:

137 
	`æush
(&
‰y
->
»ad_q
);

138 
TCSETAW
:

139 
	`wa™_uÁž_£Á
(
‰y
);

140 
TCSETA
:

141  
	`£t_‹rmio
(
‰y
,(
‹rmio
 *è
¬g
);

142 
TCSBRK
:

143 ià(!
¬g
) {

144 
	`wa™_uÁž_£Á
(
‰y
);

145 
	`£nd_b»ak
(
‰y
);

148 
TCXONC
:

149  -
EINVAL
;

150 
TCFLSH
:

151 ià(
¬g
==0)

152 
	`æush
(&
‰y
->
»ad_q
);

153 ià(
¬g
==1)

154 
	`æush
(&
‰y
->
wr™e_q
);

155 ià(
¬g
==2) {

156 
	`æush
(&
‰y
->
»ad_q
);

157 
	`æush
(&
‰y
->
wr™e_q
);

159  -
EINVAL
;

161 
TIOCEXCL
:

162  -
EINVAL
;

163 
TIOCNXCL
:

164  -
EINVAL
;

165 
TIOCSCTTY
:

166  -
EINVAL
;

167 
TIOCGPGRP
:

168 
	`v”ify_¬—
((*è
¬g
,4);

169 
	`put_fs_lÚg
(
‰y
->
pg½
,(*è
¬g
);

171 
TIOCSPGRP
:

172 
‰y
->
pg½
=
	`g‘_fs_lÚg
((*è
¬g
);

174 
TIOCOUTQ
:

175 
	`v”ify_¬—
((*è
¬g
,4);

176 
	`put_fs_lÚg
(
	`CHARS
(
‰y
->
wr™e_q
),(*è
¬g
);

178 
TIOCINQ
:

179 
	`v”ify_¬—
((*è
¬g
,4);

180 
	`put_fs_lÚg
(
	`CHARS
(
‰y
->
£cÚd¬y
),

181 (*è
¬g
);

183 
TIOCSTI
:

184  -
EINVAL
;

185 
TIOCGWINSZ
:

186  -
EINVAL
;

187 
TIOCSWINSZ
:

188  -
EINVAL
;

189 
TIOCMGET
:

190  -
EINVAL
;

191 
TIOCMBIS
:

192  -
EINVAL
;

193 
TIOCMBIC
:

194  -
EINVAL
;

195 
TIOCMSET
:

196  -
EINVAL
;

197 
TIOCGSOFTCAR
:

198  -
EINVAL
;

199 
TIOCSSOFTCAR
:

200  -
EINVAL
;

202  -
EINVAL
;

204 
	}
}

	@kernel/exit.c

7 
	~<”ºo.h
>

8 
	~<sigÇl.h
>

9 
	~<sys/wa™.h
>

11 
	~<lšux/sched.h
>

12 
	~<lšux/k”Ãl.h
>

13 
	~<lšux/‰y.h
>

14 
	~<asm/£gm’t.h
>

16 
sys_·u£
();

17 
sys_þo£
(
fd
);

19 
	$»Ëa£
(
sk_¡ruù
 * 
p
)

21 
i
;

23 ià(!
p
)

25 
i
=1 ; i<
NR_TASKS
 ; i++)

26 ià(
sk
[
i
]==
p
) {

27 
sk
[
i
]=
NULL
;

28 
	`ä“_·ge
(()
p
);

29 
	`scheduË
();

32 
	`·nic
("tryingo„elease‚on-existentask");

33 
	}
}

35 
šlše
 
	$£nd_sig
(
sig
,
sk_¡ruù
 * 
p
,
´iv
)

37 ià(!
p
 || 
sig
<1 || sig>32)

38  -
EINVAL
;

39 ià(
´iv
 || (
cu¼’t
->
euid
==
p
->euidè|| 
	`su£r
())

40 
p
->
sigÇl
 |ð(1<<(
sig
-1));

42  -
EPERM
;

44 
	}
}

46 
	$kžl_£ssiÚ
()

48 
sk_¡ruù
 **
p
 = 
NR_TASKS
 + 
sk
;

50 --
p
 > &
FIRST_TASK
) {

51 ià(*
p
 && (*p)->
£ssiÚ
 =ð
cu¼’t
->session)

52 (*
p
)->
sigÇl
 |ð1<<(
SIGHUP
-1);

54 
	}
}

60 
	$sys_kžl
(
pid
,
sig
)

62 
sk_¡ruù
 **
p
 = 
NR_TASKS
 + 
sk
;

63 
”r
, 
»tv®
 = 0;

65 ià(!
pid
è--
p
 > &
FIRST_TASK
) {

66 ià(*
p
 && (*p)->
pg½
 =ð
cu¼’t
->
pid
)

67 ià(
”r
=
	`£nd_sig
(
sig
,*
p
,1))

68 
»tv®
 = 
”r
;

69 } ià(
pid
>0è--
p
 > &
FIRST_TASK
) {

70 ià(*
p
 && (*p)->
pid
 ==…id)

71 ià(
”r
=
	`£nd_sig
(
sig
,*
p
,0))

72 
»tv®
 = 
”r
;

73 } ià(
pid
 =ð-1è--
p
 > &
FIRST_TASK
)

74 ià(
”r
 = 
	`£nd_sig
(
sig
,*
p
,0))

75 
»tv®
 = 
”r
;

76 --
p
 > &
FIRST_TASK
)

77 ià(*
p
 && (*p)->
pg½
 =ð-
pid
)

78 ià(
”r
 = 
	`£nd_sig
(
sig
,*
p
,0))

79 
»tv®
 = 
”r
;

80  
»tv®
;

81 
	}
}

83 
	$‹Î_çth”
(
pid
)

85 
i
;

87 ià(
pid
)

88 
i
=0;i<
NR_TASKS
;i++) {

89 ià(!
sk
[
i
])

91 ià(
sk
[
i
]->
pid
 !=…id)

93 
sk
[
i
]->
sigÇl
 |ð(1<<(
SIGCHLD
-1));

98 
	`´štk
("BAD BAD -‚o father found\n\r");

99 
	`»Ëa£
(
cu¼’t
);

100 
	}
}

102 
	$do_ex™
(
code
)

104 
i
;

106 
	`ä“_·ge_bËs
(
	`g‘_ba£
(
cu¼’t
->
ldt
[1]),
	`g‘_lim™
(0x0f));

107 
	`ä“_·ge_bËs
(
	`g‘_ba£
(
cu¼’t
->
ldt
[2]),
	`g‘_lim™
(0x17));

108 
i
=0 ; i<
NR_TASKS
 ; i++)

109 ià(
sk
[
i
] &&ask[i]->
çth”
 =ð
cu¼’t
->
pid
) {

110 
sk
[
i
]->
çth”
 = 1;

111 ià(
sk
[
i
]->
¡©e
 =ð
TASK_ZOMBIE
)

113 (è
	`£nd_sig
(
SIGCHLD
, 
sk
[1], 1);

115 
i
=0 ; i<
NR_OPEN
 ; i++)

116 ià(
cu¼’t
->
fžp
[
i
])

117 
	`sys_þo£
(
i
);

118 
	`ut
(
cu¼’t
->
pwd
);

119 
cu¼’t
->
pwd
=
NULL
;

120 
	`ut
(
cu¼’t
->
roÙ
);

121 
cu¼’t
->
roÙ
=
NULL
;

122 
	`ut
(
cu¼’t
->
execubË
);

123 
cu¼’t
->
execubË
=
NULL
;

124 ià(
cu¼’t
->
Ëad”
 && cu¼’t->
‰y
 >= 0)

125 
‰y_bË
[
cu¼’t
->
‰y
].
pg½
 = 0;

126 ià(
Ï¡_sk_u£d_m©h
 =ð
cu¼’t
)

127 
Ï¡_sk_u£d_m©h
 = 
NULL
;

128 ià(
cu¼’t
->
Ëad”
)

129 
	`kžl_£ssiÚ
();

130 
cu¼’t
->
¡©e
 = 
TASK_ZOMBIE
;

131 
cu¼’t
->
ex™_code
 = 
code
;

132 
	`‹Î_çth”
(
cu¼’t
->
çth”
);

133 
	`scheduË
();

135 
	}
}

137 
	$sys_ex™
(
”rÜ_code
)

139  
	`do_ex™
((
”rÜ_code
&0xff)<<8);

140 
	}
}

142 
	$sys_wa™pid
(
pid_t
 
pid
,* 
¡©_addr
, 
ÝtiÚs
)

144 
æag
, 
code
;

145 
sk_¡ruù
 ** 
p
;

147 
	`v”ify_¬—
(
¡©_addr
,4);

148 
»³©
:

149 
æag
=0;

150 
p
 = &
LAST_TASK
 ;… > &
FIRST_TASK
 ; --p) {

151 ià(!*
p
 || *°=ð
cu¼’t
)

153 ià((*
p
)->
çth”
 !ð
cu¼’t
->
pid
)

155 ià(
pid
>0) {

156 ià((*
p
)->
pid
 !=…id)

158 } ià(!
pid
) {

159 ià((*
p
)->
pg½
 !ð
cu¼’t
->pgrp)

161 } ià(
pid
 != -1) {

162 ià((*
p
)->
pg½
 !ð-
pid
)

165 (*
p
)->
¡©e
) {

166 
TASK_STOPPED
:

167 ià(!(
ÝtiÚs
 & 
WUNTRACED
))

169 
	`put_fs_lÚg
(0x7f,
¡©_addr
);

170  (*
p
)->
pid
;

171 
TASK_ZOMBIE
:

172 
cu¼’t
->
cutime
 +ð(*
p
)->
utime
;

173 
cu¼’t
->
c¡ime
 +ð(*
p
)->
¡ime
;

174 
æag
 = (*
p
)->
pid
;

175 
code
 = (*
p
)->
ex™_code
;

176 
	`»Ëa£
(*
p
);

177 
	`put_fs_lÚg
(
code
,
¡©_addr
);

178  
æag
;

180 
æag
=1;

184 ià(
æag
) {

185 ià(
ÝtiÚs
 & 
WNOHANG
)

187 
cu¼’t
->
¡©e
=
TASK_INTERRUPTIBLE
;

188 
	`scheduË
();

189 ià(!(
cu¼’t
->
sigÇl
 &ð~(1<<(
SIGCHLD
-1))))

190 
»³©
;

192  -
EINTR
;

194  -
ECHILD
;

195 
	}
}

	@kernel/fork.c

13 
	~<”ºo.h
>

15 
	~<lšux/sched.h
>

16 
	~<lšux/k”Ãl.h
>

17 
	~<asm/£gm’t.h
>

18 
	~<asm/sy¡em.h
>

20 
wr™e_v”ify
(
add»ss
);

22 
	gÏ¡_pid
=0;

24 
	$v”ify_¬—
(* 
addr
,
size
)

26 
¡¬t
;

28 
¡¬t
 = (è
addr
;

29 
size
 +ð
¡¬t
 & 0xfff;

30 
¡¬t
 &= 0xfffff000;

31 
¡¬t
 +ð
	`g‘_ba£
(
cu¼’t
->
ldt
[2]);

32 
size
>0) {

33 
size
 -= 4096;

34 
	`wr™e_v”ify
(
¡¬t
);

35 
¡¬t
 += 4096;

37 
	}
}

39 
	$cÝy_mem
(
Ä
,
sk_¡ruù
 * 
p
)

41 
Þd_d©a_ba£
,
Ãw_d©a_ba£
,
d©a_lim™
;

42 
Þd_code_ba£
,
Ãw_code_ba£
,
code_lim™
;

44 
code_lim™
=
	`g‘_lim™
(0x0f);

45 
d©a_lim™
=
	`g‘_lim™
(0x17);

46 
Þd_code_ba£
 = 
	`g‘_ba£
(
cu¼’t
->
ldt
[1]);

47 
Þd_d©a_ba£
 = 
	`g‘_ba£
(
cu¼’t
->
ldt
[2]);

48 ià(
Þd_d©a_ba£
 !ð
Þd_code_ba£
)

49 
	`·nic
("We don't support separate I&D");

50 ià(
d©a_lim™
 < 
code_lim™
)

51 
	`·nic
("Bad data_limit");

52 
Ãw_d©a_ba£
 = 
Ãw_code_ba£
 = 
Ä
 * 0x4000000;

53 
p
->
¡¬t_code
 = 
Ãw_code_ba£
;

54 
	`£t_ba£
(
p
->
ldt
[1],
Ãw_code_ba£
);

55 
	`£t_ba£
(
p
->
ldt
[2],
Ãw_d©a_ba£
);

56 ià(
	`cÝy_·ge_bËs
(
Þd_d©a_ba£
,
Ãw_d©a_ba£
,
d©a_lim™
)) {

57 
	`ä“_·ge_bËs
(
Ãw_d©a_ba£
,
d©a_lim™
);

58  -
ENOMEM
;

61 
	}
}

68 
	$cÝy_´oûss
(
Ä
,
ebp
,
edi
,
esi
,
gs
,
nÚe
,

69 
ebx
,
ecx
,
edx
,

70 
fs
,
es
,
ds
,

71 
e
,
cs
,
eæags
,
e¥
,
ss
)

73 
sk_¡ruù
 *
p
;

74 
i
;

75 
fže
 *
f
;

77 
p
 = (
sk_¡ruù
 *è
	`g‘_ä“_·ge
();

78 ià(!
p
)

79  -
EAGAIN
;

80 
sk
[
Ä
] = 
p
;

81 *
p
 = *
cu¼’t
;

82 
p
->
¡©e
 = 
TASK_UNINTERRUPTIBLE
;

83 
p
->
pid
 = 
Ï¡_pid
;

84 
p
->
çth”
 = 
cu¼’t
->
pid
;

85 
p
->
couÁ”
 =…->
´iÜ™y
;

86 
p
->
sigÇl
 = 0;

87 
p
->
®¬m
 = 0;

88 
p
->
Ëad”
 = 0;

89 
p
->
utime
 =…->
¡ime
 = 0;

90 
p
->
cutime
 =…->
c¡ime
 = 0;

91 
p
->
¡¬t_time
 = 
jiff›s
;

92 
p
->
tss
.
back_lšk
 = 0;

93 
p
->
tss
.
e¥0
 = 
PAGE_SIZE
 + ()…;

94 
p
->
tss
.
ss0
 = 0x10;

95 
p
->
tss
.
e
 =ƒip;

96 
p
->
tss
.
eæags
 =ƒflags;

97 
p
->
tss
.
—x
 = 0;

98 
p
->
tss
.
ecx
 =ƒcx;

99 
p
->
tss
.
edx
 =ƒdx;

100 
p
->
tss
.
ebx
 =ƒbx;

101 
p
->
tss
.
e¥
 =ƒsp;

102 
p
->
tss
.
ebp
 =ƒbp;

103 
p
->
tss
.
esi
 =ƒsi;

104 
p
->
tss
.
edi
 =ƒdi;

105 
p
->
tss
.
es
 =ƒs & 0xffff;

106 
p
->
tss
.
cs
 = cs & 0xffff;

107 
p
->
tss
.
ss
 = ss & 0xffff;

108 
p
->
tss
.
ds
 = ds & 0xffff;

109 
p
->
tss
.
fs
 = fs & 0xffff;

110 
p
->
tss
.
gs
 = gs & 0xffff;

111 
p
->
tss
.
ldt
 = 
	`_LDT
(
Ä
);

112 
p
->
tss
.
Œaû_b™m­
 = 0x80000000;

113 ià(
Ï¡_sk_u£d_m©h
 =ð
cu¼’t
)

114 
	`__asm__
("þt ; fn§v%0"::"m" (
p
->
tss
.
i387
));

115 ià(
	`cÝy_mem
(
Ä
,
p
)) {

116 
sk
[
Ä
] = 
NULL
;

117 
	`ä“_·ge
((è
p
);

118  -
EAGAIN
;

120 
i
=0; i<
NR_OPEN
;i++)

121 ià(
f
=
p
->
fžp
[
i
])

122 
f
->
f_couÁ
++;

123 ià(
cu¼’t
->
pwd
)

124 
cu¼’t
->
pwd
->
i_couÁ
++;

125 ià(
cu¼’t
->
roÙ
)

126 
cu¼’t
->
roÙ
->
i_couÁ
++;

127 ià(
cu¼’t
->
execubË
)

128 
cu¼’t
->
execubË
->
i_couÁ
++;

129 
	`£t_tss_desc
(
gdt
+(
Ä
<<1)+
FIRST_TSS_ENTRY
,&(
p
->
tss
));

130 
	`£t_ldt_desc
(
gdt
+(
Ä
<<1)+
FIRST_LDT_ENTRY
,&(
p
->
ldt
));

131 
p
->
¡©e
 = 
TASK_RUNNING
;

132  
Ï¡_pid
;

133 
	}
}

135 
	$fšd_em±y_´oûss
()

137 
i
;

139 
»³©
:

140 ià((++
Ï¡_pid
)<0)†ast_pid=1;

141 
i
=0 ; i<
NR_TASKS
 ; i++)

142 ià(
sk
[
i
] &&ask[i]->
pid
 =ð
Ï¡_pid
è
»³©
;

143 
i
=1 ; i<
NR_TASKS
 ; i++)

144 ià(!
sk
[
i
])

145  
i
;

146  -
EAGAIN
;

147 
	}
}

	@kernel/math/math_emulate.c

12 
	~<sigÇl.h
>

14 
	~<lšux/sched.h
>

15 
	~<lšux/k”Ãl.h
>

16 
	~<asm/£gm’t.h
>

18 
	$m©h_emuÏ‹
(
edi
, 
esi
, 
ebp
, 
sys_ÿÎ_»t
,

19 
—x
,
ebx
,
ecx
,
edx
,

20 
fs
,
es
,
ds
,

21 
e
,
cs
,
eæags
,

22 
ss
, 
e¥
)

24 
fœ¡
, 
£cÚd
;

27 ià(
cs
 != 0x000F) {

28 
	`´štk
("m©h_emuÏ‹: %04x:%08x\n\r",
cs
,
e
);

29 
	`·nic
("Mathƒmulation‚eeded in kernel");

31 
fœ¡
 = 
	`g‘_fs_by‹
((*)((*&
e
)++));

32 
£cÚd
 = 
	`g‘_fs_by‹
((*)((*&
e
)++));

33 
	`´štk
("%04x:%08x %02x %02x\n\r",
cs
,
e
-2,
fœ¡
,
£cÚd
);

34 
cu¼’t
->
sigÇl
 |ð1<<(
SIGFPE
-1);

35 
	}
}

37 
	$m©h_”rÜ
()

39 
	`__asm__
("fnclex");

40 ià(
Ï¡_sk_u£d_m©h
)

41 
Ï¡_sk_u£d_m©h
->
sigÇl
 |ð1<<(
SIGFPE
-1);

42 
	}
}

	@kernel/mktime.c

7 
	~<time.h
>

20 
	#MINUTE
 60

	)

21 
	#HOUR
 (60*
MINUTE
)

	)

22 
	#DAY
 (24*
HOUR
)

	)

23 
	#YEAR
 (365*
DAY
)

	)

26 
	gmÚth
[12] = {

28 
DAY
*(31),

29 
DAY
*(31+29),

30 
DAY
*(31+29+31),

31 
DAY
*(31+29+31+30),

32 
DAY
*(31+29+31+30+31),

33 
DAY
*(31+29+31+30+31+30),

34 
DAY
*(31+29+31+30+31+30+31),

35 
DAY
*(31+29+31+30+31+30+31+31),

36 
DAY
*(31+29+31+30+31+30+31+31+30),

37 
DAY
*(31+29+31+30+31+30+31+31+30+31),

38 
DAY
*(31+29+31+30+31+30+31+31+30+31+30)

41 
	$k”Ãl_mktime
(
tm
 *m)

43 
»s
;

44 
y—r
;

46 
y—r
 = 
tm
->
tm_y—r
 - 70;

48 
»s
 = 
YEAR
*
y—r
 + 
DAY
*((year+1)/4);

49 
»s
 +ð
mÚth
[
tm
->
tm_mÚ
];

51 ià(
tm
->
tm_mÚ
>1 && ((
y—r
+2)%4))

52 
»s
 -ð
DAY
;

53 
»s
 +ð
DAY
*(
tm
->
tm_mday
-1);

54 
»s
 +ð
HOUR
*
tm
->
tm_hour
;

55 
»s
 +ð
MINUTE
*
tm
->
tm_mš
;

56 
»s
 +ð
tm
->
tm_£c
;

57  
»s
;

58 
	}
}

	@kernel/panic.c

11 
	~<lšux/k”Ãl.h
>

12 
	~<lšux/sched.h
>

14 
sys_sync
();

16 vÞ©ž
	$·nic
(cÚ¡ * 
s
)

18 
	`´štk
("K”ÃÈ·nic: %s\n\r",
s
);

19 ià(
cu¼’t
 =ð
sk
[0])

20 
	`´štk
("In swapperask -‚ot syncing\n\r");

22 
	`sys_sync
();

24 
	}
}

	@kernel/printk.c

12 
	~<¡d¬g.h
>

13 
	~<¡ddef.h
>

15 
	~<lšux/k”Ãl.h
>

17 
	gbuf
[1024];

19 
v¥rštf
(* 
buf
, cÚ¡ * 
fmt
, 
va_li¡
 
¬gs
);

21 
	$´štk
(cÚ¡ *
fmt
, ...)

23 
va_li¡
 
¬gs
;

24 
i
;

26 
	`va_¡¬t
(
¬gs
, 
fmt
);

27 
i
=
	`v¥rštf
(
buf
,
fmt
,
¬gs
);

28 
	`va_’d
(
¬gs
);

29 
	`__asm__
("push %%fs\n\t"

39 ::"r" (
i
):"ax","cx","dx");

40  
i
;

41 
	}
}

	@kernel/sched.c

13 
	~<lšux/sched.h
>

14 
	~<lšux/k”Ãl.h
>

15 
	~<lšux/sys.h
>

16 
	~<lšux/fd»g.h
>

17 
	~<asm/sy¡em.h
>

18 
	~<asm/io.h
>

19 
	~<asm/£gm’t.h
>

21 
	~<sigÇl.h
>

23 
	#_S
(
Ä
è(1<<(Òr)-1))

	)

24 
	#_BLOCKABLE
 (~(
	`_S
(
SIGKILL
è| _S(
SIGSTOP
)))

	)

26 
	$show_sk
(
Ä
,
sk_¡ruù
 * 
p
)

28 
i
,
j
 = 4096-(
sk_¡ruù
);

30 
	`´štk
("%d:…id=%d, s‹=%d, ",
Ä
,
p
->
pid
,p->
¡©e
);

31 
i
=0;

32 
i
<
j
 && !((*)(
p
+1))[i])

33 
i
++;

34 
	`´štk
("%d (oà%dèch¬ ä“ iÀk”ÃÈ¡ack\n\r",
i
,
j
);

35 
	}
}

37 
	$show_¡©
()

39 
i
;

41 
i
=0;i<
NR_TASKS
;i++)

42 ià(
sk
[
i
])

43 
	`show_sk
(
i
,
sk
[i]);

44 
	}
}

46 
	#LATCH
 (1193180/
HZ
)

	)

48 
mem_u£
();

50 
tim”_š‹¼u±
();

51 
sy¡em_ÿÎ
();

53 
	usk_uniÚ
 {

54 
sk_¡ruù
 
	msk
;

55 
	m¡ack
[
PAGE_SIZE
];

58 
sk_uniÚ
 
	gš™_sk
 = {
INIT_TASK
,};

60 vÞ©ž
	gjiff›s
=0;

61 
	g¡¬tup_time
=0;

62 
sk_¡ruù
 *
	gcu¼’t
 = &(
š™_sk
.
sk
);

63 
sk_¡ruù
 *
	gÏ¡_sk_u£d_m©h
 = 
NULL
;

65 
sk_¡ruù
 * 
	gsk
[
NR_TASKS
] = {&(
š™_sk
.
sk
), };

67 
	gu£r_¡ack
 [ 
PAGE_SIZE
>>2 ] ;

70 * 
	ma
;

71 
	mb
;

72 } 
	g¡ack_¡¬t
 = { & 
u£r_¡ack
 [
PAGE_SIZE
>>2] , 0x10 };

77 
	$m©h_¡©e_»¡Üe
()

79 ià(
Ï¡_sk_u£d_m©h
 =ð
cu¼’t
)

81 
	`__asm__
("fwait");

82 ià(
Ï¡_sk_u£d_m©h
) {

83 
	`__asm__
("â§v%0"::"m" (
Ï¡_sk_u£d_m©h
->
tss
.
i387
));

85 
Ï¡_sk_u£d_m©h
=
cu¼’t
;

86 ià(
cu¼’t
->
u£d_m©h
) {

87 
	`__asm__
("ä¡Ü %0"::"m" (
cu¼’t
->
tss
.
i387
));

89 
	`__asm__
("fninit"::);

90 
cu¼’t
->
u£d_m©h
=1;

92 
	}
}

104 
	$scheduË
()

106 
i
,
Ãxt
,
c
;

107 
sk_¡ruù
 ** 
p
;

111 
p
 = &
LAST_TASK
 ;… > &
FIRST_TASK
 ; --p)

112 ià(*
p
) {

113 ià((*
p
)->
®¬m
 && (*p)->®¬m < 
jiff›s
) {

114 (*
p
)->
sigÇl
 |ð(1<<(
SIGALRM
-1));

115 (*
p
)->
®¬m
 = 0;

117 ià(((*
p
)->
sigÇl
 & ~(
_BLOCKABLE
 & (*p)->
blocked
)) &&

118 (*
p
)->
¡©e
==
TASK_INTERRUPTIBLE
)

119 (*
p
)->
¡©e
=
TASK_RUNNING
;

125 
c
 = -1;

126 
Ãxt
 = 0;

127 
i
 = 
NR_TASKS
;

128 
p
 = &
sk
[
NR_TASKS
];

129 --
i
) {

130 ià(!*--
p
)

132 ià((*
p
)->
¡©e
 =ð
TASK_RUNNING
 && (*p)->
couÁ”
 > 
c
)

133 
c
 = (*
p
)->
couÁ”
, 
Ãxt
 = 
i
;

135 ià(
c
) ;

136 
p
 = &
LAST_TASK
 ;… > &
FIRST_TASK
 ; --p)

137 ià(*
p
)

138 (*
p
)->
couÁ”
 = ((*p)->counter >> 1) +

139 (*
p
)->
´iÜ™y
;

141 
	`sw™ch_to
(
Ãxt
);

142 
	}
}

144 
	$sys_·u£
()

146 
cu¼’t
->
¡©e
 = 
TASK_INTERRUPTIBLE
;

147 
	`scheduË
();

149 
	}
}

151 
	$¦“p_Ú
(
sk_¡ruù
 **
p
)

153 
sk_¡ruù
 *
tmp
;

155 ià(!
p
)

157 ià(
cu¼’t
 =ð&(
š™_sk
.
sk
))

158 
	`·nic
("task[0]ryingo sleep");

159 
tmp
 = *
p
;

160 *
p
 = 
cu¼’t
;

161 
cu¼’t
->
¡©e
 = 
TASK_UNINTERRUPTIBLE
;

162 
	`scheduË
();

163 ià(
tmp
)

164 
tmp
->
¡©e
=0;

165 
	}
}

167 
	$š‹¼u±ibË_¦“p_Ú
(
sk_¡ruù
 **
p
)

169 
sk_¡ruù
 *
tmp
;

171 ià(!
p
)

173 ià(
cu¼’t
 =ð&(
š™_sk
.
sk
))

174 
	`·nic
("task[0]ryingo sleep");

175 
tmp
=*
p
;

176 *
p
=
cu¼’t
;

177 
»³©
: 
cu¼’t
->
¡©e
 = 
TASK_INTERRUPTIBLE
;

178 
	`scheduË
();

179 ià(*
p
 && *°!ð
cu¼’t
) {

180 (**
p
).
¡©e
=0;

181 
»³©
;

183 *
p
=
NULL
;

184 ià(
tmp
)

185 
tmp
->
¡©e
=0;

186 
	}
}

188 
	$wake_up
(
sk_¡ruù
 **
p
)

190 ià(
p
 && *p) {

191 (**
p
).
¡©e
=0;

192 *
p
=
NULL
;

194 
	}
}

201 
sk_¡ruù
 * 
	gwa™_mÙÜ
[4] = {
NULL
,NULL,NULL,NULL};

202 
	gmÚ_tim”
[4]={0,0,0,0};

203 
	gmoff_tim”
[4]={0,0,0,0};

204 
	gcu¼’t_DOR
 = 0x0C;

206 
	$ticks_to_æÝpy_Ú
(
Ä
)

208 
£Ëùed
;

209 
mask
 = 0x10 << 
Ä
;

211 ià(
Ä
>3)

212 
	`·nic
("floppy_on:‚r>3");

213 
moff_tim”
[
Ä
]=10000;

214 
	`þi
();

215 
mask
 |ð
cu¼’t_DOR
;

216 ià(!
£Ëùed
) {

217 
mask
 &= 0xFC;

218 
mask
 |ð
Ä
;

220 ià(
mask
 !ð
cu¼’t_DOR
) {

221 
	`outb
(
mask
,
FD_DOR
);

222 ià((
mask
 ^ 
cu¼’t_DOR
) & 0xf0)

223 
mÚ_tim”
[
Ä
] = 
HZ
/2;

224 ià(
mÚ_tim”
[
Ä
] < 2)

225 
mÚ_tim”
[
Ä
] = 2;

226 
cu¼’t_DOR
 = 
mask
;

228 
	`¡i
();

229  
mÚ_tim”
[
Ä
];

230 
	}
}

232 
	$æÝpy_Ú
(
Ä
)

234 
	`þi
();

235 
	`ticks_to_æÝpy_Ú
(
Ä
))

236 
	`¦“p_Ú
(
Ä
+
wa™_mÙÜ
);

237 
	`¡i
();

238 
	}
}

240 
	$æÝpy_off
(
Ä
)

242 
moff_tim”
[
Ä
]=3*
HZ
;

243 
	}
}

245 
	$do_æÝpy_tim”
()

247 
i
;

248 
mask
 = 0x10;

250 
i
=0 ; i<4 ; i++,
mask
 <<= 1) {

251 ià(!(
mask
 & 
cu¼’t_DOR
))

253 ià(
mÚ_tim”
[
i
]) {

254 ià(!--
mÚ_tim”
[
i
])

255 
	`wake_up
(
i
+
wa™_mÙÜ
);

256 } ià(!
moff_tim”
[
i
]) {

257 
cu¼’t_DOR
 &ð~
mask
;

258 
	`outb
(
cu¼’t_DOR
,
FD_DOR
);

260 
moff_tim”
[
i
]--;

262 
	}
}

264 
	#TIME_REQUESTS
 64

	)

266 
	stim”_li¡
 {

267 
	mjiff›s
;

268 (*
	mâ
)();

269 
tim”_li¡
 * 
	mÃxt
;

270 } 
	gtim”_li¡
[
TIME_REQUESTS
], * 
	gÃxt_tim”
 = 
NULL
;

272 
	$add_tim”
(
jiff›s
, (*
â
)())

274 
tim”_li¡
 * 
p
;

276 ià(!
â
)

278 
	`þi
();

279 ià(
jiff›s
 <= 0)

280 (
â
)();

282 
p
 = 
tim”_li¡
 ;… <im”_li¡ + 
TIME_REQUESTS
 ;…++)

283 ià(!
p
->
â
)

285 ià(
p
 >ð
tim”_li¡
 + 
TIME_REQUESTS
)

286 
	`·nic
("No moreime„equests free");

287 
p
->
â
 = fn;

288 
p
->
jiff›s
 = jiffies;

289 
p
->
Ãxt
 = 
Ãxt_tim”
;

290 
Ãxt_tim”
 = 
p
;

291 
p
->
Ãxt
 &&…->Ãxt->
jiff›s
 <…->jiffies) {

292 
p
->
jiff›s
 -ðp->
Ãxt
->jiffies;

293 
â
 = 
p
->fn;

294 
p
->
â
 =…->
Ãxt
->fn;

295 
p
->
Ãxt
->
â
 = fn;

296 
jiff›s
 = 
p
->jiffies;

297 
p
->
jiff›s
 =…->
Ãxt
->jiffies;

298 
p
->
Ãxt
->
jiff›s
 = jiffies;

299 
p
 =…->
Ãxt
;

302 
	`¡i
();

303 
	}
}

305 
	$do_tim”
(
ýl
)

307 
b“pcouÁ
;

308 
	`sysb“p¡Ý
();

310 ià(
b“pcouÁ
)

311 ià(!--
b“pcouÁ
)

312 
	`sysb“p¡Ý
();

314 ià(
ýl
)

315 
cu¼’t
->
utime
++;

317 
cu¼’t
->
¡ime
++;

319 ià(
Ãxt_tim”
) {

320 
Ãxt_tim”
->
jiff›s
--;

321 
Ãxt_tim”
 &&‚ext_tim”->
jiff›s
 <= 0) {

322 (*
â
)();

324 
â
 = 
Ãxt_tim”
->fn;

325 
Ãxt_tim”
->
â
 = 
NULL
;

326 
Ãxt_tim”
 =‚ext_tim”->
Ãxt
;

327 (
â
)();

330 ià(
cu¼’t_DOR
 & 0xf0)

331 
	`do_æÝpy_tim”
();

332 ià((--
cu¼’t
->
couÁ”
)>0) ;

333 
cu¼’t
->
couÁ”
=0;

334 ià(!
ýl
) ;

335 
	`scheduË
();

336 
	}
}

338 
	$sys_®¬m
(
£cÚds
)

340 
Þd
 = 
cu¼’t
->
®¬m
;

342 ià(
Þd
)

343 
Þd
 = (Þd - 
jiff›s
è/ 
HZ
;

344 
cu¼’t
->
®¬m
 = (
£cÚds
>0)?(
jiff›s
+
HZ
*seconds):0;

345  (
Þd
);

346 
	}
}

348 
	$sys_g‘pid
()

350  
cu¼’t
->
pid
;

351 
	}
}

353 
	$sys_g‘µid
()

355  
cu¼’t
->
çth”
;

356 
	}
}

358 
	$sys_g‘uid
()

360  
cu¼’t
->
uid
;

361 
	}
}

363 
	$sys_g‘euid
()

365  
cu¼’t
->
euid
;

366 
	}
}

368 
	$sys_g‘gid
()

370  
cu¼’t
->
gid
;

371 
	}
}

373 
	$sys_g‘egid
()

375  
cu¼’t
->
egid
;

376 
	}
}

378 
	$sys_niû
(
šüem’t
)

380 ià(
cu¼’t
->
´iÜ™y
-
šüem’t
>0)

381 
cu¼’t
->
´iÜ™y
 -ð
šüem’t
;

383 
	}
}

385 
	$sched_š™
()

387 
i
;

388 
desc_¡ruù
 * 
p
;

390 ià((
sigaùiÚ
) != 16)

391 
	`·nic
("Struct sigaction MUST be 16 bytes");

392 
	`£t_tss_desc
(
gdt
+
FIRST_TSS_ENTRY
,&(
š™_sk
.
sk
.
tss
));

393 
	`£t_ldt_desc
(
gdt
+
FIRST_LDT_ENTRY
,&(
š™_sk
.
sk
.
ldt
));

394 
p
 = 
gdt
+2+
FIRST_TSS_ENTRY
;

395 
i
=1;i<
NR_TASKS
;i++) {

396 
sk
[
i
] = 
NULL
;

397 
p
->
a
õ->
b
=0;

398 
p
++;

399 
p
->
a
õ->
b
=0;

400 
p
++;

403 
	`__asm__
("pushfl ;‡ndl $0xffffbfff,(%esp) ;…opfl");

404 
	`Ér
(0);

405 
	`Îdt
(0);

406 
	`outb_p
(0x36,0x43);

407 
	`outb_p
(
LATCH
 & 0xff , 0x40);

408 
	`outb
(
LATCH
 >> 8 , 0x40);

409 
	`£t_šŒ_g©e
(0x20,&
tim”_š‹¼u±
);

410 
	`outb
(
	`šb_p
(0x21)&~0x01,0x21);

411 
	`£t_sy¡em_g©e
(0x80,&
sy¡em_ÿÎ
);

412 
	}
}

	@kernel/signal.c

7 
	~<lšux/sched.h
>

8 
	~<lšux/k”Ãl.h
>

9 
	~<asm/£gm’t.h
>

11 
	~<sigÇl.h
>

13 vÞ©ž
do_ex™
(
”rÜ_code
);

15 
	$sys_sg‘mask
()

17  
cu¼’t
->
blocked
;

18 
	}
}

20 
	$sys_s£tmask
(
Ãwmask
)

22 
Þd
=
cu¼’t
->
blocked
;

24 
cu¼’t
->
blocked
 = 
Ãwmask
 & ~(1<<(
SIGKILL
-1));

25  
Þd
;

26 
	}
}

28 
šlše
 
	$§ve_Þd
(* 
äom
,* 
to
)

30 
i
;

32 
	`v”ify_¬—
(
to
, (
sigaùiÚ
));

33 
i
=0 ; i< (
sigaùiÚ
) ; i++) {

34 
	`put_fs_by‹
(*
äom
,
to
);

35 
äom
++;

36 
to
++;

38 
	}
}

40 
šlše
 
	$g‘_Ãw
(* 
äom
,* 
to
)

42 
i
;

44 
i
=0 ; i< (
sigaùiÚ
) ; i++)

45 *(
to
++èð
	`g‘_fs_by‹
(
äom
++);

46 
	}
}

48 
	$sys_sigÇl
(
signum
, 
hªdËr
, 
»¡Ü”
)

50 
sigaùiÚ
 
tmp
;

52 ià(
signum
<1 || signum>32 || signum==
SIGKILL
)

54 
tmp
.
§_hªdËr
 = ((*)()è
hªdËr
;

55 
tmp
.
§_mask
 = 0;

56 
tmp
.
§_æags
 = 
SA_ONESHOT
 | 
SA_NOMASK
;

57 
tmp
.
§_»¡Ü”
 = ((*)()è
»¡Ü”
;

58 
hªdËr
 = (è
cu¼’t
->
sigaùiÚ
[
signum
-1].
§_hªdËr
;

59 
cu¼’t
->
sigaùiÚ
[
signum
-1] = 
tmp
;

60  
hªdËr
;

61 
	}
}

63 
	$sys_sigaùiÚ
(
signum
, cÚ¡ 
sigaùiÚ
 * 
aùiÚ
,

64 
sigaùiÚ
 * 
ÞdaùiÚ
)

66 
sigaùiÚ
 
tmp
;

68 ià(
signum
<1 || signum>32 || signum==
SIGKILL
)

70 
tmp
 = 
cu¼’t
->
sigaùiÚ
[
signum
-1];

71 
	`g‘_Ãw
((*è
aùiÚ
,

72 (*è(
signum
-1+
cu¼’t
->
sigaùiÚ
));

73 ià(
ÞdaùiÚ
)

74 
	`§ve_Þd
((*è&
tmp
,(*è
ÞdaùiÚ
);

75 ià(
cu¼’t
->
sigaùiÚ
[
signum
-1].
§_æags
 & 
SA_NOMASK
)

76 
cu¼’t
->
sigaùiÚ
[
signum
-1].
§_mask
 = 0;

78 
cu¼’t
->
sigaùiÚ
[
signum
-1].
§_mask
 |= (1<<(signum-1));

80 
	}
}

82 
	$do_sigÇl
(
sigÄ
,
—x
, 
ebx
, 
ecx
, 
edx
,

83 
fs
, 
es
, 
ds
,

84 
e
, 
cs
, 
eæags
,

85 * 
e¥
, 
ss
)

87 
§_hªdËr
;

88 
Þd_e
=
e
;

89 
sigaùiÚ
 * 
§
 = 
cu¼’t
->sigaùiÚ + 
sigÄ
 - 1;

90 
lÚgs
;

91 * 
tmp_e¥
;

93 
§_hªdËr
 = (è
§
->sa_handler;

94 ià(
§_hªdËr
==1)

96 ià(!
§_hªdËr
) {

97 ià(
sigÄ
==
SIGCHLD
)

100 
	`do_ex™
(1<<(
sigÄ
-1));

102 ià(
§
->
§_æags
 & 
SA_ONESHOT
)

103 
§
->
§_hªdËr
 = 
NULL
;

104 *(&
e
èð
§_hªdËr
;

105 
lÚgs
 = (
§
->
§_æags
 & 
SA_NOMASK
)?7:8;

106 *(&
e¥
è-ð
lÚgs
;

107 
	`v”ify_¬—
(
e¥
,
lÚgs
*4);

108 
tmp_e¥
=
e¥
;

109 
	`put_fs_lÚg
((è
§
->
§_»¡Ü”
,
tmp_e¥
++);

110 
	`put_fs_lÚg
(
sigÄ
,
tmp_e¥
++);

111 ià(!(
§
->
§_æags
 & 
SA_NOMASK
))

112 
	`put_fs_lÚg
(
cu¼’t
->
blocked
,
tmp_e¥
++);

113 
	`put_fs_lÚg
(
—x
,
tmp_e¥
++);

114 
	`put_fs_lÚg
(
ecx
,
tmp_e¥
++);

115 
	`put_fs_lÚg
(
edx
,
tmp_e¥
++);

116 
	`put_fs_lÚg
(
eæags
,
tmp_e¥
++);

117 
	`put_fs_lÚg
(
Þd_e
,
tmp_e¥
++);

118 
cu¼’t
->
blocked
 |ð
§
->
§_mask
;

119 
	}
}

	@kernel/sys.c

7 
	~<”ºo.h
>

9 
	~<lšux/sched.h
>

10 
	~<lšux/‰y.h
>

11 
	~<lšux/k”Ãl.h
>

12 
	~<asm/£gm’t.h
>

13 
	~<sys/times.h
>

14 
	~<sys/ut¢ame.h
>

16 
	$sys_áime
()

18  -
ENOSYS
;

19 
	}
}

21 
	$sys_b»ak
()

23  -
ENOSYS
;

24 
	}
}

26 
	$sys_±¿û
()

28  -
ENOSYS
;

29 
	}
}

31 
	$sys_¡ty
()

33  -
ENOSYS
;

34 
	}
}

36 
	$sys_g‰y
()

38  -
ENOSYS
;

39 
	}
}

41 
	$sys_»Çme
()

43  -
ENOSYS
;

44 
	}
}

46 
	$sys_´of
()

48  -
ENOSYS
;

49 
	}
}

51 
	$sys_£Œegid
(
rgid
, 
egid
)

53 ià(
rgid
>0) {

54 ià((
cu¼’t
->
gid
 =ð
rgid
) ||

55 
	`su£r
())

56 
cu¼’t
->
gid
 = 
rgid
;

58 (-
EPERM
);

60 ià(
egid
>0) {

61 ià((
cu¼’t
->
gid
 =ð
egid
) ||

62 (
cu¼’t
->
egid
 ==ƒgid) ||

63 (
cu¼’t
->
sgid
 =ð
egid
) ||

64 
	`su£r
())

65 
cu¼’t
->
egid
 =ƒgid;

67 (-
EPERM
);

70 
	}
}

72 
	$sys_£tgid
(
gid
)

74 (
	`sys_£Œegid
(
gid
, gid));

75 
	}
}

77 
	$sys_acù
()

79  -
ENOSYS
;

80 
	}
}

82 
	$sys_phys
()

84  -
ENOSYS
;

85 
	}
}

87 
	$sys_lock
()

89  -
ENOSYS
;

90 
	}
}

92 
	$sys_mpx
()

94  -
ENOSYS
;

95 
	}
}

97 
	$sys_ulim™
()

99  -
ENOSYS
;

100 
	}
}

102 
	$sys_time
(* 
Žoc
)

104 
i
;

106 
i
 = 
CURRENT_TIME
;

107 ià(
Žoc
) {

108 
	`v”ify_¬—
(
Žoc
,4);

109 
	`put_fs_lÚg
(
i
,(*)
Žoc
);

111  
i
;

112 
	}
}

118 
	$sys_£Œeuid
(
ruid
, 
euid
)

120 
Þd_ruid
 = 
cu¼’t
->
uid
;

122 ià(
ruid
>0) {

123 ià((
cu¼’t
->
euid
==
ruid
) ||

124 (
Þd_ruid
 =ð
ruid
) ||

125 
	`su£r
())

126 
cu¼’t
->
uid
 = 
ruid
;

128 (-
EPERM
);

130 ià(
euid
>0) {

131 ià((
Þd_ruid
 =ð
euid
) ||

132 (
cu¼’t
->
euid
 ==ƒuid) ||

133 
	`su£r
())

134 
cu¼’t
->
euid
 =ƒuid;

136 
cu¼’t
->
uid
 = 
Þd_ruid
;

137 (-
EPERM
);

141 
	}
}

143 
	$sys_£tuid
(
uid
)

145 (
	`sys_£Œeuid
(
uid
, uid));

146 
	}
}

148 
	$sys_¡ime
(* 
Œ
)

150 ià(!
	`su£r
())

151  -
EPERM
;

152 
¡¬tup_time
 = 
	`g‘_fs_lÚg
((*)
Œ
è- 
jiff›s
/
HZ
;

154 
	}
}

156 
	$sys_times
(
tms
 * 
tbuf
)

158 ià(
tbuf
) {

159 
	`v”ify_¬—
(
tbuf
, *tbuf);

160 
	`put_fs_lÚg
(
cu¼’t
->
utime
,(*)&
tbuf
->
tms_utime
);

161 
	`put_fs_lÚg
(
cu¼’t
->
¡ime
,(*)&
tbuf
->
tms_¡ime
);

162 
	`put_fs_lÚg
(
cu¼’t
->
cutime
,(*)&
tbuf
->
tms_cutime
);

163 
	`put_fs_lÚg
(
cu¼’t
->
c¡ime
,(*)&
tbuf
->
tms_c¡ime
);

165  
jiff›s
;

166 
	}
}

168 
	$sys_brk
(
’d_d©a_£g
)

170 ià(
’d_d©a_£g
 >ð
cu¼’t
->
’d_code
 &&

171 
’d_d©a_£g
 < 
cu¼’t
->
¡¬t_¡ack
 - 16384)

172 
cu¼’t
->
brk
 = 
’d_d©a_£g
;

173  
cu¼’t
->
brk
;

174 
	}
}

181 
	$sys_£gid
(
pid
, 
pgid
)

183 
i
;

185 ià(!
pid
)

186 
pid
 = 
cu¼’t
->pid;

187 ià(!
pgid
)

188 
pgid
 = 
cu¼’t
->
pid
;

189 
i
=0 ; i<
NR_TASKS
 ; i++)

190 ià(
sk
[
i
] &&ask[i]->
pid
==pid) {

191 ià(
sk
[
i
]->
Ëad”
)

192  -
EPERM
;

193 ià(
sk
[
i
]->
£ssiÚ
 !ð
cu¼’t
->session)

194  -
EPERM
;

195 
sk
[
i
]->
pg½
 = 
pgid
;

198  -
ESRCH
;

199 
	}
}

201 
	$sys_g‘pg½
()

203  
cu¼’t
->
pg½
;

204 
	}
}

206 
	$sys_£tsid
()

208 ià(
cu¼’t
->
Ëad”
 && !
	`su£r
())

209  -
EPERM
;

210 
cu¼’t
->
Ëad”
 = 1;

211 
cu¼’t
->
£ssiÚ
 = cu¼’t->
pg½
 = cu¼’t->
pid
;

212 
cu¼’t
->
‰y
 = -1;

213  
cu¼’t
->
pg½
;

214 
	}
}

216 
	$sys_uÇme
(
ut¢ame
 * 
Çme
)

218 
ut¢ame
 
thi¢ame
 = {

221 
i
;

223 ià(!
Çme
è -
ERROR
;

224 
	`v”ify_¬—
(
Çme
, *name);

225 
i
=0;i< *
Çme
;i++)

226 
	`put_fs_by‹
(((*è&
thi¢ame
)[
i
],i+(*è
Çme
);

228 
	}
}

230 
	$sys_umask
(
mask
)

232 
Þd
 = 
cu¼’t
->
umask
;

234 
cu¼’t
->
umask
 = 
mask
 & 0777;

235  (
Þd
);

236 
	}
}

	@kernel/traps.c

13 
	~<¡ršg.h
>

15 
	~<lšux/h—d.h
>

16 
	~<lšux/sched.h
>

17 
	~<lšux/k”Ãl.h
>

18 
	~<asm/sy¡em.h
>

19 
	~<asm/£gm’t.h
>

20 
	~<asm/io.h
>

22 
	#g‘_£g_by‹
(
£g
,
addr
) ({ \

23 
__»s
; \

24 
	`__asm__
("push %%fs;mov %%ax,%%fs;movb %%fs:%2,%%al;pop %%fs" \

25 :"÷" (
__»s
):"0" (
£g
),"m" (*(
addr
))); \

26 
__»s
;})

	)

28 
	#g‘_£g_lÚg
(
£g
,
addr
) ({ \

29 
__»s
; \

30 
	`__asm__
("push %%fs;mov %%ax,%%fs;movl %%fs:%2,%%eax;pop %%fs" \

31 :"÷" (
__»s
):"0" (
£g
),"m" (*(
addr
))); \

32 
__»s
;})

	)

34 
	#_fs
() ({ \

35 
__»s
; \

36 
	`__asm__
("mov %%fs,%%ax":"÷" (
__»s
):); \

37 
__»s
;})

	)

39 
do_ex™
(
code
);

41 
·ge_exû±iÚ
();

43 
divide_”rÜ
();

44 
debug
();

45 
nmi
();

46 
št3
();

47 
ov”æow
();

48 
bounds
();

49 
šv®id_Ý
();

50 
deviû_nÙ_avažabË
();

51 
doubË_çuÉ
();

52 
cÝroûssÜ_£gm’t_ov”run
();

53 
šv®id_TSS
();

54 
£gm’t_nÙ_´e£Á
();

55 
¡ack_£gm’t
();

56 
g’”®_´ÙeùiÚ
();

57 
·ge_çuÉ
();

58 
cÝroûssÜ_”rÜ
();

59 
»£rved
();

60 
·¿Î–_š‹¼u±
();

61 
œq13
();

63 
	$d›
(* 
¡r
,
e¥_±r
,
Ä
)

65 * 
e¥
 = (*è
e¥_±r
;

66 
i
;

68 
	`´štk
("%s: %04x\n\r",
¡r
,
Ä
&0xffff);

69 
	`´štk
("EIP:\t%04x:%p\nEFLAGS:\t%p\nESP:\t%04x:%p\n",

70 
e¥
[1],esp[0],esp[2],esp[4],esp[3]);

71 
	`´štk
("fs: %04x\n",
	`_fs
());

72 
	`´štk
("ba£: %p,†im™: %p\n",
	`g‘_ba£
(
cu¼’t
->
ldt
[1]),
	`g‘_lim™
(0x17));

73 ià(
e¥
[4] == 0x17) {

74 
	`´štk
("Stack: ");

75 
i
=0;i<4;i++)

76 
	`´štk
("%°",
	`g‘_£g_lÚg
(0x17,
i
+(*)
e¥
[3]));

77 
	`´štk
("\n");

79 
	`¡r
(
i
);

80 
	`´štk
("Pid: %d,…roûs Ä: %d\n\r",
cu¼’t
->
pid
,0xfffà& 
i
);

81 
i
=0;i<10;i++)

82 
	`´štk
("%02x ",0xfà& 
	`g‘_£g_by‹
(
e¥
[1],(
i
+(*)esp[0])));

83 
	`´štk
("\n\r");

84 
	`do_ex™
(11);

85 
	}
}

87 
	$do_doubË_çuÉ
(
e¥
, 
”rÜ_code
)

89 
	`d›
("doubË fauÉ",
e¥
,
”rÜ_code
);

90 
	}
}

92 
	$do_g’”®_´ÙeùiÚ
(
e¥
, 
”rÜ_code
)

94 
	`d›
("g’”®…rÙeùiÚ",
e¥
,
”rÜ_code
);

95 
	}
}

97 
	$do_divide_”rÜ
(
e¥
, 
”rÜ_code
)

99 
	`d›
("divid”rÜ",
e¥
,
”rÜ_code
);

100 
	}
}

102 
	$do_št3
(* 
e¥
, 
”rÜ_code
,

103 
fs
,
es
,
ds
,

104 
ebp
,
esi
,
edi
,

105 
edx
,
ecx
,
ebx
,
—x
)

107 
Œ
;

109 
	`__asm__
("¡¸%%ax":"÷" (
Œ
):"0" (0));

110 
	`´štk
("eax\t\tebx\t\tecx\t\tedx\n\r%8x\t%8x\t%8x\t%8x\n\r",

111 
—x
,
ebx
,
ecx
,
edx
);

112 
	`´štk
("esi\t\tedi\t\tebp\t\tesp\n\r%8x\t%8x\t%8x\t%8x\n\r",

113 
esi
,
edi
,
ebp
,(è
e¥
);

114 
	`´štk
("\n\rds\tes\tfs\ttr\n\r%4x\t%4x\t%4x\t%4x\n\r",

115 
ds
,
es
,
fs
,
Œ
);

116 
	`´štk
("EIP: %8x CS: %4x EFLAGS: %8x\n\r",
e¥
[0],esp[1],esp[2]);

117 
	}
}

119 
	$do_nmi
(
e¥
, 
”rÜ_code
)

121 
	`d›
("nmi",
e¥
,
”rÜ_code
);

122 
	}
}

124 
	$do_debug
(
e¥
, 
”rÜ_code
)

126 
	`d›
("debug",
e¥
,
”rÜ_code
);

127 
	}
}

129 
	$do_ov”æow
(
e¥
, 
”rÜ_code
)

131 
	`d›
("ov”æow",
e¥
,
”rÜ_code
);

132 
	}
}

134 
	$do_bounds
(
e¥
, 
”rÜ_code
)

136 
	`d›
("bounds",
e¥
,
”rÜ_code
);

137 
	}
}

139 
	$do_šv®id_Ý
(
e¥
, 
”rÜ_code
)

141 
	`d›
("šv®id o³¿nd",
e¥
,
”rÜ_code
);

142 
	}
}

144 
	$do_deviû_nÙ_avažabË
(
e¥
, 
”rÜ_code
)

146 
	`d›
("deviû‚Ù‡važabË",
e¥
,
”rÜ_code
);

147 
	}
}

149 
	$do_cÝroûssÜ_£gm’t_ov”run
(
e¥
, 
”rÜ_code
)

151 
	`d›
("cÝroûssÜ segm’ˆov”run",
e¥
,
”rÜ_code
);

152 
	}
}

154 
	$do_šv®id_TSS
(
e¥
,
”rÜ_code
)

156 
	`d›
("šv®id TSS",
e¥
,
”rÜ_code
);

157 
	}
}

159 
	$do_£gm’t_nÙ_´e£Á
(
e¥
,
”rÜ_code
)

161 
	`d›
("£gm’ˆnÙ…»£Á",
e¥
,
”rÜ_code
);

162 
	}
}

164 
	$do_¡ack_£gm’t
(
e¥
,
”rÜ_code
)

166 
	`d›
("¡ack segm’t",
e¥
,
”rÜ_code
);

167 
	}
}

169 
	$do_cÝroûssÜ_”rÜ
(
e¥
, 
”rÜ_code
)

171 ià(
Ï¡_sk_u£d_m©h
 !ð
cu¼’t
)

173 
	`d›
("cÝroûssÜƒ¼Ü",
e¥
,
”rÜ_code
);

174 
	}
}

176 
	$do_»£rved
(
e¥
, 
”rÜ_code
)

178 
	`d›
("»£rved (15,17-47è”rÜ",
e¥
,
”rÜ_code
);

179 
	}
}

181 
	$Œ­_š™
()

183 
i
;

185 
	`£t_Œ­_g©e
(0,&
divide_”rÜ
);

186 
	`£t_Œ­_g©e
(1,&
debug
);

187 
	`£t_Œ­_g©e
(2,&
nmi
);

188 
	`£t_sy¡em_g©e
(3,&
št3
);

189 
	`£t_sy¡em_g©e
(4,&
ov”æow
);

190 
	`£t_sy¡em_g©e
(5,&
bounds
);

191 
	`£t_Œ­_g©e
(6,&
šv®id_Ý
);

192 
	`£t_Œ­_g©e
(7,&
deviû_nÙ_avažabË
);

193 
	`£t_Œ­_g©e
(8,&
doubË_çuÉ
);

194 
	`£t_Œ­_g©e
(9,&
cÝroûssÜ_£gm’t_ov”run
);

195 
	`£t_Œ­_g©e
(10,&
šv®id_TSS
);

196 
	`£t_Œ­_g©e
(11,&
£gm’t_nÙ_´e£Á
);

197 
	`£t_Œ­_g©e
(12,&
¡ack_£gm’t
);

198 
	`£t_Œ­_g©e
(13,&
g’”®_´ÙeùiÚ
);

199 
	`£t_Œ­_g©e
(14,&
·ge_çuÉ
);

200 
	`£t_Œ­_g©e
(15,&
»£rved
);

201 
	`£t_Œ­_g©e
(16,&
cÝroûssÜ_”rÜ
);

202 
i
=17;i<48;i++)

203 
	`£t_Œ­_g©e
(
i
,&
»£rved
);

204 
	`£t_Œ­_g©e
(45,&
œq13
);

205 
	`outb_p
(
	`šb_p
(0x21)&0xfb,0x21);

206 
	`outb
(
	`šb_p
(0xA1)&0xdf,0xA1);

207 
	`£t_Œ­_g©e
(39,&
·¿Î–_š‹¼u±
);

208 
	}
}

	@kernel/vsprintf.c

12 
	~<¡d¬g.h
>

13 
	~<¡ršg.h
>

16 
	#is_dig™
(
c
è((cè>ð'0' && (cè<ð'9')

	)

18 
	$sk_©oi
(cÚ¡ **
s
)

20 
i
=0;

22 
	`is_dig™
(**
s
))

23 
i
 = i*10 + *((*
s
)++) - '0';

24  
i
;

25 
	}
}

27 
	#ZEROPAD
 1

	)

28 
	#SIGN
 2

	)

29 
	#PLUS
 4

	)

30 
	#SPACE
 8

	)

31 
	#LEFT
 16

	)

32 
	#SPECIAL
 32

	)

33 
	#SMALL
 64

	)

35 
	#do_div
(
n
,
ba£
) ({ \

36 
__»s
; \

37 
	`__asm__
("divÈ%4":"÷" (
n
),"=d" (
__»s
):"0" (n),"1" (0),"r" (
ba£
)); \

38 
__»s
; })

	)

40 * 
	$numb”
(* 
¡r
, 
num
, 
ba£
, 
size
, 
´ecisiÚ


41 ,
ty³
)

43 
c
,
sign
,
tmp
[36];

44 cÚ¡ *
dig™s
="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";

45 
i
;

47 ià(
ty³
&
SMALL
è
dig™s
="0123456789abcdefghijklmnopqrstuvwxyz";

48 ià(
ty³
&
LEFT
èty³ &ð~
ZEROPAD
;

49 ià(
ba£
<2 || base>36)

51 
c
 = (
ty³
 & 
ZEROPAD
) ? '0' : ' ' ;

52 ià(
ty³
&
SIGN
 && 
num
<0) {

53 
sign
='-';

54 
num
 = -num;

56 
sign
=(
ty³
&
PLUS
è? '+' : (Ñy³&
SPACE
) ? ' ' : 0);

57 ià(
sign
è
size
--;

58 ià(
ty³
&
SPECIAL
)

59 ià(
ba£
==16è
size
 -= 2;

60 ià(
ba£
==8è
size
--;

61 
i
=0;

62 ià(
num
==0)

63 
tmp
[
i
++]='0';

64 
num
!=0)

65 
tmp
[
i
++]=
dig™s
[
	`do_div
(
num
,
ba£
)];

66 ià(
i
>
´ecisiÚ
)…recision=i;

67 
size
 -ð
´ecisiÚ
;

68 ià(!(
ty³
&(
ZEROPAD
+
LEFT
)))

69 
size
-->0)

70 *
¡r
++ = ' ';

71 ià(
sign
)

72 *
¡r
++ = 
sign
;

73 ià(
ty³
&
SPECIAL
)

74 ià(
ba£
==8)

75 *
¡r
++ = '0';

76 ià(
ba£
==16) {

77 *
¡r
++ = '0';

78 *
¡r
++ = 
dig™s
[33];

80 ià(!(
ty³
&
LEFT
))

81 
size
-->0)

82 *
¡r
++ = 
c
;

83 
i
<
´ecisiÚ
--)

84 *
¡r
++ = '0';

85 
i
-->0)

86 *
¡r
++ = 
tmp
[
i
];

87 
size
-->0)

88 *
¡r
++ = ' ';

89  
¡r
;

90 
	}
}

92 
	$v¥rštf
(*
buf
, cÚ¡ *
fmt
, 
va_li¡
 
¬gs
)

94 
Ën
;

95 
i
;

96 * 
¡r
;

97 *
s
;

98 *

;

100 
æags
;

102 
f›ld_width
;

103 
´ecisiÚ
;

105 
qu®if›r
;

107 
¡r
=
buf
 ; *
fmt
 ; ++fmt) {

108 ià(*
fmt
 != '%') {

109 *
¡r
++ = *
fmt
;

114 
æags
 = 0;

115 
»³©
:

116 ++
fmt
;

117 *
fmt
) {

118 '-': 
æags
 |ð
LEFT
; 
»³©
;

119 '+': 
æags
 |ð
PLUS
; 
»³©
;

120 ' ': 
æags
 |ð
SPACE
; 
»³©
;

121 '#': 
æags
 |ð
SPECIAL
; 
»³©
;

122 '0': 
æags
 |ð
ZEROPAD
; 
»³©
;

126 
f›ld_width
 = -1;

127 ià(
	`is_dig™
(*
fmt
))

128 
f›ld_width
 = 
	`sk_©oi
(&
fmt
);

129 ià(*
fmt
 == '*') {

131 
f›ld_width
 = 
	`va_¬g
(
¬gs
, );

132 ià(
f›ld_width
 < 0) {

133 
f›ld_width
 = -field_width;

134 
æags
 |ð
LEFT
;

139 
´ecisiÚ
 = -1;

140 ià(*
fmt
 == '.') {

141 ++
fmt
;

142 ià(
	`is_dig™
(*
fmt
))

143 
´ecisiÚ
 = 
	`sk_©oi
(&
fmt
);

144 ià(*
fmt
 == '*') {

146 
´ecisiÚ
 = 
	`va_¬g
(
¬gs
, );

148 ià(
´ecisiÚ
 < 0)

149 
´ecisiÚ
 = 0;

153 
qu®if›r
 = -1;

154 ià(*
fmt
 == 'h' || *fmt == 'l' || *fmt == 'L') {

155 
qu®if›r
 = *
fmt
;

156 ++
fmt
;

159 *
fmt
) {

161 ià(!(
æags
 & 
LEFT
))

162 --
f›ld_width
 > 0)

163 *
¡r
++ = ' ';

164 *
¡r
++ = (è
	`va_¬g
(
¬gs
, );

165 --
f›ld_width
 > 0)

166 *
¡r
++ = ' ';

170 
s
 = 
	`va_¬g
(
¬gs
, *);

171 
Ën
 = 
	`¡¾’
(
s
);

172 ià(
´ecisiÚ
 < 0)

173 
´ecisiÚ
 = 
Ën
;

174 ià(
Ën
 > 
´ecisiÚ
)

175 
Ën
 = 
´ecisiÚ
;

177 ià(!(
æags
 & 
LEFT
))

178 
Ën
 < 
f›ld_width
--)

179 *
¡r
++ = ' ';

180 
i
 = 0; i < 
Ën
; ++i)

181 *
¡r
++ = *
s
++;

182 
Ën
 < 
f›ld_width
--)

183 *
¡r
++ = ' ';

187 
¡r
 = 
	`numb”
(¡r, 
	`va_¬g
(
¬gs
, ), 8,

188 
f›ld_width
, 
´ecisiÚ
, 
æags
);

192 ià(
f›ld_width
 == -1) {

193 
f›ld_width
 = 8;

194 
æags
 |ð
ZEROPAD
;

196 
¡r
 = 
	`numb”
(str,

197 (è
	`va_¬g
(
¬gs
, *), 16,

198 
f›ld_width
, 
´ecisiÚ
, 
æags
);

202 
æags
 |ð
SMALL
;

204 
¡r
 = 
	`numb”
(¡r, 
	`va_¬g
(
¬gs
, ), 16,

205 
f›ld_width
, 
´ecisiÚ
, 
æags
);

210 
æags
 |ð
SIGN
;

212 
¡r
 = 
	`numb”
(¡r, 
	`va_¬g
(
¬gs
, ), 10,

213 
f›ld_width
, 
´ecisiÚ
, 
æags
);

217 

 = 
	`va_¬g
(
¬gs
, *);

218 *

 = (
¡r
 - 
buf
);

222 ià(*
fmt
 != '%')

223 *
¡r
++ = '%';

224 ià(*
fmt
)

225 *
¡r
++ = *
fmt
;

227 --
fmt
;

231 *
¡r
 = '\0';

232  
¡r
-
buf
;

233 
	}
}

	@lib/_exit.c

7 
	#__LIBRARY__


	)

8 
	~<uni¡d.h
>

10 vÞ©ž
	$_ex™
(
ex™_code
)

12 
	`__asm__
("šˆ$0x80"::"a" (
__NR_ex™
),"b" (
ex™_code
));

13 
	}
}

	@lib/close.c

7 
	#__LIBRARY__


	)

8 
	~<uni¡d.h
>

10 
_sysÿÎ1
(,
þo£
,,
fd
)

	@lib/ctype.c

7 
	~<ùy³.h
>

9 
	g_ùmp
;

10 
	g_ùy³
[] = {0x00,

11 
_C
,_C,_C,_C,_C,_C,_C,_C,

12 
_C
,_C|
_S
,_C|_S,_C|_S,_C|_S,_C|_S,_C,_C,

13 
_C
,_C,_C,_C,_C,_C,_C,_C,

14 
_C
,_C,_C,_C,_C,_C,_C,_C,

15 
_S
|
_SP
,
_P
,_P,_P,_P,_P,_P,_P,

16 
_P
,_P,_P,_P,_P,_P,_P,_P,

17 
_D
,_D,_D,_D,_D,_D,_D,_D,

18 
_D
,_D,
_P
,_P,_P,_P,_P,_P,

19 
_P
,
_U
|
_X
,_U|_X,_U|_X,_U|_X,_U|_X,_U|_X,_U,

20 
_U
,_U,_U,_U,_U,_U,_U,_U,

21 
_U
,_U,_U,_U,_U,_U,_U,_U,

22 
_U
,_U,_U,
_P
,_P,_P,_P,_P,

23 
_P
,
_L
|
_X
,_L|_X,_L|_X,_L|_X,_L|_X,_L|_X,_L,

24 
_L
,_L,_L,_L,_L,_L,_L,_L,

25 
_L
,_L,_L,_L,_L,_L,_L,_L,

26 
_L
,_L,_L,
_P
,_P,_P,_P,
_C
,

	@lib/dup.c

7 
	#__LIBRARY__


	)

8 
	~<uni¡d.h
>

10 
_sysÿÎ1
(,
dup
,,
fd
)

	@lib/errno.c

7 
	g”ºo
;

	@lib/execve.c

7 
	#__LIBRARY__


	)

8 
	~<uni¡d.h
>

10 
_sysÿÎ3
(,
execve
,cÚ¡ *,
fže
,**,
¬gv
,**,
’vp
)

	@lib/malloc.c

48 
	~<lšux/k”Ãl.h
>

49 
	~<lšux/mm.h
>

50 
	~<asm/sy¡em.h
>

52 
	sbuck‘_desc
 {

53 *
	m·ge
;

54 
buck‘_desc
 *
	mÃxt
;

55 *
	mä“±r
;

56 
	m»fút
;

57 
	mbuck‘_size
;

60 
	s_buck‘_dœ
 {

61 
	msize
;

62 
buck‘_desc
 *
	mchaš
;

77 
_buck‘_dœ
 
	gbuck‘_dœ
[] = {

78 { 16, (
buck‘_desc
 *) 0},

79 { 32, (
buck‘_desc
 *) 0},

80 { 64, (
buck‘_desc
 *) 0},

81 { 128, (
buck‘_desc
 *) 0},

82 { 256, (
buck‘_desc
 *) 0},

83 { 512, (
buck‘_desc
 *) 0},

84 { 1024, (
buck‘_desc
 *) 0},

85 { 2048, (
buck‘_desc
 *) 0},

86 { 4096, (
buck‘_desc
 *) 0},

87 { 0, (
buck‘_desc
 *) 0}};

92 
buck‘_desc
 *
	gä“_buck‘_desc
 = (bucket_desc *) 0;

97 
šlše
 
	$š™_buck‘_desc
()

99 
buck‘_desc
 *
bdesc
, *
fœ¡
;

100 
i
;

102 
fœ¡
 = 
bdesc
 = (
buck‘_desc
 *è
	`g‘_ä“_·ge
();

103 ià(!
bdesc
)

104 
	`·nic
("Out of memory in init_bucket_desc()");

105 
i
 = 
PAGE_SIZE
/(
buck‘_desc
); i > 1; i--) {

106 
bdesc
->
Ãxt
 = bdesc+1;

107 
bdesc
++;

113 
bdesc
->
Ãxt
 = 
ä“_buck‘_desc
;

114 
ä“_buck‘_desc
 = 
fœ¡
;

115 
	}
}

117 *
	$m®loc
(
Ën
)

119 
_buck‘_dœ
 *
bdœ
;

120 
buck‘_desc
 *
bdesc
;

121 *
»tv®
;

127 
bdœ
 = 
buck‘_dœ
; bdœ->
size
; bdir++)

128 ià(
bdœ
->
size
 >ð
Ën
)

130 ià(!
bdœ
->
size
) {

131 
	`´štk
("malloc called with impossibly†arge‡rgument (%d)\n",

132 
Ën
);

133 
	`·nic
("malloc: bad‡rg");

138 
	`þi
();

139 
bdesc
 = 
bdœ
->
chaš
; bdesc; bdesøðbdesc->
Ãxt
)

140 ià(
bdesc
->
ä“±r
)

146 ià(!
bdesc
) {

147 *
ý
;

148 
i
;

150 ià(!
ä“_buck‘_desc
)

151 
	`š™_buck‘_desc
();

152 
bdesc
 = 
ä“_buck‘_desc
;

153 
ä“_buck‘_desc
 = 
bdesc
->
Ãxt
;

154 
bdesc
->
»fút
 = 0;

155 
bdesc
->
buck‘_size
 = 
bdœ
->
size
;

156 
bdesc
->
·ge
 = bdesc->
ä“±r
 = (*è
ý
 = 
	`g‘_ä“_·ge
();

157 ià(!
ý
)

158 
	`·nic
("Out of memory in kernel malloc()");

160 
i
=
PAGE_SIZE
/
bdœ
->
size
; i > 1; i--) {

161 *((**è
ý
èðý + 
bdœ
->
size
;

162 
ý
 +ð
bdœ
->
size
;

164 *((**è
ý
) = 0;

165 
bdesc
->
Ãxt
 = 
bdœ
->
chaš
;

166 
bdœ
->
chaš
 = 
bdesc
;

168 
»tv®
 = (*è
bdesc
->
ä“±r
;

169 
bdesc
->
ä“±r
 = *((**è
»tv®
);

170 
bdesc
->
»fút
++;

171 
	`¡i
();

172 (
»tv®
);

173 
	}
}

182 
	$ä“_s
(*
obj
, 
size
)

184 *
·ge
;

185 
_buck‘_dœ
 *
bdœ
;

186 
buck‘_desc
 *
bdesc
, *
´ev
;

189 
·ge
 = (*è((è
obj
 & 0xfffff000);

191 
bdœ
 = 
buck‘_dœ
; bdœ->
size
; bdir++) {

192 
´ev
 = 0;

194 ià(
bdœ
->
size
 < size)

196 
bdesc
 = 
bdœ
->
chaš
; bdesc; bdesøðbdesc->
Ãxt
) {

197 ià(
bdesc
->
·ge
 ==…age)

198 
found
;

199 
´ev
 = 
bdesc
;

202 
	`·nic
("Bad‡ddress…assedo kernel free_s()");

203 
found
:

204 
	`þi
();

205 *((**)
obj
èð
bdesc
->
ä“±r
;

206 
bdesc
->
ä“±r
 = 
obj
;

207 
bdesc
->
»fút
--;

208 ià(
bdesc
->
»fút
 == 0) {

213 ià((
´ev
 && (´ev->
Ãxt
 !ð
bdesc
)) ||

214 (!
´ev
 && (
bdœ
->
chaš
 !ð
bdesc
)))

215 
´ev
 = 
bdœ
->
chaš
;…»v;…»v =…»v->
Ãxt
)

216 ià(
´ev
->
Ãxt
 =ð
bdesc
)

218 ià(
´ev
)

219 
´ev
->
Ãxt
 = 
bdesc
->next;

221 ià(
bdœ
->
chaš
 !ð
bdesc
)

222 
	`·nic
("malloc bucket chains corrupted");

223 
bdœ
->
chaš
 = 
bdesc
->
Ãxt
;

225 
	`ä“_·ge
((è
bdesc
->
·ge
);

226 
bdesc
->
Ãxt
 = 
ä“_buck‘_desc
;

227 
ä“_buck‘_desc
 = 
bdesc
;

229 
	`¡i
();

231 
	}
}

	@lib/open.c

7 
	#__LIBRARY__


	)

8 
	~<uni¡d.h
>

9 
	~<¡d¬g.h
>

11 
	$Ý’
(cÚ¡ * 
fž’ame
, 
æag
, ...)

13 
»s
;

14 
va_li¡
 
¬g
;

16 
	`va_¡¬t
(
¬g
,
æag
);

17 
	`__asm__
("int $0x80"

18 :"÷" (
»s
)

19 :"0" (
__NR_Ý’
),"b" (
fž’ame
),"c" (
æag
),

20 "d" (
	`va_¬g
(
¬g
,)));

21 ià(
»s
>=0)

22  
»s
;

23 
”ºo
 = -
»s
;

25 
	}
}

	@lib/setsid.c

7 
	#__LIBRARY__


	)

8 
	~<uni¡d.h
>

10 
_sysÿÎ0
(
pid_t
,
£tsid
)

	@lib/string.c

7 #iâdeà
__GNUC__


8 #”rÜ 
I
 
wªt
 
gcc
!

11 

	)

12 
	#šlše


	)

13 
	#__LIBRARY__


	)

14 
	~<¡ršg.h
>

	@lib/wait.c

7 
	#__LIBRARY__


	)

8 
	~<uni¡d.h
>

9 
	~<sys/wa™.h
>

11 
	$_sysÿÎ3
(
pid_t
,
wa™pid
,pid_t,
pid
,*,
wa™_¡©
,,
ÝtiÚs
)

13 
pid_t
 
	$wa™
(* 
wa™_¡©
)

15  
	`wa™pid
(-1,
wa™_¡©
,0);

16 
	}
}

	@lib/write.c

7 
	#__LIBRARY__


	)

8 
	~<uni¡d.h
>

10 
_sysÿÎ3
(,
wr™e
,,
fd
,cÚ¡ *,
buf
,
off_t
,
couÁ
)

	@mm/memory.c

23 
	~<sigÇl.h
>

25 
	~<asm/sy¡em.h
>

27 
	~<lšux/sched.h
>

28 
	~<lšux/h—d.h
>

29 
	~<lšux/k”Ãl.h
>

31 vÞ©ž
do_ex™
(
code
);

33 
šlše
 vÞ©ž
	$oom
()

35 
	`´štk
("out of memory\n\r");

36 
	`do_ex™
(
SIGSEGV
);

37 
	}
}

39 
	#šv®id©e
() \

40 
	`__asm__
("movÈ%%—x,%%ü3"::"a" (0))

	)

43 
	#LOW_MEM
 0x100000

	)

44 
	#PAGING_MEMORY
 (15*1024*1024)

	)

45 
	#PAGING_PAGES
 (
PAGING_MEMORY
>>12)

	)

46 
	#MAP_NR
(
addr
è((×ddr)-
LOW_MEM
)>>12)

	)

47 
	#USED
 100

	)

49 
	#CODE_SPACE
(
addr
) ((((addr)+4095)&~4095) < \

50 
cu¼’t
->
¡¬t_code
 + cu¼’t->
’d_code
)

	)

52 
	gHIGH_MEMORY
 = 0;

54 
	#cÝy_·ge
(
äom
,
to
) \

55 
	`__asm__
("þd ;„• ; mov¦"::"S" (
äom
),"D" (
to
),"c" (1024):"cx","di","si")

	)

57 
	gmem_m­
 [ 
PAGING_PAGES
 ] = {0,};

63 
	$g‘_ä“_·ge
()

65 
__»s
 
	`asm
("ax");

67 
	`__asm__
("std ;„epne ; scasb\n\t"

78 :"÷" (
__»s
)

79 :"0" (0),"i" (
LOW_MEM
),"c" (
PAGING_PAGES
),

80 "D" (
mem_m­
+
PAGING_PAGES
-1)

82  
__»s
;

83 
	}
}

89 
	$ä“_·ge
(
addr
)

91 ià(
addr
 < 
LOW_MEM
) ;

92 ià(
addr
 >ð
HIGH_MEMORY
)

93 
	`·nic
("tryingo free‚onexistent…age");

94 
addr
 -ð
LOW_MEM
;

95 
addr
 >>= 12;

96 ià(
mem_m­
[
addr
]--) ;

97 
mem_m­
[
addr
]=0;

98 
	`·nic
("tryingo free free…age");

99 
	}
}

105 
	$ä“_·ge_bËs
(
äom
,
size
)

107 *
pg_bË
;

108 * 
dœ
, 
Ä
;

110 ià(
äom
 & 0x3fffff)

111 
	`·nic
("free_page_tables called with wrong‡lignment");

112 ià(!
äom
)

113 
	`·nic
("Tryingo free up swapper memory space");

114 
size
 = (size + 0x3fffff) >> 22;

115 
dœ
 = (*è((
äom
>>20) & 0xffc);

116  ; 
size
-->0 ; 
dœ
++) {

117 ià(!(1 & *
dœ
))

119 
pg_bË
 = (*è(0xfffff000 & *
dœ
);

120 
Ä
=0 ;‚r<1024 ;‚r++) {

121 ià(1 & *
pg_bË
)

122 
	`ä“_·ge
(0xfffff000 & *
pg_bË
);

123 *
pg_bË
 = 0;

124 
pg_bË
++;

126 
	`ä“_·ge
(0xfffff000 & *
dœ
);

127 *
dœ
 = 0;

129 
	`šv®id©e
();

131 
	}
}

150 
	$cÝy_·ge_bËs
(
äom
,
to
,
size
)

152 * 
äom_·ge_bË
;

153 * 
to_·ge_bË
;

154 
this_·ge
;

155 * 
äom_dœ
, * 
to_dœ
;

156 
Ä
;

158 ià((
äom
&0x3fffffè|| (
to
&0x3fffff))

159 
	`·nic
("copy_page_tables called with wrong‡lignment");

160 
äom_dœ
 = (*è((
äom
>>20) & 0xffc);

161 
to_dœ
 = (*è((
to
>>20) & 0xffc);

162 
size
 = (() (size+0x3fffff)) >> 22;

163  ; 
size
-->0 ; 
äom_dœ
++,
to_dœ
++) {

164 ià(1 & *
to_dœ
)

165 
	`·nic
("copy_page_tables:‡lreadyƒxist");

166 ià(!(1 & *
äom_dœ
))

168 
äom_·ge_bË
 = (*è(0xfffff000 & *
äom_dœ
);

169 ià(!(
to_·ge_bË
 = (*è
	`g‘_ä“_·ge
()))

171 *
to_dœ
 = ((è
to_·ge_bË
) | 7;

172 
Ä
 = (
äom
==0)?0xA0:1024;

173  ; 
Ä
-- > 0 ; 
äom_·ge_bË
++,
to_·ge_bË
++) {

174 
this_·ge
 = *
äom_·ge_bË
;

175 ià(!(1 & 
this_·ge
))

177 
this_·ge
 &= ~2;

178 *
to_·ge_bË
 = 
this_·ge
;

179 ià(
this_·ge
 > 
LOW_MEM
) {

180 *
äom_·ge_bË
 = 
this_·ge
;

181 
this_·ge
 -ð
LOW_MEM
;

182 
this_·ge
 >>= 12;

183 
mem_m­
[
this_·ge
]++;

187 
	`šv®id©e
();

189 
	}
}

197 
	$put_·ge
(
·ge
,
add»ss
)

199 
tmp
, *
·ge_bË
;

203 ià(
·ge
 < 
LOW_MEM
 ||…ag>ð
HIGH_MEMORY
)

204 
	`´štk
("TryšgØpuˆ·g%°© %p\n",
·ge
,
add»ss
);

205 ià(
mem_m­
[(
·ge
-
LOW_MEM
)>>12] != 1)

206 
	`´štk
("mem_m­ di§g»e w™h %°© %p\n",
·ge
,
add»ss
);

207 
·ge_bË
 = (*è((
add»ss
>>20) & 0xffc);

208 ià((*
·ge_bË
)&1)

209 
·ge_bË
 = (*) (0xfffff000 & *page_table);

211 ià(!(
tmp
=
	`g‘_ä“_·ge
()))

213 *
·ge_bË
 = 
tmp
|7;

214 
·ge_bË
 = (*è
tmp
;

216 
·ge_bË
[(
add»ss
>>12è& 0x3ff] = 
·ge
 | 7;

218  
·ge
;

219 
	}
}

221 
	$un_wp_·ge
(* 
bË_’Œy
)

223 
Þd_·ge
,
Ãw_·ge
;

225 
Þd_·ge
 = 0xfffff000 & *
bË_’Œy
;

226 ià(
Þd_·ge
 >ð
LOW_MEM
 && 
mem_m­
[
	`MAP_NR
(old_page)]==1) {

227 *
bË_’Œy
 |= 2;

228 
	`šv®id©e
();

231 ià(!(
Ãw_·ge
=
	`g‘_ä“_·ge
()))

232 
	`oom
();

233 ià(
Þd_·ge
 >ð
LOW_MEM
)

234 
mem_m­
[
	`MAP_NR
(
Þd_·ge
)]--;

235 *
bË_’Œy
 = 
Ãw_·ge
 | 7;

236 
	`šv®id©e
();

237 
	`cÝy_·ge
(
Þd_·ge
,
Ãw_·ge
);

238 
	}
}

247 
	$do_wp_·ge
(
”rÜ_code
,
add»ss
)

252 ià(
	`CODE_SPACE
(
add»ss
))

253 
	`do_ex™
(
SIGSEGV
);

255 
	`un_wp_·ge
((*)

256 (((
add»ss
>>10) & 0xffc) + (0xfffff000 &

257 *((*è((
add»ss
>>20) &0xffc)))));

259 
	}
}

261 
	$wr™e_v”ify
(
add»ss
)

263 
·ge
;

265 ià(!Ð(
·ge
 = *((*è((
add»ss
>>20) & 0xffc)) )&1))

267 
·ge
 &= 0xfffff000;

268 
·ge
 +ð((
add»ss
>>10) & 0xffc);

269 ià((3 & *(*è
·ge
) == 1)

270 
	`un_wp_·ge
((*è
·ge
);

272 
	}
}

274 
	$g‘_em±y_·ge
(
add»ss
)

276 
tmp
;

278 ià(!(
tmp
=
	`g‘_ä“_·ge
()è|| !
	`put_·ge
Ñmp,
add»ss
)) {

279 
	`ä“_·ge
(
tmp
);

280 
	`oom
();

282 
	}
}

292 
	$Œy_to_sh¬e
(
add»ss
, 
sk_¡ruù
 * 
p
)

294 
äom
;

295 
to
;

296 
äom_·ge
;

297 
to_·ge
;

298 
phys_addr
;

300 
äom_·ge
 = 
to_·ge
 = ((
add»ss
>>20) & 0xffc);

301 
äom_·ge
 +ð((
p
->
¡¬t_code
>>20) & 0xffc);

302 
to_·ge
 +ð((
cu¼’t
->
¡¬t_code
>>20) & 0xffc);

304 
äom
 = *(*è
äom_·ge
;

305 ià(!(
äom
 & 1))

307 
äom
 &= 0xfffff000;

308 
äom_·ge
 = 
äom
 + ((
add»ss
>>10) & 0xffc);

309 
phys_addr
 = *(*è
äom_·ge
;

311 ià((
phys_addr
 & 0x41) != 0x01)

313 
phys_addr
 &= 0xfffff000;

314 ià(
phys_addr
 >ð
HIGH_MEMORY
 ||…hys_add¸< 
LOW_MEM
)

316 
to
 = *(*è
to_·ge
;

317 ià(!(
to
 & 1))

318 ià(
to
 = 
	`g‘_ä“_·ge
())

319 *(*è
to_·ge
 = 
to
 | 7;

321 
	`oom
();

322 
to
 &= 0xfffff000;

323 
to_·ge
 = 
to
 + ((
add»ss
>>10) & 0xffc);

324 ià(1 & *(*è
to_·ge
)

325 
	`·nic
("try_to_share:o_page‡lreadyƒxists");

327 *(*è
äom_·ge
 &= ~2;

328 *(*è
to_·ge
 = *(*è
äom_·ge
;

329 
	`šv®id©e
();

330 
phys_addr
 -ð
LOW_MEM
;

331 
phys_addr
 >>= 12;

332 
mem_m­
[
phys_addr
]++;

334 
	}
}

344 
	$sh¬e_·ge
(
add»ss
)

346 
sk_¡ruù
 ** 
p
;

348 ià(!
cu¼’t
->
execubË
)

350 ià(
cu¼’t
->
execubË
->
i_couÁ
 < 2)

352 
p
 = &
LAST_TASK
 ;… > &
FIRST_TASK
 ; --p) {

353 ià(!*
p
)

355 ià(
cu¼’t
 =ð*
p
)

357 ià((*
p
)->
execubË
 !ð
cu¼’t
->executable)

359 ià(
	`Œy_to_sh¬e
(
add»ss
,*
p
))

363 
	}
}

365 
	$do_no_·ge
(
”rÜ_code
,
add»ss
)

367 
Ä
[4];

368 
tmp
;

369 
·ge
;

370 
block
,
i
;

372 
add»ss
 &= 0xfffff000;

373 
tmp
 = 
add»ss
 - 
cu¼’t
->
¡¬t_code
;

374 ià(!
cu¼’t
->
execubË
 || 
tmp
 >ðcu¼’t->
’d_d©a
) {

375 
	`g‘_em±y_·ge
(
add»ss
);

378 ià(
	`sh¬e_·ge
(
tmp
))

380 ià(!(
·ge
 = 
	`g‘_ä“_·ge
()))

381 
	`oom
();

383 
block
 = 1 + 
tmp
/
BLOCK_SIZE
;

384 
i
=0 ; i<4 ; 
block
++,i++)

385 
Ä
[
i
] = 
	`bm­
(
cu¼’t
->
execubË
,
block
);

386 
	`b»ad_·ge
(
·ge
,
cu¼’t
->
execubË
->
i_dev
,
Ä
);

387 
i
 = 
tmp
 + 4096 - 
cu¼’t
->
’d_d©a
;

388 
tmp
 = 
·ge
 + 4096;

389 
i
-- > 0) {

390 
tmp
--;

391 *(*)
tmp
 = 0;

393 ià(
	`put_·ge
(
·ge
,
add»ss
))

395 
	`ä“_·ge
(
·ge
);

396 
	`oom
();

397 
	}
}

399 
	$mem_š™
(
¡¬t_mem
, 
’d_mem
)

401 
i
;

403 
HIGH_MEMORY
 = 
’d_mem
;

404 
i
=0 ; i<
PAGING_PAGES
 ; i++)

405 
mem_m­
[
i
] = 
USED
;

406 
i
 = 
	`MAP_NR
(
¡¬t_mem
);

407 
’d_mem
 -ð
¡¬t_mem
;

408 
’d_mem
 >>= 12;

409 
’d_mem
-->0)

410 
mem_m­
[
i
++]=0;

411 
	}
}

413 
	$ÿlc_mem
()

415 
i
,
j
,
k
,
ä“
=0;

416 * 
pg_tbl
;

418 
i
=0 ; i<
PAGING_PAGES
 ; i++)

419 ià(!
mem_m­
[
i
]è
ä“
++;

420 
	`´štk
("%d…age ä“ (oà%d)\n\r",
ä“
,
PAGING_PAGES
);

421 
i
=2 ; i<1024 ; i++) {

422 ià(1&
pg_dœ
[
i
]) {

423 
pg_tbl
=(*è(0xfffff000 & 
pg_dœ
[
i
]);

424 
j
=
k
=0 ; j<1024 ; j++)

425 ià(
pg_tbl
[
j
]&1)

426 
k
++;

427 
	`´štk
("Pg-dœ[%d] u£ %d…ages\n",
i
,
k
);

430 
	}
}

	@tools/build.c

23 
	~<¡dio.h
>

24 
	~<¡ršg.h
>

25 
	~<¡dlib.h
>

26 
	~<sys/ty³s.h
>

27 
	~<sys/¡©.h
>

28 
	~<lšux/fs.h
>

29 
	~<uni¡d.h
>

30 
	~<fúŽ.h
>

32 
	#MINIX_HEADER
 32

	)

33 
	#GCC_HEADER
 1024

	)

35 
	#SYS_SIZE
 0x2000

	)

37 
	#DEFAULT_MAJOR_ROOT
 3

	)

38 
	#DEFAULT_MINOR_ROOT
 6

	)

42 
	#SETUP_SECTS
 4

	)

44 
	#STRINGIFY
(
x
è#x

	)

46 
	$d›
(* 
¡r
)

48 
	`årštf
(
¡d”r
,"%s\n",
¡r
);

49 
	`ex™
(1);

50 
	}
}

52 
	$u§ge
()

54 
	`d›
("Usage: build bootsect setup system [rootdev] [> image]");

55 
	}
}

57 
	$maš
(
¬gc
, ** 
¬gv
)

59 
i
,
c
,
id
;

60 
buf
[1024];

61 
majÜ_roÙ
, 
mšÜ_roÙ
;

62 
¡©
 
sb
;

64 ià((
¬gc
 != 4) && (argc != 5))

65 
	`u§ge
();

66 ià(
¬gc
 == 5) {

67 ià(
	`¡rcmp
(
¬gv
[4], "FLOPPY")) {

68 ià(
	`¡©
(
¬gv
[4], &
sb
)) {

69 
	`³¼Ü
(
¬gv
[4]);

70 
	`d›
("Couldn't stat„oot device.");

72 
majÜ_roÙ
 = 
	`MAJOR
(
sb
.
¡_rdev
);

73 
mšÜ_roÙ
 = 
	`MINOR
(
sb
.
¡_rdev
);

75 
majÜ_roÙ
 = 0;

76 
mšÜ_roÙ
 = 0;

79 
majÜ_roÙ
 = 
DEFAULT_MAJOR_ROOT
;

80 
mšÜ_roÙ
 = 
DEFAULT_MINOR_ROOT
;

82 
	`årštf
(
¡d”r
, "RoÙ deviû i (%d, %d)\n", 
majÜ_roÙ
, 
mšÜ_roÙ
);

83 ià((
majÜ_roÙ
 != 2) && (major_root != 3) &&

84 (
majÜ_roÙ
 != 0)) {

85 
	`årštf
(
¡d”r
, "Illegal„oot device (major = %d)\n",

86 
majÜ_roÙ
);

87 
	`d›
("Bad„oot device --- major #");

89 
i
=0;i< 
buf
; i++) buf[i]=0;

90 ià((
id
=
	`Ý’
(
¬gv
[1],
O_RDONLY
,0))<0)

91 
	`d›
("Unableo open 'boot'");

92 ià(
	`»ad
(
id
,
buf
,
MINIX_HEADER
) != MINIX_HEADER)

93 
	`d›
("Unableo„ead header of 'boot'");

94 ià(((*è
buf
)[0]!=0x04100301)

95 
	`d›
("Non-Minix header of 'boot'");

96 ià(((*è
buf
)[1]!=
MINIX_HEADER
)

97 
	`d›
("Non-Minix header of 'boot'");

98 ià(((*è
buf
)[3]!=0)

99 
	`d›
("Illegal data segment in 'boot'");

100 ià(((*è
buf
)[4]!=0)

101 
	`d›
("Illegal bss in 'boot'");

102 ià(((*è
buf
)[5] != 0)

103 
	`d›
("Non-Minix header of 'boot'");

104 ià(((*è
buf
)[7] != 0)

105 
	`d›
("Illegal symbolable in 'boot'");

106 
i
=
	`»ad
(
id
,
buf
, buf);

107 
	`årštf
(
¡d”r
,"BoÙ seùÜ %d by‹s.\n",
i
);

108 ià(
i
 != 512)

109 
	`d›
("Boot block must beƒxactly 512 bytes");

110 ià((*(*)(
buf
+510)) != 0xAA55)

111 
	`d›
("Boot block hasn't got boot flag (0xAA55)");

112 
buf
[508] = (è
mšÜ_roÙ
;

113 
buf
[509] = (è
majÜ_roÙ
;

114 
i
=
	`wr™e
(1,
buf
,512);

115 ià(
i
!=512)

116 
	`d›
("Write call failed");

117 
	`þo£
 (
id
);

119 ià((
id
=
	`Ý’
(
¬gv
[2],
O_RDONLY
,0))<0)

120 
	`d›
("Unableo open 'setup'");

121 ià(
	`»ad
(
id
,
buf
,
MINIX_HEADER
) != MINIX_HEADER)

122 
	`d›
("Unableo„ead header of 'setup'");

123 ià(((*è
buf
)[0]!=0x04100301)

124 
	`d›
("Non-Minix header of 'setup'");

125 ià(((*è
buf
)[1]!=
MINIX_HEADER
)

126 
	`d›
("Non-Minix header of 'setup'");

127 ià(((*è
buf
)[3]!=0)

128 
	`d›
("Illegal data segment in 'setup'");

129 ià(((*è
buf
)[4]!=0)

130 
	`d›
("Illegal bss in 'setup'");

131 ià(((*è
buf
)[5] != 0)

132 
	`d›
("Non-Minix header of 'setup'");

133 ià(((*è
buf
)[7] != 0)

134 
	`d›
("Illegal symbolable in 'setup'");

135 
i
=0 ; (
c
=
	`»ad
(
id
,
buf
, buf))>0 ; i+=c )

136 ià(
	`wr™e
(1,
buf
,
c
)!=c)

137 
	`d›
("Write call failed");

138 
	`þo£
 (
id
);

139 ià(
i
 > 
SETUP_SECTS
*512)

140 
	`d›
("S‘u°exûed " 
	`STRINGIFY
(
SETUP_SECTS
)

142 
	`årštf
(
¡d”r
,"S‘u°i %d by‹s.\n",
i
);

143 
c
=0 ; c<(
buf
) ; c++)

144 
buf
[
c
] = '\0';

145 
i
<
SETUP_SECTS
*512) {

146 
c
 = 
SETUP_SECTS
*512-
i
;

147 ià(
c
 > (
buf
))

148 
c
 = (
buf
);

149 ià(
	`wr™e
(1,
buf
,
c
) != c)

150 
	`d›
("Write call failed");

151 
i
 +ð
c
;

154 ià((
id
=
	`Ý’
(
¬gv
[3],
O_RDONLY
,0))<0)

155 
	`d›
("Unableo open 'system'");

156 ià(
	`»ad
(
id
,
buf
,
GCC_HEADER
) != GCC_HEADER)

157 
	`d›
("Unableo„ead header of 'system'");

158 ià(((*è
buf
)[5] != 0)

159 
	`d›
("Non-GCC header of 'system'");

160 
i
=0 ; (
c
=
	`»ad
(
id
,
buf
, buf))>0 ; i+=c )

161 ià(
	`wr™e
(1,
buf
,
c
)!=c)

162 
	`d›
("Write call failed");

163 
	`þo£
(
id
);

164 
	`årštf
(
¡d”r
,"Sy¡em i %d by‹s.\n",
i
);

165 ià(
i
 > 
SYS_SIZE
*16)

166 
	`d›
("System isoo big");

168 
	}
}

	@/usr/include/ctype.h

22 #iâdef 
_CTYPE_H


23 
	#_CTYPE_H
 1

	)

25 
	~<ã©u»s.h
>

26 
	~<b™s/ty³s.h
>

28 
	g__BEGIN_DECLS


30 #iâdeà
_ISb™


39 
	~<’dŸn.h
>

40 #ià
__BYTE_ORDER
 =ð
__BIG_ENDIAN


41 
	#_ISb™
(
b™
è(1 << (b™))

	)

43 
	#_ISb™
(
b™
è((b™è< 8 ? ((1 << (b™)è<< 8è: ((1 << (b™)è>> 8))

	)

48 
	m_ISuµ”
 = 
_ISb™
 (0),

49 
	m_ISlow”
 = 
_ISb™
 (1),

50 
	m_IS®pha
 = 
_ISb™
 (2),

51 
	m_ISdig™
 = 
_ISb™
 (3),

52 
	m_ISxdig™
 = 
_ISb™
 (4),

53 
	m_IS¥aû
 = 
_ISb™
 (5),

54 
	m_IS´št
 = 
_ISb™
 (6),

55 
	m_ISg¿ph
 = 
_ISb™
 (7),

56 
	m_ISbÏnk
 = 
_ISb™
 (8),

57 
	m_ISúŒl
 = 
_ISb™
 (9),

58 
	m_ISpunù
 = 
_ISb™
 (10),

59 
	m_IS®num
 = 
_ISb™
 (11)

79 cÚ¡ **
	$__ùy³_b_loc
 ()

80 
__THROW
 
	`__©Œibu‹__
 ((
__cÚ¡__
));

81 cÚ¡ 
__št32_t
 **
	$__ùy³_tÞow”_loc
 ()

82 
__THROW
 
	`__©Œibu‹__
 ((
__cÚ¡__
));

83 cÚ¡ 
__št32_t
 **
	$__ùy³_touµ”_loc
 ()

84 
__THROW
 
	`__©Œibu‹__
 ((
__cÚ¡__
));

87 #iâdeà
__ýlu¥lus


88 
	#__isùy³
(
c
, 
ty³
) \

89 ((*
	`__ùy³_b_loc
 ())[(è(
c
)] & (è
ty³
)

	)

90 #–ià
defšed
 
__USE_EXTERN_INLINES


91 
	#__isùy³_f
(
ty³
) \

92 
__ex‹º_šlše
 \

93 
is
##
	`ty³
 (
__c
è
__THROW
 \

95  (*
	`__ùy³_b_loc
 ())[(è(
__c
)] & (è
_IS
##
ty³
; \

96 
	}

	)
}

99 
	#__i§scii
(
c
è(((cè& ~0x7fè=ð0è

	)

100 
	#__tßscii
(
c
è((cè& 0x7fè

	)

102 
	#__exùy³
(
Çme
è
	`Çme
 (è
__THROW


	)

104 
__BEGIN_NAMESPACE_STD


110 
__exùy³
 (
i§Êum
);

111 
__exùy³
 (
i§Íha
);

112 
__exùy³
 (
isúŒl
);

113 
__exùy³
 (
isdig™
);

114 
__exùy³
 (
i¦ow”
);

115 
__exùy³
 (
isg¿ph
);

116 
__exùy³
 (
i¥ršt
);

117 
__exùy³
 (
i¥unù
);

118 
__exùy³
 (
is¥aû
);

119 
__exùy³
 (
isuµ”
);

120 
__exùy³
 (
isxdig™
);

124 
	$tÞow”
 (
__c
è
__THROW
;

127 
	$touµ”
 (
__c
è
__THROW
;

129 
__END_NAMESPACE_STD


133 #ifdef 
__USE_ISOC99


134 
__BEGIN_NAMESPACE_C99


136 
	`__exùy³
 (
isbÏnk
);

138 
__END_NAMESPACE_C99


141 #ifdeà
__USE_GNU


143 
	$isùy³
 (
__c
, 
__mask
è
__THROW
;

146 #ià
defšed
 
__USE_MISC
 || defšed 
__USE_XOPEN


150 
	$i§scii
 (
__c
è
__THROW
;

154 
	$tßscii
 (
__c
è
__THROW
;

158 
	`__exùy³
 (
_touµ”
);

159 
	`__exùy³
 (
_tÞow”
);

163 
	#__tobody
(
c
, 
f
, 
a
, 
¬gs
) \

164 (
__ex‹nsiÚ__
 \

165 ({ 
__»s
; \

166 ià( (
c
) > 1) \

168 ià(
	`__bužtš_cÚ¡ªt_p
 (
c
)) \

170 
__c
 = (
c
); \

171 
__»s
 = 
__c
 < -128 || __ø> 255 ? __ø: (
a
)[__c]; \

174 
__»s
 = 
f
 
¬gs
; \

177 
__»s
 = (
a
)[(è(
c
)]; \

178 
__»s
; 
	}
}))

	)

180 #ià!
defšed
 
__NO_CTYPE


181 #ifdeà
__isùy³_f


182 
	$__isùy³_f
 (
®num
)

183 
	$__isùy³_f
 (
®pha
)

184 
	$__isùy³_f
 (
úŒl
)

185 
	$__isùy³_f
 (
dig™
)

186 
	$__isùy³_f
 (
low”
)

187 
	$__isùy³_f
 (
g¿ph
)

188 
	$__isùy³_f
 (
´št
)

189 
	$__isùy³_f
 (
punù
)

190 
	$__isùy³_f
 (
¥aû
)

191 
	$__isùy³_f
 (
uµ”
)

192 
	$__isùy³_f
 (
xdig™
)

193 #ifdeà
__USE_ISOC99


194 
	$__isùy³_f
 (
bÏnk
)

196 #–ià
defšed
 
__isùy³


197 
	#i§Êum
(
c
è
	`__isùy³
((c), 
_IS®num
)

	)

198 
	#i§Íha
(
c
è
	`__isùy³
((c), 
_IS®pha
)

	)

199 
	#isúŒl
(
c
è
	`__isùy³
((c), 
_ISúŒl
)

	)

200 
	#isdig™
(
c
è
	`__isùy³
((c), 
_ISdig™
)

	)

201 
	#i¦ow”
(
c
è
	`__isùy³
((c), 
_ISlow”
)

	)

202 
	#isg¿ph
(
c
è
	`__isùy³
((c), 
_ISg¿ph
)

	)

203 
	#i¥ršt
(
c
è
	`__isùy³
((c), 
_IS´št
)

	)

204 
	#i¥unù
(
c
è
	`__isùy³
((c), 
_ISpunù
)

	)

205 
	#is¥aû
(
c
è
	`__isùy³
((c), 
_IS¥aû
)

	)

206 
	#isuµ”
(
c
è
	`__isùy³
((c), 
_ISuµ”
)

	)

207 
	#isxdig™
(
c
è
	`__isùy³
((c), 
_ISxdig™
)

	)

208 #ifdeà
__USE_ISOC99


209 
	#isbÏnk
(
c
è
	`__isùy³
((c), 
_ISbÏnk
)

	)

213 #ifdeà
__USE_EXTERN_INLINES


214 
__ex‹º_šlše
 

215 
	`__NTH
 (
	$tÞow”
 (
__c
))

217  
__c
 >ð-128 && __ø< 256 ? (*
	`__ùy³_tÞow”_loc
 ())[__c] : __c;

218 
	}
}

220 
__ex‹º_šlše
 

221 
__NTH
 (
	$touµ”
 (
__c
))

223  
__c
 >ð-128 && __ø< 256 ? (*
	`__ùy³_touµ”_loc
 ())[__c] : __c;

224 
	}
}

227 #ià
__GNUC__
 >ð2 && 
defšed
 
__OPTIMIZE__
 && !defšed 
__ýlu¥lus


228 
	#tÞow”
(
c
è
	`__tobody
 (c, 
tÞow”
, *
	`__ùy³_tÞow”_loc
 (), (c))

	)

229 
	#touµ”
(
c
è
	`__tobody
 (c, 
touµ”
, *
	`__ùy³_touµ”_loc
 (), (c))

	)

232 #ià
defšed
 
__USE_MISC
 || defšed 
__USE_XOPEN


233 
	#i§scii
(
c
è
	`__i§scii
 (c)

	)

234 
	#tßscii
(
c
è
	`__tßscii
 (c)

	)

236 
	#_tÞow”
(
c
è((è(*
	`__ùy³_tÞow”_loc
 ())[(è(c)])

	)

237 
	#_touµ”
(
c
è((è(*
	`__ùy³_touµ”_loc
 ())[(è(c)])

	)

243 #ifdeà
__USE_XOPEN2K8


257 
	~<xloÿË.h
>

261 
	#__isùy³_l
(
c
, 
ty³
, 
loÿË
) \

262 ((
loÿË
)->
__ùy³_b
[(è(
c
)] & (è
ty³
)

	)

264 
	#__exùy³_l
(
Çme
) \

265 
	`Çme
 (, 
__loÿË_t
è
__THROW


	)

271 
__exùy³_l
 (
i§Êum_l
);

272 
__exùy³_l
 (
i§Íha_l
);

273 
__exùy³_l
 (
isúŒl_l
);

274 
__exùy³_l
 (
isdig™_l
);

275 
__exùy³_l
 (
i¦ow”_l
);

276 
__exùy³_l
 (
isg¿ph_l
);

277 
__exùy³_l
 (
i¥ršt_l
);

278 
__exùy³_l
 (
i¥unù_l
);

279 
__exùy³_l
 (
is¥aû_l
);

280 
__exùy³_l
 (
isuµ”_l
);

281 
__exùy³_l
 (
isxdig™_l
);

283 
__exùy³_l
 (
isbÏnk_l
);

287 
	$__tÞow”_l
 (
__c
, 
__loÿË_t
 
__l
è
__THROW
;

288 
	$tÞow”_l
 (
__c
, 
__loÿË_t
 
__l
è
__THROW
;

291 
	$__touµ”_l
 (
__c
, 
__loÿË_t
 
__l
è
__THROW
;

292 
	$touµ”_l
 (
__c
, 
__loÿË_t
 
__l
è
__THROW
;

294 #ià
__GNUC__
 >ð2 && 
defšed
 
__OPTIMIZE__
 && !defšed 
__ýlu¥lus


295 
	#__tÞow”_l
(
c
, 
loÿË
) \

296 
	`__tobody
 (
c
, 
__tÞow”_l
, (
loÿË
)->
__ùy³_tÞow”
, (c,†oÿË))

	)

297 
	#__touµ”_l
(
c
, 
loÿË
) \

298 
	`__tobody
 (
c
, 
__touµ”_l
, (
loÿË
)->
__ùy³_touµ”
, (c,†oÿË))

	)

299 
	#tÞow”_l
(
c
, 
loÿË
è
	`__tÞow”_l
 ((c), (loÿË))

	)

300 
	#touµ”_l
(
c
, 
loÿË
è
	`__touµ”_l
 ((c), (loÿË))

	)

304 #iâdeà
__NO_CTYPE


305 
	#__i§Êum_l
(
c
,
l
è
	`__isùy³_l
((c), 
_IS®num
, (l))

	)

306 
	#__i§Íha_l
(
c
,
l
è
	`__isùy³_l
((c), 
_IS®pha
, (l))

	)

307 
	#__isúŒl_l
(
c
,
l
è
	`__isùy³_l
((c), 
_ISúŒl
, (l))

	)

308 
	#__isdig™_l
(
c
,
l
è
	`__isùy³_l
((c), 
_ISdig™
, (l))

	)

309 
	#__i¦ow”_l
(
c
,
l
è
	`__isùy³_l
((c), 
_ISlow”
, (l))

	)

310 
	#__isg¿ph_l
(
c
,
l
è
	`__isùy³_l
((c), 
_ISg¿ph
, (l))

	)

311 
	#__i¥ršt_l
(
c
,
l
è
	`__isùy³_l
((c), 
_IS´št
, (l))

	)

312 
	#__i¥unù_l
(
c
,
l
è
	`__isùy³_l
((c), 
_ISpunù
, (l))

	)

313 
	#__is¥aû_l
(
c
,
l
è
	`__isùy³_l
((c), 
_IS¥aû
, (l))

	)

314 
	#__isuµ”_l
(
c
,
l
è
	`__isùy³_l
((c), 
_ISuµ”
, (l))

	)

315 
	#__isxdig™_l
(
c
,
l
è
	`__isùy³_l
((c), 
_ISxdig™
, (l))

	)

317 
	#__isbÏnk_l
(
c
,
l
è
	`__isùy³_l
((c), 
_ISbÏnk
, (l))

	)

319 #ifdeà
__USE_MISC


320 
	#__i§scii_l
(
c
,
l
è(Ö), 
	`__i§scii
 (c))

	)

321 
	#__tßscii_l
(
c
,
l
è(Ö), 
	`__tßscii
 (c))

	)

324 
	#i§Êum_l
(
c
,
l
è
	`__i§Êum_l
 ((c), (l))

	)

325 
	#i§Íha_l
(
c
,
l
è
	`__i§Íha_l
 ((c), (l))

	)

326 
	#isúŒl_l
(
c
,
l
è
	`__isúŒl_l
 ((c), (l))

	)

327 
	#isdig™_l
(
c
,
l
è
	`__isdig™_l
 ((c), (l))

	)

328 
	#i¦ow”_l
(
c
,
l
è
	`__i¦ow”_l
 ((c), (l))

	)

329 
	#isg¿ph_l
(
c
,
l
è
	`__isg¿ph_l
 ((c), (l))

	)

330 
	#i¥ršt_l
(
c
,
l
è
	`__i¥ršt_l
 ((c), (l))

	)

331 
	#i¥unù_l
(
c
,
l
è
	`__i¥unù_l
 ((c), (l))

	)

332 
	#is¥aû_l
(
c
,
l
è
	`__is¥aû_l
 ((c), (l))

	)

333 
	#isuµ”_l
(
c
,
l
è
	`__isuµ”_l
 ((c), (l))

	)

334 
	#isxdig™_l
(
c
,
l
è
	`__isxdig™_l
 ((c), (l))

	)

336 
	#isbÏnk_l
(
c
,
l
è
	`__isbÏnk_l
 ((c), (l))

	)

338 #ifdeà
__USE_MISC


339 
	#i§scii_l
(
c
,
l
è
	`__i§scii_l
 ((c), (l))

	)

340 
	#tßscii_l
(
c
,
l
è
	`__tßscii_l
 ((c), (l))

	)

347 
__END_DECLS


	@/usr/include/errno.h

22 #iâdef 
_ERRNO_H


26 #iâdef 
__Ãed_Em©h


27 
	#_ERRNO_H
 1

	)

28 
	~<ã©u»s.h
>

31 
	g__BEGIN_DECLS


35 
	~<b™s/”ºo.h
>

36 #undeà
__Ãed_Em©h


38 #ifdef 
_ERRNO_H


45 #iâdef 
”ºo


46 
”ºo
;

49 #ifdeà
__USE_GNU


54 *
´og¿m_švoÿtiÚ_Çme
, *
´og¿m_švoÿtiÚ_shÜt_Çme
;

58 
	g__END_DECLS


66 #ià
defšed
 
__USE_GNU
 || defšed 
__Ãed_”rÜ_t


67 #iâdeà
__”rÜ_t_defšed


68 
	t”rÜ_t
;

69 
	#__”rÜ_t_defšed
 1

	)

71 #undeà
__Ãed_”rÜ_t


	@/usr/include/fcntl.h

22 #iâdef 
_FCNTL_H


23 
	#_FCNTL_H
 1

	)

25 
	~<ã©u»s.h
>

28 
	g__BEGIN_DECLS


31 
	~<b™s/ty³s.h
>

35 
	~<b™s/fúŽ.h
>

39 #ifdeà
__O_TMPFILE


40 
	#__OPEN_NEEDS_MODE
(
oæag
) \

41 (((
oæag
è& 
O_CREAT
è!ð0 || ((oæagè& 
__O_TMPFILE
è=ð__O_TMPFILE)

	)

43 
	#__OPEN_NEEDS_MODE
(
oæag
è(((oæagè& 
O_CREAT
è!ð0)

	)

49 #iâdeà
__mode_t_defšed


50 
__mode_t
 
	tmode_t
;

51 
	#__mode_t_defšed


	)

54 #iâdeà
__off_t_defšed


55 #iâdeà
__USE_FILE_OFFSET64


56 
__off_t
 
	toff_t
;

58 
__off64_t
 
	toff_t
;

60 
	#__off_t_defšed


	)

63 #ià
defšed
 
__USE_LARGEFILE64
 && !defšed 
__off64_t_defšed


64 
__off64_t
 
	toff64_t
;

65 
	#__off64_t_defšed


	)

68 #iâdeà
__pid_t_defšed


69 
__pid_t
 
	tpid_t
;

70 
	#__pid_t_defšed


	)

74 #ià
defšed
 
__USE_XOPEN
 || defšed 
__USE_XOPEN2K8


75 
	#__Ãed_time¥ec


	)

76 
	~<time.h
>

77 
	~<b™s/¡©.h
>

79 
	#S_IFMT
 
__S_IFMT


	)

80 
	#S_IFDIR
 
__S_IFDIR


	)

81 
	#S_IFCHR
 
__S_IFCHR


	)

82 
	#S_IFBLK
 
__S_IFBLK


	)

83 
	#S_IFREG
 
__S_IFREG


	)

84 #ifdeà
__S_IFIFO


85 
	#S_IFIFO
 
__S_IFIFO


	)

87 #ifdeà
__S_IFLNK


88 
	#S_IFLNK
 
__S_IFLNK


	)

90 #ià(
defšed
 
__USE_UNIX98
 || defšed 
__USE_XOPEN2K8
è&& defšed 
__S_IFSOCK


91 
	#S_IFSOCK
 
__S_IFSOCK


	)

96 
	#S_ISUID
 
__S_ISUID


	)

97 
	#S_ISGID
 
__S_ISGID


	)

99 #ià
defšed
 
__USE_MISC
 || defšed 
__USE_XOPEN


101 
	#S_ISVTX
 
__S_ISVTX


	)

104 
	#S_IRUSR
 
__S_IREAD


	)

105 
	#S_IWUSR
 
__S_IWRITE


	)

106 
	#S_IXUSR
 
__S_IEXEC


	)

108 
	#S_IRWXU
 (
__S_IREAD
|
__S_IWRITE
|
__S_IEXEC
)

	)

110 
	#S_IRGRP
 (
S_IRUSR
 >> 3è

	)

111 
	#S_IWGRP
 (
S_IWUSR
 >> 3è

	)

112 
	#S_IXGRP
 (
S_IXUSR
 >> 3è

	)

114 
	#S_IRWXG
 (
S_IRWXU
 >> 3)

	)

116 
	#S_IROTH
 (
S_IRGRP
 >> 3è

	)

117 
	#S_IWOTH
 (
S_IWGRP
 >> 3è

	)

118 
	#S_IXOTH
 (
S_IXGRP
 >> 3è

	)

120 
	#S_IRWXO
 (
S_IRWXG
 >> 3)

	)

123 #ifdef 
__USE_MISC


124 #iâdeà
R_OK


127 
	#R_OK
 4

	)

128 
	#W_OK
 2

	)

129 
	#X_OK
 1

	)

130 
	#F_OK
 0

	)

135 #ià
defšed
 
__USE_XOPEN
 || defšed 
__USE_XOPEN2K8


136 
	#SEEK_SET
 0

	)

137 
	#SEEK_CUR
 1

	)

138 
	#SEEK_END
 2

	)

146 
fúŽ
 (
__fd
, 
__cmd
, ...);

155 #iâdeà
__USE_FILE_OFFSET64


156 
	$Ý’
 (cÚ¡ *
__fže
, 
__oæag
, ...è
	`__nÚnuÎ
 ((1));

158 #ifdeà
__REDIRECT


159 
	`__REDIRECT
 (
Ý’
, (cÚ¡ *
__fže
, 
__oæag
, ...), 
Ý’64
)

160 
	`__nÚnuÎ
 ((1));

162 
	#Ý’
 
Ý’64


	)

165 #ifdeà
__USE_LARGEFILE64


166 
	$Ý’64
 (cÚ¡ *
__fže
, 
__oæag
, ...è
	`__nÚnuÎ
 ((1));

169 #ifdeà
__USE_ATFILE


179 #iâdeà
__USE_FILE_OFFSET64


180 
	$Ý’©
 (
__fd
, cÚ¡ *
__fže
, 
__oæag
, ...)

181 
	`__nÚnuÎ
 ((2));

183 #ifdeà
__REDIRECT


184 
	`__REDIRECT
 (
Ý’©
, (
__fd
, cÚ¡ *
__fže
, 
__oæag
,

185 ...), 
Ý’©64
è
	`__nÚnuÎ
 ((2));

187 
	#Ý’©
 
Ý’©64


	)

190 #ifdeà
__USE_LARGEFILE64


191 
	$Ý’©64
 (
__fd
, cÚ¡ *
__fže
, 
__oæag
, ...)

192 
	`__nÚnuÎ
 ((2));

201 #iâdeà
__USE_FILE_OFFSET64


202 
	$ü—t
 (cÚ¡ *
__fže
, 
mode_t
 
__mode
è
	`__nÚnuÎ
 ((1));

204 #ifdeà
__REDIRECT


205 
	`__REDIRECT
 (
ü—t
, (cÚ¡ *
__fže
, 
mode_t
 
__mode
),

206 
ü—t64
è
	`__nÚnuÎ
 ((1));

208 
	#ü—t
 
ü—t64


	)

211 #ifdeà
__USE_LARGEFILE64


212 
	$ü—t64
 (cÚ¡ *
__fže
, 
mode_t
 
__mode
è
	`__nÚnuÎ
 ((1));

215 #ià!
defšed
 
F_LOCK
 && (defšed 
__USE_MISC
 || (defšed 
__USE_XOPEN_EXTENDED
 \

216 && !
defšed
 
__USE_POSIX
))

225 
	#F_ULOCK
 0

	)

226 
	#F_LOCK
 1

	)

227 
	#F_TLOCK
 2

	)

228 
	#F_TEST
 3

	)

230 #iâdeà
__USE_FILE_OFFSET64


231 
	`lockf
 (
__fd
, 
__cmd
, 
off_t
 
__Ën
);

233 #ifdeà
__REDIRECT


234 
	`__REDIRECT
 (
lockf
, (
__fd
, 
__cmd
, 
__off64_t
 
__Ën
), 
lockf64
);

236 
	#lockf
 
lockf64


	)

239 #ifdeà
__USE_LARGEFILE64


240 
	`lockf64
 (
__fd
, 
__cmd
, 
off64_t
 
__Ën
);

244 #ifdeà
__USE_XOPEN2K


247 #iâdeà
__USE_FILE_OFFSET64


248 
	$posix_çdvi£
 (
__fd
, 
off_t
 
__off£t
, off_ˆ
__Ën
,

249 
__advi£
è
__THROW
;

251 #ifdeà
__REDIRECT_NTH


252 
	`__REDIRECT_NTH
 (
posix_çdvi£
, (
__fd
, 
__off64_t
 
__off£t
,

253 
__off64_t
 
__Ën
, 
__advi£
),

254 
posix_çdvi£64
);

256 
	#posix_çdvi£
 
posix_çdvi£64


	)

259 #ifdeà
__USE_LARGEFILE64


260 
	$posix_çdvi£64
 (
__fd
, 
off64_t
 
__off£t
, off64_ˆ
__Ën
,

261 
__advi£
è
__THROW
;

269 #iâdeà
__USE_FILE_OFFSET64


270 
	`posix_çÎoÿ‹
 (
__fd
, 
off_t
 
__off£t
, off_ˆ
__Ën
);

272 #ifdeà
__REDIRECT


273 
	`__REDIRECT
 (
posix_çÎoÿ‹
, (
__fd
, 
__off64_t
 
__off£t
,

274 
__off64_t
 
__Ën
),

275 
posix_çÎoÿ‹64
);

277 
	#posix_çÎoÿ‹
 
posix_çÎoÿ‹64


	)

280 #ifdeà
__USE_LARGEFILE64


281 
	`posix_çÎoÿ‹64
 (
__fd
, 
off64_t
 
__off£t
, off64_ˆ
__Ën
);

287 #ià
__USE_FORTIFY_LEVEL
 > 0 && 
defšed
 
__fÜtify_funùiÚ
 \

288 && 
defšed
 
__va_¬g_·ck_Ën


289 
	~<b™s/fúŽ2.h
>

292 
__END_DECLS


	@/usr/include/linux/fdreg.h

1 #iâdeà
_LINUX_FDREG_H


2 
	#_LINUX_FDREG_H


	)

9 #ifdeà
FDPATCHES


10 
	#FD_IOPORT
 
fdc_¡©e
[
fdc
].
add»ss


	)

14 
	#FD_IOPORT
 0x3f0

	)

18 
	#FD_STATUS
 (4 + 
FD_IOPORT
 )

	)

19 
	#FD_DATA
 (5 + 
FD_IOPORT
 )

	)

22 
	#FD_DOR
 (2 + 
FD_IOPORT
 )

	)

25 
	#FD_DIR
 (7 + 
FD_IOPORT
 )

	)

28 
	#FD_DCR
 (7 + 
FD_IOPORT
 )

	)

31 
	#STATUS_BUSYMASK
 0x0F

	)

32 
	#STATUS_BUSY
 0x10

	)

33 
	#STATUS_DMA
 0x20

	)

34 
	#STATUS_DIR
 0x40

	)

35 
	#STATUS_READY
 0x80

	)

38 
	#ST0_DS
 0x03

	)

39 
	#ST0_HA
 0x04

	)

40 
	#ST0_NR
 0x08

	)

41 
	#ST0_ECE
 0x10

	)

42 
	#ST0_SE
 0x20

	)

43 
	#ST0_INTR
 0xC0

	)

46 
	#ST1_MAM
 0x01

	)

47 
	#ST1_WP
 0x02

	)

48 
	#ST1_ND
 0x04

	)

49 
	#ST1_OR
 0x10

	)

50 
	#ST1_CRC
 0x20

	)

51 
	#ST1_EOC
 0x80

	)

54 
	#ST2_MAM
 0x01

	)

55 
	#ST2_BC
 0x02

	)

56 
	#ST2_SNS
 0x04

	)

57 
	#ST2_SEH
 0x08

	)

58 
	#ST2_WC
 0x10

	)

59 
	#ST2_CRC
 0x20

	)

60 
	#ST2_CM
 0x40

	)

63 
	#ST3_HA
 0x04

	)

64 
	#ST3_DS
 0x08

	)

65 
	#ST3_TZ
 0x10

	)

66 
	#ST3_RY
 0x20

	)

67 
	#ST3_WP
 0x40

	)

68 
	#ST3_FT
 0x80

	)

71 
	#FD_RECALIBRATE
 0x07

	)

72 
	#FD_SEEK
 0x0F

	)

73 
	#FD_READ
 0xE6

	)

74 
	#FD_WRITE
 0xC5

	)

75 
	#FD_SENSEI
 0x08

	)

76 
	#FD_SPECIFY
 0x03

	)

77 
	#FD_FORMAT
 0x4D

	)

78 
	#FD_VERSION
 0x10

	)

79 
	#FD_CONFIGURE
 0x13

	)

80 
	#FD_PERPENDICULAR
 0x12

	)

81 
	#FD_GETSTATUS
 0x04

	)

82 
	#FD_DUMPREGS
 0x0E

	)

83 
	#FD_READID
 0xEA

	)

84 
	#FD_UNLOCK
 0x14

	)

85 
	#FD_LOCK
 0x94

	)

86 
	#FD_RSEEK_OUT
 0x8à

	)

87 
	#FD_RSEEK_IN
 0xcà

	)

94 
	#FD_PARTID
 0x18

	)

95 
	#FD_SAVE
 0x2

	)

96 
	#FD_DRIVESPEC
 0x8

	)

100 
	#FD_RESTORE
 0x4

	)

101 
	#FD_POWERDOWN
 0x27

	)

102 
	#FD_FORMAT_N_WRITE
 0xeà

	)

103 
	#FD_OPTION
 0x33

	)

107 
	#DMA_READ
 0x46

	)

108 
	#DMA_WRITE
 0x4A

	)

111 
	#FDC_NONE
 0x00

	)

112 
	#FDC_UNKNOWN
 0x10

	)

114 
	#FDC_8272A
 0x20

	)

115 
	#FDC_765ED
 0x30

	)

116 
	#FDC_82072
 0x40

	)

117 
	#FDC_82072A
 0x45

	)

118 
	#FDC_82077_ORIG
 0x51

	)

119 
	#FDC_82077
 0x52

	)

120 
	#FDC_82078_UNKN
 0x5à

	)

121 
	#FDC_82078
 0x60

	)

122 
	#FDC_82078_1
 0x61

	)

123 
	#FDC_S82078B
 0x62

	)

125 
	#FDC_87306
 0x63

	)

136 
	#FD_RESET_DELAY
 20

	)

	@/usr/include/linux/fs.h

1 #iâdeà
_LINUX_FS_H


2 
	#_LINUX_FS_H


	)

9 
	~<lšux/lim™s.h
>

10 
	~<lšux/ioùl.h
>

11 
	~<lšux/ty³s.h
>

24 #undeà
NR_OPEN


25 
	#INR_OPEN_CUR
 1024

	)

26 
	#INR_OPEN_MAX
 4096

	)

28 
	#BLOCK_SIZE_BITS
 10

	)

29 
	#BLOCK_SIZE
 (1<<
BLOCK_SIZE_BITS
)

	)

31 
	#SEEK_SET
 0

	)

32 
	#SEEK_CUR
 1

	)

33 
	#SEEK_END
 2

	)

34 
	#SEEK_DATA
 3

	)

35 
	#SEEK_HOLE
 4

	)

36 
	#SEEK_MAX
 
SEEK_HOLE


	)

38 
	#RENAME_NOREPLACE
 (1 << 0è

	)

39 
	#RENAME_EXCHANGE
 (1 << 1è

	)

40 
	#RENAME_WHITEOUT
 (1 << 2è

	)

42 
	sf¡rim_¿nge
 {

43 
__u64
 
	m¡¬t
;

44 
__u64
 
	mËn
;

45 
__u64
 
	mmšËn
;

49 
	sfžes_¡©_¡ruù
 {

50 
	mÄ_fžes
;

51 
	mÄ_ä“_fžes
;

52 
	mmax_fžes
;

55 
	sšodes_¡©_t
 {

56 
	mÄ_šodes
;

57 
	mÄ_unu£d
;

58 
	mdummy
[5];

62 
	#NR_FILE
 8192

	)

68 
	#MS_RDONLY
 1

	)

69 
	#MS_NOSUID
 2

	)

70 
	#MS_NODEV
 4

	)

71 
	#MS_NOEXEC
 8

	)

72 
	#MS_SYNCHRONOUS
 16

	)

73 
	#MS_REMOUNT
 32

	)

74 
	#MS_MANDLOCK
 64

	)

75 
	#MS_DIRSYNC
 128

	)

76 
	#MS_NOATIME
 1024

	)

77 
	#MS_NODIRATIME
 2048

	)

78 
	#MS_BIND
 4096

	)

79 
	#MS_MOVE
 8192

	)

80 
	#MS_REC
 16384

	)

81 
	#MS_VERBOSE
 32768

	)

83 
	#MS_SILENT
 32768

	)

84 
	#MS_POSIXACL
 (1<<16è

	)

85 
	#MS_UNBINDABLE
 (1<<17è

	)

86 
	#MS_PRIVATE
 (1<<18è

	)

87 
	#MS_SLAVE
 (1<<19è

	)

88 
	#MS_SHARED
 (1<<20è

	)

89 
	#MS_RELATIME
 (1<<21è

	)

90 
	#MS_KERNMOUNT
 (1<<22è

	)

91 
	#MS_I_VERSION
 (1<<23è

	)

92 
	#MS_STRICTATIME
 (1<<24è

	)

93 
	#MS_LAZYTIME
 (1<<25è

	)

96 
	#MS_SUBMOUNT
 (1<<26)

	)

97 
	#MS_NOSEC
 (1<<28)

	)

98 
	#MS_BORN
 (1<<29)

	)

99 
	#MS_ACTIVE
 (1<<30)

	)

100 
	#MS_NOUSER
 (1<<31)

	)

105 
	#MS_RMT_MASK
 (
MS_RDONLY
|
MS_SYNCHRONOUS
|
MS_MANDLOCK
|
MS_I_VERSION
|\

106 
MS_LAZYTIME
)

	)

111 
	#MS_MGC_VAL
 0xC0ED0000

	)

112 
	#MS_MGC_MSK
 0xffff0000

	)

117 
	#BLKROSET
 
	`_IO
(0x12,93è

	)

118 
	#BLKROGET
 
	`_IO
(0x12,94è

	)

119 
	#BLKRRPART
 
	`_IO
(0x12,95è

	)

120 
	#BLKGETSIZE
 
	`_IO
(0x12,96è

	)

121 
	#BLKFLSBUF
 
	`_IO
(0x12,97è

	)

122 
	#BLKRASET
 
	`_IO
(0x12,98è

	)

123 
	#BLKRAGET
 
	`_IO
(0x12,99è

	)

124 
	#BLKFRASET
 
	`_IO
(0x12,100)

	)

125 
	#BLKFRAGET
 
	`_IO
(0x12,101)

	)

126 
	#BLKSECTSET
 
	`_IO
(0x12,102)

	)

127 
	#BLKSECTGET
 
	`_IO
(0x12,103)

	)

128 
	#BLKSSZGET
 
	`_IO
(0x12,104)

	)

130 
	#BLKPG
 
	`_IO
(0x12,105)

	)

134 
	#BLKELVGET
 
	`_IOR
(0x12,106,
size_t
)

	)

135 
	#BLKELVSET
 
	`_IOW
(0x12,107,
size_t
)

	)

140 
	#BLKBSZGET
 
	`_IOR
(0x12,112,
size_t
)

	)

141 
	#BLKBSZSET
 
	`_IOW
(0x12,113,
size_t
)

	)

142 
	#BLKGETSIZE64
 
	`_IOR
(0x12,114,
size_t
è

	)

143 
	#BLKTRACESETUP
 
	`_IOWR
(0x12,115,
blk_u£r_Œaû_£tup
)

	)

144 
	#BLKTRACESTART
 
	`_IO
(0x12,116)

	)

145 
	#BLKTRACESTOP
 
	`_IO
(0x12,117)

	)

146 
	#BLKTRACETEARDOWN
 
	`_IO
(0x12,118)

	)

147 
	#BLKDISCARD
 
	`_IO
(0x12,119)

	)

148 
	#BLKIOMIN
 
	`_IO
(0x12,120)

	)

149 
	#BLKIOOPT
 
	`_IO
(0x12,121)

	)

150 
	#BLKALIGNOFF
 
	`_IO
(0x12,122)

	)

151 
	#BLKPBSZGET
 
	`_IO
(0x12,123)

	)

152 
	#BLKDISCARDZEROES
 
	`_IO
(0x12,124)

	)

153 
	#BLKSECDISCARD
 
	`_IO
(0x12,125)

	)

154 
	#BLKROTATIONAL
 
	`_IO
(0x12,126)

	)

155 
	#BLKZEROOUT
 
	`_IO
(0x12,127)

	)

157 
	#BMAP_IOCTL
 1

	)

158 
	#FIBMAP
 
	`_IO
(0x00,1è

	)

159 
	#FIGETBSZ
 
	`_IO
(0x00,2è

	)

160 
	#FIFREEZE
 
	`_IOWR
('X', 119, è

	)

161 
	#FITHAW
 
	`_IOWR
('X', 120, è

	)

162 
	#FITRIM
 
	`_IOWR
('X', 121, 
f¡rim_¿nge
è

	)

164 
	#FS_IOC_GETFLAGS
 
	`_IOR
('f', 1, )

	)

165 
	#FS_IOC_SETFLAGS
 
	`_IOW
('f', 2, )

	)

166 
	#FS_IOC_GETVERSION
 
	`_IOR
('v', 1, )

	)

167 
	#FS_IOC_SETVERSION
 
	`_IOW
('v', 2, )

	)

168 
	#FS_IOC_FIEMAP
 
	`_IOWR
('f', 11, 
f›m­
)

	)

169 
	#FS_IOC32_GETFLAGS
 
	`_IOR
('f', 1, )

	)

170 
	#FS_IOC32_SETFLAGS
 
	`_IOW
('f', 2, )

	)

171 
	#FS_IOC32_GETVERSION
 
	`_IOR
('v', 1, )

	)

172 
	#FS_IOC32_SETVERSION
 
	`_IOW
('v', 2, )

	)

177 
	#FS_SECRM_FL
 0x00000001

	)

178 
	#FS_UNRM_FL
 0x00000002

	)

179 
	#FS_COMPR_FL
 0x00000004

	)

180 
	#FS_SYNC_FL
 0x00000008

	)

181 
	#FS_IMMUTABLE_FL
 0x00000010

	)

182 
	#FS_APPEND_FL
 0x00000020

	)

183 
	#FS_NODUMP_FL
 0x00000040

	)

184 
	#FS_NOATIME_FL
 0x00000080

	)

186 
	#FS_DIRTY_FL
 0x00000100

	)

187 
	#FS_COMPRBLK_FL
 0x00000200

	)

188 
	#FS_NOCOMP_FL
 0x00000400

	)

189 
	#FS_ECOMPR_FL
 0x00000800

	)

191 
	#FS_BTREE_FL
 0x00001000

	)

192 
	#FS_INDEX_FL
 0x00001000

	)

193 
	#FS_IMAGIC_FL
 0x00002000

	)

194 
	#FS_JOURNAL_DATA_FL
 0x00004000

	)

195 
	#FS_NOTAIL_FL
 0x00008000

	)

196 
	#FS_DIRSYNC_FL
 0x00010000

	)

197 
	#FS_TOPDIR_FL
 0x00020000

	)

198 
	#FS_EXTENT_FL
 0x00080000

	)

199 
	#FS_DIRECTIO_FL
 0x00100000

	)

200 
	#FS_NOCOW_FL
 0x00800000

	)

201 
	#FS_PROJINHERIT_FL
 0x20000000

	)

202 
	#FS_RESERVED_FL
 0x80000000

	)

204 
	#FS_FL_USER_VISIBLE
 0x0003DFFF

	)

205 
	#FS_FL_USER_MODIFIABLE
 0x000380FF

	)

208 
	#SYNC_FILE_RANGE_WAIT_BEFORE
 1

	)

209 
	#SYNC_FILE_RANGE_WRITE
 2

	)

210 
	#SYNC_FILE_RANGE_WAIT_AFTER
 4

	)

	@/usr/include/linux/hdreg.h

1 #iâdeà
_LINUX_HDREG_H


2 
	#_LINUX_HDREG_H


	)

4 
	~<lšux/ty³s.h
>

10 
	#HDIO_DRIVE_CMD_HDR_SIZE
 (4 * (
__u8
))

	)

11 
	#HDIO_DRIVE_HOB_HDR_SIZE
 (8 * (
__u8
))

	)

12 
	#HDIO_DRIVE_TASK_HDR_SIZE
 (8 * (
__u8
))

	)

14 
	#IDE_DRIVE_TASK_NO_DATA
 0

	)

15 
	#IDE_DRIVE_TASK_INVALID
 -1

	)

16 
	#IDE_DRIVE_TASK_SET_XFER
 1

	)

17 
	#IDE_DRIVE_TASK_IN
 2

	)

18 
	#IDE_DRIVE_TASK_OUT
 3

	)

19 
	#IDE_DRIVE_TASK_RAW_WRITE
 4

	)

24 
	#IDE_TASKFILE_STD_IN_FLAGS
 0xFE

	)

25 
	#IDE_HOB_STD_IN_FLAGS
 0x3C

	)

26 
	#IDE_TASKFILE_STD_OUT_FLAGS
 0xFE

	)

27 
	#IDE_HOB_STD_OUT_FLAGS
 0x3C

	)

29 
	tsk_iÜeg_t
;

30 
	t§_iÜeg_t
;

32 
	uide_»g_v®id_s
 {

33 
	m®l
 : 16;

35 
	md©a
 : 1;

36 
	m”rÜ_ã©u»
 : 1;

37 
	m£ùÜ
 : 1;

38 
	mn£ùÜ
 : 1;

39 
	mlcyl
 : 1;

40 
	mhcyl
 : 1;

41 
	m£Ëù
 : 1;

42 
	m¡©us_commªd
 : 1;

44 
	md©a_hob
 : 1;

45 
	m”rÜ_ã©u»_hob
 : 1;

46 
	m£ùÜ_hob
 : 1;

47 
	mn£ùÜ_hob
 : 1;

48 
	mlcyl_hob
 : 1;

49 
	mhcyl_hob
 : 1;

50 
	m£Ëù_hob
 : 1;

51 
	mcÚŒÞ_hob
 : 1;

52 } 
	mb
;

53 } 
	tide_»g_v®id_t
;

55 
	side_sk_»que¡_s
 {

56 
__u8
 
	mio_pÜts
[8];

57 
__u8
 
	mhob_pÜts
[8];

58 
ide_»g_v®id_t
 
	mout_æags
;

59 
ide_»g_v®id_t
 
	mš_æags
;

60 
	md©a_pha£
;

61 
	m»q_cmd
;

62 
	mout_size
;

63 
	mš_size
;

64 } 
	tide_sk_»que¡_t
;

66 
	side_ioùl_»que¡_s
 {

67 
ide_sk_»que¡_t
 *
	msk_»que¡
;

68 *
	mout_bufãr
;

69 *
	mš_bufãr
;

70 } 
	tide_ioùl_»que¡_t
;

72 
	shd_drive_cmd_hdr
 {

73 
__u8
 
	mcommªd
;

74 
__u8
 
	m£ùÜ_numb”
;

75 
__u8
 
	mã©u»
;

76 
__u8
 
	m£ùÜ_couÁ
;

79 
	shd_drive_sk_hdr
 {

80 
__u8
 
	md©a
;

81 
__u8
 
	mã©u»
;

82 
__u8
 
	m£ùÜ_couÁ
;

83 
__u8
 
	m£ùÜ_numb”
;

84 
__u8
 
	mlow_cylšd”
;

85 
__u8
 
	mhigh_cylšd”
;

86 
__u8
 
	mdeviû_h—d
;

87 
__u8
 
	mcommªd
;

88 } 
	tsk_¡ruù_t
;

90 
	shd_drive_hob_hdr
 {

91 
__u8
 
	md©a
;

92 
__u8
 
	mã©u»
;

93 
__u8
 
	m£ùÜ_couÁ
;

94 
__u8
 
	m£ùÜ_numb”
;

95 
__u8
 
	mlow_cylšd”
;

96 
__u8
 
	mhigh_cylšd”
;

97 
__u8
 
	mdeviû_h—d
;

98 
__u8
 
	mcÚŒÞ
;

99 } 
	thob_¡ruù_t
;

101 
	#TASKFILE_NO_DATA
 0x0000

	)

103 
	#TASKFILE_IN
 0x0001

	)

104 
	#TASKFILE_MULTI_IN
 0x0002

	)

106 
	#TASKFILE_OUT
 0x0004

	)

107 
	#TASKFILE_MULTI_OUT
 0x0008

	)

108 
	#TASKFILE_IN_OUT
 0x0010

	)

110 
	#TASKFILE_IN_DMA
 0x0020

	)

111 
	#TASKFILE_OUT_DMA
 0x0040

	)

112 
	#TASKFILE_IN_DMAQ
 0x0080

	)

113 
	#TASKFILE_OUT_DMAQ
 0x0100

	)

115 
	#TASKFILE_P_IN
 0x0200

	)

116 
	#TASKFILE_P_OUT
 0x0400

	)

117 
	#TASKFILE_P_IN_DMA
 0x0800

	)

118 
	#TASKFILE_P_OUT_DMA
 0x1000

	)

119 
	#TASKFILE_P_IN_DMAQ
 0x2000

	)

120 
	#TASKFILE_P_OUT_DMAQ
 0x4000

	)

121 
	#TASKFILE_48
 0x8000

	)

122 
	#TASKFILE_INVALID
 0x7fff

	)

125 
	#WIN_NOP
 0x00

	)

129 
	#CFA_REQ_EXT_ERROR_CODE
 0x03

	)

133 
	#WIN_SRST
 0x08

	)

134 
	#WIN_DEVICE_RESET
 0x08

	)

138 
	#WIN_RECAL
 0x10

	)

139 
	#WIN_RESTORE
 
WIN_RECAL


	)

143 
	#WIN_READ
 0x20

	)

144 
	#WIN_READ_ONCE
 0x21

	)

145 
	#WIN_READ_LONG
 0x22

	)

146 
	#WIN_READ_LONG_ONCE
 0x23

	)

147 
	#WIN_READ_EXT
 0x24

	)

148 
	#WIN_READDMA_EXT
 0x25

	)

149 
	#WIN_READDMA_QUEUED_EXT
 0x26

	)

150 
	#WIN_READ_NATIVE_MAX_EXT
 0x27

	)

154 
	#WIN_MULTREAD_EXT
 0x29

	)

158 
	#WIN_WRITE
 0x30

	)

159 
	#WIN_WRITE_ONCE
 0x31

	)

160 
	#WIN_WRITE_LONG
 0x32

	)

161 
	#WIN_WRITE_LONG_ONCE
 0x33

	)

162 
	#WIN_WRITE_EXT
 0x34

	)

163 
	#WIN_WRITEDMA_EXT
 0x35

	)

164 
	#WIN_WRITEDMA_QUEUED_EXT
 0x36

	)

165 
	#WIN_SET_MAX_EXT
 0x37

	)

166 
	#CFA_WRITE_SECT_WO_ERASE
 0x38

	)

167 
	#WIN_MULTWRITE_EXT
 0x39

	)

171 
	#WIN_WRITE_VERIFY
 0x3C

	)

175 
	#WIN_VERIFY
 0x40

	)

176 
	#WIN_VERIFY_ONCE
 0x41

	)

177 
	#WIN_VERIFY_EXT
 0x42

	)

181 
	#WIN_FORMAT
 0x50

	)

185 
	#WIN_INIT
 0x60

	)

189 
	#WIN_SEEK
 0x70

	)

191 
	#CFA_TRANSLATE_SECTOR
 0x87

	)

192 
	#WIN_DIAGNOSE
 0x90

	)

193 
	#WIN_SPECIFY
 0x91

	)

194 
	#WIN_DOWNLOAD_MICROCODE
 0x92

	)

195 
	#WIN_STANDBYNOW2
 0x94

	)

196 
	#WIN_STANDBY2
 0x96

	)

197 
	#WIN_SETIDLE2
 0x97

	)

198 
	#WIN_CHECKPOWERMODE2
 0x98

	)

199 
	#WIN_SLEEPNOW2
 0x99

	)

203 
	#WIN_PACKETCMD
 0xA0

	)

204 
	#WIN_PIDENTIFY
 0xA1

	)

205 
	#WIN_QUEUED_SERVICE
 0xA2

	)

206 
	#WIN_SMART
 0xB0

	)

207 
	#CFA_ERASE_SECTORS
 0xC0

	)

208 
	#WIN_MULTREAD
 0xC4

	)

209 
	#WIN_MULTWRITE
 0xC5

	)

210 
	#WIN_SETMULT
 0xC6

	)

211 
	#WIN_READDMA_QUEUED
 0xC7

	)

212 
	#WIN_READDMA
 0xC8

	)

213 
	#WIN_READDMA_ONCE
 0xC9

	)

214 
	#WIN_WRITEDMA
 0xCA

	)

215 
	#WIN_WRITEDMA_ONCE
 0xCB

	)

216 
	#WIN_WRITEDMA_QUEUED
 0xCC

	)

217 
	#CFA_WRITE_MULTI_WO_ERASE
 0xCD

	)

218 
	#WIN_GETMEDIASTATUS
 0xDA

	)

219 
	#WIN_ACKMEDIACHANGE
 0xDB

	)

220 
	#WIN_POSTBOOT
 0xDC

	)

221 
	#WIN_PREBOOT
 0xDD

	)

222 
	#WIN_DOORLOCK
 0xDE

	)

223 
	#WIN_DOORUNLOCK
 0xDF

	)

224 
	#WIN_STANDBYNOW1
 0xE0

	)

225 
	#WIN_IDLEIMMEDIATE
 0xE1

	)

226 
	#WIN_STANDBY
 0xE2

	)

227 
	#WIN_SETIDLE1
 0xE3

	)

228 
	#WIN_READ_BUFFER
 0xE4

	)

229 
	#WIN_CHECKPOWERMODE1
 0xE5

	)

230 
	#WIN_SLEEPNOW1
 0xE6

	)

231 
	#WIN_FLUSH_CACHE
 0xE7

	)

232 
	#WIN_WRITE_BUFFER
 0xE8

	)

233 
	#WIN_WRITE_SAME
 0xE9

	)

235 
	#WIN_FLUSH_CACHE_EXT
 0xEA

	)

236 
	#WIN_IDENTIFY
 0xEC

	)

237 
	#WIN_MEDIAEJECT
 0xED

	)

238 
	#WIN_IDENTIFY_DMA
 0xEE

	)

239 
	#WIN_SETFEATURES
 0xEF

	)

240 
	#EXABYTE_ENABLE_NEST
 0xF0

	)

241 
	#WIN_SECURITY_SET_PASS
 0xF1

	)

242 
	#WIN_SECURITY_UNLOCK
 0xF2

	)

243 
	#WIN_SECURITY_ERASE_PREPARE
 0xF3

	)

244 
	#WIN_SECURITY_ERASE_UNIT
 0xF4

	)

245 
	#WIN_SECURITY_FREEZE_LOCK
 0xF5

	)

246 
	#WIN_SECURITY_DISABLE
 0xF6

	)

247 
	#WIN_READ_NATIVE_MAX
 0xF8

	)

248 
	#WIN_SET_MAX
 0xF9

	)

249 
	#DISABLE_SEAGATE
 0xFB

	)

253 
	#SMART_READ_VALUES
 0xD0

	)

254 
	#SMART_READ_THRESHOLDS
 0xD1

	)

255 
	#SMART_AUTOSAVE
 0xD2

	)

256 
	#SMART_SAVE
 0xD3

	)

257 
	#SMART_IMMEDIATE_OFFLINE
 0xD4

	)

258 
	#SMART_READ_LOG_SECTOR
 0xD5

	)

259 
	#SMART_WRITE_LOG_SECTOR
 0xD6

	)

260 
	#SMART_WRITE_THRESHOLDS
 0xD7

	)

261 
	#SMART_ENABLE
 0xD8

	)

262 
	#SMART_DISABLE
 0xD9

	)

263 
	#SMART_STATUS
 0xDA

	)

264 
	#SMART_AUTO_OFFLINE
 0xDB

	)

268 
	#SMART_LCYL_PASS
 0x4F

	)

269 
	#SMART_HCYL_PASS
 0xC2

	)

272 
	#SETFEATURES_EN_8BIT
 0x01

	)

273 
	#SETFEATURES_EN_WCACHE
 0x02

	)

274 
	#SETFEATURES_DIS_DEFECT
 0x04

	)

275 
	#SETFEATURES_EN_APM
 0x05

	)

276 
	#SETFEATURES_EN_SAME_R
 0x22

	)

277 
	#SETFEATURES_DIS_MSN
 0x31

	)

278 
	#SETFEATURES_DIS_RETRY
 0x33

	)

279 
	#SETFEATURES_EN_AAM
 0x42

	)

280 
	#SETFEATURES_RW_LONG
 0x44

	)

281 
	#SETFEATURES_SET_CACHE
 0x54

	)

282 
	#SETFEATURES_DIS_RLA
 0x55

	)

283 
	#SETFEATURES_EN_RI
 0x5D

	)

284 
	#SETFEATURES_EN_SI
 0x5E

	)

285 
	#SETFEATURES_DIS_RPOD
 0x66

	)

286 
	#SETFEATURES_DIS_ECC
 0x77

	)

287 
	#SETFEATURES_DIS_8BIT
 0x81

	)

288 
	#SETFEATURES_DIS_WCACHE
 0x82

	)

289 
	#SETFEATURES_EN_DEFECT
 0x84

	)

290 
	#SETFEATURES_DIS_APM
 0x85

	)

291 
	#SETFEATURES_EN_ECC
 0x88

	)

292 
	#SETFEATURES_EN_MSN
 0x95

	)

293 
	#SETFEATURES_EN_RETRY
 0x99

	)

294 
	#SETFEATURES_EN_RLA
 0xAA

	)

295 
	#SETFEATURES_PREFETCH
 0xAB

	)

296 
	#SETFEATURES_EN_REST
 0xAC

	)

297 
	#SETFEATURES_4B_RW_LONG
 0xBB

	)

298 
	#SETFEATURES_DIS_AAM
 0xC2

	)

299 
	#SETFEATURES_EN_RPOD
 0xCC

	)

300 
	#SETFEATURES_DIS_RI
 0xDD

	)

301 
	#SETFEATURES_EN_SAME_M
 0xDD

	)

302 
	#SETFEATURES_DIS_SI
 0xDE

	)

306 
	#SECURITY_SET_PASSWORD
 0xBA

	)

307 
	#SECURITY_UNLOCK
 0xBB

	)

308 
	#SECURITY_ERASE_PREPARE
 0xBC

	)

309 
	#SECURITY_ERASE_UNIT
 0xBD

	)

310 
	#SECURITY_FREEZE_LOCK
 0xBE

	)

311 
	#SECURITY_DISABLE_PASSWORD
 0xBF

	)

313 
	shd_geom‘ry
 {

314 
	mh—ds
;

315 
	m£ùÜs
;

316 
	mcylšd”s
;

317 
	m¡¬t
;

321 
	#HDIO_GETGEO
 0x0301

	)

322 
	#HDIO_GET_UNMASKINTR
 0x0302

	)

323 
	#HDIO_GET_MULTCOUNT
 0x0304

	)

324 
	#HDIO_GET_QDMA
 0x0305

	)

326 
	#HDIO_SET_XFER
 0x0306

	)

328 
	#HDIO_OBSOLETE_IDENTITY
 0x0307

	)

329 
	#HDIO_GET_KEEPSETTINGS
 0x0308

	)

330 
	#HDIO_GET_32BIT
 0x0309

	)

331 
	#HDIO_GET_NOWERR
 0x030¨

	)

332 
	#HDIO_GET_DMA
 0x030b

	)

333 
	#HDIO_GET_NICE
 0x030ø

	)

334 
	#HDIO_GET_IDENTITY
 0x030d

	)

335 
	#HDIO_GET_WCACHE
 0x030

	)

336 
	#HDIO_GET_ACOUSTIC
 0x030à

	)

337 
	#HDIO_GET_ADDRESS
 0x0310

	)

339 
	#HDIO_GET_BUSSTATE
 0x031¨

	)

340 
	#HDIO_TRISTATE_HWIF
 0x031b

	)

341 
	#HDIO_DRIVE_RESET
 0x031ø

	)

342 
	#HDIO_DRIVE_TASKFILE
 0x031d

	)

343 
	#HDIO_DRIVE_TASK
 0x031

	)

344 
	#HDIO_DRIVE_CMD
 0x031à

	)

345 
	#HDIO_DRIVE_CMD_AEB
 
HDIO_DRIVE_TASK


	)

348 
	#HDIO_SET_MULTCOUNT
 0x0321

	)

349 
	#HDIO_SET_UNMASKINTR
 0x0322

	)

350 
	#HDIO_SET_KEEPSETTINGS
 0x0323

	)

351 
	#HDIO_SET_32BIT
 0x0324

	)

352 
	#HDIO_SET_NOWERR
 0x0325

	)

353 
	#HDIO_SET_DMA
 0x0326

	)

354 
	#HDIO_SET_PIO_MODE
 0x0327

	)

355 
	#HDIO_SCAN_HWIF
 0x0328

	)

356 
	#HDIO_UNREGISTER_HWIF
 0x032¨

	)

357 
	#HDIO_SET_NICE
 0x0329

	)

358 
	#HDIO_SET_WCACHE
 0x032b

	)

359 
	#HDIO_SET_ACOUSTIC
 0x032ø

	)

360 
	#HDIO_SET_BUSSTATE
 0x032d

	)

361 
	#HDIO_SET_QDMA
 0x032

	)

362 
	#HDIO_SET_ADDRESS
 0x032à

	)

366 
	mBUSSTATE_OFF
 = 0,

367 
	mBUSSTATE_ON
,

368 
	mBUSSTATE_TRISTATE


377 
	#__NEW_HD_DRIVE_ID


	)

385 
	shd_driveid
 {

386 
	mcÚfig
;

387 
	mcyls
;

388 
	m»£rved2
;

389 
	mh—ds
;

390 
	mŒack_by‹s
;

391 
	m£ùÜ_by‹s
;

392 
	m£ùÜs
;

393 
	mv’dÜ0
;

394 
	mv’dÜ1
;

395 
	mv’dÜ2
;

396 
	m£rŸl_no
[20];

397 
	mbuf_ty³
;

398 
	mbuf_size
;

401 
	mecc_by‹s
;

402 
	mfw_»v
[8];

403 
	mmod–
[40];

404 
	mmax_muÉ£ù
;

405 
	mv’dÜ3
;

406 
	mdwÜd_io
;

407 
	mv’dÜ4
;

408 
	mÿ·bž™y
;

414 
	m»£rved50
;

415 
	mv’dÜ5
;

416 
	mtPIO
;

417 
	mv’dÜ6
;

418 
	mtDMA
;

419 
	mf›ld_v®id
;

424 
	mcur_cyls
;

425 
	mcur_h—ds
;

426 
	mcur_£ùÜs
;

427 
	mcur_ÿ·c™y0
;

428 
	mcur_ÿ·c™y1
;

429 
	mmuÉ£ù
;

430 
	mmuÉ£ù_v®id
;

431 
	mlba_ÿ·c™y
;

432 
	mdma_1wÜd
;

433 
	mdma_mwÜd
;

434 
	meide_pio_modes
;

435 
	meide_dma_mš
;

436 
	meide_dma_time
;

437 
	meide_pio
;

438 
	meide_pio_iÜdy
;

439 
	mwÜds69_70
[2];

442 
	mwÜds71_74
[4];

445 
	mqueue_d•th
;

449 
	mwÜds76_79
[4];

450 
	mmajÜ_»v_num
;

451 
	mmšÜ_»v_num
;

452 
	mcommªd_£t_1
;

470 
	mcommªd_£t_2
;

488 
	mcfs£
;

500 
	mcfs_’abË_1
;

519 
	mcfs_’abË_2
;

538 
	mcsf_deçuÉ
;

550 
	mdma_uÉ¿
;

551 
	mŒ£uc
;

552 
	mŒsEuc
;

553 
	mCurAPMv®ues
;

554 
	mm´c
;

555 
	mhw_cÚfig
;

573 
	macou¡ic
;

577 
	mm¤qs
;

578 
	msxã¹
;

579 
	m§l
;

580 
	m¥g
;

581 
	mlba_ÿ·c™y_2
;

582 
	mwÜds104_125
[22];

583 
	mÏ¡_lun
;

584 
	mwÜd127
;

592 
	mdlf
;

604 
	mcsfo
;

612 
	mwÜds130_155
[26];

613 
	mwÜd156
;

614 
	mwÜds157_159
[3];

615 
	mcç_pow”
;

622 
	mwÜds161_175
[15];

623 
	mwÜds176_205
[30];

624 
	mwÜds206_254
[49];

625 
	mš‹gr™y_wÜd
;

636 
	#IDE_NICE_DSC_OVERLAP
 (0è

	)

637 
	#IDE_NICE_ATAPI_OVERLAP
 (1è

	)

638 
	#IDE_NICE_1
 (3è

	)

639 
	#IDE_NICE_0
 (2è

	)

640 
	#IDE_NICE_2
 (4è

	)

	@/usr/include/linux/kernel.h

1 #iâdeà
_LINUX_KERNEL_H


2 
	#_LINUX_KERNEL_H


	)

4 
	~<lšux/sysšfo.h
>

9 
	#__ALIGN_KERNEL
(
x
, 
a
è
	`__ALIGN_KERNEL_MASK
(x, (
	`ty³of
(x))×è- 1)

	)

10 
	#__ALIGN_KERNEL_MASK
(
x
, 
mask
è(((xè+ (mask)è& ~(mask))

	)

	@/usr/include/linux/sched.h

1 #iâdeà
_LINUX_SCHED_H


2 
	#_LINUX_SCHED_H


	)

7 
	#CSIGNAL
 0x000000fà

	)

8 
	#CLONE_VM
 0x00000100

	)

9 
	#CLONE_FS
 0x00000200

	)

10 
	#CLONE_FILES
 0x00000400

	)

11 
	#CLONE_SIGHAND
 0x00000800

	)

12 
	#CLONE_PTRACE
 0x00002000

	)

13 
	#CLONE_VFORK
 0x00004000

	)

14 
	#CLONE_PARENT
 0x00008000

	)

15 
	#CLONE_THREAD
 0x00010000

	)

16 
	#CLONE_NEWNS
 0x00020000

	)

17 
	#CLONE_SYSVSEM
 0x00040000

	)

18 
	#CLONE_SETTLS
 0x00080000

	)

19 
	#CLONE_PARENT_SETTID
 0x00100000

	)

20 
	#CLONE_CHILD_CLEARTID
 0x00200000

	)

21 
	#CLONE_DETACHED
 0x00400000

	)

22 
	#CLONE_UNTRACED
 0x00800000

	)

23 
	#CLONE_CHILD_SETTID
 0x01000000

	)

24 
	#CLONE_NEWCGROUP
 0x02000000

	)

25 
	#CLONE_NEWUTS
 0x04000000

	)

26 
	#CLONE_NEWIPC
 0x08000000

	)

27 
	#CLONE_NEWUSER
 0x10000000

	)

28 
	#CLONE_NEWPID
 0x20000000

	)

29 
	#CLONE_NEWNET
 0x40000000

	)

30 
	#CLONE_IO
 0x80000000

	)

35 
	#SCHED_NORMAL
 0

	)

36 
	#SCHED_FIFO
 1

	)

37 
	#SCHED_RR
 2

	)

38 
	#SCHED_BATCH
 3

	)

40 
	#SCHED_IDLE
 5

	)

41 
	#SCHED_DEADLINE
 6

	)

44 
	#SCHED_RESET_ON_FORK
 0x40000000

	)

49 
	#SCHED_FLAG_RESET_ON_FORK
 0x01

	)

	@/usr/include/linux/tty.h

1 #iâdeà
_LINUX_TTY_H


2 
	#_LINUX_TTY_H


	)

8 
	#NR_LDISCS
 30

	)

11 
	#N_TTY
 0

	)

12 
	#N_SLIP
 1

	)

13 
	#N_MOUSE
 2

	)

14 
	#N_PPP
 3

	)

15 
	#N_STRIP
 4

	)

16 
	#N_AX25
 5

	)

17 
	#N_X25
 6

	)

18 
	#N_6PACK
 7

	)

19 
	#N_MASC
 8

	)

20 
	#N_R3964
 9

	)

21 
	#N_PROFIBUS_FDL
 10

	)

22 
	#N_IRDA
 11

	)

23 
	#N_SMSBLOCK
 12

	)

25 
	#N_HDLC
 13

	)

26 
	#N_SYNC_PPP
 14

	)

27 
	#N_HCI
 15

	)

28 
	#N_GIGASET_M101
 16

	)

29 
	#N_SLCAN
 17

	)

30 
	#N_PPS
 18

	)

31 
	#N_V253
 19

	)

32 
	#N_CAIF
 20

	)

33 
	#N_GSM0710
 21

	)

34 
	#N_TI_WL
 22

	)

35 
	#N_TRACESINK
 23

	)

36 
	#N_TRACEROUTER
 24

	)

37 
	#N_NCI
 25

	)

	@/usr/include/signal.h

22 #iâdef 
_SIGNAL_H


24 #ià!
defšed
 
__Ãed_sig_©omic_t
 && !defšed 
__Ãed_sig£t_t


25 
	#_SIGNAL_H


	)

28 
	~<ã©u»s.h
>

30 
	g__BEGIN_DECLS


32 
	~<b™s/sig£t.h
>

36 #ià
defšed
 
__Ãed_sig_©omic_t
 || defšed 
_SIGNAL_H


37 #iâdeà
__sig_©omic_t_defšed


38 
	#__sig_©omic_t_defšed


	)

39 
__BEGIN_NAMESPACE_STD


40 
__sig_©omic_t
 
	tsig_©omic_t
;

41 
	g__END_NAMESPACE_STD


43 #undeà
__Ãed_sig_©omic_t


46 #ià
defšed
 
__Ãed_sig£t_t
 || (defšed 
_SIGNAL_H
 && defšed 
__USE_POSIX
)

47 #iâdeà
__sig£t_t_defšed


48 
	#__sig£t_t_defšed


	)

49 
__sig£t_t
 
	tsig£t_t
;

51 #undeà
__Ãed_sig£t_t


54 #ifdeà
_SIGNAL_H


56 
	~<b™s/ty³s.h
>

57 
	~<b™s/signum.h
>

59 #ià
defšed
 
__USE_XOPEN
 || defšed 
__USE_XOPEN2K


60 #iâdeà
__pid_t_defšed


61 
__pid_t
 
	tpid_t
;

62 
	#__pid_t_defšed


	)

64 #ifdeà
__USE_XOPEN


66 #iâdeà
__uid_t_defšed


67 
__uid_t
 
	tuid_t
;

68 
	#__uid_t_defšed


	)

72 #ifdeà
__USE_POSIX199309


74 
	#__Ãed_time¥ec


	)

75 
	~<time.h
>

78 #ià
defšed
 
__USE_POSIX199309
 || defšed 
__USE_XOPEN_EXTENDED


80 
	~<b™s/sigšfo.h
>

85 (*
	t__sighªdËr_t
) ();

90 
__sighªdËr_t
 
	$__sysv_sigÇl
 (
__sig
, 
__sighªdËr_t
 
__hªdËr
)

91 
__THROW
;

92 #ifdeà
__USE_GNU


93 
__sighªdËr_t
 
	$sysv_sigÇl
 (
__sig
, 
__sighªdËr_t
 
__hªdËr
)

94 
__THROW
;

100 
__BEGIN_NAMESPACE_STD


101 #ifdeà
__USE_MISC


102 
__sighªdËr_t
 
	$sigÇl
 (
__sig
, 
__sighªdËr_t
 
__hªdËr
)

103 
__THROW
;

106 #ifdeà
__REDIRECT_NTH


107 
__sighªdËr_t
 
	`__REDIRECT_NTH
 (
sigÇl
,

108 (
__sig
, 
__sighªdËr_t
 
__hªdËr
),

109 
__sysv_sigÇl
);

111 
	#sigÇl
 
__sysv_sigÇl


	)

114 
__END_NAMESPACE_STD


116 #ifdeà
__USE_XOPEN


119 
__sighªdËr_t
 
	$bsd_sigÇl
 (
__sig
, 
__sighªdËr_t
 
__hªdËr
)

120 
__THROW
;

126 #ifdeà
__USE_POSIX


127 
	$kžl
 (
__pid_t
 
__pid
, 
__sig
è
__THROW
;

130 #ià
defšed
 
__USE_MISC
 || defšed 
__USE_XOPEN_EXTENDED


134 
	$kžÍg
 (
__pid_t
 
__pg½
, 
__sig
è
__THROW
;

137 
__BEGIN_NAMESPACE_STD


139 
	$¿i£
 (
__sig
è
__THROW
;

140 
__END_NAMESPACE_STD


142 #ifdeà
__USE_MISC


144 
__sighªdËr_t
 
	$ssigÇl
 (
__sig
, 
__sighªdËr_t
 
__hªdËr
)

145 
__THROW
;

146 
	$gsigÇl
 (
__sig
è
__THROW
;

149 #ifdeà
__USE_XOPEN2K8


151 
	`psigÇl
 (
__sig
, cÚ¡ *
__s
);

154 
	`psigšfo
 (cÚ¡ 
sigšfo_t
 *
__pšfo
, cÚ¡ *
__s
);

166 #ifdeà
__USE_XOPEN


167 #ifdeà
__GNUC__


168 
	$sig·u£
 (
__sig
è
	`__asm__
 ("__xpg_sigpause");

170 
	`__sig·u£
 (
__sig_Ü_mask
, 
__is_sig
);

172 
	#sig·u£
(
sig
è
	`__sig·u£
 ((sig), 1)

	)

177 #ifdeà
__USE_MISC


184 
	#sigmask
(
sig
è
	`__sigmask
(sig)

	)

187 
	$sigblock
 (
__mask
è
__THROW
 
__©Œibu‹_d•»ÿ‹d__
;

190 
	$sig£tmask
 (
__mask
è
__THROW
 
__©Œibu‹_d•»ÿ‹d__
;

193 
	$sigg‘mask
 (è
__THROW
 
__©Œibu‹_d•»ÿ‹d__
;

197 #ifdeà
__USE_MISC


198 
	#NSIG
 
_NSIG


	)

201 #ifdeà
__USE_GNU


202 
__sighªdËr_t
 
	tsighªdËr_t
;

206 #ifdeà
__USE_MISC


207 
__sighªdËr_t
 
	tsig_t
;

210 #ifdeà
__USE_POSIX


213 
	$sigem±y£t
 (
sig£t_t
 *
__£t
è
__THROW
 
	`__nÚnuÎ
 ((1));

216 
	$sigfžl£t
 (
sig£t_t
 *
__£t
è
__THROW
 
	`__nÚnuÎ
 ((1));

219 
	$sigadd£t
 (
sig£t_t
 *
__£t
, 
__signo
è
__THROW
 
	`__nÚnuÎ
 ((1));

222 
	$sigd–£t
 (
sig£t_t
 *
__£t
, 
__signo
è
__THROW
 
	`__nÚnuÎ
 ((1));

225 
	$sigismemb”
 (cÚ¡ 
sig£t_t
 *
__£t
, 
__signo
)

226 
__THROW
 
	`__nÚnuÎ
 ((1));

228 #ifdeà
__USE_GNU


230 
	$sigi£m±y£t
 (cÚ¡ 
sig£t_t
 *
__£t
è
__THROW
 
	`__nÚnuÎ
 ((1));

233 
	$sigªd£t
 (
sig£t_t
 *
__£t
, cÚ¡ sig£t_ˆ*
__Ëá
,

234 cÚ¡ 
sig£t_t
 *
__right
è
__THROW
 
	`__nÚnuÎ
 ((1, 2, 3));

237 
	$sigÜ£t
 (
sig£t_t
 *
__£t
, cÚ¡ sig£t_ˆ*
__Ëá
,

238 cÚ¡ 
sig£t_t
 *
__right
è
__THROW
 
	`__nÚnuÎ
 ((1, 2, 3));

243 
	~<b™s/sigaùiÚ.h
>

246 
	$sig´ocmask
 (
__how
, cÚ¡ 
sig£t_t
 *
__»¡riù
 
__£t
,

247 
sig£t_t
 *
__»¡riù
 
__o£t
è
__THROW
;

254 
	$sigsu¥’d
 (cÚ¡ 
sig£t_t
 *
__£t
è
	`__nÚnuÎ
 ((1));

257 
	$sigaùiÚ
 (
__sig
, cÚ¡ 
sigaùiÚ
 *
__»¡riù
 
__aù
,

258 
sigaùiÚ
 *
__»¡riù
 
__ßù
è
__THROW
;

261 
	$sig³ndšg
 (
sig£t_t
 *
__£t
è
__THROW
 
	`__nÚnuÎ
 ((1));

268 
	$sigwa™
 (cÚ¡ 
sig£t_t
 *
__»¡riù
 
__£t
, *__»¡riù 
__sig
)

269 
	`__nÚnuÎ
 ((1, 2));

271 #ifdeà
__USE_POSIX199309


276 
	$sigwa™šfo
 (cÚ¡ 
sig£t_t
 *
__»¡riù
 
__£t
,

277 
sigšfo_t
 *
__»¡riù
 
__šfo
è
	`__nÚnuÎ
 ((1));

284 
	$sigtimedwa™
 (cÚ¡ 
sig£t_t
 *
__»¡riù
 
__£t
,

285 
sigšfo_t
 *
__»¡riù
 
__šfo
,

286 cÚ¡ 
time¥ec
 *
__»¡riù
 
__timeout
)

287 
	`__nÚnuÎ
 ((1));

291 
	$sigqueue
 (
__pid_t
 
__pid
, 
__sig
, cÚ¡ 
sigv®
 
__v®
)

292 
__THROW
;

297 #ifdeà
__USE_MISC


301 cÚ¡ *cÚ¡ 
_sys_sigli¡
[
_NSIG
];

302 cÚ¡ *cÚ¡ 
sys_sigli¡
[
_NSIG
];

306 
	~<b™s/sigcÚ‹xt.h
>

309 
	$sig»tuº
 (
sigcÚ‹xt
 *
__sý
è
__THROW
;

314 #ià
defšed
 
__USE_XOPEN_EXTENDED
 || defšed 
__USE_XOPEN2K8


315 
	#__Ãed_size_t


	)

316 
	~<¡ddef.h
>

321 
	$sigš‹¼u±
 (
__sig
, 
__š‹¼u±
è
__THROW
;

323 
	~<b™s/sig¡ack.h
>

324 #ià
defšed
 
__USE_XOPEN
 || defšed 
__USE_XOPEN2K8


326 
	~<sys/ucÚ‹xt.h
>

332 
	$sig¡ack
 (
sig¡ack
 *
__ss
, sig¡ack *
__oss
)

333 
__THROW
 
__©Œibu‹_d•»ÿ‹d__
;

337 
	$sig®t¡ack
 (cÚ¡ 
sig®t¡ack
 *
__»¡riù
 
__ss
,

338 
sig®t¡ack
 *
__»¡riù
 
__oss
è
__THROW
;

342 #ifdeà
__USE_XOPEN_EXTENDED


346 
	$sighÞd
 (
__sig
è
__THROW
;

349 
	$sig»l£
 (
__sig
è
__THROW
;

352 
	$sigignÜe
 (
__sig
è
__THROW
;

355 
__sighªdËr_t
 
	$sig£t
 (
__sig
, 
__sighªdËr_t
 
__di¥
è
__THROW
;

358 #ià
defšed
 
__USE_POSIX199506
 || defšed 
__USE_UNIX98


361 
	~<b™s/±h»adty³s.h
>

362 
	~<b™s/sigth»ad.h
>

369 
	$__libc_cu¼’t_sig¹mš
 (è
__THROW
;

371 
	$__libc_cu¼’t_sig¹max
 (è
__THROW
;

375 
__END_DECLS


	@/usr/include/stdio.h

23 #iâdeà
_STDIO_H


25 #ià!
defšed
 
__Ãed_FILE
 && !defšed 
__Ãed___FILE


26 
	#_STDIO_H
 1

	)

27 
	~<ã©u»s.h
>

29 
	g__BEGIN_DECLS


31 
	#__Ãed_size_t


	)

32 
	#__Ãed_NULL


	)

33 
	~<¡ddef.h
>

35 
	~<b™s/ty³s.h
>

36 
	#__Ãed_FILE


	)

37 
	#__Ãed___FILE


	)

41 #ià!
defšed
 
__FILE_defšed
 && defšed 
__Ãed_FILE


44 
	g_IO_FILE
;

46 
__BEGIN_NAMESPACE_STD


48 
_IO_FILE
 
	tFILE
;

49 
	g__END_NAMESPACE_STD


50 #ià
defšed
 
__USE_LARGEFILE64
 || defšed 
__USE_POSIX
 \

51 || 
defšed
 
	g__USE_ISOC99
 || defšed 
	g__USE_XOPEN
 \

52 || 
defšed
 
__USE_POSIX2


53 
	$__USING_NAMESPACE_STD
(
FILE
)

56 
	#__FILE_defšed
 1

	)

58 #undeà
__Ãed_FILE


61 #ià!
defšed
 
____FILE_defšed
 && defšed 
__Ãed___FILE


64 
_IO_FILE
 
	t__FILE
;

66 
	#____FILE_defšed
 1

	)

68 #undeà
__Ãed___FILE


71 #ifdef 
_STDIO_H


72 
	#_STDIO_USES_IOSTREAM


	)

74 
	~<libio.h
>

76 #ià
defšed
 
__USE_XOPEN
 || defšed 
__USE_XOPEN2K8


77 #ifdeà
__GNUC__


78 #iâdeà
_VA_LIST_DEFINED


79 
_G_va_li¡
 
	tva_li¡
;

80 
	#_VA_LIST_DEFINED


	)

83 
	~<¡d¬g.h
>

87 #ifdeà
__USE_XOPEN2K8


88 #iâdeà
__off_t_defšed


89 #iâdeà
__USE_FILE_OFFSET64


90 
__off_t
 
	toff_t
;

92 
__off64_t
 
	toff_t
;

94 
	#__off_t_defšed


	)

96 #ià
defšed
 
__USE_LARGEFILE64
 && !defšed 
__off64_t_defšed


97 
__off64_t
 
	toff64_t
;

98 
	#__off64_t_defšed


	)

101 #iâdeà
__ssize_t_defšed


102 
__ssize_t
 
	tssize_t
;

103 
	#__ssize_t_defšed


	)

108 
__BEGIN_NAMESPACE_STD


109 #iâdeà
__USE_FILE_OFFSET64


110 
_G_åos_t
 
	tåos_t
;

112 
_G_åos64_t
 
	tåos_t
;

114 
__END_NAMESPACE_STD


115 #ifdeà
__USE_LARGEFILE64


116 
_G_åos64_t
 
	tåos64_t
;

120 
	#_IOFBF
 0

	)

121 
	#_IOLBF
 1

	)

122 
	#_IONBF
 2

	)

126 #iâdeà
BUFSIZ


127 
	#BUFSIZ
 
_IO_BUFSIZ


	)

133 #iâdeà
EOF


134 
	#EOF
 (-1)

	)

140 
	#SEEK_SET
 0

	)

141 
	#SEEK_CUR
 1

	)

142 
	#SEEK_END
 2

	)

143 #ifdeà
__USE_GNU


144 
	#SEEK_DATA
 3

	)

145 
	#SEEK_HOLE
 4

	)

149 #ià
defšed
 
__USE_MISC
 || defšed 
__USE_XOPEN


151 
	#P_tmpdœ
 "/tmp"

	)

164 
	~<b™s/¡dio_lim.h
>

168 
_IO_FILE
 *
¡dš
;

169 
_IO_FILE
 *
¡dout
;

170 
_IO_FILE
 *
¡d”r
;

172 
	#¡dš
 
¡dš


	)

173 
	#¡dout
 
¡dout


	)

174 
	#¡d”r
 
¡d”r


	)

176 
__BEGIN_NAMESPACE_STD


178 
	$»move
 (cÚ¡ *
__fž’ame
è
__THROW
;

180 
	$»Çme
 (cÚ¡ *
__Þd
, cÚ¡ *
__Ãw
è
__THROW
;

181 
__END_NAMESPACE_STD


183 #ifdeà
__USE_ATFILE


185 
	$»Çm—t
 (
__Þdfd
, cÚ¡ *
__Þd
, 
__Ãwfd
,

186 cÚ¡ *
__Ãw
è
__THROW
;

189 
__BEGIN_NAMESPACE_STD


194 #iâdeà
__USE_FILE_OFFSET64


195 
FILE
 *
	$tmpfže
 (è
__wur
;

197 #ifdeà
__REDIRECT


198 
FILE
 *
	`__REDIRECT
 (
tmpfže
, (), 
tmpfže64
è
__wur
;

200 
	#tmpfže
 
tmpfže64


	)

204 #ifdeà
__USE_LARGEFILE64


205 
FILE
 *
	$tmpfže64
 (è
__wur
;

209 *
	$tm²am
 (*
__s
è
__THROW
 
__wur
;

210 
__END_NAMESPACE_STD


212 #ifdeà
__USE_MISC


215 *
	$tm²am_r
 (*
__s
è
__THROW
 
__wur
;

219 #ià
defšed
 
__USE_MISC
 || defšed 
__USE_XOPEN


227 *
	$‹m²am
 (cÚ¡ *
__dœ
, cÚ¡ *
__pfx
)

228 
__THROW
 
__©Œibu‹_m®loc__
 
__wur
;

232 
__BEGIN_NAMESPACE_STD


237 
	`fþo£
 (
FILE
 *
__¡»am
);

242 
	`fæush
 (
FILE
 *
__¡»am
);

243 
__END_NAMESPACE_STD


245 #ifdeà
__USE_MISC


252 
	`fæush_uÆocked
 (
FILE
 *
__¡»am
);

255 #ifdeà
__USE_GNU


262 
	`fþo£®l
 ();

266 
__BEGIN_NAMESPACE_STD


267 #iâdeà
__USE_FILE_OFFSET64


272 
FILE
 *
	$fÝ’
 (cÚ¡ *
__»¡riù
 
__fž’ame
,

273 cÚ¡ *
__»¡riù
 
__modes
è
__wur
;

278 
FILE
 *
	$äeÝ’
 (cÚ¡ *
__»¡riù
 
__fž’ame
,

279 cÚ¡ *
__»¡riù
 
__modes
,

280 
FILE
 *
__»¡riù
 
__¡»am
è
__wur
;

282 #ifdeà
__REDIRECT


283 
FILE
 *
	`__REDIRECT
 (
fÝ’
, (cÚ¡ *
__»¡riù
 
__fž’ame
,

284 cÚ¡ *
__»¡riù
 
__modes
), 
fÝ’64
)

285 
__wur
;

286 
FILE
 *
	`__REDIRECT
 (
äeÝ’
, (cÚ¡ *
__»¡riù
 
__fž’ame
,

287 cÚ¡ *
__»¡riù
 
__modes
,

288 
FILE
 *
__»¡riù
 
__¡»am
), 
äeÝ’64
)

289 
__wur
;

291 
	#fÝ’
 
fÝ’64


	)

292 
	#äeÝ’
 
äeÝ’64


	)

295 
__END_NAMESPACE_STD


296 #ifdeà
__USE_LARGEFILE64


297 
FILE
 *
	$fÝ’64
 (cÚ¡ *
__»¡riù
 
__fž’ame
,

298 cÚ¡ *
__»¡riù
 
__modes
è
__wur
;

299 
FILE
 *
	$äeÝ’64
 (cÚ¡ *
__»¡riù
 
__fž’ame
,

300 cÚ¡ *
__»¡riù
 
__modes
,

301 
FILE
 *
__»¡riù
 
__¡»am
è
__wur
;

304 #ifdef 
__USE_POSIX


306 
FILE
 *
	$fdÝ’
 (
__fd
, cÚ¡ *
__modes
è
__THROW
 
__wur
;

309 #ifdef 
__USE_GNU


312 
FILE
 *
	$fÝ’cook›
 (*
__»¡riù
 
__magic_cook›
,

313 cÚ¡ *
__»¡riù
 
__modes
,

314 
_IO_cook›_io_funùiÚs_t
 
__io_funcs
è
__THROW
 
__wur
;

317 #ifdeà
__USE_XOPEN2K8


319 
FILE
 *
	$fmemÝ’
 (*
__s
, 
size_t
 
__Ën
, cÚ¡ *
__modes
)

320 
__THROW
 
__wur
;

325 
FILE
 *
	$Ý’_mem¡»am
 (**
__buæoc
, 
size_t
 *
__siz–oc
è
__THROW
 
__wur
;

329 
__BEGIN_NAMESPACE_STD


332 
	$£tbuf
 (
FILE
 *
__»¡riù
 
__¡»am
, *__»¡riù 
__buf
è
__THROW
;

336 
	$£tvbuf
 (
FILE
 *
__»¡riù
 
__¡»am
, *__»¡riù 
__buf
,

337 
__modes
, 
size_t
 
__n
è
__THROW
;

338 
__END_NAMESPACE_STD


340 #ifdef 
__USE_MISC


343 
	$£tbufãr
 (
FILE
 *
__»¡riù
 
__¡»am
, *__»¡riù 
__buf
,

344 
size_t
 
__size
è
__THROW
;

347 
	$£Žšebuf
 (
FILE
 *
__¡»am
è
__THROW
;

351 
__BEGIN_NAMESPACE_STD


356 
	`årštf
 (
FILE
 *
__»¡riù
 
__¡»am
,

357 cÚ¡ *
__»¡riù
 
__fÜm©
, ...);

362 
	`´štf
 (cÚ¡ *
__»¡riù
 
__fÜm©
, ...);

364 
	$¥rštf
 (*
__»¡riù
 
__s
,

365 cÚ¡ *
__»¡riù
 
__fÜm©
, ...è
__THROWNL
;

371 
	`vårštf
 (
FILE
 *
__»¡riù
 
__s
, cÚ¡ *__»¡riù 
__fÜm©
,

372 
_G_va_li¡
 
__¬g
);

377 
	`v´štf
 (cÚ¡ *
__»¡riù
 
__fÜm©
, 
_G_va_li¡
 
__¬g
);

379 
	$v¥rštf
 (*
__»¡riù
 
__s
, cÚ¡ *__»¡riù 
__fÜm©
,

380 
_G_va_li¡
 
__¬g
è
__THROWNL
;

381 
__END_NAMESPACE_STD


383 #ià
defšed
 
__USE_ISOC99
 || defšed 
__USE_UNIX98


384 
__BEGIN_NAMESPACE_C99


386 
	$¢´štf
 (*
__»¡riù
 
__s
, 
size_t
 
__maxËn
,

387 cÚ¡ *
__»¡riù
 
__fÜm©
, ...)

388 
__THROWNL
 
	`__©Œibu‹__
 ((
	`__fÜm©__
 (
__´štf__
, 3, 4)));

390 
	$v¢´štf
 (*
__»¡riù
 
__s
, 
size_t
 
__maxËn
,

391 cÚ¡ *
__»¡riù
 
__fÜm©
, 
_G_va_li¡
 
__¬g
)

392 
__THROWNL
 
	`__©Œibu‹__
 ((
	`__fÜm©__
 (
__´štf__
, 3, 0)));

393 
__END_NAMESPACE_C99


396 #ifdeà
__USE_GNU


399 
	$va¥rštf
 (**
__»¡riù
 
__±r
, cÚ¡ *__»¡riù 
__f
,

400 
_G_va_li¡
 
__¬g
)

401 
__THROWNL
 
	`__©Œibu‹__
 ((
	$__fÜm©__
 (
__´štf__
, 2, 0))è
__wur
;

402 
	$__a¥rštf
 (**
__»¡riù
 
__±r
,

403 cÚ¡ *
__»¡riù
 
__fmt
, ...)

404 
__THROWNL
 
	`__©Œibu‹__
 ((
	$__fÜm©__
 (
__´štf__
, 2, 3))è
__wur
;

405 
	$a¥rštf
 (**
__»¡riù
 
__±r
,

406 cÚ¡ *
__»¡riù
 
__fmt
, ...)

407 
__THROWNL
 
	`__©Œibu‹__
 ((
	$__fÜm©__
 (
__´štf__
, 2, 3))è
__wur
;

410 #ifdeà
__USE_XOPEN2K8


412 
	$vd´štf
 (
__fd
, cÚ¡ *
__»¡riù
 
__fmt
,

413 
_G_va_li¡
 
__¬g
)

414 
	`__©Œibu‹__
 ((
	`__fÜm©__
 (
__´štf__
, 2, 0)));

415 
	$d´štf
 (
__fd
, cÚ¡ *
__»¡riù
 
__fmt
, ...)

416 
	`__©Œibu‹__
 ((
	`__fÜm©__
 (
__´štf__
, 2, 3)));

420 
__BEGIN_NAMESPACE_STD


425 
	$fsÿnf
 (
FILE
 *
__»¡riù
 
__¡»am
,

426 cÚ¡ *
__»¡riù
 
__fÜm©
, ...è
__wur
;

431 
	$sÿnf
 (cÚ¡ *
__»¡riù
 
__fÜm©
, ...è
__wur
;

433 
	$ssÿnf
 (cÚ¡ *
__»¡riù
 
__s
,

434 cÚ¡ *
__»¡riù
 
__fÜm©
, ...è
__THROW
;

436 #ià
defšed
 
__USE_ISOC99
 && !defšed 
__USE_GNU
 \

437 && (!
defšed
 
__LDBL_COMPAT
 || !defšed 
__REDIRECT
) \

438 && (
defšed
 
__STRICT_ANSI__
 || defšed 
__USE_XOPEN2K
)

439 #ifdeà
__REDIRECT


443 
	`__REDIRECT
 (
fsÿnf
, (
FILE
 *
__»¡riù
 
__¡»am
,

444 cÚ¡ *
__»¡riù
 
__fÜm©
, ...),

445 
__isoc99_fsÿnf
è
__wur
;

446 
	`__REDIRECT
 (
sÿnf
, (cÚ¡ *
__»¡riù
 
__fÜm©
, ...),

447 
__isoc99_sÿnf
è
__wur
;

448 
	`__REDIRECT_NTH
 (
ssÿnf
, (cÚ¡ *
__»¡riù
 
__s
,

449 cÚ¡ *
__»¡riù
 
__fÜm©
, ...),

450 
__isoc99_ssÿnf
);

452 
	$__isoc99_fsÿnf
 (
FILE
 *
__»¡riù
 
__¡»am
,

453 cÚ¡ *
__»¡riù
 
__fÜm©
, ...è
__wur
;

454 
	$__isoc99_sÿnf
 (cÚ¡ *
__»¡riù
 
__fÜm©
, ...è
__wur
;

455 
	$__isoc99_ssÿnf
 (cÚ¡ *
__»¡riù
 
__s
,

456 cÚ¡ *
__»¡riù
 
__fÜm©
, ...è
__THROW
;

457 
	#fsÿnf
 
__isoc99_fsÿnf


	)

458 
	#sÿnf
 
__isoc99_sÿnf


	)

459 
	#ssÿnf
 
__isoc99_ssÿnf


	)

463 
__END_NAMESPACE_STD


465 #ifdef 
__USE_ISOC99


466 
__BEGIN_NAMESPACE_C99


471 
	$vfsÿnf
 (
FILE
 *
__»¡riù
 
__s
, cÚ¡ *__»¡riù 
__fÜm©
,

472 
_G_va_li¡
 
__¬g
)

473 
	`__©Œibu‹__
 ((
	$__fÜm©__
 (
__sÿnf__
, 2, 0))è
__wur
;

479 
	$vsÿnf
 (cÚ¡ *
__»¡riù
 
__fÜm©
, 
_G_va_li¡
 
__¬g
)

480 
	`__©Œibu‹__
 ((
	$__fÜm©__
 (
__sÿnf__
, 1, 0))è
__wur
;

483 
	$vssÿnf
 (cÚ¡ *
__»¡riù
 
__s
,

484 cÚ¡ *
__»¡riù
 
__fÜm©
, 
_G_va_li¡
 
__¬g
)

485 
__THROW
 
	`__©Œibu‹__
 ((
	`__fÜm©__
 (
__sÿnf__
, 2, 0)));

487 #ià!
defšed
 
__USE_GNU
 \

488 && (!
defšed
 
__LDBL_COMPAT
 || !defšed 
__REDIRECT
) \

489 && (
defšed
 
__STRICT_ANSI__
 || defšed 
__USE_XOPEN2K
)

490 #ifdeà
__REDIRECT


494 
	`__REDIRECT
 (
vfsÿnf
,

495 (
FILE
 *
__»¡riù
 
__s
,

496 cÚ¡ *
__»¡riù
 
__fÜm©
, 
_G_va_li¡
 
__¬g
),

497 
__isoc99_vfsÿnf
)

498 
	`__©Œibu‹__
 ((
	$__fÜm©__
 (
__sÿnf__
, 2, 0))è
__wur
;

499 
	`__REDIRECT
 (
vsÿnf
, (cÚ¡ *
__»¡riù
 
__fÜm©
,

500 
_G_va_li¡
 
__¬g
), 
__isoc99_vsÿnf
)

501 
	`__©Œibu‹__
 ((
	$__fÜm©__
 (
__sÿnf__
, 1, 0))è
__wur
;

502 
	`__REDIRECT_NTH
 (
vssÿnf
,

503 (cÚ¡ *
__»¡riù
 
__s
,

504 cÚ¡ *
__»¡riù
 
__fÜm©
,

505 
_G_va_li¡
 
__¬g
), 
__isoc99_vssÿnf
)

506 
	`__©Œibu‹__
 ((
	`__fÜm©__
 (
__sÿnf__
, 2, 0)));

508 
	$__isoc99_vfsÿnf
 (
FILE
 *
__»¡riù
 
__s
,

509 cÚ¡ *
__»¡riù
 
__fÜm©
,

510 
_G_va_li¡
 
__¬g
è
__wur
;

511 
	$__isoc99_vsÿnf
 (cÚ¡ *
__»¡riù
 
__fÜm©
,

512 
_G_va_li¡
 
__¬g
è
__wur
;

513 
	$__isoc99_vssÿnf
 (cÚ¡ *
__»¡riù
 
__s
,

514 cÚ¡ *
__»¡riù
 
__fÜm©
,

515 
_G_va_li¡
 
__¬g
è
__THROW
;

516 
	#vfsÿnf
 
__isoc99_vfsÿnf


	)

517 
	#vsÿnf
 
__isoc99_vsÿnf


	)

518 
	#vssÿnf
 
__isoc99_vssÿnf


	)

522 
__END_NAMESPACE_C99


526 
__BEGIN_NAMESPACE_STD


531 
	`fg‘c
 (
FILE
 *
__¡»am
);

532 
	`g‘c
 (
FILE
 *
__¡»am
);

538 
	`g‘ch¬
 ();

539 
__END_NAMESPACE_STD


543 
	#g‘c
(
_å
è
	`_IO_g‘c
 (_å)

	)

545 #ifdeà
__USE_POSIX


550 
	`g‘c_uÆocked
 (
FILE
 *
__¡»am
);

551 
	`g‘ch¬_uÆocked
 ();

554 #ifdeà
__USE_MISC


561 
	`fg‘c_uÆocked
 (
FILE
 *
__¡»am
);

565 
__BEGIN_NAMESPACE_STD


573 
	`åutc
 (
__c
, 
FILE
 *
__¡»am
);

574 
	`putc
 (
__c
, 
FILE
 *
__¡»am
);

580 
	`putch¬
 (
__c
);

581 
__END_NAMESPACE_STD


585 
	#putc
(
_ch
, 
_å
è
	`_IO_putc
 (_ch, _å)

	)

587 #ifdeà
__USE_MISC


594 
	`åutc_uÆocked
 (
__c
, 
FILE
 *
__¡»am
);

597 #ifdeà
__USE_POSIX


602 
	`putc_uÆocked
 (
__c
, 
FILE
 *
__¡»am
);

603 
	`putch¬_uÆocked
 (
__c
);

607 #ià
defšed
 
__USE_MISC
 \

608 || (
defšed
 
__USE_XOPEN
 && !defšed 
__USE_XOPEN2K
)

610 
	`g‘w
 (
FILE
 *
__¡»am
);

613 
	`putw
 (
__w
, 
FILE
 *
__¡»am
);

617 
__BEGIN_NAMESPACE_STD


622 *
	$fg‘s
 (*
__»¡riù
 
__s
, 
__n
, 
FILE
 *__»¡riù 
__¡»am
)

623 
__wur
;

625 #ià!
defšed
 
__USE_ISOC11
 \

626 || (
defšed
 
__ýlu¥lus
 && __cplusplus <= 201103L)

638 *
	$g‘s
 (*
__s
è
__wur
 
__©Œibu‹_d•»ÿ‹d__
;

640 
__END_NAMESPACE_STD


642 #ifdeà
__USE_GNU


649 *
	$fg‘s_uÆocked
 (*
__»¡riù
 
__s
, 
__n
,

650 
FILE
 *
__»¡riù
 
__¡»am
è
__wur
;

654 #ifdef 
__USE_XOPEN2K8


665 
_IO_ssize_t
 
	$__g‘d–im
 (**
__»¡riù
 
__lš•Œ
,

666 
size_t
 *
__»¡riù
 
__n
, 
__d–im™”
,

667 
FILE
 *
__»¡riù
 
__¡»am
è
__wur
;

668 
_IO_ssize_t
 
	$g‘d–im
 (**
__»¡riù
 
__lš•Œ
,

669 
size_t
 *
__»¡riù
 
__n
, 
__d–im™”
,

670 
FILE
 *
__»¡riù
 
__¡»am
è
__wur
;

678 
_IO_ssize_t
 
	$g‘lše
 (**
__»¡riù
 
__lš•Œ
,

679 
size_t
 *
__»¡riù
 
__n
,

680 
FILE
 *
__»¡riù
 
__¡»am
è
__wur
;

684 
__BEGIN_NAMESPACE_STD


689 
	`åuts
 (cÚ¡ *
__»¡riù
 
__s
, 
FILE
 *__»¡riù 
__¡»am
);

695 
	`puts
 (cÚ¡ *
__s
);

702 
	`ung‘c
 (
__c
, 
FILE
 *
__¡»am
);

709 
size_t
 
	$ä—d
 (*
__»¡riù
 
__±r
, 
size_t
 
__size
,

710 
size_t
 
__n
, 
FILE
 *
__»¡riù
 
__¡»am
è
__wur
;

715 
size_t
 
	`fwr™e
 (cÚ¡ *
__»¡riù
 
__±r
, size_ˆ
__size
,

716 
size_t
 
__n
, 
FILE
 *
__»¡riù
 
__s
);

717 
__END_NAMESPACE_STD


719 #ifdeà
__USE_GNU


726 
	`åuts_uÆocked
 (cÚ¡ *
__»¡riù
 
__s
,

727 
FILE
 *
__»¡riù
 
__¡»am
);

730 #ifdeà
__USE_MISC


737 
size_t
 
	$ä—d_uÆocked
 (*
__»¡riù
 
__±r
, 
size_t
 
__size
,

738 
size_t
 
__n
, 
FILE
 *
__»¡riù
 
__¡»am
è
__wur
;

739 
size_t
 
	`fwr™e_uÆocked
 (cÚ¡ *
__»¡riù
 
__±r
, size_ˆ
__size
,

740 
size_t
 
__n
, 
FILE
 *
__»¡riù
 
__¡»am
);

744 
__BEGIN_NAMESPACE_STD


749 
	`f£ek
 (
FILE
 *
__¡»am
, 
__off
, 
__wh’û
);

754 
	$á–l
 (
FILE
 *
__¡»am
è
__wur
;

759 
	`»wšd
 (
FILE
 *
__¡»am
);

760 
__END_NAMESPACE_STD


767 #ià
defšed
 
__USE_LARGEFILE
 || defšed 
__USE_XOPEN2K


768 #iâdeà
__USE_FILE_OFFSET64


773 
	`f£eko
 (
FILE
 *
__¡»am
, 
__off_t
 
__off
, 
__wh’û
);

778 
__off_t
 
	$á–lo
 (
FILE
 *
__¡»am
è
__wur
;

780 #ifdeà
__REDIRECT


781 
	`__REDIRECT
 (
f£eko
,

782 (
FILE
 *
__¡»am
, 
__off64_t
 
__off
, 
__wh’û
),

783 
f£eko64
);

784 
__off64_t
 
	`__REDIRECT
 (
á–lo
, (
FILE
 *
__¡»am
), 
á–lo64
);

786 
	#f£eko
 
f£eko64


	)

787 
	#á–lo
 
á–lo64


	)

792 
__BEGIN_NAMESPACE_STD


793 #iâdeà
__USE_FILE_OFFSET64


798 
	`fg‘pos
 (
FILE
 *
__»¡riù
 
__¡»am
, 
åos_t
 *__»¡riù 
__pos
);

803 
	`f£os
 (
FILE
 *
__¡»am
, cÚ¡ 
åos_t
 *
__pos
);

805 #ifdeà
__REDIRECT


806 
	`__REDIRECT
 (
fg‘pos
, (
FILE
 *
__»¡riù
 
__¡»am
,

807 
åos_t
 *
__»¡riù
 
__pos
), 
fg‘pos64
);

808 
	`__REDIRECT
 (
f£os
,

809 (
FILE
 *
__¡»am
, cÚ¡ 
åos_t
 *
__pos
), 
f£os64
);

811 
	#fg‘pos
 
fg‘pos64


	)

812 
	#f£os
 
f£os64


	)

815 
__END_NAMESPACE_STD


817 #ifdeà
__USE_LARGEFILE64


818 
	`f£eko64
 (
FILE
 *
__¡»am
, 
__off64_t
 
__off
, 
__wh’û
);

819 
__off64_t
 
	$á–lo64
 (
FILE
 *
__¡»am
è
__wur
;

820 
	`fg‘pos64
 (
FILE
 *
__»¡riù
 
__¡»am
, 
åos64_t
 *__»¡riù 
__pos
);

821 
	`f£os64
 (
FILE
 *
__¡»am
, cÚ¡ 
åos64_t
 *
__pos
);

824 
__BEGIN_NAMESPACE_STD


826 
	$þ—»¼
 (
FILE
 *
__¡»am
è
__THROW
;

828 
	$ãof
 (
FILE
 *
__¡»am
è
__THROW
 
__wur
;

830 
	$ã¼Ü
 (
FILE
 *
__¡»am
è
__THROW
 
__wur
;

831 
__END_NAMESPACE_STD


833 #ifdeà
__USE_MISC


835 
	$þ—»¼_uÆocked
 (
FILE
 *
__¡»am
è
__THROW
;

836 
	$ãof_uÆocked
 (
FILE
 *
__¡»am
è
__THROW
 
__wur
;

837 
	$ã¼Ü_uÆocked
 (
FILE
 *
__¡»am
è
__THROW
 
__wur
;

841 
__BEGIN_NAMESPACE_STD


846 
	`³¼Ü
 (cÚ¡ *
__s
);

847 
__END_NAMESPACE_STD


853 
	~<b™s/sys_”¾i¡.h
>

856 #ifdef 
__USE_POSIX


858 
	$fž’o
 (
FILE
 *
__¡»am
è
__THROW
 
__wur
;

861 #ifdeà
__USE_MISC


863 
	$fž’o_uÆocked
 (
FILE
 *
__¡»am
è
__THROW
 
__wur
;

867 #ifdeà
__USE_POSIX2


872 
FILE
 *
	$pÝ’
 (cÚ¡ *
__commªd
, cÚ¡ *
__modes
è
__wur
;

878 
	`pþo£
 (
FILE
 *
__¡»am
);

882 #ifdef 
__USE_POSIX


884 *
	$ù”mid
 (*
__s
è
__THROW
;

888 #ifdeà
__USE_XOPEN


890 *
	`cu£rid
 (*
__s
);

894 #ifdef 
__USE_GNU


895 
ob¡ack
;

898 
	$ob¡ack_´štf
 (
ob¡ack
 *
__»¡riù
 
__ob¡ack
,

899 cÚ¡ *
__»¡riù
 
__fÜm©
, ...)

900 
__THROWNL
 
	`__©Œibu‹__
 ((
	`__fÜm©__
 (
__´štf__
, 2, 3)));

901 
	$ob¡ack_v´štf
 (
ob¡ack
 *
__»¡riù
 
__ob¡ack
,

902 cÚ¡ *
__»¡riù
 
__fÜm©
,

903 
_G_va_li¡
 
__¬gs
)

904 
__THROWNL
 
	`__©Œibu‹__
 ((
	`__fÜm©__
 (
__´štf__
, 2, 0)));

908 #ifdeà
__USE_POSIX


912 
	$æockfže
 (
FILE
 *
__¡»am
è
__THROW
;

916 
	$árylockfže
 (
FILE
 *
__¡»am
è
__THROW
 
__wur
;

919 
	$fuÆockfže
 (
FILE
 *
__¡»am
è
__THROW
;

922 #ià
defšed
 
__USE_XOPEN
 && !defšed 
__USE_XOPEN2K
 && !defšed 
__USE_GNU


926 
	#__Ãed_g‘Ýt


	)

927 
	~<g‘Ýt.h
>

932 #ifdeà
__USE_EXTERN_INLINES


933 
	~<b™s/¡dio.h
>

935 #ià
__USE_FORTIFY_LEVEL
 > 0 && 
defšed
 
__fÜtify_funùiÚ


936 
	~<b™s/¡dio2.h
>

938 #ifdeà
__LDBL_COMPAT


939 
	~<b™s/¡dio-ldbl.h
>

942 
__END_DECLS


	@/usr/include/stdlib.h

22 #iâdef 
_STDLIB_H


24 
	~<ã©u»s.h
>

27 
	#__Ãed_size_t


	)

28 #iâdeà
__Ãed_m®loc_ªd_ÿÎoc


29 
	#__Ãed_wch¬_t


	)

30 
	#__Ãed_NULL


	)

32 
	~<¡ddef.h
>

34 
	g__BEGIN_DECLS


36 #iâdeà
__Ãed_m®loc_ªd_ÿÎoc


37 
	#_STDLIB_H
 1

	)

39 #ià(
defšed
 
__USE_XOPEN
 || defšed 
__USE_XOPEN2K8
è&& !defšed 
_SYS_WAIT_H


41 
	~<b™s/wa™æags.h
>

42 
	~<b™s/wa™¡©us.h
>

44 #ifdeà
__USE_MISC


49 #ià
defšed
 
__GNUC__
 && !defšed 
__ýlu¥lus


50 
	#__WAIT_INT
(
¡©us
) \

51 (
	`__ex‹nsiÚ__
 (((uniÚ { 
	`__ty³of
(
¡©us
è
__š
; 
__i
; }) \

52 { .
__š
 = (
¡©us
è}).
__i
))

	)

54 
	#__WAIT_INT
(
¡©us
è(*(*è&(¡©us))

	)

62 #ià!
defšed
 
__GNUC__
 || __GNUC__ < 2 || defšed 
__ýlu¥lus


63 
	#__WAIT_STATUS
 *

	)

64 
	#__WAIT_STATUS_DEFN
 *

	)

69 
wa™
 *
	m__u±r
;

70 *
	m__Œ
;

71 } 
	t__WAIT_STATUS
 
	t__©Œibu‹__
 ((
	t__Œª¥¬’t_uniÚ__
));

72 
	#__WAIT_STATUS_DEFN
 *

	)

77 
	#__WAIT_INT
(
¡©us
è(¡©us)

	)

78 
	#__WAIT_STATUS
 *

	)

79 
	#__WAIT_STATUS_DEFN
 *

	)

84 
	#WEXITSTATUS
(
¡©us
è
	`__WEXITSTATUS
 (
	`__WAIT_INT
 (¡©us))

	)

85 
	#WTERMSIG
(
¡©us
è
	`__WTERMSIG
 (
	`__WAIT_INT
 (¡©us))

	)

86 
	#WSTOPSIG
(
¡©us
è
	`__WSTOPSIG
 (
	`__WAIT_INT
 (¡©us))

	)

87 
	#WIFEXITED
(
¡©us
è
	`__WIFEXITED
 (
	`__WAIT_INT
 (¡©us))

	)

88 
	#WIFSIGNALED
(
¡©us
è
	`__WIFSIGNALED
 (
	`__WAIT_INT
 (¡©us))

	)

89 
	#WIFSTOPPED
(
¡©us
è
	`__WIFSTOPPED
 (
	`__WAIT_INT
 (¡©us))

	)

90 #ifdeà
__WIFCONTINUED


91 
	#WIFCONTINUED
(
¡©us
è
	`__WIFCONTINUED
 (
	`__WAIT_INT
 (¡©us))

	)

95 
__BEGIN_NAMESPACE_STD


99 
	mquÙ
;

100 
	m»m
;

101 } 
	tdiv_t
;

104 #iâdeà
__ldiv_t_defšed


107 
	mquÙ
;

108 
	m»m
;

109 } 
	tldiv_t
;

110 
	#__ldiv_t_defšed
 1

	)

112 
	g__END_NAMESPACE_STD


114 #ià
defšed
 
__USE_ISOC99
 && !defšed 
__Îdiv_t_defšed


115 
__BEGIN_NAMESPACE_C99


117 
__ex‹nsiÚ__
 struct

119 
	mquÙ
;

120 
	m»m
;

121 } 
	tÎdiv_t
;

122 
	#__Îdiv_t_defšed
 1

	)

123 
	g__END_NAMESPACE_C99


128 
	#RAND_MAX
 2147483647

	)

133 
	#EXIT_FAILURE
 1

	)

134 
	#EXIT_SUCCESS
 0

	)

138 
	#MB_CUR_MAX
 (
	`__ùy³_g‘_mb_cur_max
 ())

	)

139 
size_t
 
	$__ùy³_g‘_mb_cur_max
 (è
__THROW
 
__wur
;

142 
__BEGIN_NAMESPACE_STD


144 
	$©of
 (cÚ¡ *
__ÅŒ
)

145 
__THROW
 
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1)è
__wur
;

147 
	$©oi
 (cÚ¡ *
__ÅŒ
)

148 
__THROW
 
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1)è
__wur
;

150 
	$©Þ
 (cÚ¡ *
__ÅŒ
)

151 
__THROW
 
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1)è
__wur
;

152 
__END_NAMESPACE_STD


154 #ifdeà
__USE_ISOC99


155 
__BEGIN_NAMESPACE_C99


157 
__ex‹nsiÚ__
 
	$©Þl
 (cÚ¡ *
__ÅŒ
)

158 
__THROW
 
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1)è
__wur
;

159 
__END_NAMESPACE_C99


162 
__BEGIN_NAMESPACE_STD


164 
	$¡¹od
 (cÚ¡ *
__»¡riù
 
__ÅŒ
,

165 **
__»¡riù
 
__’d±r
)

166 
__THROW
 
	`__nÚnuÎ
 ((1));

167 
__END_NAMESPACE_STD


169 #ifdef 
__USE_ISOC99


170 
__BEGIN_NAMESPACE_C99


172 
	$¡¹of
 (cÚ¡ *
__»¡riù
 
__ÅŒ
,

173 **
__»¡riù
 
__’d±r
è
__THROW
 
	`__nÚnuÎ
 ((1));

175 
	$¡¹Þd
 (cÚ¡ *
__»¡riù
 
__ÅŒ
,

176 **
__»¡riù
 
__’d±r
)

177 
__THROW
 
	`__nÚnuÎ
 ((1));

178 
__END_NAMESPACE_C99


181 
__BEGIN_NAMESPACE_STD


183 
	$¡¹Þ
 (cÚ¡ *
__»¡riù
 
__ÅŒ
,

184 **
__»¡riù
 
__’d±r
, 
__ba£
)

185 
__THROW
 
	`__nÚnuÎ
 ((1));

187 
	$¡¹oul
 (cÚ¡ *
__»¡riù
 
__ÅŒ
,

188 **
__»¡riù
 
__’d±r
, 
__ba£
)

189 
__THROW
 
	`__nÚnuÎ
 ((1));

190 
__END_NAMESPACE_STD


192 #ifdeà
__USE_MISC


194 
__ex‹nsiÚ__


195 
	$¡¹oq
 (cÚ¡ *
__»¡riù
 
__ÅŒ
,

196 **
__»¡riù
 
__’d±r
, 
__ba£
)

197 
__THROW
 
	`__nÚnuÎ
 ((1));

199 
__ex‹nsiÚ__


200 
	$¡¹ouq
 (cÚ¡ *
__»¡riù
 
__ÅŒ
,

201 **
__»¡riù
 
__’d±r
, 
__ba£
)

202 
__THROW
 
	`__nÚnuÎ
 ((1));

205 #ifdeà
__USE_ISOC99


206 
__BEGIN_NAMESPACE_C99


208 
__ex‹nsiÚ__


209 
	$¡¹Þl
 (cÚ¡ *
__»¡riù
 
__ÅŒ
,

210 **
__»¡riù
 
__’d±r
, 
__ba£
)

211 
__THROW
 
	`__nÚnuÎ
 ((1));

213 
__ex‹nsiÚ__


214 
	$¡¹ouÎ
 (cÚ¡ *
__»¡riù
 
__ÅŒ
,

215 **
__»¡riù
 
__’d±r
, 
__ba£
)

216 
__THROW
 
	`__nÚnuÎ
 ((1));

217 
__END_NAMESPACE_C99


221 #ifdeà
__USE_GNU


235 
	~<xloÿË.h
>

239 
	$¡¹Þ_l
 (cÚ¡ *
__»¡riù
 
__ÅŒ
,

240 **
__»¡riù
 
__’d±r
, 
__ba£
,

241 
__loÿË_t
 
__loc
è
__THROW
 
	`__nÚnuÎ
 ((1, 4));

243 
	$¡¹oul_l
 (cÚ¡ *
__»¡riù
 
__ÅŒ
,

244 **
__»¡riù
 
__’d±r
,

245 
__ba£
, 
__loÿË_t
 
__loc
)

246 
__THROW
 
	`__nÚnuÎ
 ((1, 4));

248 
__ex‹nsiÚ__


249 
	$¡¹Þl_l
 (cÚ¡ *
__»¡riù
 
__ÅŒ
,

250 **
__»¡riù
 
__’d±r
, 
__ba£
,

251 
__loÿË_t
 
__loc
)

252 
__THROW
 
	`__nÚnuÎ
 ((1, 4));

254 
__ex‹nsiÚ__


255 
	$¡¹ouÎ_l
 (cÚ¡ *
__»¡riù
 
__ÅŒ
,

256 **
__»¡riù
 
__’d±r
,

257 
__ba£
, 
__loÿË_t
 
__loc
)

258 
__THROW
 
	`__nÚnuÎ
 ((1, 4));

260 
	$¡¹od_l
 (cÚ¡ *
__»¡riù
 
__ÅŒ
,

261 **
__»¡riù
 
__’d±r
, 
__loÿË_t
 
__loc
)

262 
__THROW
 
	`__nÚnuÎ
 ((1, 3));

264 
	$¡¹of_l
 (cÚ¡ *
__»¡riù
 
__ÅŒ
,

265 **
__»¡riù
 
__’d±r
, 
__loÿË_t
 
__loc
)

266 
__THROW
 
	`__nÚnuÎ
 ((1, 3));

268 
	$¡¹Þd_l
 (cÚ¡ *
__»¡riù
 
__ÅŒ
,

269 **
__»¡riù
 
__’d±r
,

270 
__loÿË_t
 
__loc
)

271 
__THROW
 
	`__nÚnuÎ
 ((1, 3));

275 #ifdeà
__USE_EXTERN_INLINES


276 
__BEGIN_NAMESPACE_STD


277 
__ex‹º_šlše
 

278 
	`__NTH
 (
	$©oi
 (cÚ¡ *
__ÅŒ
))

280  (è
	`¡¹Þ
 (
__ÅŒ
, (**è
NULL
, 10);

281 
	}
}

282 
__ex‹º_šlše
 

283 
__NTH
 (
	$©Þ
 (cÚ¡ *
__ÅŒ
))

285  
	`¡¹Þ
 (
__ÅŒ
, (**è
NULL
, 10);

286 
	}
}

287 
	g__END_NAMESPACE_STD


289 #ifdeà
__USE_ISOC99


290 
__BEGIN_NAMESPACE_C99


291 
__ex‹nsiÚ__
 
__ex‹º_šlše
 

292 
__NTH
 (
	$©Þl
 (cÚ¡ *
__ÅŒ
))

294  
	`¡¹Þl
 (
__ÅŒ
, (**è
NULL
, 10);

295 
	}
}

296 
	g__END_NAMESPACE_C99


301 #ià
defšed
 
__USE_MISC
 || defšed 
__USE_XOPEN_EXTENDED


305 *
	$l64a
 (
__n
è
__THROW
 
__wur
;

308 
	$a64l
 (cÚ¡ *
__s
)

309 
__THROW
 
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1)è
__wur
;

313 #ià
defšed
 
__USE_MISC
 || defšed 
__USE_XOPEN_EXTENDED


314 
	~<sys/ty³s.h
>

321 
	$¿ndom
 (è
__THROW
;

324 
	$¤ªdom
 (
__£ed
è
__THROW
;

330 *
	$š™¡©e
 (
__£ed
, *
__¡©ebuf
,

331 
size_t
 
__¡©–’
è
__THROW
 
	`__nÚnuÎ
 ((2));

335 *
	$£t¡©e
 (*
__¡©ebuf
è
__THROW
 
	`__nÚnuÎ
 ((1));

338 #ifdeà
__USE_MISC


343 
	s¿ndom_d©a


345 
št32_t
 *
åŒ
;

346 
št32_t
 *
½Œ
;

347 
št32_t
 *
¡©e
;

348 
¿nd_ty³
;

349 
¿nd_deg
;

350 
¿nd_£p
;

351 
št32_t
 *
’d_±r
;

354 
	$¿ndom_r
 (
¿ndom_d©a
 *
__»¡riù
 
__buf
,

355 
št32_t
 *
__»¡riù
 
__»suÉ
è
__THROW
 
	`__nÚnuÎ
 ((1, 2));

357 
	$¤ªdom_r
 (
__£ed
, 
¿ndom_d©a
 *
__buf
)

358 
__THROW
 
	`__nÚnuÎ
 ((2));

360 
	$š™¡©e_r
 (
__£ed
, *
__»¡riù
 
__¡©ebuf
,

361 
size_t
 
__¡©–’
,

362 
¿ndom_d©a
 *
__»¡riù
 
__buf
)

363 
__THROW
 
	`__nÚnuÎ
 ((2, 4));

365 
	$£t¡©e_r
 (*
__»¡riù
 
__¡©ebuf
,

366 
¿ndom_d©a
 *
__»¡riù
 
__buf
)

367 
__THROW
 
	`__nÚnuÎ
 ((1, 2));

372 
__BEGIN_NAMESPACE_STD


374 
	$¿nd
 (è
__THROW
;

376 
	$¤ªd
 (
__£ed
è
__THROW
;

377 
__END_NAMESPACE_STD


379 #ifdeà
__USE_POSIX


381 
	$¿nd_r
 (*
__£ed
è
__THROW
;

385 #ià
defšed
 
__USE_MISC
 || defšed 
__USE_XOPEN


389 
	$d¿nd48
 (è
__THROW
;

390 
	$”ªd48
 (
__xsubi
[3]è
__THROW
 
	`__nÚnuÎ
 ((1));

393 
	$Ìªd48
 (è
__THROW
;

394 
	$Äªd48
 (
__xsubi
[3])

395 
__THROW
 
	`__nÚnuÎ
 ((1));

398 
	$m¿nd48
 (è
__THROW
;

399 
	$j¿nd48
 (
__xsubi
[3])

400 
__THROW
 
	`__nÚnuÎ
 ((1));

403 
	$¤ªd48
 (
__£edv®
è
__THROW
;

404 *
	$£ed48
 (
__£ed16v
[3])

405 
__THROW
 
	`__nÚnuÎ
 ((1));

406 
	$lcÚg48
 (
__·¿m
[7]è
__THROW
 
	`__nÚnuÎ
 ((1));

408 #ifdeà
__USE_MISC


412 
	sd¿nd48_d©a


414 
__x
[3];

415 
__Þd_x
[3];

416 
__c
;

417 
__š™
;

418 
__ex‹nsiÚ__
 
__a
;

423 
	$d¿nd48_r
 (
d¿nd48_d©a
 *
__»¡riù
 
__bufãr
,

424 *
__»¡riù
 
__»suÉ
è
__THROW
 
	`__nÚnuÎ
 ((1, 2));

425 
	$”ªd48_r
 (
__xsubi
[3],

426 
d¿nd48_d©a
 *
__»¡riù
 
__bufãr
,

427 *
__»¡riù
 
__»suÉ
è
__THROW
 
	`__nÚnuÎ
 ((1, 2));

430 
	$Ìªd48_r
 (
d¿nd48_d©a
 *
__»¡riù
 
__bufãr
,

431 *
__»¡riù
 
__»suÉ
)

432 
__THROW
 
	`__nÚnuÎ
 ((1, 2));

433 
	$Äªd48_r
 (
__xsubi
[3],

434 
d¿nd48_d©a
 *
__»¡riù
 
__bufãr
,

435 *
__»¡riù
 
__»suÉ
)

436 
__THROW
 
	`__nÚnuÎ
 ((1, 2));

439 
	$m¿nd48_r
 (
d¿nd48_d©a
 *
__»¡riù
 
__bufãr
,

440 *
__»¡riù
 
__»suÉ
)

441 
__THROW
 
	`__nÚnuÎ
 ((1, 2));

442 
	$j¿nd48_r
 (
__xsubi
[3],

443 
d¿nd48_d©a
 *
__»¡riù
 
__bufãr
,

444 *
__»¡riù
 
__»suÉ
)

445 
__THROW
 
	`__nÚnuÎ
 ((1, 2));

448 
	$¤ªd48_r
 (
__£edv®
, 
d¿nd48_d©a
 *
__bufãr
)

449 
__THROW
 
	`__nÚnuÎ
 ((2));

451 
	$£ed48_r
 (
__£ed16v
[3],

452 
d¿nd48_d©a
 *
__bufãr
è
__THROW
 
	`__nÚnuÎ
 ((1, 2));

454 
	$lcÚg48_r
 (
__·¿m
[7],

455 
d¿nd48_d©a
 *
__bufãr
)

456 
__THROW
 
	`__nÚnuÎ
 ((1, 2));

462 #iâdeà
__m®loc_ªd_ÿÎoc_defšed


463 
	#__m®loc_ªd_ÿÎoc_defšed


	)

464 
__BEGIN_NAMESPACE_STD


466 *
	$m®loc
 (
size_t
 
__size
è
__THROW
 
__©Œibu‹_m®loc__
 
__wur
;

468 *
	$ÿÎoc
 (
size_t
 
__nmemb
, size_ˆ
__size
)

469 
__THROW
 
__©Œibu‹_m®loc__
 
__wur
;

470 
__END_NAMESPACE_STD


473 #iâdeà
__Ãed_m®loc_ªd_ÿÎoc


474 
__BEGIN_NAMESPACE_STD


480 *
	$»®loc
 (*
__±r
, 
size_t
 
__size
)

481 
__THROW
 
__©Œibu‹_w¬n_unu£d_»suÉ__
;

483 
	$ä“
 (*
__±r
è
__THROW
;

484 
__END_NAMESPACE_STD


486 #ifdef 
__USE_MISC


488 
	$cä“
 (*
__±r
è
__THROW
;

491 #ifdeà
__USE_MISC


492 
	~<®loÿ.h
>

495 #ià(
defšed
 
__USE_XOPEN_EXTENDED
 && !defšed 
__USE_XOPEN2K
) \

496 || 
defšed
 
__USE_MISC


498 *
	$v®loc
 (
size_t
 
__size
è
__THROW
 
__©Œibu‹_m®loc__
 
__wur
;

501 #ifdeà
__USE_XOPEN2K


503 
	$posix_mem®ign
 (**
__mem±r
, 
size_t
 
__®ignm’t
, size_ˆ
__size
)

504 
__THROW
 
	`__nÚnuÎ
 ((1)è
__wur
;

507 #ifdeà
__USE_ISOC11


509 *
	$®igÃd_®loc
 (
size_t
 
__®ignm’t
, size_ˆ
__size
)

510 
__THROW
 
__©Œibu‹_m®loc__
 
	`__©Œibu‹_®loc_size__
 ((2)è
__wur
;

513 
__BEGIN_NAMESPACE_STD


515 
	$abÜt
 (è
__THROW
 
	`__©Œibu‹__
 ((
__nÜ‘uº__
));

519 
	$©ex™
 ((*
__func
è()è
__THROW
 
	`__nÚnuÎ
 ((1));

521 #ià
defšed
 
__USE_ISOC11
 || defšed 
__USE_ISOCXX11


523 #ifdeà
__ýlu¥lus


524 "C++" 
	$©_quick_ex™
 ((*
__func
) ())

525 
__THROW
 
	`__asm
 ("©_quick_ex™"è
	`__nÚnuÎ
 ((1));

527 
	$©_quick_ex™
 ((*
__func
è()è
__THROW
 
	`__nÚnuÎ
 ((1));

530 
__END_NAMESPACE_STD


532 #ifdef 
__USE_MISC


535 
	$Ú_ex™
 ((*
__func
è(
__¡©us
, *
__¬g
), *__arg)

536 
__THROW
 
	`__nÚnuÎ
 ((1));

539 
__BEGIN_NAMESPACE_STD


543 
	$ex™
 (
__¡©us
è
__THROW
 
	`__©Œibu‹__
 ((
__nÜ‘uº__
));

545 #ià
defšed
 
__USE_ISOC11
 || defšed 
__USE_ISOCXX11


549 
	$quick_ex™
 (
__¡©us
è
__THROW
 
	`__©Œibu‹__
 ((
__nÜ‘uº__
));

551 
__END_NAMESPACE_STD


553 #ifdeà
__USE_ISOC99


554 
__BEGIN_NAMESPACE_C99


557 
	$_Ex™
 (
__¡©us
è
__THROW
 
	`__©Œibu‹__
 ((
__nÜ‘uº__
));

558 
__END_NAMESPACE_C99


562 
__BEGIN_NAMESPACE_STD


564 *
	$g‘’v
 (cÚ¡ *
__Çme
è
__THROW
 
	`__nÚnuÎ
 ((1)è
__wur
;

565 
__END_NAMESPACE_STD


567 #ifdeà
__USE_GNU


570 *
	$£cu»_g‘’v
 (cÚ¡ *
__Çme
)

571 
__THROW
 
	`__nÚnuÎ
 ((1)è
__wur
;

574 #ià
defšed
 
__USE_MISC
 || defšed 
__USE_XOPEN


578 
	$pu‹nv
 (*
__¡ršg
è
__THROW
 
	`__nÚnuÎ
 ((1));

581 #ifdeà
__USE_XOPEN2K


584 
	$£‹nv
 (cÚ¡ *
__Çme
, cÚ¡ *
__v®ue
, 
__»¶aû
)

585 
__THROW
 
	`__nÚnuÎ
 ((2));

588 
	$un£‹nv
 (cÚ¡ *
__Çme
è
__THROW
 
	`__nÚnuÎ
 ((1));

591 #ifdef 
__USE_MISC


595 
	$þ—»nv
 (è
__THROW
;

599 #ià
defšed
 
__USE_MISC
 \

600 || (
defšed
 
__USE_XOPEN_EXTENDED
 && !defšed 
__USE_XOPEN2K8
)

606 *
	$mk‹mp
 (*
__‹m¶©e
è
__THROW
 
	`__nÚnuÎ
 ((1));

609 #ià
defšed
 
__USE_XOPEN_EXTENDED
 || defšed 
__USE_XOPEN2K8


618 #iâdeà
__USE_FILE_OFFSET64


619 
	$mk¡emp
 (*
__‹m¶©e
è
	`__nÚnuÎ
 ((1)è
__wur
;

621 #ifdeà
__REDIRECT


622 
	`__REDIRECT
 (
mk¡emp
, (*
__‹m¶©e
), 
mk¡emp64
)

623 
	`__nÚnuÎ
 ((1)è
__wur
;

625 
	#mk¡emp
 
mk¡emp64


	)

628 #ifdeà
__USE_LARGEFILE64


629 
	$mk¡emp64
 (*
__‹m¶©e
è
	`__nÚnuÎ
 ((1)è
__wur
;

633 #ifdeà
__USE_MISC


640 #iâdeà
__USE_FILE_OFFSET64


641 
	$mk¡emps
 (*
__‹m¶©e
, 
__suffixËn
è
	`__nÚnuÎ
 ((1)è
__wur
;

643 #ifdeà
__REDIRECT


644 
	`__REDIRECT
 (
mk¡emps
, (*
__‹m¶©e
, 
__suffixËn
),

645 
mk¡emps64
è
	`__nÚnuÎ
 ((1)è
__wur
;

647 
	#mk¡emps
 
mk¡emps64


	)

650 #ifdeà
__USE_LARGEFILE64


651 
	$mk¡emps64
 (*
__‹m¶©e
, 
__suffixËn
)

652 
	`__nÚnuÎ
 ((1)è
__wur
;

656 #ifdeà
__USE_XOPEN2K8


662 *
	$mkd‹mp
 (*
__‹m¶©e
è
__THROW
 
	`__nÚnuÎ
 ((1)è
__wur
;

665 #ifdeà
__USE_GNU


672 #iâdeà
__USE_FILE_OFFSET64


673 
	$mko¡emp
 (*
__‹m¶©e
, 
__æags
è
	`__nÚnuÎ
 ((1)è
__wur
;

675 #ifdeà
__REDIRECT


676 
	`__REDIRECT
 (
mko¡emp
, (*
__‹m¶©e
, 
__æags
), 
mko¡emp64
)

677 
	`__nÚnuÎ
 ((1)è
__wur
;

679 
	#mko¡emp
 
mko¡emp64


	)

682 #ifdeà
__USE_LARGEFILE64


683 
	$mko¡emp64
 (*
__‹m¶©e
, 
__æags
è
	`__nÚnuÎ
 ((1)è
__wur
;

692 #iâdeà
__USE_FILE_OFFSET64


693 
	$mko¡emps
 (*
__‹m¶©e
, 
__suffixËn
, 
__æags
)

694 
	`__nÚnuÎ
 ((1)è
__wur
;

696 #ifdeà
__REDIRECT


697 
	`__REDIRECT
 (
mko¡emps
, (*
__‹m¶©e
, 
__suffixËn
,

698 
__æags
), 
mko¡emps64
)

699 
	`__nÚnuÎ
 ((1)è
__wur
;

701 
	#mko¡emps
 
mko¡emps64


	)

704 #ifdeà
__USE_LARGEFILE64


705 
	$mko¡emps64
 (*
__‹m¶©e
, 
__suffixËn
, 
__æags
)

706 
	`__nÚnuÎ
 ((1)è
__wur
;

711 
__BEGIN_NAMESPACE_STD


716 
	$sy¡em
 (cÚ¡ *
__commªd
è
__wur
;

717 
__END_NAMESPACE_STD


720 #ifdef 
__USE_GNU


723 *
	$ÿnÚiÿlize_fže_Çme
 (cÚ¡ *
__Çme
)

724 
__THROW
 
	`__nÚnuÎ
 ((1)è
__wur
;

727 #ià
defšed
 
__USE_MISC
 || defšed 
__USE_XOPEN_EXTENDED


733 *
	$»®·th
 (cÚ¡ *
__»¡riù
 
__Çme
,

734 *
__»¡riù
 
__»sÞved
è
__THROW
 
__wur
;

739 #iâdeà
__COMPAR_FN_T


740 
	#__COMPAR_FN_T


	)

741 (*
	t__com·r_â_t
) (const *, const *);

743 #ifdef 
__USE_GNU


744 
__com·r_â_t
 
	tcom·risÚ_â_t
;

747 #ifdeà
__USE_GNU


748 (*
	t__com·r_d_â_t
) (const *, const *, *);

751 
__BEGIN_NAMESPACE_STD


754 *
	$b£¬ch
 (cÚ¡ *
__key
, cÚ¡ *
__ba£
,

755 
size_t
 
__nmemb
, size_ˆ
__size
, 
__com·r_â_t
 
__com·r
)

756 
	`__nÚnuÎ
 ((1, 2, 5)è
__wur
;

758 #ifdeà
__USE_EXTERN_INLINES


759 
	~<b™s/¡dlib-b£¬ch.h
>

764 
	$qsÜt
 (*
__ba£
, 
size_t
 
__nmemb
, size_ˆ
__size
,

765 
__com·r_â_t
 
__com·r
è
	`__nÚnuÎ
 ((1, 4));

766 #ifdeà
__USE_GNU


767 
	$qsÜt_r
 (*
__ba£
, 
size_t
 
__nmemb
, size_ˆ
__size
,

768 
__com·r_d_â_t
 
__com·r
, *
__¬g
)

769 
	`__nÚnuÎ
 ((1, 4));

774 
	$abs
 (
__x
è
__THROW
 
	`__©Œibu‹__
 ((
__cÚ¡__
)è
__wur
;

775 
	$Ïbs
 (
__x
è
__THROW
 
	`__©Œibu‹__
 ((
__cÚ¡__
)è
__wur
;

776 
__END_NAMESPACE_STD


778 #ifdeà
__USE_ISOC99


779 
__ex‹nsiÚ__
 
	$Îabs
 (
__x
)

780 
__THROW
 
	`__©Œibu‹__
 ((
__cÚ¡__
)è
__wur
;

784 
__BEGIN_NAMESPACE_STD


788 
div_t
 
	$div
 (
__num”
, 
__d’om
)

789 
__THROW
 
	`__©Œibu‹__
 ((
__cÚ¡__
)è
__wur
;

790 
ldiv_t
 
	$ldiv
 (
__num”
, 
__d’om
)

791 
__THROW
 
	`__©Œibu‹__
 ((
__cÚ¡__
)è
__wur
;

792 
__END_NAMESPACE_STD


794 #ifdeà
__USE_ISOC99


795 
__BEGIN_NAMESPACE_C99


796 
__ex‹nsiÚ__
 
Îdiv_t
 
	$Îdiv
 (
__num”
,

797 
__d’om
)

798 
__THROW
 
	`__©Œibu‹__
 ((
__cÚ¡__
)è
__wur
;

799 
__END_NAMESPACE_C99


803 #ià(
defšed
 
__USE_XOPEN_EXTENDED
 && !defšed 
__USE_XOPEN2K8
) \

804 || 
defšed
 
__USE_MISC


811 *
	$ecvt
 (
__v®ue
, 
__ndig™
, *
__»¡riù
 
__deýt
,

812 *
__»¡riù
 
__sign
è
__THROW
 
	`__nÚnuÎ
 ((3, 4)è
__wur
;

817 *
	$fcvt
 (
__v®ue
, 
__ndig™
, *
__»¡riù
 
__deýt
,

818 *
__»¡riù
 
__sign
è
__THROW
 
	`__nÚnuÎ
 ((3, 4)è
__wur
;

823 *
	$gcvt
 (
__v®ue
, 
__ndig™
, *
__buf
)

824 
__THROW
 
	`__nÚnuÎ
 ((3)è
__wur
;

827 #ifdeà
__USE_MISC


829 *
	$qecvt
 (
__v®ue
, 
__ndig™
,

830 *
__»¡riù
 
__deýt
, *__»¡riù 
__sign
)

831 
__THROW
 
	`__nÚnuÎ
 ((3, 4)è
__wur
;

832 *
	$qfcvt
 (
__v®ue
, 
__ndig™
,

833 *
__»¡riù
 
__deýt
, *__»¡riù 
__sign
)

834 
__THROW
 
	`__nÚnuÎ
 ((3, 4)è
__wur
;

835 *
	$qgcvt
 (
__v®ue
, 
__ndig™
, *
__buf
)

836 
__THROW
 
	`__nÚnuÎ
 ((3)è
__wur
;

841 
	$ecvt_r
 (
__v®ue
, 
__ndig™
, *
__»¡riù
 
__deýt
,

842 *
__»¡riù
 
__sign
, *__»¡riù 
__buf
,

843 
size_t
 
__Ën
è
__THROW
 
	`__nÚnuÎ
 ((3, 4, 5));

844 
	$fcvt_r
 (
__v®ue
, 
__ndig™
, *
__»¡riù
 
__deýt
,

845 *
__»¡riù
 
__sign
, *__»¡riù 
__buf
,

846 
size_t
 
__Ën
è
__THROW
 
	`__nÚnuÎ
 ((3, 4, 5));

848 
	$qecvt_r
 (
__v®ue
, 
__ndig™
,

849 *
__»¡riù
 
__deýt
, *__»¡riù 
__sign
,

850 *
__»¡riù
 
__buf
, 
size_t
 
__Ën
)

851 
__THROW
 
	`__nÚnuÎ
 ((3, 4, 5));

852 
	$qfcvt_r
 (
__v®ue
, 
__ndig™
,

853 *
__»¡riù
 
__deýt
, *__»¡riù 
__sign
,

854 *
__»¡riù
 
__buf
, 
size_t
 
__Ën
)

855 
__THROW
 
	`__nÚnuÎ
 ((3, 4, 5));

859 
__BEGIN_NAMESPACE_STD


862 
	$mbËn
 (cÚ¡ *
__s
, 
size_t
 
__n
è
__THROW
;

865 
	$mbtowc
 (
wch¬_t
 *
__»¡riù
 
__pwc
,

866 cÚ¡ *
__»¡riù
 
__s
, 
size_t
 
__n
è
__THROW
;

869 
	$wùomb
 (*
__s
, 
wch¬_t
 
__wch¬
è
__THROW
;

873 
size_t
 
	$mb¡owcs
 (
wch¬_t
 *
__»¡riù
 
__pwcs
,

874 cÚ¡ *
__»¡riù
 
__s
, 
size_t
 
__n
è
__THROW
;

876 
size_t
 
	$wc¡ombs
 (*
__»¡riù
 
__s
,

877 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__pwcs
, 
size_t
 
__n
)

878 
__THROW
;

879 
__END_NAMESPACE_STD


882 #ifdeà
__USE_MISC


887 
	$½m©ch
 (cÚ¡ *
__»¥Ú£
è
__THROW
 
	`__nÚnuÎ
 ((1)è
__wur
;

891 #ià
defšed
 
__USE_XOPEN_EXTENDED
 || defšed 
__USE_XOPEN2K8


898 
	$g‘subÝt
 (**
__»¡riù
 
__ÝtiÚp
,

899 *cÚ¡ *
__»¡riù
 
__tok’s
,

900 **
__»¡riù
 
__v®u•
)

901 
__THROW
 
	`__nÚnuÎ
 ((1, 2, 3)è
__wur
;

905 #ifdeà
__USE_XOPEN


907 
	$£tkey
 (cÚ¡ *
__key
è
__THROW
 
	`__nÚnuÎ
 ((1));

913 #ifdeà
__USE_XOPEN2KXSI


915 
	$posix_Ý’±
 (
__oæag
è
__wur
;

918 #ifdeà
__USE_XOPEN


923 
	$g¿Á±
 (
__fd
è
__THROW
;

927 
	$uÆock±
 (
__fd
è
__THROW
;

932 *
	$±¢ame
 (
__fd
è
__THROW
 
__wur
;

935 #ifdeà
__USE_GNU


939 
	$±¢ame_r
 (
__fd
, *
__buf
, 
size_t
 
__buæ’
)

940 
__THROW
 
	`__nÚnuÎ
 ((2));

943 
	`g‘±
 ();

946 #ifdeà
__USE_MISC


950 
	$g‘lßdavg
 (
__lßdavg
[], 
__ÃËm
)

951 
__THROW
 
	`__nÚnuÎ
 ((1));

954 
	~<b™s/¡dlib-æßt.h
>

957 #ià
__USE_FORTIFY_LEVEL
 > 0 && 
defšed
 
__fÜtify_funùiÚ


958 
	~<b™s/¡dlib.h
>

960 #ifdeà
__LDBL_COMPAT


961 
	~<b™s/¡dlib-ldbl.h
>

965 #undeà
__Ãed_m®loc_ªd_ÿÎoc


967 
__END_DECLS


	@/usr/include/string.h

22 #iâdef 
_STRING_H


23 
	#_STRING_H
 1

	)

25 
	~<ã©u»s.h
>

27 
	g__BEGIN_DECLS


30 
	#__Ãed_size_t


	)

31 
	#__Ãed_NULL


	)

32 
	~<¡ddef.h
>

35 #ià
defšed
 
__ýlu¥lus
 && 
__GNUC_PREREQ
 (4, 4)

36 
	#__CORRECT_ISO_CPP_STRING_H_PROTO


	)

40 
__BEGIN_NAMESPACE_STD


42 *
	$memýy
 (*
__»¡riù
 
__de¡
, cÚ¡ *__»¡riù 
__¤c
,

43 
size_t
 
__n
è
__THROW
 
	`__nÚnuÎ
 ((1, 2));

46 *
	$memmove
 (*
__de¡
, cÚ¡ *
__¤c
, 
size_t
 
__n
)

47 
__THROW
 
	`__nÚnuÎ
 ((1, 2));

48 
__END_NAMESPACE_STD


53 #ià
defšed
 
__USE_MISC
 || defšed 
__USE_XOPEN


54 *
	$memcýy
 (*
__»¡riù
 
__de¡
, cÚ¡ *__»¡riù 
__¤c
,

55 
__c
, 
size_t
 
__n
)

56 
__THROW
 
	`__nÚnuÎ
 ((1, 2));

60 
__BEGIN_NAMESPACE_STD


62 *
	$mem£t
 (*
__s
, 
__c
, 
size_t
 
__n
è
__THROW
 
	`__nÚnuÎ
 ((1));

65 
	$memcmp
 (cÚ¡ *
__s1
, cÚ¡ *
__s2
, 
size_t
 
__n
)

66 
__THROW
 
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1, 2));

69 #ifdeà
__CORRECT_ISO_CPP_STRING_H_PROTO


72 *
	`memchr
 (*
__s
, 
__c
, 
size_t
 
__n
)

73 
__THROW
 
	`__asm
 ("memchr"è
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1));

74 cÚ¡ *
	`memchr
 (cÚ¡ *
__s
, 
__c
, 
size_t
 
__n
)

75 
__THROW
 
	`__asm
 ("memchr"è
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1));

77 #ifdeà
__OPTIMIZE__


78 
__ex‹º_®ways_šlše
 *

79 
	`memchr
 (*
__s
, 
__c
, 
size_t
 
__n
è
__THROW


81  
	`__bužtš_memchr
 (
__s
, 
__c
, 
__n
);

84 
__ex‹º_®ways_šlše
 const *

85 
	`memchr
 (cÚ¡ *
__s
, 
__c
, 
size_t
 
__n
è
__THROW


87  
	`__bužtš_memchr
 (
__s
, 
__c
, 
__n
);

90 
	}
}

92 *
	$memchr
 (cÚ¡ *
__s
, 
__c
, 
size_t
 
__n
)

93 
__THROW
 
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1));

95 
__END_NAMESPACE_STD


97 #ifdeà
__USE_GNU


100 #ifdeà
__CORRECT_ISO_CPP_STRING_H_PROTO


101 "C++" *
	$¿wmemchr
 (*
__s
, 
__c
)

102 
__THROW
 
	`__asm
 ("¿wmemchr"è
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1));

103 "C++" cÚ¡ *
	$¿wmemchr
 (cÚ¡ *
__s
, 
__c
)

104 
__THROW
 
	`__asm
 ("¿wmemchr"è
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1));

106 *
	$¿wmemchr
 (cÚ¡ *
__s
, 
__c
)

107 
__THROW
 
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1));

111 #ifdeà
__CORRECT_ISO_CPP_STRING_H_PROTO


112 "C++" *
	$memrchr
 (*
__s
, 
__c
, 
size_t
 
__n
)

113 
__THROW
 
	`__asm
 ("memrchr"è
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1));

114 "C++" cÚ¡ *
	$memrchr
 (cÚ¡ *
__s
, 
__c
, 
size_t
 
__n
)

115 
__THROW
 
	`__asm
 ("memrchr"è
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1));

117 *
	$memrchr
 (cÚ¡ *
__s
, 
__c
, 
size_t
 
__n
)

118 
__THROW
 
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1));

123 
__BEGIN_NAMESPACE_STD


125 *
	$¡rýy
 (*
__»¡riù
 
__de¡
, cÚ¡ *__»¡riù 
__¤c
)

126 
__THROW
 
	`__nÚnuÎ
 ((1, 2));

128 *
	$¡ºýy
 (*
__»¡riù
 
__de¡
,

129 cÚ¡ *
__»¡riù
 
__¤c
, 
size_t
 
__n
)

130 
__THROW
 
	`__nÚnuÎ
 ((1, 2));

133 *
	$¡rÿt
 (*
__»¡riù
 
__de¡
, cÚ¡ *__»¡riù 
__¤c
)

134 
__THROW
 
	`__nÚnuÎ
 ((1, 2));

136 *
	$¡ºÿt
 (*
__»¡riù
 
__de¡
, cÚ¡ *__»¡riù 
__¤c
,

137 
size_t
 
__n
è
__THROW
 
	`__nÚnuÎ
 ((1, 2));

140 
	$¡rcmp
 (cÚ¡ *
__s1
, cÚ¡ *
__s2
)

141 
__THROW
 
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1, 2));

143 
	$¡ºcmp
 (cÚ¡ *
__s1
, cÚ¡ *
__s2
, 
size_t
 
__n
)

144 
__THROW
 
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1, 2));

147 
	$¡rcÞl
 (cÚ¡ *
__s1
, cÚ¡ *
__s2
)

148 
__THROW
 
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1, 2));

150 
size_t
 
	$¡rxäm
 (*
__»¡riù
 
__de¡
,

151 cÚ¡ *
__»¡riù
 
__¤c
, 
size_t
 
__n
)

152 
__THROW
 
	`__nÚnuÎ
 ((2));

153 
__END_NAMESPACE_STD


155 #ifdeà
__USE_XOPEN2K8


159 
	~<xloÿË.h
>

162 
	$¡rcÞl_l
 (cÚ¡ *
__s1
, cÚ¡ *
__s2
, 
__loÿË_t
 
__l
)

163 
__THROW
 
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1, 2, 3));

165 
size_t
 
	$¡rxäm_l
 (*
__de¡
, cÚ¡ *
__¤c
, 
size_t
 
__n
,

166 
__loÿË_t
 
__l
è
__THROW
 
	`__nÚnuÎ
 ((2, 4));

169 #ià
defšed
 
__USE_XOPEN_EXTENDED
 || defšed 
__USE_XOPEN2K8


171 *
	$¡rdup
 (cÚ¡ *
__s
)

172 
__THROW
 
__©Œibu‹_m®loc__
 
	`__nÚnuÎ
 ((1));

178 #ià
defšed
 
__USE_XOPEN2K8


179 *
	$¡ºdup
 (cÚ¡ *
__¡ršg
, 
size_t
 
__n
)

180 
__THROW
 
__©Œibu‹_m®loc__
 
	`__nÚnuÎ
 ((1));

183 #ià
defšed
 
__USE_GNU
 && defšed 
__GNUC__


185 
	#¡rdu·
(
s
) \

186 (
__ex‹nsiÚ__
 \

188 cÚ¡ *
__Þd
 = (
s
); \

189 
size_t
 
__Ën
 = 
	`¡¾’
 (
__Þd
) + 1; \

190 *
__Ãw
 = (*è
	`__bužtš_®loÿ
 (
__Ën
); \

191 (*è
	`memýy
 (
__Ãw
, 
__Þd
, 
__Ën
); \

192 
	}
}))

	)

195 
	#¡ºdu·
(
s
, 
n
) \

196 (
__ex‹nsiÚ__
 \

198 cÚ¡ *
__Þd
 = (
s
); \

199 
size_t
 
__Ën
 = 
	`¡ºËn
 (
__Þd
, (
n
)); \

200 *
__Ãw
 = (*è
	`__bužtš_®loÿ
 (
__Ën
 + 1); \

201 
__Ãw
[
__Ën
] = '\0'; \

202 (*è
	`memýy
 (
__Ãw
, 
__Þd
, 
__Ën
); \

203 }))

	)

206 
	g__BEGIN_NAMESPACE_STD


208 #ifdeà
__CORRECT_ISO_CPP_STRING_H_PROTO


211 *
¡rchr
 (*
__s
, 
__c
)

212 
__THROW
 
__asm
 ("¡rchr"è
__©Œibu‹_pu»__
 
__nÚnuÎ
 ((1));

213 cÚ¡ *
¡rchr
 (cÚ¡ *
__s
, 
__c
)

214 
__THROW
 
__asm
 ("¡rchr"è
__©Œibu‹_pu»__
 
__nÚnuÎ
 ((1));

216 #ifdeà
__OPTIMIZE__


217 
__ex‹º_®ways_šlše
 *

218 
¡rchr
 (*
__s
, 
__c
è
	g__THROW


220  
__bužtš_¡rchr
 (
__s
, 
__c
);

223 
__ex‹º_®ways_šlše
 const *

224 
¡rchr
 (cÚ¡ *
__s
, 
__c
è
	g__THROW


226  
__bužtš_¡rchr
 (
__s
, 
__c
);

231 *
	$¡rchr
 (cÚ¡ *
__s
, 
__c
)

232 
__THROW
 
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1));

235 #ifdeà
__CORRECT_ISO_CPP_STRING_H_PROTO


238 *
	`¡¼chr
 (*
__s
, 
__c
)

239 
__THROW
 
	`__asm
 ("¡¼chr"è
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1));

240 cÚ¡ *
	`¡¼chr
 (cÚ¡ *
__s
, 
__c
)

241 
__THROW
 
	`__asm
 ("¡¼chr"è
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1));

243 #ifdeà
__OPTIMIZE__


244 
__ex‹º_®ways_šlše
 *

245 
	`¡¼chr
 (*
__s
, 
__c
è
__THROW


247  
	`__bužtš_¡¼chr
 (
__s
, 
__c
);

250 
__ex‹º_®ways_šlše
 const *

251 
	`¡¼chr
 (cÚ¡ *
__s
, 
__c
è
__THROW


253  
	`__bužtš_¡¼chr
 (
__s
, 
__c
);

256 
	}
}

258 *
	$¡¼chr
 (cÚ¡ *
__s
, 
__c
)

259 
__THROW
 
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1));

261 
__END_NAMESPACE_STD


263 #ifdeà
__USE_GNU


266 #ifdeà
__CORRECT_ISO_CPP_STRING_H_PROTO


267 "C++" *
	$¡rchºul
 (*
__s
, 
__c
)

268 
__THROW
 
	`__asm
 ("¡rchºul"è
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1));

269 "C++" cÚ¡ *
	$¡rchºul
 (cÚ¡ *
__s
, 
__c
)

270 
__THROW
 
	`__asm
 ("¡rchºul"è
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1));

272 *
	$¡rchºul
 (cÚ¡ *
__s
, 
__c
)

273 
__THROW
 
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1));

277 
__BEGIN_NAMESPACE_STD


280 
size_t
 
	$¡rc¥n
 (cÚ¡ *
__s
, cÚ¡ *
__»jeù
)

281 
__THROW
 
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1, 2));

284 
size_t
 
	$¡r¥n
 (cÚ¡ *
__s
, cÚ¡ *
__acû±
)

285 
__THROW
 
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1, 2));

287 #ifdeà
__CORRECT_ISO_CPP_STRING_H_PROTO


290 *
	`¡½brk
 (*
__s
, cÚ¡ *
__acû±
)

291 
__THROW
 
	`__asm
 ("¡½brk"è
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1, 2));

292 cÚ¡ *
	`¡½brk
 (cÚ¡ *
__s
, cÚ¡ *
__acû±
)

293 
__THROW
 
	`__asm
 ("¡½brk"è
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1, 2));

295 #ifdeà
__OPTIMIZE__


296 
__ex‹º_®ways_šlše
 *

297 
	`¡½brk
 (*
__s
, cÚ¡ *
__acû±
è
__THROW


299  
	`__bužtš_¡½brk
 (
__s
, 
__acû±
);

302 
__ex‹º_®ways_šlše
 const *

303 
	`¡½brk
 (cÚ¡ *
__s
, cÚ¡ *
__acû±
è
__THROW


305  
	`__bužtš_¡½brk
 (
__s
, 
__acû±
);

308 
	}
}

310 *
	$¡½brk
 (cÚ¡ *
__s
, cÚ¡ *
__acû±
)

311 
__THROW
 
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1, 2));

314 #ifdeà
__CORRECT_ISO_CPP_STRING_H_PROTO


317 *
	`¡r¡r
 (*
__hay¡ack
, cÚ¡ *
__ÃedË
)

318 
__THROW
 
	`__asm
 ("¡r¡r"è
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1, 2));

319 cÚ¡ *
	`¡r¡r
 (cÚ¡ *
__hay¡ack
, cÚ¡ *
__ÃedË
)

320 
__THROW
 
	`__asm
 ("¡r¡r"è
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1, 2));

322 #ifdeà
__OPTIMIZE__


323 
__ex‹º_®ways_šlše
 *

324 
	`¡r¡r
 (*
__hay¡ack
, cÚ¡ *
__ÃedË
è
__THROW


326  
	`__bužtš_¡r¡r
 (
__hay¡ack
, 
__ÃedË
);

329 
__ex‹º_®ways_šlše
 const *

330 
	`¡r¡r
 (cÚ¡ *
__hay¡ack
, cÚ¡ *
__ÃedË
è
__THROW


332  
	`__bužtš_¡r¡r
 (
__hay¡ack
, 
__ÃedË
);

335 
	}
}

337 *
	$¡r¡r
 (cÚ¡ *
__hay¡ack
, cÚ¡ *
__ÃedË
)

338 
__THROW
 
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1, 2));

343 *
	$¡¹ok
 (*
__»¡riù
 
__s
, cÚ¡ *__»¡riù 
__d–im
)

344 
__THROW
 
	`__nÚnuÎ
 ((2));

345 
__END_NAMESPACE_STD


349 *
	$__¡¹ok_r
 (*
__»¡riù
 
__s
,

350 cÚ¡ *
__»¡riù
 
__d–im
,

351 **
__»¡riù
 
__§ve_±r
)

352 
__THROW
 
	`__nÚnuÎ
 ((2, 3));

353 #ifdeà
__USE_POSIX


354 *
	$¡¹ok_r
 (*
__»¡riù
 
__s
, cÚ¡ *__»¡riù 
__d–im
,

355 **
__»¡riù
 
__§ve_±r
)

356 
__THROW
 
	`__nÚnuÎ
 ((2, 3));

359 #ifdeà
__USE_GNU


361 #ifdeà
__CORRECT_ISO_CPP_STRING_H_PROTO


362 "C++" *
	$¡rÿ£¡r
 (*
__hay¡ack
, cÚ¡ *
__ÃedË
)

363 
__THROW
 
	`__asm
 ("¡rÿ£¡r"è
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1, 2));

364 "C++" cÚ¡ *
	$¡rÿ£¡r
 (cÚ¡ *
__hay¡ack
,

365 cÚ¡ *
__ÃedË
)

366 
__THROW
 
	`__asm
 ("¡rÿ£¡r"è
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1, 2));

368 *
	$¡rÿ£¡r
 (cÚ¡ *
__hay¡ack
, cÚ¡ *
__ÃedË
)

369 
__THROW
 
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1, 2));

373 #ifdeà
__USE_GNU


377 *
	$memmem
 (cÚ¡ *
__hay¡ack
, 
size_t
 
__hay¡ackËn
,

378 cÚ¡ *
__ÃedË
, 
size_t
 
__ÃedËËn
)

379 
__THROW
 
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1, 3));

383 *
	$__mempýy
 (*
__»¡riù
 
__de¡
,

384 cÚ¡ *
__»¡riù
 
__¤c
, 
size_t
 
__n
)

385 
__THROW
 
	`__nÚnuÎ
 ((1, 2));

386 *
	$mempýy
 (*
__»¡riù
 
__de¡
,

387 cÚ¡ *
__»¡riù
 
__¤c
, 
size_t
 
__n
)

388 
__THROW
 
	`__nÚnuÎ
 ((1, 2));

392 
__BEGIN_NAMESPACE_STD


394 
size_t
 
	$¡¾’
 (cÚ¡ *
__s
)

395 
__THROW
 
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1));

396 
__END_NAMESPACE_STD


398 #ifdef 
__USE_XOPEN2K8


401 
size_t
 
	$¡ºËn
 (cÚ¡ *
__¡ršg
, 
size_t
 
__maxËn
)

402 
__THROW
 
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1));

406 
__BEGIN_NAMESPACE_STD


408 *
	$¡»¼Ü
 (
__”ºum
è
__THROW
;

409 
__END_NAMESPACE_STD


410 #ifdeà
__USE_XOPEN2K


418 #ià
defšed
 
__USE_XOPEN2K
 && !defšed 
__USE_GNU


421 #ifdeà
__REDIRECT_NTH


422 
	`__REDIRECT_NTH
 (
¡»¼Ü_r
,

423 (
__”ºum
, *
__buf
, 
size_t
 
__buæ’
),

424 
__xpg_¡»¼Ü_r
è
	`__nÚnuÎ
 ((2));

426 
	$__xpg_¡»¼Ü_r
 (
__”ºum
, *
__buf
, 
size_t
 
__buæ’
)

427 
__THROW
 
	`__nÚnuÎ
 ((2));

428 
	#¡»¼Ü_r
 
__xpg_¡»¼Ü_r


	)

433 *
	$¡»¼Ü_r
 (
__”ºum
, *
__buf
, 
size_t
 
__buæ’
)

434 
__THROW
 
	`__nÚnuÎ
 ((2)è
__wur
;

438 #ifdeà
__USE_XOPEN2K8


440 *
	$¡»¼Ü_l
 (
__”ºum
, 
__loÿË_t
 
__l
è
__THROW
;

446 
	$__bz”o
 (*
__s
, 
size_t
 
__n
è
__THROW
 
	`__nÚnuÎ
 ((1));

448 #ifdeà
__USE_MISC


450 
	$bcÝy
 (cÚ¡ *
__¤c
, *
__de¡
, 
size_t
 
__n
)

451 
__THROW
 
	`__nÚnuÎ
 ((1, 2));

454 
	$bz”o
 (*
__s
, 
size_t
 
__n
è
__THROW
 
	`__nÚnuÎ
 ((1));

457 
	$bcmp
 (cÚ¡ *
__s1
, cÚ¡ *
__s2
, 
size_t
 
__n
)

458 
__THROW
 
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1, 2));

461 #ifdeà
__CORRECT_ISO_CPP_STRING_H_PROTO


464 *
	`šdex
 (*
__s
, 
__c
)

465 
__THROW
 
	`__asm
 ("šdex"è
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1));

466 cÚ¡ *
	`šdex
 (cÚ¡ *
__s
, 
__c
)

467 
__THROW
 
	`__asm
 ("šdex"è
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1));

469 #ià
defšed
 
__OPTIMIZE__
 && !defšed 
__CORRECT_ISO_CPP_STRINGS_H_PROTO


470 
__ex‹º_®ways_šlše
 *

471 
	`šdex
 (*
__s
, 
__c
è
__THROW


473  
	`__bužtš_šdex
 (
__s
, 
__c
);

476 
__ex‹º_®ways_šlše
 const *

477 
	`šdex
 (cÚ¡ *
__s
, 
__c
è
__THROW


479  
	`__bužtš_šdex
 (
__s
, 
__c
);

482 
	}
}

484 *
	$šdex
 (cÚ¡ *
__s
, 
__c
)

485 
__THROW
 
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1));

489 #ifdeà
__CORRECT_ISO_CPP_STRING_H_PROTO


492 *
	`ršdex
 (*
__s
, 
__c
)

493 
__THROW
 
	`__asm
 ("ršdex"è
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1));

494 cÚ¡ *
	`ršdex
 (cÚ¡ *
__s
, 
__c
)

495 
__THROW
 
	`__asm
 ("ršdex"è
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1));

497 #ià
defšed
 
__OPTIMIZE__
 && !defšed 
__CORRECT_ISO_CPP_STRINGS_H_PROTO


498 
__ex‹º_®ways_šlše
 *

499 
	`ršdex
 (*
__s
, 
__c
è
__THROW


501  
	`__bužtš_ršdex
 (
__s
, 
__c
);

504 
__ex‹º_®ways_šlše
 const *

505 
	`ršdex
 (cÚ¡ *
__s
, 
__c
è
__THROW


507  
	`__bužtš_ršdex
 (
__s
, 
__c
);

510 
	}
}

512 *
	$ršdex
 (cÚ¡ *
__s
, 
__c
)

513 
__THROW
 
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1));

518 
	$ffs
 (
__i
è
__THROW
 
	`__©Œibu‹__
 ((
__cÚ¡__
));

522 #ifdef 
__USE_GNU


523 
	$ff¦
 (
__l
è
__THROW
 
	`__©Œibu‹__
 ((
__cÚ¡__
));

524 
__ex‹nsiÚ__
 
	$ff¦l
 (
__Î
)

525 
__THROW
 
	`__©Œibu‹__
 ((
__cÚ¡__
));

529 
	$¡rÿ£cmp
 (cÚ¡ *
__s1
, cÚ¡ *
__s2
)

530 
__THROW
 
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1, 2));

533 
	$¡ºÿ£cmp
 (cÚ¡ *
__s1
, cÚ¡ *
__s2
, 
size_t
 
__n
)

534 
__THROW
 
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1, 2));

537 #ifdef 
__USE_GNU


540 
	$¡rÿ£cmp_l
 (cÚ¡ *
__s1
, cÚ¡ *
__s2
,

541 
__loÿË_t
 
__loc
)

542 
__THROW
 
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1, 2, 3));

544 
	$¡ºÿ£cmp_l
 (cÚ¡ *
__s1
, cÚ¡ *
__s2
,

545 
size_t
 
__n
, 
__loÿË_t
 
__loc
)

546 
__THROW
 
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1, 2, 4));

549 #ifdef 
__USE_MISC


552 *
	$¡r£p
 (**
__»¡riù
 
__¡ršgp
,

553 cÚ¡ *
__»¡riù
 
__d–im
)

554 
__THROW
 
	`__nÚnuÎ
 ((1, 2));

557 #ifdef 
__USE_XOPEN2K8


559 *
	$¡rsigÇl
 (
__sig
è
__THROW
;

562 *
	$__¡pýy
 (*
__»¡riù
 
__de¡
, cÚ¡ *__»¡riù 
__¤c
)

563 
__THROW
 
	`__nÚnuÎ
 ((1, 2));

564 *
	$¡pýy
 (*
__»¡riù
 
__de¡
, cÚ¡ *__»¡riù 
__¤c
)

565 
__THROW
 
	`__nÚnuÎ
 ((1, 2));

569 *
	$__¡²ýy
 (*
__»¡riù
 
__de¡
,

570 cÚ¡ *
__»¡riù
 
__¤c
, 
size_t
 
__n
)

571 
__THROW
 
	`__nÚnuÎ
 ((1, 2));

572 *
	$¡²ýy
 (*
__»¡riù
 
__de¡
,

573 cÚ¡ *
__»¡riù
 
__¤c
, 
size_t
 
__n
)

574 
__THROW
 
	`__nÚnuÎ
 ((1, 2));

577 #ifdef 
__USE_GNU


579 
	$¡rv”scmp
 (cÚ¡ *
__s1
, cÚ¡ *
__s2
)

580 
__THROW
 
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1, 2));

583 *
	$¡räy
 (*
__¡ršg
è
__THROW
 
	`__nÚnuÎ
 ((1));

586 *
	$memäob
 (*
__s
, 
size_t
 
__n
è
__THROW
 
	`__nÚnuÎ
 ((1));

588 #iâdeà
ba£Çme


593 #ifdeà
__CORRECT_ISO_CPP_STRING_H_PROTO


594 "C++" *
	$ba£Çme
 (*
__fž’ame
)

595 
__THROW
 
	`__asm
 ("ba£Çme"è
	`__nÚnuÎ
 ((1));

596 "C++" cÚ¡ *
	$ba£Çme
 (cÚ¡ *
__fž’ame
)

597 
__THROW
 
	`__asm
 ("ba£Çme"è
	`__nÚnuÎ
 ((1));

599 *
	$ba£Çme
 (cÚ¡ *
__fž’ame
è
__THROW
 
	`__nÚnuÎ
 ((1));

605 #ià
defšed
 
__GNUC__
 && __GNUC__ >= 2

606 #ià
defšed
 
__OPTIMIZE__
 && !defšed 
__OPTIMIZE_SIZE__
 \

607 && !
defšed
 
__NO_INLINE__
 && !defšed 
__ýlu¥lus


627 
	~<b™s/¡ršg.h
>

630 
	~<b™s/¡ršg2.h
>

633 #ià
__USE_FORTIFY_LEVEL
 > 0 && 
defšed
 
__fÜtify_funùiÚ


635 
	~<b™s/¡ršg3.h
>

639 #ià
defšed
 
__USE_GNU
 && defšed 
__OPTIMIZE__
 \

640 && 
defšed
 
__ex‹º_®ways_šlše
 && 
	$__GNUC_PREREQ
 (3,2)

641 #ià!
defšed
 
_FORCE_INLINES
 && !defšed 
_HAVE_STRING_ARCH_mempýy


643 #undeà
mempýy


644 #undeà
__mempýy


645 
	#mempýy
(
de¡
, 
¤c
, 
n
è
	`__mempýy_šlše
 (de¡, src,‚)

	)

646 
	#__mempýy
(
de¡
, 
¤c
, 
n
è
	`__mempýy_šlše
 (de¡, src,‚)

	)

648 
__ex‹º_®ways_šlše
 *

649 
	$__mempýy_šlše
 (*
__»¡riù
 
__de¡
,

650 cÚ¡ *
__»¡riù
 
__¤c
, 
size_t
 
__n
)

652  (*è
	`memýy
 (
__de¡
, 
__¤c
, 
__n
) + __n;

653 
	}
}

658 
	g__END_DECLS


	@/usr/include/sys/stat.h

22 #iâdef 
_SYS_STAT_H


23 
	#_SYS_STAT_H
 1

	)

25 
	~<ã©u»s.h
>

27 
	~<b™s/ty³s.h
>

29 #ià
defšed
 
__USE_XOPEN
 || defšed 
__USE_XOPEN2K
 || defšed 
__USE_ATFILE


30 #ià
defšed
 
__USE_XOPEN
 || defšed 
__USE_XOPEN2K


31 
	#__Ãed_time_t


	)

33 #ifdeà
__USE_ATFILE


34 
	#__Ãed_time¥ec


	)

36 
	~<time.h
>

39 #ià
defšed
 
__USE_XOPEN
 || defšed 
__USE_XOPEN2K


42 #iâdeà
__dev_t_defšed


43 
__dev_t
 
	tdev_t
;

44 
	#__dev_t_defšed


	)

47 #iâdeà
__gid_t_defšed


48 
__gid_t
 
	tgid_t
;

49 
	#__gid_t_defšed


	)

52 #iâdeà
__šo_t_defšed


53 #iâdeà
__USE_FILE_OFFSET64


54 
__šo_t
 
	tšo_t
;

56 
__šo64_t
 
	tšo_t
;

58 
	#__šo_t_defšed


	)

61 #iâdeà
__mode_t_defšed


62 
__mode_t
 
	tmode_t
;

63 
	#__mode_t_defšed


	)

66 #iâdeà
__Æšk_t_defšed


67 
__Æšk_t
 
	tÆšk_t
;

68 
	#__Æšk_t_defšed


	)

71 #iâdeà
__off_t_defšed


72 #iâdeà
__USE_FILE_OFFSET64


73 
__off_t
 
	toff_t
;

75 
__off64_t
 
	toff_t
;

77 
	#__off_t_defšed


	)

80 #iâdeà
__uid_t_defšed


81 
__uid_t
 
	tuid_t
;

82 
	#__uid_t_defšed


	)

86 #ifdeà
__USE_UNIX98


87 #iâdeà
__blkút_t_defšed


88 #iâdeà
__USE_FILE_OFFSET64


89 
__blkút_t
 
	tblkút_t
;

91 
__blkút64_t
 
	tblkút_t
;

93 
	#__blkút_t_defšed


	)

96 #iâdeà
__blksize_t_defšed


97 
__blksize_t
 
	tblksize_t
;

98 
	#__blksize_t_defšed


	)

102 
	g__BEGIN_DECLS


104 
	~<b™s/¡©.h
>

106 #ià
defšed
 
__USE_MISC
 || defšed 
__USE_XOPEN


107 
	#S_IFMT
 
__S_IFMT


	)

108 
	#S_IFDIR
 
__S_IFDIR


	)

109 
	#S_IFCHR
 
__S_IFCHR


	)

110 
	#S_IFBLK
 
__S_IFBLK


	)

111 
	#S_IFREG
 
__S_IFREG


	)

112 #ifdeà
__S_IFIFO


113 
	#S_IFIFO
 
__S_IFIFO


	)

115 #ifdeà
__S_IFLNK


116 
	#S_IFLNK
 
__S_IFLNK


	)

118 #ià(
defšed
 
__USE_MISC
 || defšed 
__USE_UNIX98
) \

119 && 
defšed
 
	g__S_IFSOCK


120 
	#S_IFSOCK
 
__S_IFSOCK


	)

126 
	#__S_ISTYPE
(
mode
, 
mask
è(((modeè& 
__S_IFMT
è=ð(mask))

	)

128 
	#S_ISDIR
(
mode
è
	`__S_ISTYPE
((mode), 
__S_IFDIR
)

	)

129 
	#S_ISCHR
(
mode
è
	`__S_ISTYPE
((mode), 
__S_IFCHR
)

	)

130 
	#S_ISBLK
(
mode
è
	`__S_ISTYPE
((mode), 
__S_IFBLK
)

	)

131 
	#S_ISREG
(
mode
è
	`__S_ISTYPE
((mode), 
__S_IFREG
)

	)

132 #ifdeà
__S_IFIFO


133 
	#S_ISFIFO
(
mode
è
	`__S_ISTYPE
((mode), 
__S_IFIFO
)

	)

135 #ifdeà
__S_IFLNK


136 
	#S_ISLNK
(
mode
è
	`__S_ISTYPE
((mode), 
__S_IFLNK
)

	)

139 #ià
defšed
 
__USE_MISC
 && !defšed 
__S_IFLNK


140 
	#S_ISLNK
(
mode
è0

	)

143 #ià(
defšed
 
__USE_UNIX98
 || defšed 
__USE_XOPEN2K
) \

144 && 
defšed
 
	g__S_IFSOCK


145 
	#S_ISSOCK
(
mode
è
	`__S_ISTYPE
((mode), 
__S_IFSOCK
)

	)

146 #–ià
defšed
 
__USE_XOPEN2K


147 
	#S_ISSOCK
(
mode
è0

	)

154 #ifdef 
__USE_POSIX199309


155 
	#S_TYPEISMQ
(
buf
è
	`__S_TYPEISMQ
(buf)

	)

156 
	#S_TYPEISSEM
(
buf
è
	`__S_TYPEISSEM
(buf)

	)

157 
	#S_TYPEISSHM
(
buf
è
	`__S_TYPEISSHM
(buf)

	)

163 
	#S_ISUID
 
__S_ISUID


	)

164 
	#S_ISGID
 
__S_ISGID


	)

166 #ià
defšed
 
__USE_MISC
 || defšed 
__USE_XOPEN


168 
	#S_ISVTX
 
__S_ISVTX


	)

171 
	#S_IRUSR
 
__S_IREAD


	)

172 
	#S_IWUSR
 
__S_IWRITE


	)

173 
	#S_IXUSR
 
__S_IEXEC


	)

175 
	#S_IRWXU
 (
__S_IREAD
|
__S_IWRITE
|
__S_IEXEC
)

	)

177 #ifdeà
__USE_MISC


178 
	#S_IREAD
 
S_IRUSR


	)

179 
	#S_IWRITE
 
S_IWUSR


	)

180 
	#S_IEXEC
 
S_IXUSR


	)

183 
	#S_IRGRP
 (
S_IRUSR
 >> 3è

	)

184 
	#S_IWGRP
 (
S_IWUSR
 >> 3è

	)

185 
	#S_IXGRP
 (
S_IXUSR
 >> 3è

	)

187 
	#S_IRWXG
 (
S_IRWXU
 >> 3)

	)

189 
	#S_IROTH
 (
S_IRGRP
 >> 3è

	)

190 
	#S_IWOTH
 (
S_IWGRP
 >> 3è

	)

191 
	#S_IXOTH
 (
S_IXGRP
 >> 3è

	)

193 
	#S_IRWXO
 (
S_IRWXG
 >> 3)

	)

196 #ifdef 
__USE_MISC


198 
	#ACCESSPERMS
 (
S_IRWXU
|
S_IRWXG
|
S_IRWXO
è

	)

199 
	#ALLPERMS
 (
S_ISUID
|
S_ISGID
|
S_ISVTX
|
S_IRWXU
|
S_IRWXG
|
S_IRWXO
)

	)

200 
	#DEFFILEMODE
 (
S_IRUSR
|
S_IWUSR
|
S_IRGRP
|
S_IWGRP
|
S_IROTH
|
S_IWOTH
)

	)

202 
	#S_BLKSIZE
 512

	)

206 #iâdeà
__USE_FILE_OFFSET64


208 
	$¡©
 (cÚ¡ *
__»¡riù
 
__fže
,

209 
¡©
 *
__»¡riù
 
__buf
è
__THROW
 
	`__nÚnuÎ
 ((1, 2));

213 
	$f¡©
 (
__fd
, 
¡©
 *
__buf
è
__THROW
 
	`__nÚnuÎ
 ((2));

215 #ifdeà
__REDIRECT_NTH


216 
	`__REDIRECT_NTH
 (
¡©
, (cÚ¡ *
__»¡riù
 
__fže
,

217 
¡©
 *
__»¡riù
 
__buf
), 
¡©64
)

218 
	`__nÚnuÎ
 ((1, 2));

219 
	`__REDIRECT_NTH
 (
f¡©
, (
__fd
, 
¡©
 *
__buf
), 
f¡©64
)

220 
	`__nÚnuÎ
 ((2));

222 
	#¡©
 
¡©64


	)

223 
	#f¡©
 
f¡©64


	)

226 #ifdeà
__USE_LARGEFILE64


227 
	$¡©64
 (cÚ¡ *
__»¡riù
 
__fže
,

228 
¡©64
 *
__»¡riù
 
__buf
è
__THROW
 
	`__nÚnuÎ
 ((1, 2));

229 
	$f¡©64
 (
__fd
, 
¡©64
 *
__buf
è
__THROW
 
	`__nÚnuÎ
 ((2));

232 #ifdeà
__USE_ATFILE


236 #iâdeà
__USE_FILE_OFFSET64


237 
	$f¡©©
 (
__fd
, cÚ¡ *
__»¡riù
 
__fže
,

238 
¡©
 *
__»¡riù
 
__buf
, 
__æag
)

239 
__THROW
 
	`__nÚnuÎ
 ((2, 3));

241 #ifdeà
__REDIRECT_NTH


242 
	`__REDIRECT_NTH
 (
f¡©©
, (
__fd
, cÚ¡ *
__»¡riù
 
__fže
,

243 
¡©
 *
__»¡riù
 
__buf
,

244 
__æag
),

245 
f¡©©64
è
	`__nÚnuÎ
 ((2, 3));

247 
	#f¡©©
 
f¡©©64


	)

251 #ifdeà
__USE_LARGEFILE64


252 
	$f¡©©64
 (
__fd
, cÚ¡ *
__»¡riù
 
__fže
,

253 
¡©64
 *
__»¡riù
 
__buf
, 
__æag
)

254 
__THROW
 
	`__nÚnuÎ
 ((2, 3));

258 #ià
defšed
 
__USE_XOPEN_EXTENDED
 || defšed 
__USE_XOPEN2K


259 #iâdeà
__USE_FILE_OFFSET64


262 
	$l¡©
 (cÚ¡ *
__»¡riù
 
__fže
,

263 
¡©
 *
__»¡riù
 
__buf
è
__THROW
 
	`__nÚnuÎ
 ((1, 2));

265 #ifdeà
__REDIRECT_NTH


266 
	`__REDIRECT_NTH
 (
l¡©
,

267 (cÚ¡ *
__»¡riù
 
__fže
,

268 
¡©
 *
__»¡riù
 
__buf
), 
l¡©64
)

269 
	`__nÚnuÎ
 ((1, 2));

271 
	#l¡©
 
l¡©64


	)

274 #ifdeà
__USE_LARGEFILE64


275 
	$l¡©64
 (cÚ¡ *
__»¡riù
 
__fže
,

276 
¡©64
 *
__»¡riù
 
__buf
)

277 
__THROW
 
	`__nÚnuÎ
 ((1, 2));

283 
	$chmod
 (cÚ¡ *
__fže
, 
__mode_t
 
__mode
)

284 
__THROW
 
	`__nÚnuÎ
 ((1));

286 #ifdeà
__USE_MISC


290 
	$lchmod
 (cÚ¡ *
__fže
, 
__mode_t
 
__mode
)

291 
__THROW
 
	`__nÚnuÎ
 ((1));

295 #ifdeà
__USE_POSIX


296 
	$fchmod
 (
__fd
, 
__mode_t
 
__mode
è
__THROW
;

299 #ifdeà
__USE_ATFILE


302 
	$fchmod©
 (
__fd
, cÚ¡ *
__fže
, 
__mode_t
 
__mode
,

303 
__æag
)

304 
__THROW
 
	`__nÚnuÎ
 ((2)è
__wur
;

311 
__mode_t
 
	$umask
 (
__mode_t
 
__mask
è
__THROW
;

313 #ifdef 
__USE_GNU


316 
__mode_t
 
	$g‘umask
 (è
__THROW
;

320 
	$mkdœ
 (cÚ¡ *
__·th
, 
__mode_t
 
__mode
)

321 
__THROW
 
	`__nÚnuÎ
 ((1));

323 #ifdeà
__USE_ATFILE


327 
	$mkdœ©
 (
__fd
, cÚ¡ *
__·th
, 
__mode_t
 
__mode
)

328 
__THROW
 
	`__nÚnuÎ
 ((2));

334 #ià
defšed
 
__USE_MISC
 || defšed 
__USE_XOPEN_EXTENDED


335 
	$mknod
 (cÚ¡ *
__·th
, 
__mode_t
 
__mode
, 
__dev_t
 
__dev
)

336 
__THROW
 
	`__nÚnuÎ
 ((1));

338 #ifdeà
__USE_ATFILE


342 
	$mknod©
 (
__fd
, cÚ¡ *
__·th
, 
__mode_t
 
__mode
,

343 
__dev_t
 
__dev
è
__THROW
 
	`__nÚnuÎ
 ((2));

349 
	$mkfifo
 (cÚ¡ *
__·th
, 
__mode_t
 
__mode
)

350 
__THROW
 
	`__nÚnuÎ
 ((1));

352 #ifdeà
__USE_ATFILE


356 
	$mkfifßt
 (
__fd
, cÚ¡ *
__·th
, 
__mode_t
 
__mode
)

357 
__THROW
 
	`__nÚnuÎ
 ((2));

360 #ifdeà
__USE_ATFILE


363 
	$utim’§t
 (
__fd
, cÚ¡ *
__·th
,

364 cÚ¡ 
time¥ec
 
__times
[2],

365 
__æags
)

366 
__THROW
 
	`__nÚnuÎ
 ((2));

369 #ifdeà
__USE_XOPEN2K8


371 
	$futim’s
 (
__fd
, cÚ¡ 
time¥ec
 
__times
[2]è
__THROW
;

389 #iâdeà
_STAT_VER


390 
	#_STAT_VER
 0

	)

392 #iâdeà
_MKNOD_VER


393 
	#_MKNOD_VER
 0

	)

397 #iâdeà
__USE_FILE_OFFSET64


398 
	$__fx¡©
 (
__v”
, 
__fždes
, 
¡©
 *
__¡©_buf
)

399 
__THROW
 
	`__nÚnuÎ
 ((3));

400 
	$__x¡©
 (
__v”
, cÚ¡ *
__fž’ame
,

401 
¡©
 *
__¡©_buf
è
__THROW
 
	`__nÚnuÎ
 ((2, 3));

402 
	$__lx¡©
 (
__v”
, cÚ¡ *
__fž’ame
,

403 
¡©
 *
__¡©_buf
è
__THROW
 
	`__nÚnuÎ
 ((2, 3));

404 
	$__fx¡©©
 (
__v”
, 
__fždes
, cÚ¡ *
__fž’ame
,

405 
¡©
 *
__¡©_buf
, 
__æag
)

406 
__THROW
 
	`__nÚnuÎ
 ((3, 4));

408 #ifdeà
__REDIRECT_NTH


409 
	`__REDIRECT_NTH
 (
__fx¡©
, (
__v”
, 
__fždes
,

410 
¡©
 *
__¡©_buf
), 
__fx¡©64
)

411 
	`__nÚnuÎ
 ((3));

412 
	`__REDIRECT_NTH
 (
__x¡©
, (
__v”
, cÚ¡ *
__fž’ame
,

413 
¡©
 *
__¡©_buf
), 
__x¡©64
)

414 
	`__nÚnuÎ
 ((2, 3));

415 
	`__REDIRECT_NTH
 (
__lx¡©
, (
__v”
, cÚ¡ *
__fž’ame
,

416 
¡©
 *
__¡©_buf
), 
__lx¡©64
)

417 
	`__nÚnuÎ
 ((2, 3));

418 
	`__REDIRECT_NTH
 (
__fx¡©©
, (
__v”
, 
__fždes
,

419 cÚ¡ *
__fž’ame
,

420 
¡©
 *
__¡©_buf
, 
__æag
),

421 
__fx¡©©64
è
	`__nÚnuÎ
 ((3, 4));

424 
	#__fx¡©
 
__fx¡©64


	)

425 
	#__x¡©
 
__x¡©64


	)

426 
	#__lx¡©
 
__lx¡©64


	)

430 #ifdeà
__USE_LARGEFILE64


431 
	$__fx¡©64
 (
__v”
, 
__fždes
, 
¡©64
 *
__¡©_buf
)

432 
__THROW
 
	`__nÚnuÎ
 ((3));

433 
	$__x¡©64
 (
__v”
, cÚ¡ *
__fž’ame
,

434 
¡©64
 *
__¡©_buf
è
__THROW
 
	`__nÚnuÎ
 ((2, 3));

435 
	$__lx¡©64
 (
__v”
, cÚ¡ *
__fž’ame
,

436 
¡©64
 *
__¡©_buf
è
__THROW
 
	`__nÚnuÎ
 ((2, 3));

437 
	$__fx¡©©64
 (
__v”
, 
__fždes
, cÚ¡ *
__fž’ame
,

438 
¡©64
 *
__¡©_buf
, 
__æag
)

439 
__THROW
 
	`__nÚnuÎ
 ((3, 4));

441 
	$__xmknod
 (
__v”
, cÚ¡ *
__·th
, 
__mode_t
 
__mode
,

442 
__dev_t
 *
__dev
è
__THROW
 
	`__nÚnuÎ
 ((2, 4));

444 
	$__xmknod©
 (
__v”
, 
__fd
, cÚ¡ *
__·th
,

445 
__mode_t
 
__mode
, 
__dev_t
 *
__dev
)

446 
__THROW
 
	`__nÚnuÎ
 ((3, 5));

448 #ifdeà
__USE_EXTERN_INLINES


451 
__ex‹º_šlše
 

452 
	`__NTH
 (
	$¡©
 (cÚ¡ *
__·th
, 
¡©
 *
__¡©buf
))

454  
	`__x¡©
 (
_STAT_VER
, 
__·th
, 
__¡©buf
);

455 
	}
}

457 #ià
defšed
 
__USE_MISC
 || defšed 
__USE_XOPEN_EXTENDED


458 
__ex‹º_šlše
 

459 
__NTH
 (
	$l¡©
 (cÚ¡ *
__·th
, 
¡©
 *
__¡©buf
))

461  
	`__lx¡©
 (
_STAT_VER
, 
__·th
, 
__¡©buf
);

462 
	}
}

465 
__ex‹º_šlše
 

466 
__NTH
 (
	$f¡©
 (
__fd
, 
¡©
 *
__¡©buf
))

468  
	`__fx¡©
 (
_STAT_VER
, 
__fd
, 
__¡©buf
);

469 
	}
}

471 #ifdeà
__USE_ATFILE


472 
__ex‹º_šlše
 

473 
__NTH
 (
	$f¡©©
 (
__fd
, cÚ¡ *
__fž’ame
, 
¡©
 *
__¡©buf
,

474 
__æag
))

476  
	`__fx¡©©
 (
_STAT_VER
, 
__fd
, 
__fž’ame
, 
__¡©buf
, 
__æag
);

477 
	}
}

480 #ifdeà
__USE_MISC


481 
__ex‹º_šlše
 

482 
__NTH
 (
	$mknod
 (cÚ¡ *
__·th
, 
__mode_t
 
__mode
, 
__dev_t
 
__dev
))

484  
	`__xmknod
 (
_MKNOD_VER
, 
__·th
, 
__mode
, &
__dev
);

485 
	}
}

488 #ifdeà
__USE_ATFILE


489 
__ex‹º_šlše
 

490 
__NTH
 (
	$mknod©
 (
__fd
, cÚ¡ *
__·th
, 
__mode_t
 
__mode
,

491 
__dev_t
 
__dev
))

493  
	`__xmknod©
 (
_MKNOD_VER
, 
__fd
, 
__·th
, 
__mode
, &
__dev
);

494 
	}
}

497 #ià
defšed
 
__USE_LARGEFILE64
 \

498 && (! 
defšed
 
	g__USE_FILE_OFFSET64
 \

499 || (
defšed
 
	g__REDIRECT_NTH
 && defšed 
	g__OPTIMIZE__
))

500 
__ex‹º_šlše
 

501 
__NTH
 (
	$¡©64
 (cÚ¡ *
__·th
, 
¡©64
 *
__¡©buf
))

503  
	`__x¡©64
 (
_STAT_VER
, 
__·th
, 
__¡©buf
);

504 
	}
}

506 #ià
defšed
 
__USE_MISC
 || defšed 
__USE_XOPEN_EXTENDED


507 
__ex‹º_šlše
 

508 
__NTH
 (
	$l¡©64
 (cÚ¡ *
__·th
, 
¡©64
 *
__¡©buf
))

510  
	`__lx¡©64
 (
_STAT_VER
, 
__·th
, 
__¡©buf
);

511 
	}
}

514 
__ex‹º_šlše
 

515 
__NTH
 (
	$f¡©64
 (
__fd
, 
¡©64
 *
__¡©buf
))

517  
	`__fx¡©64
 (
_STAT_VER
, 
__fd
, 
__¡©buf
);

518 
	}
}

520 #ifdeà
__USE_ATFILE


521 
__ex‹º_šlše
 

522 
__NTH
 (
	$f¡©©64
 (
__fd
, cÚ¡ *
__fž’ame
, 
¡©64
 *
__¡©buf
,

523 
__æag
))

525  
	`__fx¡©©64
 (
_STAT_VER
, 
__fd
, 
__fž’ame
, 
__¡©buf
, 
__æag
);

526 
	}
}

533 
	g__END_DECLS


	@/usr/include/sys/times.h

22 #iâdef 
_SYS_TIMES_H


23 
	#_SYS_TIMES_H
 1

	)

25 
	~<ã©u»s.h
>

27 
	#__Ãed_þock_t


	)

28 
	~<time.h
>

31 
__BEGIN_DECLS


34 
	stms


36 
þock_t
 
	mtms_utime
;

37 
þock_t
 
	mtms_¡ime
;

39 
þock_t
 
	mtms_cutime
;

40 
þock_t
 
	mtms_c¡ime
;

48 
þock_t
 
	$times
 (
tms
 *
__bufãr
è
__THROW
;

50 
__END_DECLS


	@/usr/include/sys/types.h

22 #iâdef 
_SYS_TYPES_H


23 
	#_SYS_TYPES_H
 1

	)

25 
	~<ã©u»s.h
>

27 
	g__BEGIN_DECLS


29 
	~<b™s/ty³s.h
>

31 #ifdef 
__USE_MISC


32 #iâdeà
__u_ch¬_defšed


33 
__u_ch¬
 
	tu_ch¬
;

34 
__u_shÜt
 
	tu_shÜt
;

35 
__u_št
 
	tu_št
;

36 
__u_lÚg
 
	tu_lÚg
;

37 
__quad_t
 
	tquad_t
;

38 
__u_quad_t
 
	tu_quad_t
;

39 
__fsid_t
 
	tfsid_t
;

40 
	#__u_ch¬_defšed


	)

44 
__loff_t
 
	tloff_t
;

46 #iâdeà
__šo_t_defšed


47 #iâdeà
__USE_FILE_OFFSET64


48 
__šo_t
 
	tšo_t
;

50 
__šo64_t
 
	tšo_t
;

52 
	#__šo_t_defšed


	)

54 #ià
defšed
 
__USE_LARGEFILE64
 && !defšed 
__šo64_t_defšed


55 
__šo64_t
 
	tšo64_t
;

56 
	#__šo64_t_defšed


	)

59 #iâdeà
__dev_t_defšed


60 
__dev_t
 
	tdev_t
;

61 
	#__dev_t_defšed


	)

64 #iâdeà
__gid_t_defšed


65 
__gid_t
 
	tgid_t
;

66 
	#__gid_t_defšed


	)

69 #iâdeà
__mode_t_defšed


70 
__mode_t
 
	tmode_t
;

71 
	#__mode_t_defšed


	)

74 #iâdeà
__Æšk_t_defšed


75 
__Æšk_t
 
	tÆšk_t
;

76 
	#__Æšk_t_defšed


	)

79 #iâdeà
__uid_t_defšed


80 
__uid_t
 
	tuid_t
;

81 
	#__uid_t_defšed


	)

84 #iâdeà
__off_t_defšed


85 #iâdeà
__USE_FILE_OFFSET64


86 
__off_t
 
	toff_t
;

88 
__off64_t
 
	toff_t
;

90 
	#__off_t_defšed


	)

92 #ià
defšed
 
__USE_LARGEFILE64
 && !defšed 
__off64_t_defšed


93 
__off64_t
 
	toff64_t
;

94 
	#__off64_t_defšed


	)

97 #iâdeà
__pid_t_defšed


98 
__pid_t
 
	tpid_t
;

99 
	#__pid_t_defšed


	)

102 #ià(
defšed
 
__USE_XOPEN
 || defšed 
__USE_XOPEN2K8
) \

103 && !
defšed
 
__id_t_defšed


104 
__id_t
 
	tid_t
;

105 
	#__id_t_defšed


	)

108 #iâdeà
__ssize_t_defšed


109 
__ssize_t
 
	tssize_t
;

110 
	#__ssize_t_defšed


	)

113 #ifdef 
__USE_MISC


114 #iâdeà
__daddr_t_defšed


115 
__daddr_t
 
	tdaddr_t
;

116 
__ÿddr_t
 
	tÿddr_t
;

117 
	#__daddr_t_defšed


	)

121 #ià(
defšed
 
__USE_MISC
 || defšed 
__USE_XOPEN
è&& !defšed 
__key_t_defšed


122 
__key_t
 
	tkey_t
;

123 
	#__key_t_defšed


	)

126 #ià
defšed
 
__USE_XOPEN
 || defšed 
__USE_XOPEN2K8


127 
	#__Ãed_þock_t


	)

129 
	#__Ãed_time_t


	)

130 
	#__Ãed_tim”_t


	)

131 
	#__Ãed_þockid_t


	)

132 
	~<time.h
>

134 #ifdeà
__USE_XOPEN


135 #iâdeà
__u£cÚds_t_defšed


136 
__u£cÚds_t
 
	tu£cÚds_t
;

137 
	#__u£cÚds_t_defšed


	)

139 #iâdeà
__su£cÚds_t_defšed


140 
__su£cÚds_t
 
	tsu£cÚds_t
;

141 
	#__su£cÚds_t_defšed


	)

145 
	#__Ãed_size_t


	)

146 
	~<¡ddef.h
>

148 #ifdeà
__USE_MISC


150 
	tulÚg
;

151 
	tushÜt
;

152 
	tušt
;

157 #ià!
__GNUC_PREREQ
 (2, 7)

160 #iâdeà
__št8_t_defšed


161 
	#__št8_t_defšed


	)

162 
	tšt8_t
;

163 
	tšt16_t
;

164 
	tšt32_t
;

165 #ià
__WORDSIZE
 == 64

166 
	tšt64_t
;

168 
__ex‹nsiÚ__
 
	tšt64_t
;

173 
	tu_št8_t
;

174 
	tu_št16_t
;

175 
	tu_št32_t
;

176 #ià
__WORDSIZE
 == 64

177 
	tu_št64_t
;

179 
__ex‹nsiÚ__
 
	tu_št64_t
;

182 
	t»gi¡”_t
;

187 
	#__štN_t
(
N
, 
MODE
) \

188 ##
	tN
##
	t_t
 
	t__©Œibu‹__
 ((
	t__mode__
 (
	tMODE
)))

	)

189 
	t__u_štN_t
(
	tN
, 
	tMODE
) \

190 
	tu_št
##
	tN
##
	t_t
 
	t__©Œibu‹__
 ((
	t__mode__
 (
	tMODE
)))

	)

192 #iâdeà
	t__št8_t_defšed


193 
	t__št8_t_defšed


	)

194 
	t__štN_t
 (8, 
	t__QI__
);

195 
__štN_t
 (16, 
__HI__
);

196 
__štN_t
 (32, 
__SI__
);

197 
__štN_t
 (64, 
__DI__
);

200 
__u_štN_t
 (8, 
__QI__
);

201 
__u_štN_t
 (16, 
__HI__
);

202 
__u_štN_t
 (32, 
__SI__
);

203 
__u_štN_t
 (64, 
__DI__
);

205 
	t»gi¡”_t
 
	t__©Œibu‹__
 ((
	t__mode__
 (
	t__wÜd__
)));

211 
	#__BIT_TYPES_DEFINED__
 1

	)

214 #ifdef 
__USE_MISC


216 
	~<’dŸn.h
>

219 
	~<sys/£Ëù.h
>

222 
	~<sys/sysmaüos.h
>

226 #ià(
defšed
 
__USE_UNIX98
 || defšed 
__USE_XOPEN2K8
) \

227 && !
defšed
 
__blksize_t_defšed


228 
__blksize_t
 
	tblksize_t
;

229 
	#__blksize_t_defšed


	)

233 #iâdeà
__USE_FILE_OFFSET64


234 #iâdeà
__blkút_t_defšed


235 
__blkút_t
 
	tblkút_t
;

236 
	#__blkút_t_defšed


	)

238 #iâdeà
__fsblkút_t_defšed


239 
__fsblkút_t
 
	tfsblkút_t
;

240 
	#__fsblkút_t_defšed


	)

242 #iâdeà
__fsfžút_t_defšed


243 
__fsfžút_t
 
	tfsfžút_t
;

244 
	#__fsfžút_t_defšed


	)

247 #iâdeà
__blkút_t_defšed


248 
__blkút64_t
 
	tblkút_t
;

249 
	#__blkút_t_defšed


	)

251 #iâdeà
__fsblkút_t_defšed


252 
__fsblkút64_t
 
	tfsblkút_t
;

253 
	#__fsblkút_t_defšed


	)

255 #iâdeà
__fsfžút_t_defšed


256 
__fsfžút64_t
 
	tfsfžút_t
;

257 
	#__fsfžút_t_defšed


	)

261 #ifdeà
__USE_LARGEFILE64


262 
__blkút64_t
 
	tblkút64_t
;

263 
__fsblkút64_t
 
	tfsblkút64_t
;

264 
__fsfžút64_t
 
	tfsfžút64_t
;

269 #ià
defšed
 
__USE_POSIX199506
 || defšed 
__USE_UNIX98


270 
	~<b™s/±h»adty³s.h
>

273 
	g__END_DECLS


	@/usr/include/sys/utsname.h

22 #iâdef 
_SYS_UTSNAME_H


23 
	#_SYS_UTSNAME_H
 1

	)

25 
	~<ã©u»s.h
>

27 
	g__BEGIN_DECLS


29 
	~<b™s/ut¢ame.h
>

31 #iâdeà
_UTSNAME_SYSNAME_LENGTH


32 
	#_UTSNAME_SYSNAME_LENGTH
 
_UTSNAME_LENGTH


	)

34 #iâdeà
_UTSNAME_NODENAME_LENGTH


35 
	#_UTSNAME_NODENAME_LENGTH
 
_UTSNAME_LENGTH


	)

37 #iâdeà
_UTSNAME_RELEASE_LENGTH


38 
	#_UTSNAME_RELEASE_LENGTH
 
_UTSNAME_LENGTH


	)

40 #iâdeà
_UTSNAME_VERSION_LENGTH


41 
	#_UTSNAME_VERSION_LENGTH
 
_UTSNAME_LENGTH


	)

43 #iâdeà
_UTSNAME_MACHINE_LENGTH


44 
	#_UTSNAME_MACHINE_LENGTH
 
_UTSNAME_LENGTH


	)

48 
	sut¢ame


51 
	msy¢ame
[
_UTSNAME_SYSNAME_LENGTH
];

54 
	mnod’ame
[
_UTSNAME_NODENAME_LENGTH
];

57 
	m»Ëa£
[
_UTSNAME_RELEASE_LENGTH
];

59 
	mv”siÚ
[
_UTSNAME_VERSION_LENGTH
];

62 
	mmachše
[
_UTSNAME_MACHINE_LENGTH
];

64 #ià
_UTSNAME_DOMAIN_LENGTH
 - 0

66 #ifdeà
__USE_GNU


67 
	mdomašÇme
[
_UTSNAME_DOMAIN_LENGTH
];

69 
	m__domašÇme
[
_UTSNAME_DOMAIN_LENGTH
];

74 #ifdeà
__USE_MISC


76 
	#SYS_NMLN
 
_UTSNAME_LENGTH


	)

81 
	$uÇme
 (
ut¢ame
 *
__Çme
è
__THROW
;

84 
__END_DECLS


	@/usr/include/sys/wait.h

22 #iâdef 
_SYS_WAIT_H


23 
	#_SYS_WAIT_H
 1

	)

25 
	~<ã©u»s.h
>

27 
	g__BEGIN_DECLS


29 
	~<sigÇl.h
>

32 #ià!
defšed
 
_STDLIB_H
 || (!defšed 
__USE_XOPEN
 && !defšed 
__USE_XOPEN2K8
)

35 
	~<b™s/wa™æags.h
>

37 #ifdef 
__USE_MISC


42 #ià
defšed
 
__GNUC__
 && !defšed 
__ýlu¥lus


43 
	#__WAIT_INT
(
¡©us
) \

44 (
	`__ex‹nsiÚ__
 (((uniÚ { 
	`__ty³of
(
¡©us
è
__š
; 
__i
; }) \

45 { .
__š
 = (
¡©us
è}).
__i
))

	)

47 
	#__WAIT_INT
(
¡©us
è(*(cÚ¡ *è&(¡©us))

	)

55 #ià!
defšed
 
__GNUC__
 || __GNUC__ < 2 || defšed 
__ýlu¥lus


56 
	#__WAIT_STATUS
 *

	)

57 
	#__WAIT_STATUS_DEFN
 *

	)

62 
wa™
 *
	m__u±r
;

63 *
	m__Œ
;

64 } 
	t__WAIT_STATUS
 
	t__©Œibu‹__
 ((
	t__Œª¥¬’t_uniÚ__
));

65 
	#__WAIT_STATUS_DEFN
 *

	)

70 
	#__WAIT_INT
(
¡©us
è(¡©us)

	)

71 
	#__WAIT_STATUS
 *

	)

72 
	#__WAIT_STATUS_DEFN
 *

	)

77 
	~<b™s/wa™¡©us.h
>

79 
	#WEXITSTATUS
(
¡©us
è
	`__WEXITSTATUS
 (
	`__WAIT_INT
 (¡©us))

	)

80 
	#WTERMSIG
(
¡©us
è
	`__WTERMSIG
 (
	`__WAIT_INT
 (¡©us))

	)

81 
	#WSTOPSIG
(
¡©us
è
	`__WSTOPSIG
 (
	`__WAIT_INT
 (¡©us))

	)

82 
	#WIFEXITED
(
¡©us
è
	`__WIFEXITED
 (
	`__WAIT_INT
 (¡©us))

	)

83 
	#WIFSIGNALED
(
¡©us
è
	`__WIFSIGNALED
 (
	`__WAIT_INT
 (¡©us))

	)

84 
	#WIFSTOPPED
(
¡©us
è
	`__WIFSTOPPED
 (
	`__WAIT_INT
 (¡©us))

	)

85 #ifdeà
__WIFCONTINUED


86 
	#WIFCONTINUED
(
¡©us
è
	`__WIFCONTINUED
 (
	`__WAIT_INT
 (¡©us))

	)

90 #ifdef 
__USE_MISC


91 
	#WCOREFLAG
 
__WCOREFLAG


	)

92 
	#WCOREDUMP
(
¡©us
è
	`__WCOREDUMP
 (
	`__WAIT_INT
 (¡©us))

	)

93 
	#W_EXITCODE
(
»t
, 
sig
è
	`__W_EXITCODE
 (»t, sig)

	)

94 
	#W_STOPCODE
(
sig
è
	`__W_STOPCODE
 (sig)

	)

102 
__pid_t
 
wa™
 (
__WAIT_STATUS
 
__¡©_loc
);

104 #ifdef 
__USE_MISC


106 
	#WAIT_ANY
 (-1è

	)

107 
	#WAIT_MYPGRP
 0

	)

125 
__pid_t
 
wa™pid
 (__pid_ˆ
__pid
, *
__¡©_loc
, 
__ÝtiÚs
);

127 #ià
defšed
 
__USE_XOPEN
 || defšed 
__USE_XOPEN2K8


128 #iâdeà
__id_t_defšed


129 
	~<b™s/ty³s.h
>

130 
__id_t
 
	tid_t
;

131 
	#__id_t_defšed


	)

134 
	#__Ãed_sigšfo_t


	)

135 
	~<b™s/sigšfo.h
>

148 
wa™id
 (
idty³_t
 
__idty³
, 
__id_t
 
__id
, 
sigšfo_t
 *
__šfÝ
,

149 
__ÝtiÚs
);

152 #ià
defšed
 
__USE_MISC
 || defšed 
__USE_XOPEN_EXTENDED


155 
	gru§ge
;

162 
__pid_t
 
	$wa™3
 (
__WAIT_STATUS
 
__¡©_loc
, 
__ÝtiÚs
,

163 
ru§ge
 * 
__u§ge
è
__THROWNL
;

166 #ifdeà
__USE_MISC


168 
__pid_t
 
	$wa™4
 (
__pid_t
 
__pid
, 
__WAIT_STATUS
 
__¡©_loc
, 
__ÝtiÚs
,

169 
ru§ge
 *
__u§ge
è
__THROWNL
;

173 
__END_DECLS


	@/usr/include/termios.h

22 #iâdef 
_TERMIOS_H


23 
	#_TERMIOS_H
 1

	)

25 
	~<ã©u»s.h
>

26 #ià
defšed
 
__USE_UNIX98
 || defšed 
__USE_XOPEN2K8


28 
	~<b™s/ty³s.h
>

29 #iâdeà
__pid_t_defšed


30 
__pid_t
 
	tpid_t
;

31 
	#__pid_t_defšed


	)

35 
	g__BEGIN_DECLS


39 
	~<b™s/‹rmios.h
>

41 #ifdeà
__USE_MISC


44 
	#CCEQ
(
v®
, 
c
è((cè=ð(v®è&& (v®è!ð
_POSIX_VDISABLE
)

	)

48 
¥“d_t
 
	$cfg‘o¥“d
 (cÚ¡ 
‹rmios
 *
__‹rmios_p
è
__THROW
;

51 
¥“d_t
 
	$cfg‘i¥“d
 (cÚ¡ 
‹rmios
 *
__‹rmios_p
è
__THROW
;

54 
	$cf£to¥“d
 (
‹rmios
 *
__‹rmios_p
, 
¥“d_t
 
__¥“d
è
__THROW
;

57 
	$cf£ti¥“d
 (
‹rmios
 *
__‹rmios_p
, 
¥“d_t
 
__¥“d
è
__THROW
;

59 #ifdef 
__USE_MISC


61 
	$cf£t¥“d
 (
‹rmios
 *
__‹rmios_p
, 
¥“d_t
 
__¥“d
è
__THROW
;

66 
	$tcg‘©Œ
 (
__fd
, 
‹rmios
 *
__‹rmios_p
è
__THROW
;

70 
	$tc£‰r
 (
__fd
, 
__ÝtiÚ®_aùiÚs
,

71 cÚ¡ 
‹rmios
 *
__‹rmios_p
è
__THROW
;

74 #ifdef 
__USE_MISC


76 
	$cfmak”aw
 (
‹rmios
 *
__‹rmios_p
è
__THROW
;

80 
	$tc£ndb»ak
 (
__fd
, 
__du¿tiÚ
è
__THROW
;

86 
	`tcd¿š
 (
__fd
);

90 
	$tcæush
 (
__fd
, 
__queue_£ËùÜ
è
__THROW
;

94 
	$tcæow
 (
__fd
, 
__aùiÚ
è
__THROW
;

97 #ià
defšed
 
__USE_UNIX98
 || defšed 
__USE_XOPEN2K8


99 
__pid_t
 
	$tcg‘sid
 (
__fd
è
__THROW
;

103 #ifdeà
__USE_MISC


104 
	~<sys/‰ydeçuÉs.h
>

107 
__END_DECLS


	@/usr/include/time.h

22 #iâdef 
_TIME_H


24 #ià(! 
defšed
 
__Ãed_time_t
 && !defšed 
__Ãed_þock_t
 && \

25 ! 
defšed
 
	g__Ãed_time¥ec
)

26 
	#_TIME_H
 1

	)

27 
	~<ã©u»s.h
>

29 
	g__BEGIN_DECLS


33 #ifdef 
_TIME_H


35 
	#__Ãed_size_t


	)

36 
	#__Ãed_NULL


	)

37 
	~<¡ddef.h
>

41 
	~<b™s/time.h
>

44 #ià!
defšed
 
__STRICT_ANSI__
 && !defšed 
__USE_XOPEN2K


45 #iâdeà
CLK_TCK


46 
	#CLK_TCK
 
CLOCKS_PER_SEC


	)

52 #ià!
defšed
 
__þock_t_defšed
 && (defšed 
_TIME_H
 || defšed 
__Ãed_þock_t
)

53 
	#__þock_t_defšed
 1

	)

55 
	~<b™s/ty³s.h
>

57 
__BEGIN_NAMESPACE_STD


59 
__þock_t
 
	tþock_t
;

60 
	g__END_NAMESPACE_STD


61 #ià
defšed
 
__USE_XOPEN
 || defšed 
__USE_POSIX


62 
	$__USING_NAMESPACE_STD
(
þock_t
)

66 #undeà
__Ãed_þock_t


68 #ià!
defšed
 
__time_t_defšed
 && (defšed 
_TIME_H
 || defšed 
__Ãed_time_t
)

69 
	#__time_t_defšed
 1

	)

71 
	~<b™s/ty³s.h
>

73 
__BEGIN_NAMESPACE_STD


75 
__time_t
 
	ttime_t
;

76 
__END_NAMESPACE_STD


77 #ifdeà
__USE_POSIX


78 
	$__USING_NAMESPACE_STD
(
time_t
)

82 #undeà
__Ãed_time_t


84 #ià!
defšed
 
__þockid_t_defšed
 && \

85 ((
defšed
 
_TIME_H
 && defšed 
__USE_POSIX199309
è|| defšed 
__Ãed_þockid_t
)

86 
	#__þockid_t_defšed
 1

	)

88 
	~<b™s/ty³s.h
>

91 
__þockid_t
 
	tþockid_t
;

94 #undeà
__þockid_time_t


96 #ià!
defšed
 
__tim”_t_defšed
 && \

97 ((
defšed
 
_TIME_H
 && defšed 
__USE_POSIX199309
è|| defšed 
__Ãed_tim”_t
)

98 
	#__tim”_t_defšed
 1

	)

100 
	~<b™s/ty³s.h
>

103 
__tim”_t
 
	ttim”_t
;

106 #undeà
__Ãed_tim”_t


109 #ià(!
defšed
 
__time¥ec_defšed
 \

110 && ((
defšed
 
_TIME_H
 \

111 && (
defšed
 
__USE_POSIX199309
 \

112 || 
defšed
 
__USE_ISOC11
)) \

113 || 
defšed
 
__Ãed_time¥ec
))

114 
	#__time¥ec_defšed
 1

	)

116 
	~<b™s/ty³s.h
>

120 
	stime¥ec


122 
__time_t
 
tv_£c
;

123 
__sysÿÎ_¦Úg_t
 
tv_n£c
;

127 #undeà
__Ãed_time¥ec


130 #ifdef 
_TIME_H


131 
__BEGIN_NAMESPACE_STD


133 
	stm


135 
tm_£c
;

136 
tm_mš
;

137 
tm_hour
;

138 
tm_mday
;

139 
tm_mÚ
;

140 
tm_y—r
;

141 
tm_wday
;

142 
tm_yday
;

143 
tm_isd¡
;

145 #ifdef 
__USE_MISC


146 
tm_gmtoff
;

147 cÚ¡ *
tm_zÚe
;

149 
__tm_gmtoff
;

150 cÚ¡ *
__tm_zÚe
;

153 
__END_NAMESPACE_STD


154 #ià
defšed
 
__USE_XOPEN
 || defšed 
__USE_POSIX


155 
	$__USING_NAMESPACE_STD
(
tm
)

159 #ifdeà
__USE_POSIX199309


161 
	s™im”¥ec


163 
time¥ec
 
™_š‹rv®
;

164 
time¥ec
 
™_v®ue
;

168 
sigev’t
;

172 #ifdeà
__USE_XOPEN2K


173 #iâdeà
__pid_t_defšed


174 
__pid_t
 
	tpid_t
;

175 
	#__pid_t_defšed


	)

180 #ifdeà
__USE_ISOC11


182 
	#TIME_UTC
 1

	)

186 
__BEGIN_NAMESPACE_STD


189 
þock_t
 
	$þock
 (è
__THROW
;

192 
time_t
 
	$time
 (
time_t
 *
__tim”
è
__THROW
;

195 
	$difáime
 (
time_t
 
__time1
,ime_ˆ
__time0
)

196 
__THROW
 
	`__©Œibu‹__
 ((
__cÚ¡__
));

199 
time_t
 
	$mktime
 (
tm
 *
__
è
__THROW
;

205 
size_t
 
	$¡ráime
 (*
__»¡riù
 
__s
, 
size_t
 
__maxsize
,

206 cÚ¡ *
__»¡riù
 
__fÜm©
,

207 cÚ¡ 
tm
 *
__»¡riù
 
__
è
__THROW
;

208 
__END_NAMESPACE_STD


210 #ifdeà
__USE_XOPEN


213 *
	$¡½time
 (cÚ¡ *
__»¡riù
 
__s
,

214 cÚ¡ *
__»¡riù
 
__fmt
, 
tm
 *
__
)

215 
__THROW
;

218 #ifdeà
__USE_XOPEN2K8


221 
	~<xloÿË.h
>

223 
size_t
 
	$¡ráime_l
 (*
__»¡riù
 
__s
, 
size_t
 
__maxsize
,

224 cÚ¡ *
__»¡riù
 
__fÜm©
,

225 cÚ¡ 
tm
 *
__»¡riù
 
__
,

226 
__loÿË_t
 
__loc
è
__THROW
;

229 #ifdeà
__USE_GNU


230 *
	$¡½time_l
 (cÚ¡ *
__»¡riù
 
__s
,

231 cÚ¡ *
__»¡riù
 
__fmt
, 
tm
 *
__
,

232 
__loÿË_t
 
__loc
è
__THROW
;

236 
__BEGIN_NAMESPACE_STD


239 
tm
 *
	$gmtime
 (cÚ¡ 
time_t
 *
__tim”
è
__THROW
;

243 
tm
 *
	$loÿÉime
 (cÚ¡ 
time_t
 *
__tim”
è
__THROW
;

244 
__END_NAMESPACE_STD


246 #ifdeà
__USE_POSIX


249 
tm
 *
	$gmtime_r
 (cÚ¡ 
time_t
 *
__»¡riù
 
__tim”
,

250 
tm
 *
__»¡riù
 
__
è
__THROW
;

254 
tm
 *
	$loÿÉime_r
 (cÚ¡ 
time_t
 *
__»¡riù
 
__tim”
,

255 
tm
 *
__»¡riù
 
__
è
__THROW
;

258 
__BEGIN_NAMESPACE_STD


261 *
	$asùime
 (cÚ¡ 
tm
 *
__
è
__THROW
;

264 *
	$ùime
 (cÚ¡ 
time_t
 *
__tim”
è
__THROW
;

265 
__END_NAMESPACE_STD


267 #ifdeà
__USE_POSIX


272 *
	$asùime_r
 (cÚ¡ 
tm
 *
__»¡riù
 
__
,

273 *
__»¡riù
 
__buf
è
__THROW
;

276 *
	$ùime_r
 (cÚ¡ 
time_t
 *
__»¡riù
 
__tim”
,

277 *
__»¡riù
 
__buf
è
__THROW
;

282 *
__tzÇme
[2];

283 
__daylight
;

284 
__timezÚe
;

287 #ifdef 
__USE_POSIX


289 *
tzÇme
[2];

293 
	$tz£t
 (è
__THROW
;

296 #ià
defšed
 
__USE_MISC
 || defšed 
__USE_XOPEN


297 
daylight
;

298 
timezÚe
;

301 #ifdeà
__USE_MISC


304 
	$¡ime
 (cÚ¡ 
time_t
 *
__wh’
è
__THROW
;

310 
	#__i¦—p
(
y—r
) \

311 ((
y—r
è% 4 =ð0 && ((y—rè% 100 !ð0 || (y—rè% 400 =ð0))

	)

314 #ifdeà
__USE_MISC


319 
time_t
 
	$timegm
 (
tm
 *
__
è
__THROW
;

322 
time_t
 
	$tim–oÿl
 (
tm
 *
__
è
__THROW
;

325 
	$dysize
 (
__y—r
è
__THROW
 
	`__©Œibu‹__
 ((
__cÚ¡__
));

329 #ifdeà
__USE_POSIX199309


334 
	`Çno¦“p
 (cÚ¡ 
time¥ec
 *
__»que¡ed_time
,

335 
time¥ec
 *
__»maššg
);

339 
	$þock_g‘»s
 (
þockid_t
 
__þock_id
, 
time¥ec
 *
__»s
è
__THROW
;

342 
	$þock_g‘time
 (
þockid_t
 
__þock_id
, 
time¥ec
 *
__
è
__THROW
;

345 
	$þock_£‰ime
 (
þockid_t
 
__þock_id
, cÚ¡ 
time¥ec
 *
__
)

346 
__THROW
;

348 #ifdeà
__USE_XOPEN2K


353 
	`þock_Çno¦“p
 (
þockid_t
 
__þock_id
, 
__æags
,

354 cÚ¡ 
time¥ec
 *
__»q
,

355 
time¥ec
 *
__»m
);

358 
	$þock_g‘ýuþockid
 (
pid_t
 
__pid
, 
þockid_t
 *
__þock_id
è
__THROW
;

363 
	$tim”_ü—‹
 (
þockid_t
 
__þock_id
,

364 
sigev’t
 *
__»¡riù
 
__evp
,

365 
tim”_t
 *
__»¡riù
 
__tim”id
è
__THROW
;

368 
	$tim”_d–‘e
 (
tim”_t
 
__tim”id
è
__THROW
;

371 
	$tim”_£‰ime
 (
tim”_t
 
__tim”id
, 
__æags
,

372 cÚ¡ 
™im”¥ec
 *
__»¡riù
 
__v®ue
,

373 
™im”¥ec
 *
__»¡riù
 
__ov®ue
è
__THROW
;

376 
	$tim”_g‘time
 (
tim”_t
 
__tim”id
, 
™im”¥ec
 *
__v®ue
)

377 
__THROW
;

380 
	$tim”_g‘ov”run
 (
tim”_t
 
__tim”id
è
__THROW
;

384 #ifdeà
__USE_ISOC11


386 
	$time¥ec_g‘
 (
time¥ec
 *
__ts
, 
__ba£
)

387 
__THROW
 
	`__nÚnuÎ
 ((1));

391 #ifdeà
__USE_XOPEN_EXTENDED


403 
g‘d©e_”r
;

412 
tm
 *
	`g‘d©e
 (cÚ¡ *
__¡ršg
);

415 #ifdeà
__USE_GNU


426 
	`g‘d©e_r
 (cÚ¡ *
__»¡riù
 
__¡ršg
,

427 
tm
 *
__»¡riù
 
__»sbuå
);

430 
__END_DECLS


	@/usr/include/unistd.h

22 #iâdef 
_UNISTD_H


23 
	#_UNISTD_H
 1

	)

25 
	~<ã©u»s.h
>

27 
	g__BEGIN_DECLS


32 #ifdeà
__USE_XOPEN2K8


34 
	#_POSIX_VERSION
 200809L

	)

35 #–ià
defšed
 
__USE_XOPEN2K


37 
	#_POSIX_VERSION
 200112L

	)

38 #–ià
defšed
 
__USE_POSIX199506


40 
	#_POSIX_VERSION
 199506L

	)

41 #–ià
defšed
 
__USE_POSIX199309


43 
	#_POSIX_VERSION
 199309L

	)

46 
	#_POSIX_VERSION
 199009L

	)

52 #ifdeà
__USE_XOPEN2K8


53 
	#__POSIX2_THIS_VERSION
 200809L

	)

55 #–ià
defšed
 
__USE_XOPEN2K


57 
	#__POSIX2_THIS_VERSION
 200112L

	)

58 #–ià
defšed
 
__USE_POSIX199506


60 
	#__POSIX2_THIS_VERSION
 199506L

	)

63 
	#__POSIX2_THIS_VERSION
 199209L

	)

67 
	#_POSIX2_VERSION
 
__POSIX2_THIS_VERSION


	)

70 
	#_POSIX2_C_VERSION
 
__POSIX2_THIS_VERSION


	)

74 
	#_POSIX2_C_BIND
 
__POSIX2_THIS_VERSION


	)

78 
	#_POSIX2_C_DEV
 
__POSIX2_THIS_VERSION


	)

82 
	#_POSIX2_SW_DEV
 
__POSIX2_THIS_VERSION


	)

86 
	#_POSIX2_LOCALEDEF
 
__POSIX2_THIS_VERSION


	)

89 #ifdeà
__USE_XOPEN2K8


90 
	#_XOPEN_VERSION
 700

	)

91 #–ià
defšed
 
__USE_XOPEN2K


92 
	#_XOPEN_VERSION
 600

	)

93 #–ià
defšed
 
__USE_UNIX98


94 
	#_XOPEN_VERSION
 500

	)

96 
	#_XOPEN_VERSION
 4

	)

100 
	#_XOPEN_XCU_VERSION
 4

	)

103 
	#_XOPEN_XPG2
 1

	)

104 
	#_XOPEN_XPG3
 1

	)

105 
	#_XOPEN_XPG4
 1

	)

108 
	#_XOPEN_UNIX
 1

	)

111 
	#_XOPEN_CRYPT
 1

	)

115 
	#_XOPEN_ENH_I18N
 1

	)

118 
	#_XOPEN_LEGACY
 1

	)

205 
	~<b™s/posix_Ýt.h
>

208 #ià
defšed
 
__USE_UNIX98
 || defšed 
__USE_XOPEN2K


209 
	~<b™s/’vœÚm’ts.h
>

213 
	#STDIN_FILENO
 0

	)

214 
	#STDOUT_FILENO
 1

	)

215 
	#STDERR_FILENO
 2

	)

220 
	~<b™s/ty³s.h
>

222 #iâdef 
__ssize_t_defšed


223 
__ssize_t
 
	tssize_t
;

224 
	#__ssize_t_defšed


	)

227 
	#__Ãed_size_t


	)

228 
	#__Ãed_NULL


	)

229 
	~<¡ddef.h
>

231 #ià
defšed
 
__USE_XOPEN
 || defšed 
__USE_XOPEN2K


234 #iâdeà
__gid_t_defšed


235 
__gid_t
 
	tgid_t
;

236 
	#__gid_t_defšed


	)

239 #iâdeà
__uid_t_defšed


240 
__uid_t
 
	tuid_t
;

241 
	#__uid_t_defšed


	)

244 #iâdeà
__off_t_defšed


245 #iâdeà
__USE_FILE_OFFSET64


246 
__off_t
 
	toff_t
;

248 
__off64_t
 
	toff_t
;

250 
	#__off_t_defšed


	)

252 #ià
defšed
 
__USE_LARGEFILE64
 && !defšed 
__off64_t_defšed


253 
__off64_t
 
	toff64_t
;

254 
	#__off64_t_defšed


	)

257 #iâdeà
__u£cÚds_t_defšed


258 
__u£cÚds_t
 
	tu£cÚds_t
;

259 
	#__u£cÚds_t_defšed


	)

262 #iâdeà
__pid_t_defšed


263 
__pid_t
 
	tpid_t
;

264 
	#__pid_t_defšed


	)

268 #ià
defšed
 
__USE_XOPEN_EXTENDED
 || defšed 
__USE_XOPEN2K


269 #iâdeà
__šŒ_t_defšed


270 
__šŒ_t
 
	tšŒ_t
;

271 
	#__šŒ_t_defšed


	)

275 #ià
defšed
 
__USE_MISC
 || defšed 
__USE_XOPEN


276 #iâdeà
__sockËn_t_defšed


277 
__sockËn_t
 
	tsockËn_t
;

278 
	#__sockËn_t_defšed


	)

284 
	#R_OK
 4

	)

285 
	#W_OK
 2

	)

286 
	#X_OK
 1

	)

287 
	#F_OK
 0

	)

290 
	$acûss
 (cÚ¡ *
__Çme
, 
__ty³
è
__THROW
 
	`__nÚnuÎ
 ((1));

292 #ifdeà
__USE_GNU


295 
	$euidacûss
 (cÚ¡ *
__Çme
, 
__ty³
)

296 
__THROW
 
	`__nÚnuÎ
 ((1));

299 
	$—cûss
 (cÚ¡ *
__Çme
, 
__ty³
)

300 
__THROW
 
	`__nÚnuÎ
 ((1));

303 #ifdeà
__USE_ATFILE


307 
	$çcûs§t
 (
__fd
, cÚ¡ *
__fže
, 
__ty³
, 
__æag
)

308 
__THROW
 
	`__nÚnuÎ
 ((2)è
__wur
;

313 #iâdef 
_STDIO_H


314 
	#SEEK_SET
 0

	)

315 
	#SEEK_CUR
 1

	)

316 
	#SEEK_END
 2

	)

317 #ifdeà
__USE_GNU


318 
	#SEEK_DATA
 3

	)

319 
	#SEEK_HOLE
 4

	)

323 #ià
defšed
 
__USE_MISC
 && !defšed 
L_SET


325 
	#L_SET
 
SEEK_SET


	)

326 
	#L_INCR
 
SEEK_CUR


	)

327 
	#L_XTND
 
SEEK_END


	)

336 #iâdeà
__USE_FILE_OFFSET64


337 
__off_t
 
	$l£ek
 (
__fd
, 
__off_t
 
__off£t
, 
__wh’û
è
__THROW
;

339 #ifdeà
__REDIRECT_NTH


340 
__off64_t
 
	`__REDIRECT_NTH
 (
l£ek
,

341 (
__fd
, 
__off64_t
 
__off£t
, 
__wh’û
),

342 
l£ek64
);

344 
	#l£ek
 
l£ek64


	)

347 #ifdeà
__USE_LARGEFILE64


348 
__off64_t
 
	$l£ek64
 (
__fd
, 
__off64_t
 
__off£t
, 
__wh’û
)

349 
__THROW
;

356 
	`þo£
 (
__fd
);

363 
ssize_t
 
	$»ad
 (
__fd
, *
__buf
, 
size_t
 
__nby‹s
è
__wur
;

369 
ssize_t
 
	$wr™e
 (
__fd
, cÚ¡ *
__buf
, 
size_t
 
__n
è
__wur
;

371 #ià
defšed
 
__USE_UNIX98
 || defšed 
__USE_XOPEN2K8


372 #iâdeà
__USE_FILE_OFFSET64


379 
ssize_t
 
	$´—d
 (
__fd
, *
__buf
, 
size_t
 
__nby‹s
,

380 
__off_t
 
__off£t
è
__wur
;

387 
ssize_t
 
	$pwr™e
 (
__fd
, cÚ¡ *
__buf
, 
size_t
 
__n
,

388 
__off_t
 
__off£t
è
__wur
;

390 #ifdeà
__REDIRECT


391 
ssize_t
 
	`__REDIRECT
 (
´—d
, (
__fd
, *
__buf
, 
size_t
 
__nby‹s
,

392 
__off64_t
 
__off£t
),

393 
´—d64
è
__wur
;

394 
ssize_t
 
	`__REDIRECT
 (
pwr™e
, (
__fd
, cÚ¡ *
__buf
,

395 
size_t
 
__nby‹s
, 
__off64_t
 
__off£t
),

396 
pwr™e64
è
__wur
;

398 
	#´—d
 
´—d64


	)

399 
	#pwr™e
 
pwr™e64


	)

403 #ifdeà
__USE_LARGEFILE64


407 
ssize_t
 
	$´—d64
 (
__fd
, *
__buf
, 
size_t
 
__nby‹s
,

408 
__off64_t
 
__off£t
è
__wur
;

411 
ssize_t
 
	$pwr™e64
 (
__fd
, cÚ¡ *
__buf
, 
size_t
 
__n
,

412 
__off64_t
 
__off£t
è
__wur
;

420 
	$pe
 (
__pedes
[2]è
__THROW
 
__wur
;

422 #ifdeà
__USE_GNU


425 
	$pe2
 (
__pedes
[2], 
__æags
è
__THROW
 
__wur
;

435 
	$®¬m
 (
__£cÚds
è
__THROW
;

447 
	`¦“p
 (
__£cÚds
);

449 #ià(
defšed
 
__USE_XOPEN_EXTENDED
 && !defšed 
__USE_XOPEN2K8
) \

450 || 
defšed
 
__USE_MISC


455 
__u£cÚds_t
 
	$u®¬m
 (
__u£cÚds_t
 
__v®ue
, __u£cÚds_ˆ
__š‹rv®
)

456 
__THROW
;

463 
	`u¦“p
 (
__u£cÚds_t
 
__u£cÚds
);

472 
	`·u£
 ();

476 
	$chown
 (cÚ¡ *
__fže
, 
__uid_t
 
__owÃr
, 
__gid_t
 
__group
)

477 
__THROW
 
	`__nÚnuÎ
 ((1)è
__wur
;

479 #ià
defšed
 
__USE_XOPEN_EXTENDED
 || defšed 
__USE_XOPEN2K8


481 
	$fchown
 (
__fd
, 
__uid_t
 
__owÃr
, 
__gid_t
 
__group
è
__THROW
 
__wur
;

486 
	$lchown
 (cÚ¡ *
__fže
, 
__uid_t
 
__owÃr
, 
__gid_t
 
__group
)

487 
__THROW
 
	`__nÚnuÎ
 ((1)è
__wur
;

491 #ifdeà
__USE_ATFILE


494 
	$fchowÇt
 (
__fd
, cÚ¡ *
__fže
, 
__uid_t
 
__owÃr
,

495 
__gid_t
 
__group
, 
__æag
)

496 
__THROW
 
	`__nÚnuÎ
 ((2)è
__wur
;

500 
	$chdœ
 (cÚ¡ *
__·th
è
__THROW
 
	`__nÚnuÎ
 ((1)è
__wur
;

502 #ià
defšed
 
__USE_XOPEN_EXTENDED
 || defšed 
__USE_XOPEN2K8


504 
	$fchdœ
 (
__fd
è
__THROW
 
__wur
;

514 *
	$g‘cwd
 (*
__buf
, 
size_t
 
__size
è
__THROW
 
__wur
;

516 #ifdef 
__USE_GNU


520 *
	$g‘_cu¼’t_dœ_Çme
 (è
__THROW
;

523 #ià(
defšed
 
__USE_XOPEN_EXTENDED
 && !defšed 
__USE_XOPEN2K8
) \

524 || 
defšed
 
__USE_MISC


528 *
	$g‘wd
 (*
__buf
)

529 
__THROW
 
	`__nÚnuÎ
 ((1)è
__©Œibu‹_d•»ÿ‹d__
 
__wur
;

534 
	$dup
 (
__fd
è
__THROW
 
__wur
;

537 
	$dup2
 (
__fd
, 
__fd2
è
__THROW
;

539 #ifdeà
__USE_GNU


542 
	$dup3
 (
__fd
, 
__fd2
, 
__æags
è
__THROW
;

546 **
__’vœÚ
;

547 #ifdeà
__USE_GNU


548 **
’vœÚ
;

554 
	$execve
 (cÚ¡ *
__·th
, *cÚ¡ 
__¬gv
[],

555 *cÚ¡ 
__’vp
[]è
__THROW
 
	`__nÚnuÎ
 ((1, 2));

557 #ifdeà
__USE_XOPEN2K8


560 
	$ãxecve
 (
__fd
, *cÚ¡ 
__¬gv
[], *cÚ¡ 
__’vp
[])

561 
__THROW
 
	`__nÚnuÎ
 ((2));

566 
	$execv
 (cÚ¡ *
__·th
, *cÚ¡ 
__¬gv
[])

567 
__THROW
 
	`__nÚnuÎ
 ((1, 2));

571 
	$exeþe
 (cÚ¡ *
__·th
, cÚ¡ *
__¬g
, ...)

572 
__THROW
 
	`__nÚnuÎ
 ((1, 2));

576 
	$exeþ
 (cÚ¡ *
__·th
, cÚ¡ *
__¬g
, ...)

577 
__THROW
 
	`__nÚnuÎ
 ((1, 2));

581 
	$execvp
 (cÚ¡ *
__fže
, *cÚ¡ 
__¬gv
[])

582 
__THROW
 
	`__nÚnuÎ
 ((1, 2));

587 
	$exeþp
 (cÚ¡ *
__fže
, cÚ¡ *
__¬g
, ...)

588 
__THROW
 
	`__nÚnuÎ
 ((1, 2));

590 #ifdeà
__USE_GNU


593 
	$execv³
 (cÚ¡ *
__fže
, *cÚ¡ 
__¬gv
[],

594 *cÚ¡ 
__’vp
[])

595 
__THROW
 
	`__nÚnuÎ
 ((1, 2));

599 #ià
defšed
 
__USE_MISC
 || defšed 
__USE_XOPEN


601 
	$niû
 (
__šc
è
__THROW
 
__wur
;

606 
	$_ex™
 (
__¡©us
è
	`__©Œibu‹__
 ((
__nÜ‘uº__
));

612 
	~<b™s/cÚâame.h
>

615 
	$·thcÚf
 (cÚ¡ *
__·th
, 
__Çme
)

616 
__THROW
 
	`__nÚnuÎ
 ((1));

619 
	$å©hcÚf
 (
__fd
, 
__Çme
è
__THROW
;

622 
	$syscÚf
 (
__Çme
è
__THROW
;

624 #ifdef 
__USE_POSIX2


626 
size_t
 
	$cÚf¡r
 (
__Çme
, *
__buf
, 
size_t
 
__Ën
è
__THROW
;

631 
__pid_t
 
	$g‘pid
 (è
__THROW
;

634 
__pid_t
 
	$g‘µid
 (è
__THROW
;

637 
__pid_t
 
	$g‘pg½
 (è
__THROW
;

640 
__pid_t
 
	$__g‘pgid
 (
__pid_t
 
__pid
è
__THROW
;

641 #ià
defšed
 
__USE_XOPEN_EXTENDED
 || defšed 
__USE_XOPEN2K8


642 
__pid_t
 
	$g‘pgid
 (
__pid_t
 
__pid
è
__THROW
;

649 
	$£gid
 (
__pid_t
 
__pid
, __pid_ˆ
__pgid
è
__THROW
;

651 #ià
defšed
 
__USE_MISC
 || defšed 
__USE_XOPEN_EXTENDED


663 
	$£g½
 (è
__THROW
;

670 
__pid_t
 
	$£tsid
 (è
__THROW
;

672 #ià
defšed
 
__USE_XOPEN_EXTENDED
 || defšed 
__USE_XOPEN2K8


674 
__pid_t
 
	$g‘sid
 (
__pid_t
 
__pid
è
__THROW
;

678 
__uid_t
 
	$g‘uid
 (è
__THROW
;

681 
__uid_t
 
	$g‘euid
 (è
__THROW
;

684 
__gid_t
 
	$g‘gid
 (è
__THROW
;

687 
__gid_t
 
	$g‘egid
 (è
__THROW
;

692 
	$g‘groups
 (
__size
, 
__gid_t
 
__li¡
[]è
__THROW
 
__wur
;

694 #ifdef 
__USE_GNU


696 
	$group_memb”
 (
__gid_t
 
__gid
è
__THROW
;

703 
	$£tuid
 (
__uid_t
 
__uid
è
__THROW
 
__wur
;

705 #ià
defšed
 
__USE_MISC
 || defšed 
__USE_XOPEN_EXTENDED


708 
	$£Œeuid
 (
__uid_t
 
__ruid
, __uid_ˆ
__euid
è
__THROW
 
__wur
;

711 #ifdeà
__USE_XOPEN2K


713 
	$£‹uid
 (
__uid_t
 
__uid
è
__THROW
 
__wur
;

720 
	$£tgid
 (
__gid_t
 
__gid
è
__THROW
 
__wur
;

722 #ià
defšed
 
__USE_MISC
 || defšed 
__USE_XOPEN_EXTENDED


725 
	$£Œegid
 (
__gid_t
 
__rgid
, __gid_ˆ
__egid
è
__THROW
 
__wur
;

728 #ifdeà
__USE_XOPEN2K


730 
	$£‹gid
 (
__gid_t
 
__gid
è
__THROW
 
__wur
;

733 #ifdeà
__USE_GNU


736 
	$g‘»suid
 (
__uid_t
 *
__ruid
, __uid_ˆ*
__euid
, __uid_ˆ*
__suid
)

737 
__THROW
;

741 
	$g‘»sgid
 (
__gid_t
 *
__rgid
, __gid_ˆ*
__egid
, __gid_ˆ*
__sgid
)

742 
__THROW
;

746 
	$£Œesuid
 (
__uid_t
 
__ruid
, __uid_ˆ
__euid
, __uid_ˆ
__suid
)

747 
__THROW
 
__wur
;

751 
	$£Œesgid
 (
__gid_t
 
__rgid
, __gid_ˆ
__egid
, __gid_ˆ
__sgid
)

752 
__THROW
 
__wur
;

759 
__pid_t
 
	$fÜk
 (è
__THROWNL
;

761 #ià(
defšed
 
__USE_XOPEN_EXTENDED
 && !defšed 
__USE_XOPEN2K8
) \

762 || 
defšed
 
__USE_MISC


767 
__pid_t
 
	$vfÜk
 (è
__THROW
;

773 *
	$‰yÇme
 (
__fd
è
__THROW
;

777 
	$‰yÇme_r
 (
__fd
, *
__buf
, 
size_t
 
__buæ’
)

778 
__THROW
 
	`__nÚnuÎ
 ((2)è
__wur
;

782 
	$i§‰y
 (
__fd
è
__THROW
;

784 #ià
defšed
 
__USE_MISC
 \

785 || (
defšed
 
__USE_XOPEN_EXTENDED
 && !defšed 
__USE_UNIX98
)

788 
	$‰y¦Ù
 (è
__THROW
;

793 
	$lšk
 (cÚ¡ *
__äom
, cÚ¡ *
__to
)

794 
__THROW
 
	`__nÚnuÎ
 ((1, 2)è
__wur
;

796 #ifdeà
__USE_ATFILE


799 
	$lšk©
 (
__äomfd
, cÚ¡ *
__äom
, 
__tofd
,

800 cÚ¡ *
__to
, 
__æags
)

801 
__THROW
 
	`__nÚnuÎ
 ((2, 4)è
__wur
;

804 #ià
defšed
 
__USE_XOPEN_EXTENDED
 || defšed 
__USE_XOPEN2K


806 
	$symlšk
 (cÚ¡ *
__äom
, cÚ¡ *
__to
)

807 
__THROW
 
	`__nÚnuÎ
 ((1, 2)è
__wur
;

812 
ssize_t
 
	$»adlšk
 (cÚ¡ *
__»¡riù
 
__·th
,

813 *
__»¡riù
 
__buf
, 
size_t
 
__Ën
)

814 
__THROW
 
	`__nÚnuÎ
 ((1, 2)è
__wur
;

817 #ifdeà
__USE_ATFILE


819 
	$symlšk©
 (cÚ¡ *
__äom
, 
__tofd
,

820 cÚ¡ *
__to
è
__THROW
 
	`__nÚnuÎ
 ((1, 3)è
__wur
;

823 
ssize_t
 
	$»adlšk©
 (
__fd
, cÚ¡ *
__»¡riù
 
__·th
,

824 *
__»¡riù
 
__buf
, 
size_t
 
__Ën
)

825 
__THROW
 
	`__nÚnuÎ
 ((2, 3)è
__wur
;

829 
	$uÆšk
 (cÚ¡ *
__Çme
è
__THROW
 
	`__nÚnuÎ
 ((1));

831 #ifdeà
__USE_ATFILE


833 
	$uÆšk©
 (
__fd
, cÚ¡ *
__Çme
, 
__æag
)

834 
__THROW
 
	`__nÚnuÎ
 ((2));

838 
	$rmdœ
 (cÚ¡ *
__·th
è
__THROW
 
	`__nÚnuÎ
 ((1));

842 
__pid_t
 
	$tcg‘pg½
 (
__fd
è
__THROW
;

845 
	$tc£g½
 (
__fd
, 
__pid_t
 
__pg½_id
è
__THROW
;

852 *
	`g‘logš
 ();

853 #ià
defšed
 
__USE_REENTRANT
 || defšed 
__USE_POSIX199506


860 
	$g‘logš_r
 (*
__Çme
, 
size_t
 
__Çme_Ën
è
	`__nÚnuÎ
 ((1));

863 #ifdef 
__USE_MISC


865 
	$£Žogš
 (cÚ¡ *
__Çme
è
__THROW
 
	`__nÚnuÎ
 ((1));

869 #ifdef 
__USE_POSIX2


873 
	#__Ãed_g‘Ýt


	)

874 
	~<g‘Ýt.h
>

878 #ià
defšed
 
__USE_UNIX98
 || defšed 
__USE_XOPEN2K


882 
	$g‘ho¡Çme
 (*
__Çme
, 
size_t
 
__Ën
è
__THROW
 
	`__nÚnuÎ
 ((1));

886 #ià
defšed
 
__USE_MISC


889 
	$£tho¡Çme
 (cÚ¡ *
__Çme
, 
size_t
 
__Ën
)

890 
__THROW
 
	`__nÚnuÎ
 ((1)è
__wur
;

894 
	$£tho¡id
 (
__id
è
__THROW
 
__wur
;

900 
	$g‘domašÇme
 (*
__Çme
, 
size_t
 
__Ën
)

901 
__THROW
 
	`__nÚnuÎ
 ((1)è
__wur
;

902 
	$£tdomašÇme
 (cÚ¡ *
__Çme
, 
size_t
 
__Ën
)

903 
__THROW
 
	`__nÚnuÎ
 ((1)è
__wur
;

909 
	$vhªgup
 (è
__THROW
;

912 
	$»voke
 (cÚ¡ *
__fže
è
__THROW
 
	`__nÚnuÎ
 ((1)è
__wur
;

920 
	$´ofž
 (*
__§m¶e_bufãr
, 
size_t
 
__size
,

921 
size_t
 
__off£t
, 
__sÿË
)

922 
__THROW
 
	`__nÚnuÎ
 ((1));

928 
	$acù
 (cÚ¡ *
__Çme
è
__THROW
;

932 *
	$g‘u£rsh–l
 (è
__THROW
;

933 
	$’du£rsh–l
 (è
__THROW
;

934 
	$£tu£rsh–l
 (è
__THROW
;

940 
	$d«mÚ
 (
__nochdœ
, 
__noþo£
è
__THROW
 
__wur
;

944 #ià
defšed
 
__USE_MISC
 || (defšed 
__USE_XOPEN
 && !defšed 
__USE_XOPEN2K
)

947 
	$chroÙ
 (cÚ¡ *
__·th
è
__THROW
 
	`__nÚnuÎ
 ((1)è
__wur
;

951 *
	$g‘·ss
 (cÚ¡ *
__´om±
è
	`__nÚnuÎ
 ((1));

959 
	`fsync
 (
__fd
);

962 #ifdeà
__USE_GNU


965 
	$syncfs
 (
__fd
è
__THROW
;

969 #ià
defšed
 
__USE_MISC
 || defšed 
__USE_XOPEN_EXTENDED


972 
	`g‘ho¡id
 ();

975 
	$sync
 (è
__THROW
;

978 #ià
defšed
 
__USE_MISC
 || !defšed 
__USE_XOPEN2K


981 
	$g‘·gesize
 (è
__THROW
 
	`__©Œibu‹__
 ((
__cÚ¡__
));

986 
	$g‘dbËsize
 (è
__THROW
;

992 #ià
defšed
 
__USE_XOPEN_EXTENDED
 || defšed 
__USE_XOPEN2K8


995 #iâdeà
__USE_FILE_OFFSET64


996 
	$Œunÿ‹
 (cÚ¡ *
__fže
, 
__off_t
 
__Ëngth
)

997 
__THROW
 
	`__nÚnuÎ
 ((1)è
__wur
;

999 #ifdeà
__REDIRECT_NTH


1000 
	`__REDIRECT_NTH
 (
Œunÿ‹
,

1001 (cÚ¡ *
__fže
, 
__off64_t
 
__Ëngth
),

1002 
Œunÿ‹64
è
	`__nÚnuÎ
 ((1)è
__wur
;

1004 
	#Œunÿ‹
 
Œunÿ‹64


	)

1007 #ifdeà
__USE_LARGEFILE64


1008 
	$Œunÿ‹64
 (cÚ¡ *
__fže
, 
__off64_t
 
__Ëngth
)

1009 
__THROW
 
	`__nÚnuÎ
 ((1)è
__wur
;

1014 #ià
defšed
 
__USE_POSIX199309
 \

1015 || 
defšed
 
__USE_XOPEN_EXTENDED
 || defšed 
__USE_XOPEN2K


1018 #iâdeà
__USE_FILE_OFFSET64


1019 
	$árunÿ‹
 (
__fd
, 
__off_t
 
__Ëngth
è
__THROW
 
__wur
;

1021 #ifdeà
__REDIRECT_NTH


1022 
	`__REDIRECT_NTH
 (
árunÿ‹
, (
__fd
, 
__off64_t
 
__Ëngth
),

1023 
árunÿ‹64
è
__wur
;

1025 
	#árunÿ‹
 
árunÿ‹64


	)

1028 #ifdeà
__USE_LARGEFILE64


1029 
	$árunÿ‹64
 (
__fd
, 
__off64_t
 
__Ëngth
è
__THROW
 
__wur
;

1035 #ià(
defšed
 
__USE_XOPEN_EXTENDED
 && !defšed 
__USE_XOPEN2K
) \

1036 || 
defšed
 
__USE_MISC


1040 
	$brk
 (*
__addr
è
__THROW
 
__wur
;

1046 *
	$sbrk
 (
šŒ_t
 
__d–
è
__THROW
;

1050 #ifdeà
__USE_MISC


1061 
	$sysÿÎ
 (
__sy¢o
, ...è
__THROW
;

1066 #ià(
defšed
 
__USE_MISC
 || defšed 
__USE_XOPEN_EXTENDED
è&& !defšed 
F_LOCK


1078 
	#F_ULOCK
 0

	)

1079 
	#F_LOCK
 1

	)

1080 
	#F_TLOCK
 2

	)

1081 
	#F_TEST
 3

	)

1083 #iâdeà
__USE_FILE_OFFSET64


1084 
	$lockf
 (
__fd
, 
__cmd
, 
__off_t
 
__Ën
è
__wur
;

1086 #ifdeà
__REDIRECT


1087 
	`__REDIRECT
 (
lockf
, (
__fd
, 
__cmd
, 
__off64_t
 
__Ën
),

1088 
lockf64
è
__wur
;

1090 
	#lockf
 
lockf64


	)

1093 #ifdeà
__USE_LARGEFILE64


1094 
	$lockf64
 (
__fd
, 
__cmd
, 
__off64_t
 
__Ën
è
__wur
;

1099 #ifdeà
__USE_GNU


1104 
	#TEMP_FAILURE_RETRY
(
ex´essiÚ
) \

1105 (
__ex‹nsiÚ__
 \

1106 ({ 
__»suÉ
; \

1107 dØ
__»suÉ
 = (è(
ex´essiÚ
); \

1108 
__»suÉ
 =ð-1L && 
”ºo
 =ð
EINTR
); \

1109 
__»suÉ
; 
	}
}))

	)

1112 #ià
defšed
 
__USE_POSIX199309
 || defšed 
__USE_UNIX98


1115 
fd©async
 (
__fždes
);

1121 #ifdef 
__USE_XOPEN


1123 *
	$üy±
 (cÚ¡ *
__key
, cÚ¡ *
__§É
)

1124 
__THROW
 
	`__nÚnuÎ
 ((1, 2));

1128 
	$’üy±
 (*
__glibc_block
, 
__edæag
)

1129 
__THROW
 
	`__nÚnuÎ
 ((1));

1136 
	$swab
 (cÚ¡ *
__»¡riù
 
__äom
, *__»¡riù 
__to
,

1137 
ssize_t
 
__n
è
__THROW
 
	`__nÚnuÎ
 ((1, 2));

1143 #ià
defšed
 
__USE_XOPEN
 && !defšed 
__USE_XOPEN2K


1145 *
	$ù”mid
 (*
__s
è
__THROW
;

1150 #ià
__USE_FORTIFY_LEVEL
 > 0 && 
defšed
 
__fÜtify_funùiÚ


1151 
	~<b™s/uni¡d.h
>

1154 
__END_DECLS


	@/usr/include/utime.h

22 #iâdef 
_UTIME_H


23 
	#_UTIME_H
 1

	)

25 
	~<ã©u»s.h
>

27 
	g__BEGIN_DECLS


29 
	~<b™s/ty³s.h
>

31 #ià
defšed
 
__USE_XOPEN
 || defšed 
__USE_XOPEN2K


32 
	#__Ãed_time_t


	)

33 
	~<time.h
>

37 
	sutimbuf


39 
__time_t
 
	maùime
;

40 
__time_t
 
	mmodtime
;

45 
	$utime
 (cÚ¡ *
__fže
,

46 cÚ¡ 
utimbuf
 *
__fže_times
)

47 
__THROW
 
	`__nÚnuÎ
 ((1));

49 
__END_DECLS


	@/usr/include/alloca.h

18 #iâdef 
_ALLOCA_H


19 
	#_ALLOCA_H
 1

	)

21 
	~<ã©u»s.h
>

23 
	#__Ãed_size_t


	)

24 
	~<¡ddef.h
>

26 
	g__BEGIN_DECLS


29 #undeà
®loÿ


32 *
	$®loÿ
 (
size_t
 
__size
è
__THROW
;

34 #ifdef 
__GNUC__


35 
	#®loÿ
(
size
è
	`__bužtš_®loÿ
 (size)

	)

38 
__END_DECLS


	@/usr/include/bits/confname.h

19 #iâdeà
_UNISTD_H


26 
	m_PC_LINK_MAX
,

27 
	#_PC_LINK_MAX
 
_PC_LINK_MAX


	)

28 
	m_PC_MAX_CANON
,

29 
	#_PC_MAX_CANON
 
_PC_MAX_CANON


	)

30 
	m_PC_MAX_INPUT
,

31 
	#_PC_MAX_INPUT
 
_PC_MAX_INPUT


	)

32 
	m_PC_NAME_MAX
,

33 
	#_PC_NAME_MAX
 
_PC_NAME_MAX


	)

34 
	m_PC_PATH_MAX
,

35 
	#_PC_PATH_MAX
 
_PC_PATH_MAX


	)

36 
	m_PC_PIPE_BUF
,

37 
	#_PC_PIPE_BUF
 
_PC_PIPE_BUF


	)

38 
	m_PC_CHOWN_RESTRICTED
,

39 
	#_PC_CHOWN_RESTRICTED
 
_PC_CHOWN_RESTRICTED


	)

40 
	m_PC_NO_TRUNC
,

41 
	#_PC_NO_TRUNC
 
_PC_NO_TRUNC


	)

42 
	m_PC_VDISABLE
,

43 
	#_PC_VDISABLE
 
_PC_VDISABLE


	)

44 
	m_PC_SYNC_IO
,

45 
	#_PC_SYNC_IO
 
_PC_SYNC_IO


	)

46 
	m_PC_ASYNC_IO
,

47 
	#_PC_ASYNC_IO
 
_PC_ASYNC_IO


	)

48 
	m_PC_PRIO_IO
,

49 
	#_PC_PRIO_IO
 
_PC_PRIO_IO


	)

50 
	m_PC_SOCK_MAXBUF
,

51 
	#_PC_SOCK_MAXBUF
 
_PC_SOCK_MAXBUF


	)

52 
	m_PC_FILESIZEBITS
,

53 
	#_PC_FILESIZEBITS
 
_PC_FILESIZEBITS


	)

54 
	m_PC_REC_INCR_XFER_SIZE
,

55 
	#_PC_REC_INCR_XFER_SIZE
 
_PC_REC_INCR_XFER_SIZE


	)

56 
	m_PC_REC_MAX_XFER_SIZE
,

57 
	#_PC_REC_MAX_XFER_SIZE
 
_PC_REC_MAX_XFER_SIZE


	)

58 
	m_PC_REC_MIN_XFER_SIZE
,

59 
	#_PC_REC_MIN_XFER_SIZE
 
_PC_REC_MIN_XFER_SIZE


	)

60 
	m_PC_REC_XFER_ALIGN
,

61 
	#_PC_REC_XFER_ALIGN
 
_PC_REC_XFER_ALIGN


	)

62 
	m_PC_ALLOC_SIZE_MIN
,

63 
	#_PC_ALLOC_SIZE_MIN
 
_PC_ALLOC_SIZE_MIN


	)

64 
	m_PC_SYMLINK_MAX
,

65 
	#_PC_SYMLINK_MAX
 
_PC_SYMLINK_MAX


	)

66 
	m_PC_2_SYMLINKS


67 
	#_PC_2_SYMLINKS
 
_PC_2_SYMLINKS


	)

73 
	m_SC_ARG_MAX
,

74 
	#_SC_ARG_MAX
 
_SC_ARG_MAX


	)

75 
	m_SC_CHILD_MAX
,

76 
	#_SC_CHILD_MAX
 
_SC_CHILD_MAX


	)

77 
	m_SC_CLK_TCK
,

78 
	#_SC_CLK_TCK
 
_SC_CLK_TCK


	)

79 
	m_SC_NGROUPS_MAX
,

80 
	#_SC_NGROUPS_MAX
 
_SC_NGROUPS_MAX


	)

81 
	m_SC_OPEN_MAX
,

82 
	#_SC_OPEN_MAX
 
_SC_OPEN_MAX


	)

83 
	m_SC_STREAM_MAX
,

84 
	#_SC_STREAM_MAX
 
_SC_STREAM_MAX


	)

85 
	m_SC_TZNAME_MAX
,

86 
	#_SC_TZNAME_MAX
 
_SC_TZNAME_MAX


	)

87 
	m_SC_JOB_CONTROL
,

88 
	#_SC_JOB_CONTROL
 
_SC_JOB_CONTROL


	)

89 
	m_SC_SAVED_IDS
,

90 
	#_SC_SAVED_IDS
 
_SC_SAVED_IDS


	)

91 
	m_SC_REALTIME_SIGNALS
,

92 
	#_SC_REALTIME_SIGNALS
 
_SC_REALTIME_SIGNALS


	)

93 
	m_SC_PRIORITY_SCHEDULING
,

94 
	#_SC_PRIORITY_SCHEDULING
 
_SC_PRIORITY_SCHEDULING


	)

95 
	m_SC_TIMERS
,

96 
	#_SC_TIMERS
 
_SC_TIMERS


	)

97 
	m_SC_ASYNCHRONOUS_IO
,

98 
	#_SC_ASYNCHRONOUS_IO
 
_SC_ASYNCHRONOUS_IO


	)

99 
	m_SC_PRIORITIZED_IO
,

100 
	#_SC_PRIORITIZED_IO
 
_SC_PRIORITIZED_IO


	)

101 
	m_SC_SYNCHRONIZED_IO
,

102 
	#_SC_SYNCHRONIZED_IO
 
_SC_SYNCHRONIZED_IO


	)

103 
	m_SC_FSYNC
,

104 
	#_SC_FSYNC
 
_SC_FSYNC


	)

105 
	m_SC_MAPPED_FILES
,

106 
	#_SC_MAPPED_FILES
 
_SC_MAPPED_FILES


	)

107 
	m_SC_MEMLOCK
,

108 
	#_SC_MEMLOCK
 
_SC_MEMLOCK


	)

109 
	m_SC_MEMLOCK_RANGE
,

110 
	#_SC_MEMLOCK_RANGE
 
_SC_MEMLOCK_RANGE


	)

111 
	m_SC_MEMORY_PROTECTION
,

112 
	#_SC_MEMORY_PROTECTION
 
_SC_MEMORY_PROTECTION


	)

113 
	m_SC_MESSAGE_PASSING
,

114 
	#_SC_MESSAGE_PASSING
 
_SC_MESSAGE_PASSING


	)

115 
	m_SC_SEMAPHORES
,

116 
	#_SC_SEMAPHORES
 
_SC_SEMAPHORES


	)

117 
	m_SC_SHARED_MEMORY_OBJECTS
,

118 
	#_SC_SHARED_MEMORY_OBJECTS
 
_SC_SHARED_MEMORY_OBJECTS


	)

119 
	m_SC_AIO_LISTIO_MAX
,

120 
	#_SC_AIO_LISTIO_MAX
 
_SC_AIO_LISTIO_MAX


	)

121 
	m_SC_AIO_MAX
,

122 
	#_SC_AIO_MAX
 
_SC_AIO_MAX


	)

123 
	m_SC_AIO_PRIO_DELTA_MAX
,

124 
	#_SC_AIO_PRIO_DELTA_MAX
 
_SC_AIO_PRIO_DELTA_MAX


	)

125 
	m_SC_DELAYTIMER_MAX
,

126 
	#_SC_DELAYTIMER_MAX
 
_SC_DELAYTIMER_MAX


	)

127 
	m_SC_MQ_OPEN_MAX
,

128 
	#_SC_MQ_OPEN_MAX
 
_SC_MQ_OPEN_MAX


	)

129 
	m_SC_MQ_PRIO_MAX
,

130 
	#_SC_MQ_PRIO_MAX
 
_SC_MQ_PRIO_MAX


	)

131 
	m_SC_VERSION
,

132 
	#_SC_VERSION
 
_SC_VERSION


	)

133 
	m_SC_PAGESIZE
,

134 
	#_SC_PAGESIZE
 
_SC_PAGESIZE


	)

135 
	#_SC_PAGE_SIZE
 
_SC_PAGESIZE


	)

136 
	m_SC_RTSIG_MAX
,

137 
	#_SC_RTSIG_MAX
 
_SC_RTSIG_MAX


	)

138 
	m_SC_SEM_NSEMS_MAX
,

139 
	#_SC_SEM_NSEMS_MAX
 
_SC_SEM_NSEMS_MAX


	)

140 
	m_SC_SEM_VALUE_MAX
,

141 
	#_SC_SEM_VALUE_MAX
 
_SC_SEM_VALUE_MAX


	)

142 
	m_SC_SIGQUEUE_MAX
,

143 
	#_SC_SIGQUEUE_MAX
 
_SC_SIGQUEUE_MAX


	)

144 
	m_SC_TIMER_MAX
,

145 
	#_SC_TIMER_MAX
 
_SC_TIMER_MAX


	)

149 
	m_SC_BC_BASE_MAX
,

150 
	#_SC_BC_BASE_MAX
 
_SC_BC_BASE_MAX


	)

151 
	m_SC_BC_DIM_MAX
,

152 
	#_SC_BC_DIM_MAX
 
_SC_BC_DIM_MAX


	)

153 
	m_SC_BC_SCALE_MAX
,

154 
	#_SC_BC_SCALE_MAX
 
_SC_BC_SCALE_MAX


	)

155 
	m_SC_BC_STRING_MAX
,

156 
	#_SC_BC_STRING_MAX
 
_SC_BC_STRING_MAX


	)

157 
	m_SC_COLL_WEIGHTS_MAX
,

158 
	#_SC_COLL_WEIGHTS_MAX
 
_SC_COLL_WEIGHTS_MAX


	)

159 
	m_SC_EQUIV_CLASS_MAX
,

160 
	#_SC_EQUIV_CLASS_MAX
 
_SC_EQUIV_CLASS_MAX


	)

161 
	m_SC_EXPR_NEST_MAX
,

162 
	#_SC_EXPR_NEST_MAX
 
_SC_EXPR_NEST_MAX


	)

163 
	m_SC_LINE_MAX
,

164 
	#_SC_LINE_MAX
 
_SC_LINE_MAX


	)

165 
	m_SC_RE_DUP_MAX
,

166 
	#_SC_RE_DUP_MAX
 
_SC_RE_DUP_MAX


	)

167 
	m_SC_CHARCLASS_NAME_MAX
,

168 
	#_SC_CHARCLASS_NAME_MAX
 
_SC_CHARCLASS_NAME_MAX


	)

170 
	m_SC_2_VERSION
,

171 
	#_SC_2_VERSION
 
_SC_2_VERSION


	)

172 
	m_SC_2_C_BIND
,

173 
	#_SC_2_C_BIND
 
_SC_2_C_BIND


	)

174 
	m_SC_2_C_DEV
,

175 
	#_SC_2_C_DEV
 
_SC_2_C_DEV


	)

176 
	m_SC_2_FORT_DEV
,

177 
	#_SC_2_FORT_DEV
 
_SC_2_FORT_DEV


	)

178 
	m_SC_2_FORT_RUN
,

179 
	#_SC_2_FORT_RUN
 
_SC_2_FORT_RUN


	)

180 
	m_SC_2_SW_DEV
,

181 
	#_SC_2_SW_DEV
 
_SC_2_SW_DEV


	)

182 
	m_SC_2_LOCALEDEF
,

183 
	#_SC_2_LOCALEDEF
 
_SC_2_LOCALEDEF


	)

185 
	m_SC_PII
,

186 
	#_SC_PII
 
_SC_PII


	)

187 
	m_SC_PII_XTI
,

188 
	#_SC_PII_XTI
 
_SC_PII_XTI


	)

189 
	m_SC_PII_SOCKET
,

190 
	#_SC_PII_SOCKET
 
_SC_PII_SOCKET


	)

191 
	m_SC_PII_INTERNET
,

192 
	#_SC_PII_INTERNET
 
_SC_PII_INTERNET


	)

193 
	m_SC_PII_OSI
,

194 
	#_SC_PII_OSI
 
_SC_PII_OSI


	)

195 
	m_SC_POLL
,

196 
	#_SC_POLL
 
_SC_POLL


	)

197 
	m_SC_SELECT
,

198 
	#_SC_SELECT
 
_SC_SELECT


	)

199 
	m_SC_UIO_MAXIOV
,

200 
	#_SC_UIO_MAXIOV
 
_SC_UIO_MAXIOV


	)

201 
	m_SC_IOV_MAX
 = 
_SC_UIO_MAXIOV
,

202 
	#_SC_IOV_MAX
 
_SC_IOV_MAX


	)

203 
	m_SC_PII_INTERNET_STREAM
,

204 
	#_SC_PII_INTERNET_STREAM
 
_SC_PII_INTERNET_STREAM


	)

205 
	m_SC_PII_INTERNET_DGRAM
,

206 
	#_SC_PII_INTERNET_DGRAM
 
_SC_PII_INTERNET_DGRAM


	)

207 
	m_SC_PII_OSI_COTS
,

208 
	#_SC_PII_OSI_COTS
 
_SC_PII_OSI_COTS


	)

209 
	m_SC_PII_OSI_CLTS
,

210 
	#_SC_PII_OSI_CLTS
 
_SC_PII_OSI_CLTS


	)

211 
	m_SC_PII_OSI_M
,

212 
	#_SC_PII_OSI_M
 
_SC_PII_OSI_M


	)

213 
	m_SC_T_IOV_MAX
,

214 
	#_SC_T_IOV_MAX
 
_SC_T_IOV_MAX


	)

217 
	m_SC_THREADS
,

218 
	#_SC_THREADS
 
_SC_THREADS


	)

219 
	m_SC_THREAD_SAFE_FUNCTIONS
,

220 
	#_SC_THREAD_SAFE_FUNCTIONS
 
_SC_THREAD_SAFE_FUNCTIONS


	)

221 
	m_SC_GETGR_R_SIZE_MAX
,

222 
	#_SC_GETGR_R_SIZE_MAX
 
_SC_GETGR_R_SIZE_MAX


	)

223 
	m_SC_GETPW_R_SIZE_MAX
,

224 
	#_SC_GETPW_R_SIZE_MAX
 
_SC_GETPW_R_SIZE_MAX


	)

225 
	m_SC_LOGIN_NAME_MAX
,

226 
	#_SC_LOGIN_NAME_MAX
 
_SC_LOGIN_NAME_MAX


	)

227 
	m_SC_TTY_NAME_MAX
,

228 
	#_SC_TTY_NAME_MAX
 
_SC_TTY_NAME_MAX


	)

229 
	m_SC_THREAD_DESTRUCTOR_ITERATIONS
,

230 
	#_SC_THREAD_DESTRUCTOR_ITERATIONS
 
_SC_THREAD_DESTRUCTOR_ITERATIONS


	)

231 
	m_SC_THREAD_KEYS_MAX
,

232 
	#_SC_THREAD_KEYS_MAX
 
_SC_THREAD_KEYS_MAX


	)

233 
	m_SC_THREAD_STACK_MIN
,

234 
	#_SC_THREAD_STACK_MIN
 
_SC_THREAD_STACK_MIN


	)

235 
	m_SC_THREAD_THREADS_MAX
,

236 
	#_SC_THREAD_THREADS_MAX
 
_SC_THREAD_THREADS_MAX


	)

237 
	m_SC_THREAD_ATTR_STACKADDR
,

238 
	#_SC_THREAD_ATTR_STACKADDR
 
_SC_THREAD_ATTR_STACKADDR


	)

239 
	m_SC_THREAD_ATTR_STACKSIZE
,

240 
	#_SC_THREAD_ATTR_STACKSIZE
 
_SC_THREAD_ATTR_STACKSIZE


	)

241 
	m_SC_THREAD_PRIORITY_SCHEDULING
,

242 
	#_SC_THREAD_PRIORITY_SCHEDULING
 
_SC_THREAD_PRIORITY_SCHEDULING


	)

243 
	m_SC_THREAD_PRIO_INHERIT
,

244 
	#_SC_THREAD_PRIO_INHERIT
 
_SC_THREAD_PRIO_INHERIT


	)

245 
	m_SC_THREAD_PRIO_PROTECT
,

246 
	#_SC_THREAD_PRIO_PROTECT
 
_SC_THREAD_PRIO_PROTECT


	)

247 
	m_SC_THREAD_PROCESS_SHARED
,

248 
	#_SC_THREAD_PROCESS_SHARED
 
_SC_THREAD_PROCESS_SHARED


	)

250 
	m_SC_NPROCESSORS_CONF
,

251 
	#_SC_NPROCESSORS_CONF
 
_SC_NPROCESSORS_CONF


	)

252 
	m_SC_NPROCESSORS_ONLN
,

253 
	#_SC_NPROCESSORS_ONLN
 
_SC_NPROCESSORS_ONLN


	)

254 
	m_SC_PHYS_PAGES
,

255 
	#_SC_PHYS_PAGES
 
_SC_PHYS_PAGES


	)

256 
	m_SC_AVPHYS_PAGES
,

257 
	#_SC_AVPHYS_PAGES
 
_SC_AVPHYS_PAGES


	)

258 
	m_SC_ATEXIT_MAX
,

259 
	#_SC_ATEXIT_MAX
 
_SC_ATEXIT_MAX


	)

260 
	m_SC_PASS_MAX
,

261 
	#_SC_PASS_MAX
 
_SC_PASS_MAX


	)

263 
	m_SC_XOPEN_VERSION
,

264 
	#_SC_XOPEN_VERSION
 
_SC_XOPEN_VERSION


	)

265 
	m_SC_XOPEN_XCU_VERSION
,

266 
	#_SC_XOPEN_XCU_VERSION
 
_SC_XOPEN_XCU_VERSION


	)

267 
	m_SC_XOPEN_UNIX
,

268 
	#_SC_XOPEN_UNIX
 
_SC_XOPEN_UNIX


	)

269 
	m_SC_XOPEN_CRYPT
,

270 
	#_SC_XOPEN_CRYPT
 
_SC_XOPEN_CRYPT


	)

271 
	m_SC_XOPEN_ENH_I18N
,

272 
	#_SC_XOPEN_ENH_I18N
 
_SC_XOPEN_ENH_I18N


	)

273 
	m_SC_XOPEN_SHM
,

274 
	#_SC_XOPEN_SHM
 
_SC_XOPEN_SHM


	)

276 
	m_SC_2_CHAR_TERM
,

277 
	#_SC_2_CHAR_TERM
 
_SC_2_CHAR_TERM


	)

278 
	m_SC_2_C_VERSION
,

279 
	#_SC_2_C_VERSION
 
_SC_2_C_VERSION


	)

280 
	m_SC_2_UPE
,

281 
	#_SC_2_UPE
 
_SC_2_UPE


	)

283 
	m_SC_XOPEN_XPG2
,

284 
	#_SC_XOPEN_XPG2
 
_SC_XOPEN_XPG2


	)

285 
	m_SC_XOPEN_XPG3
,

286 
	#_SC_XOPEN_XPG3
 
_SC_XOPEN_XPG3


	)

287 
	m_SC_XOPEN_XPG4
,

288 
	#_SC_XOPEN_XPG4
 
_SC_XOPEN_XPG4


	)

290 
	m_SC_CHAR_BIT
,

291 
	#_SC_CHAR_BIT
 
_SC_CHAR_BIT


	)

292 
	m_SC_CHAR_MAX
,

293 
	#_SC_CHAR_MAX
 
_SC_CHAR_MAX


	)

294 
	m_SC_CHAR_MIN
,

295 
	#_SC_CHAR_MIN
 
_SC_CHAR_MIN


	)

296 
	m_SC_INT_MAX
,

297 
	#_SC_INT_MAX
 
_SC_INT_MAX


	)

298 
	m_SC_INT_MIN
,

299 
	#_SC_INT_MIN
 
_SC_INT_MIN


	)

300 
	m_SC_LONG_BIT
,

301 
	#_SC_LONG_BIT
 
_SC_LONG_BIT


	)

302 
	m_SC_WORD_BIT
,

303 
	#_SC_WORD_BIT
 
_SC_WORD_BIT


	)

304 
	m_SC_MB_LEN_MAX
,

305 
	#_SC_MB_LEN_MAX
 
_SC_MB_LEN_MAX


	)

306 
	m_SC_NZERO
,

307 
	#_SC_NZERO
 
_SC_NZERO


	)

308 
	m_SC_SSIZE_MAX
,

309 
	#_SC_SSIZE_MAX
 
_SC_SSIZE_MAX


	)

310 
	m_SC_SCHAR_MAX
,

311 
	#_SC_SCHAR_MAX
 
_SC_SCHAR_MAX


	)

312 
	m_SC_SCHAR_MIN
,

313 
	#_SC_SCHAR_MIN
 
_SC_SCHAR_MIN


	)

314 
	m_SC_SHRT_MAX
,

315 
	#_SC_SHRT_MAX
 
_SC_SHRT_MAX


	)

316 
	m_SC_SHRT_MIN
,

317 
	#_SC_SHRT_MIN
 
_SC_SHRT_MIN


	)

318 
	m_SC_UCHAR_MAX
,

319 
	#_SC_UCHAR_MAX
 
_SC_UCHAR_MAX


	)

320 
	m_SC_UINT_MAX
,

321 
	#_SC_UINT_MAX
 
_SC_UINT_MAX


	)

322 
	m_SC_ULONG_MAX
,

323 
	#_SC_ULONG_MAX
 
_SC_ULONG_MAX


	)

324 
	m_SC_USHRT_MAX
,

325 
	#_SC_USHRT_MAX
 
_SC_USHRT_MAX


	)

327 
	m_SC_NL_ARGMAX
,

328 
	#_SC_NL_ARGMAX
 
_SC_NL_ARGMAX


	)

329 
	m_SC_NL_LANGMAX
,

330 
	#_SC_NL_LANGMAX
 
_SC_NL_LANGMAX


	)

331 
	m_SC_NL_MSGMAX
,

332 
	#_SC_NL_MSGMAX
 
_SC_NL_MSGMAX


	)

333 
	m_SC_NL_NMAX
,

334 
	#_SC_NL_NMAX
 
_SC_NL_NMAX


	)

335 
	m_SC_NL_SETMAX
,

336 
	#_SC_NL_SETMAX
 
_SC_NL_SETMAX


	)

337 
	m_SC_NL_TEXTMAX
,

338 
	#_SC_NL_TEXTMAX
 
_SC_NL_TEXTMAX


	)

340 
	m_SC_XBS5_ILP32_OFF32
,

341 
	#_SC_XBS5_ILP32_OFF32
 
_SC_XBS5_ILP32_OFF32


	)

342 
	m_SC_XBS5_ILP32_OFFBIG
,

343 
	#_SC_XBS5_ILP32_OFFBIG
 
_SC_XBS5_ILP32_OFFBIG


	)

344 
	m_SC_XBS5_LP64_OFF64
,

345 
	#_SC_XBS5_LP64_OFF64
 
_SC_XBS5_LP64_OFF64


	)

346 
	m_SC_XBS5_LPBIG_OFFBIG
,

347 
	#_SC_XBS5_LPBIG_OFFBIG
 
_SC_XBS5_LPBIG_OFFBIG


	)

349 
	m_SC_XOPEN_LEGACY
,

350 
	#_SC_XOPEN_LEGACY
 
_SC_XOPEN_LEGACY


	)

351 
	m_SC_XOPEN_REALTIME
,

352 
	#_SC_XOPEN_REALTIME
 
_SC_XOPEN_REALTIME


	)

353 
	m_SC_XOPEN_REALTIME_THREADS
,

354 
	#_SC_XOPEN_REALTIME_THREADS
 
_SC_XOPEN_REALTIME_THREADS


	)

356 
	m_SC_ADVISORY_INFO
,

357 
	#_SC_ADVISORY_INFO
 
_SC_ADVISORY_INFO


	)

358 
	m_SC_BARRIERS
,

359 
	#_SC_BARRIERS
 
_SC_BARRIERS


	)

360 
	m_SC_BASE
,

361 
	#_SC_BASE
 
_SC_BASE


	)

362 
	m_SC_C_LANG_SUPPORT
,

363 
	#_SC_C_LANG_SUPPORT
 
_SC_C_LANG_SUPPORT


	)

364 
	m_SC_C_LANG_SUPPORT_R
,

365 
	#_SC_C_LANG_SUPPORT_R
 
_SC_C_LANG_SUPPORT_R


	)

366 
	m_SC_CLOCK_SELECTION
,

367 
	#_SC_CLOCK_SELECTION
 
_SC_CLOCK_SELECTION


	)

368 
	m_SC_CPUTIME
,

369 
	#_SC_CPUTIME
 
_SC_CPUTIME


	)

370 
	m_SC_THREAD_CPUTIME
,

371 
	#_SC_THREAD_CPUTIME
 
_SC_THREAD_CPUTIME


	)

372 
	m_SC_DEVICE_IO
,

373 
	#_SC_DEVICE_IO
 
_SC_DEVICE_IO


	)

374 
	m_SC_DEVICE_SPECIFIC
,

375 
	#_SC_DEVICE_SPECIFIC
 
_SC_DEVICE_SPECIFIC


	)

376 
	m_SC_DEVICE_SPECIFIC_R
,

377 
	#_SC_DEVICE_SPECIFIC_R
 
_SC_DEVICE_SPECIFIC_R


	)

378 
	m_SC_FD_MGMT
,

379 
	#_SC_FD_MGMT
 
_SC_FD_MGMT


	)

380 
	m_SC_FIFO
,

381 
	#_SC_FIFO
 
_SC_FIFO


	)

382 
	m_SC_PIPE
,

383 
	#_SC_PIPE
 
_SC_PIPE


	)

384 
	m_SC_FILE_ATTRIBUTES
,

385 
	#_SC_FILE_ATTRIBUTES
 
_SC_FILE_ATTRIBUTES


	)

386 
	m_SC_FILE_LOCKING
,

387 
	#_SC_FILE_LOCKING
 
_SC_FILE_LOCKING


	)

388 
	m_SC_FILE_SYSTEM
,

389 
	#_SC_FILE_SYSTEM
 
_SC_FILE_SYSTEM


	)

390 
	m_SC_MONOTONIC_CLOCK
,

391 
	#_SC_MONOTONIC_CLOCK
 
_SC_MONOTONIC_CLOCK


	)

392 
	m_SC_MULTI_PROCESS
,

393 
	#_SC_MULTI_PROCESS
 
_SC_MULTI_PROCESS


	)

394 
	m_SC_SINGLE_PROCESS
,

395 
	#_SC_SINGLE_PROCESS
 
_SC_SINGLE_PROCESS


	)

396 
	m_SC_NETWORKING
,

397 
	#_SC_NETWORKING
 
_SC_NETWORKING


	)

398 
	m_SC_READER_WRITER_LOCKS
,

399 
	#_SC_READER_WRITER_LOCKS
 
_SC_READER_WRITER_LOCKS


	)

400 
	m_SC_SPIN_LOCKS
,

401 
	#_SC_SPIN_LOCKS
 
_SC_SPIN_LOCKS


	)

402 
	m_SC_REGEXP
,

403 
	#_SC_REGEXP
 
_SC_REGEXP


	)

404 
	m_SC_REGEX_VERSION
,

405 
	#_SC_REGEX_VERSION
 
_SC_REGEX_VERSION


	)

406 
	m_SC_SHELL
,

407 
	#_SC_SHELL
 
_SC_SHELL


	)

408 
	m_SC_SIGNALS
,

409 
	#_SC_SIGNALS
 
_SC_SIGNALS


	)

410 
	m_SC_SPAWN
,

411 
	#_SC_SPAWN
 
_SC_SPAWN


	)

412 
	m_SC_SPORADIC_SERVER
,

413 
	#_SC_SPORADIC_SERVER
 
_SC_SPORADIC_SERVER


	)

414 
	m_SC_THREAD_SPORADIC_SERVER
,

415 
	#_SC_THREAD_SPORADIC_SERVER
 
_SC_THREAD_SPORADIC_SERVER


	)

416 
	m_SC_SYSTEM_DATABASE
,

417 
	#_SC_SYSTEM_DATABASE
 
_SC_SYSTEM_DATABASE


	)

418 
	m_SC_SYSTEM_DATABASE_R
,

419 
	#_SC_SYSTEM_DATABASE_R
 
_SC_SYSTEM_DATABASE_R


	)

420 
	m_SC_TIMEOUTS
,

421 
	#_SC_TIMEOUTS
 
_SC_TIMEOUTS


	)

422 
	m_SC_TYPED_MEMORY_OBJECTS
,

423 
	#_SC_TYPED_MEMORY_OBJECTS
 
_SC_TYPED_MEMORY_OBJECTS


	)

424 
	m_SC_USER_GROUPS
,

425 
	#_SC_USER_GROUPS
 
_SC_USER_GROUPS


	)

426 
	m_SC_USER_GROUPS_R
,

427 
	#_SC_USER_GROUPS_R
 
_SC_USER_GROUPS_R


	)

428 
	m_SC_2_PBS
,

429 
	#_SC_2_PBS
 
_SC_2_PBS


	)

430 
	m_SC_2_PBS_ACCOUNTING
,

431 
	#_SC_2_PBS_ACCOUNTING
 
_SC_2_PBS_ACCOUNTING


	)

432 
	m_SC_2_PBS_LOCATE
,

433 
	#_SC_2_PBS_LOCATE
 
_SC_2_PBS_LOCATE


	)

434 
	m_SC_2_PBS_MESSAGE
,

435 
	#_SC_2_PBS_MESSAGE
 
_SC_2_PBS_MESSAGE


	)

436 
	m_SC_2_PBS_TRACK
,

437 
	#_SC_2_PBS_TRACK
 
_SC_2_PBS_TRACK


	)

438 
	m_SC_SYMLOOP_MAX
,

439 
	#_SC_SYMLOOP_MAX
 
_SC_SYMLOOP_MAX


	)

440 
	m_SC_STREAMS
,

441 
	#_SC_STREAMS
 
_SC_STREAMS


	)

442 
	m_SC_2_PBS_CHECKPOINT
,

443 
	#_SC_2_PBS_CHECKPOINT
 
_SC_2_PBS_CHECKPOINT


	)

445 
	m_SC_V6_ILP32_OFF32
,

446 
	#_SC_V6_ILP32_OFF32
 
_SC_V6_ILP32_OFF32


	)

447 
	m_SC_V6_ILP32_OFFBIG
,

448 
	#_SC_V6_ILP32_OFFBIG
 
_SC_V6_ILP32_OFFBIG


	)

449 
	m_SC_V6_LP64_OFF64
,

450 
	#_SC_V6_LP64_OFF64
 
_SC_V6_LP64_OFF64


	)

451 
	m_SC_V6_LPBIG_OFFBIG
,

452 
	#_SC_V6_LPBIG_OFFBIG
 
_SC_V6_LPBIG_OFFBIG


	)

454 
	m_SC_HOST_NAME_MAX
,

455 
	#_SC_HOST_NAME_MAX
 
_SC_HOST_NAME_MAX


	)

456 
	m_SC_TRACE
,

457 
	#_SC_TRACE
 
_SC_TRACE


	)

458 
	m_SC_TRACE_EVENT_FILTER
,

459 
	#_SC_TRACE_EVENT_FILTER
 
_SC_TRACE_EVENT_FILTER


	)

460 
	m_SC_TRACE_INHERIT
,

461 
	#_SC_TRACE_INHERIT
 
_SC_TRACE_INHERIT


	)

462 
	m_SC_TRACE_LOG
,

463 
	#_SC_TRACE_LOG
 
_SC_TRACE_LOG


	)

465 
	m_SC_LEVEL1_ICACHE_SIZE
,

466 
	#_SC_LEVEL1_ICACHE_SIZE
 
_SC_LEVEL1_ICACHE_SIZE


	)

467 
	m_SC_LEVEL1_ICACHE_ASSOC
,

468 
	#_SC_LEVEL1_ICACHE_ASSOC
 
_SC_LEVEL1_ICACHE_ASSOC


	)

469 
	m_SC_LEVEL1_ICACHE_LINESIZE
,

470 
	#_SC_LEVEL1_ICACHE_LINESIZE
 
_SC_LEVEL1_ICACHE_LINESIZE


	)

471 
	m_SC_LEVEL1_DCACHE_SIZE
,

472 
	#_SC_LEVEL1_DCACHE_SIZE
 
_SC_LEVEL1_DCACHE_SIZE


	)

473 
	m_SC_LEVEL1_DCACHE_ASSOC
,

474 
	#_SC_LEVEL1_DCACHE_ASSOC
 
_SC_LEVEL1_DCACHE_ASSOC


	)

475 
	m_SC_LEVEL1_DCACHE_LINESIZE
,

476 
	#_SC_LEVEL1_DCACHE_LINESIZE
 
_SC_LEVEL1_DCACHE_LINESIZE


	)

477 
	m_SC_LEVEL2_CACHE_SIZE
,

478 
	#_SC_LEVEL2_CACHE_SIZE
 
_SC_LEVEL2_CACHE_SIZE


	)

479 
	m_SC_LEVEL2_CACHE_ASSOC
,

480 
	#_SC_LEVEL2_CACHE_ASSOC
 
_SC_LEVEL2_CACHE_ASSOC


	)

481 
	m_SC_LEVEL2_CACHE_LINESIZE
,

482 
	#_SC_LEVEL2_CACHE_LINESIZE
 
_SC_LEVEL2_CACHE_LINESIZE


	)

483 
	m_SC_LEVEL3_CACHE_SIZE
,

484 
	#_SC_LEVEL3_CACHE_SIZE
 
_SC_LEVEL3_CACHE_SIZE


	)

485 
	m_SC_LEVEL3_CACHE_ASSOC
,

486 
	#_SC_LEVEL3_CACHE_ASSOC
 
_SC_LEVEL3_CACHE_ASSOC


	)

487 
	m_SC_LEVEL3_CACHE_LINESIZE
,

488 
	#_SC_LEVEL3_CACHE_LINESIZE
 
_SC_LEVEL3_CACHE_LINESIZE


	)

489 
	m_SC_LEVEL4_CACHE_SIZE
,

490 
	#_SC_LEVEL4_CACHE_SIZE
 
_SC_LEVEL4_CACHE_SIZE


	)

491 
	m_SC_LEVEL4_CACHE_ASSOC
,

492 
	#_SC_LEVEL4_CACHE_ASSOC
 
_SC_LEVEL4_CACHE_ASSOC


	)

493 
	m_SC_LEVEL4_CACHE_LINESIZE
,

494 
	#_SC_LEVEL4_CACHE_LINESIZE
 
_SC_LEVEL4_CACHE_LINESIZE


	)

497 
	m_SC_IPV6
 = 
_SC_LEVEL1_ICACHE_SIZE
 + 50,

498 
	#_SC_IPV6
 
_SC_IPV6


	)

499 
	m_SC_RAW_SOCKETS
,

500 
	#_SC_RAW_SOCKETS
 
_SC_RAW_SOCKETS


	)

502 
	m_SC_V7_ILP32_OFF32
,

503 
	#_SC_V7_ILP32_OFF32
 
_SC_V7_ILP32_OFF32


	)

504 
	m_SC_V7_ILP32_OFFBIG
,

505 
	#_SC_V7_ILP32_OFFBIG
 
_SC_V7_ILP32_OFFBIG


	)

506 
	m_SC_V7_LP64_OFF64
,

507 
	#_SC_V7_LP64_OFF64
 
_SC_V7_LP64_OFF64


	)

508 
	m_SC_V7_LPBIG_OFFBIG
,

509 
	#_SC_V7_LPBIG_OFFBIG
 
_SC_V7_LPBIG_OFFBIG


	)

511 
	m_SC_SS_REPL_MAX
,

512 
	#_SC_SS_REPL_MAX
 
_SC_SS_REPL_MAX


	)

514 
	m_SC_TRACE_EVENT_NAME_MAX
,

515 
	#_SC_TRACE_EVENT_NAME_MAX
 
_SC_TRACE_EVENT_NAME_MAX


	)

516 
	m_SC_TRACE_NAME_MAX
,

517 
	#_SC_TRACE_NAME_MAX
 
_SC_TRACE_NAME_MAX


	)

518 
	m_SC_TRACE_SYS_MAX
,

519 
	#_SC_TRACE_SYS_MAX
 
_SC_TRACE_SYS_MAX


	)

520 
	m_SC_TRACE_USER_EVENT_MAX
,

521 
	#_SC_TRACE_USER_EVENT_MAX
 
_SC_TRACE_USER_EVENT_MAX


	)

523 
	m_SC_XOPEN_STREAMS
,

524 
	#_SC_XOPEN_STREAMS
 
_SC_XOPEN_STREAMS


	)

526 
	m_SC_THREAD_ROBUST_PRIO_INHERIT
,

527 
	#_SC_THREAD_ROBUST_PRIO_INHERIT
 
_SC_THREAD_ROBUST_PRIO_INHERIT


	)

528 
	m_SC_THREAD_ROBUST_PRIO_PROTECT


529 
	#_SC_THREAD_ROBUST_PRIO_PROTECT
 
_SC_THREAD_ROBUST_PRIO_PROTECT


	)

535 
	m_CS_PATH
,

536 
	#_CS_PATH
 
_CS_PATH


	)

538 
	m_CS_V6_WIDTH_RESTRICTED_ENVS
,

539 
	#_CS_V6_WIDTH_RESTRICTED_ENVS
 
_CS_V6_WIDTH_RESTRICTED_ENVS


	)

540 
	#_CS_POSIX_V6_WIDTH_RESTRICTED_ENVS
 
_CS_V6_WIDTH_RESTRICTED_ENVS


	)

542 
	m_CS_GNU_LIBC_VERSION
,

543 
	#_CS_GNU_LIBC_VERSION
 
_CS_GNU_LIBC_VERSION


	)

544 
	m_CS_GNU_LIBPTHREAD_VERSION
,

545 
	#_CS_GNU_LIBPTHREAD_VERSION
 
_CS_GNU_LIBPTHREAD_VERSION


	)

547 
	m_CS_V5_WIDTH_RESTRICTED_ENVS
,

548 
	#_CS_V5_WIDTH_RESTRICTED_ENVS
 
_CS_V5_WIDTH_RESTRICTED_ENVS


	)

549 
	#_CS_POSIX_V5_WIDTH_RESTRICTED_ENVS
 
_CS_V5_WIDTH_RESTRICTED_ENVS


	)

551 
	m_CS_V7_WIDTH_RESTRICTED_ENVS
,

552 
	#_CS_V7_WIDTH_RESTRICTED_ENVS
 
_CS_V7_WIDTH_RESTRICTED_ENVS


	)

553 
	#_CS_POSIX_V7_WIDTH_RESTRICTED_ENVS
 
_CS_V7_WIDTH_RESTRICTED_ENVS


	)

555 
	m_CS_LFS_CFLAGS
 = 1000,

556 
	#_CS_LFS_CFLAGS
 
_CS_LFS_CFLAGS


	)

557 
	m_CS_LFS_LDFLAGS
,

558 
	#_CS_LFS_LDFLAGS
 
_CS_LFS_LDFLAGS


	)

559 
	m_CS_LFS_LIBS
,

560 
	#_CS_LFS_LIBS
 
_CS_LFS_LIBS


	)

561 
	m_CS_LFS_LINTFLAGS
,

562 
	#_CS_LFS_LINTFLAGS
 
_CS_LFS_LINTFLAGS


	)

563 
	m_CS_LFS64_CFLAGS
,

564 
	#_CS_LFS64_CFLAGS
 
_CS_LFS64_CFLAGS


	)

565 
	m_CS_LFS64_LDFLAGS
,

566 
	#_CS_LFS64_LDFLAGS
 
_CS_LFS64_LDFLAGS


	)

567 
	m_CS_LFS64_LIBS
,

568 
	#_CS_LFS64_LIBS
 
_CS_LFS64_LIBS


	)

569 
	m_CS_LFS64_LINTFLAGS
,

570 
	#_CS_LFS64_LINTFLAGS
 
_CS_LFS64_LINTFLAGS


	)

572 
	m_CS_XBS5_ILP32_OFF32_CFLAGS
 = 1100,

573 
	#_CS_XBS5_ILP32_OFF32_CFLAGS
 
_CS_XBS5_ILP32_OFF32_CFLAGS


	)

574 
	m_CS_XBS5_ILP32_OFF32_LDFLAGS
,

575 
	#_CS_XBS5_ILP32_OFF32_LDFLAGS
 
_CS_XBS5_ILP32_OFF32_LDFLAGS


	)

576 
	m_CS_XBS5_ILP32_OFF32_LIBS
,

577 
	#_CS_XBS5_ILP32_OFF32_LIBS
 
_CS_XBS5_ILP32_OFF32_LIBS


	)

578 
	m_CS_XBS5_ILP32_OFF32_LINTFLAGS
,

579 
	#_CS_XBS5_ILP32_OFF32_LINTFLAGS
 
_CS_XBS5_ILP32_OFF32_LINTFLAGS


	)

580 
	m_CS_XBS5_ILP32_OFFBIG_CFLAGS
,

581 
	#_CS_XBS5_ILP32_OFFBIG_CFLAGS
 
_CS_XBS5_ILP32_OFFBIG_CFLAGS


	)

582 
	m_CS_XBS5_ILP32_OFFBIG_LDFLAGS
,

583 
	#_CS_XBS5_ILP32_OFFBIG_LDFLAGS
 
_CS_XBS5_ILP32_OFFBIG_LDFLAGS


	)

584 
	m_CS_XBS5_ILP32_OFFBIG_LIBS
,

585 
	#_CS_XBS5_ILP32_OFFBIG_LIBS
 
_CS_XBS5_ILP32_OFFBIG_LIBS


	)

586 
	m_CS_XBS5_ILP32_OFFBIG_LINTFLAGS
,

587 
	#_CS_XBS5_ILP32_OFFBIG_LINTFLAGS
 
_CS_XBS5_ILP32_OFFBIG_LINTFLAGS


	)

588 
	m_CS_XBS5_LP64_OFF64_CFLAGS
,

589 
	#_CS_XBS5_LP64_OFF64_CFLAGS
 
_CS_XBS5_LP64_OFF64_CFLAGS


	)

590 
	m_CS_XBS5_LP64_OFF64_LDFLAGS
,

591 
	#_CS_XBS5_LP64_OFF64_LDFLAGS
 
_CS_XBS5_LP64_OFF64_LDFLAGS


	)

592 
	m_CS_XBS5_LP64_OFF64_LIBS
,

593 
	#_CS_XBS5_LP64_OFF64_LIBS
 
_CS_XBS5_LP64_OFF64_LIBS


	)

594 
	m_CS_XBS5_LP64_OFF64_LINTFLAGS
,

595 
	#_CS_XBS5_LP64_OFF64_LINTFLAGS
 
_CS_XBS5_LP64_OFF64_LINTFLAGS


	)

596 
	m_CS_XBS5_LPBIG_OFFBIG_CFLAGS
,

597 
	#_CS_XBS5_LPBIG_OFFBIG_CFLAGS
 
_CS_XBS5_LPBIG_OFFBIG_CFLAGS


	)

598 
	m_CS_XBS5_LPBIG_OFFBIG_LDFLAGS
,

599 
	#_CS_XBS5_LPBIG_OFFBIG_LDFLAGS
 
_CS_XBS5_LPBIG_OFFBIG_LDFLAGS


	)

600 
	m_CS_XBS5_LPBIG_OFFBIG_LIBS
,

601 
	#_CS_XBS5_LPBIG_OFFBIG_LIBS
 
_CS_XBS5_LPBIG_OFFBIG_LIBS


	)

602 
	m_CS_XBS5_LPBIG_OFFBIG_LINTFLAGS
,

603 
	#_CS_XBS5_LPBIG_OFFBIG_LINTFLAGS
 
_CS_XBS5_LPBIG_OFFBIG_LINTFLAGS


	)

605 
	m_CS_POSIX_V6_ILP32_OFF32_CFLAGS
,

606 
	#_CS_POSIX_V6_ILP32_OFF32_CFLAGS
 
_CS_POSIX_V6_ILP32_OFF32_CFLAGS


	)

607 
	m_CS_POSIX_V6_ILP32_OFF32_LDFLAGS
,

608 
	#_CS_POSIX_V6_ILP32_OFF32_LDFLAGS
 
_CS_POSIX_V6_ILP32_OFF32_LDFLAGS


	)

609 
	m_CS_POSIX_V6_ILP32_OFF32_LIBS
,

610 
	#_CS_POSIX_V6_ILP32_OFF32_LIBS
 
_CS_POSIX_V6_ILP32_OFF32_LIBS


	)

611 
	m_CS_POSIX_V6_ILP32_OFF32_LINTFLAGS
,

612 
	#_CS_POSIX_V6_ILP32_OFF32_LINTFLAGS
 
_CS_POSIX_V6_ILP32_OFF32_LINTFLAGS


	)

613 
	m_CS_POSIX_V6_ILP32_OFFBIG_CFLAGS
,

614 
	#_CS_POSIX_V6_ILP32_OFFBIG_CFLAGS
 
_CS_POSIX_V6_ILP32_OFFBIG_CFLAGS


	)

615 
	m_CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS
,

616 
	#_CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS
 
_CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS


	)

617 
	m_CS_POSIX_V6_ILP32_OFFBIG_LIBS
,

618 
	#_CS_POSIX_V6_ILP32_OFFBIG_LIBS
 
_CS_POSIX_V6_ILP32_OFFBIG_LIBS


	)

619 
	m_CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS
,

620 
	#_CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS
 
_CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS


	)

621 
	m_CS_POSIX_V6_LP64_OFF64_CFLAGS
,

622 
	#_CS_POSIX_V6_LP64_OFF64_CFLAGS
 
_CS_POSIX_V6_LP64_OFF64_CFLAGS


	)

623 
	m_CS_POSIX_V6_LP64_OFF64_LDFLAGS
,

624 
	#_CS_POSIX_V6_LP64_OFF64_LDFLAGS
 
_CS_POSIX_V6_LP64_OFF64_LDFLAGS


	)

625 
	m_CS_POSIX_V6_LP64_OFF64_LIBS
,

626 
	#_CS_POSIX_V6_LP64_OFF64_LIBS
 
_CS_POSIX_V6_LP64_OFF64_LIBS


	)

627 
	m_CS_POSIX_V6_LP64_OFF64_LINTFLAGS
,

628 
	#_CS_POSIX_V6_LP64_OFF64_LINTFLAGS
 
_CS_POSIX_V6_LP64_OFF64_LINTFLAGS


	)

629 
	m_CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS
,

630 
	#_CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS
 
_CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS


	)

631 
	m_CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS
,

632 
	#_CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS
 
_CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS


	)

633 
	m_CS_POSIX_V6_LPBIG_OFFBIG_LIBS
,

634 
	#_CS_POSIX_V6_LPBIG_OFFBIG_LIBS
 
_CS_POSIX_V6_LPBIG_OFFBIG_LIBS


	)

635 
	m_CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS
,

636 
	#_CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS
 
_CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS


	)

638 
	m_CS_POSIX_V7_ILP32_OFF32_CFLAGS
,

639 
	#_CS_POSIX_V7_ILP32_OFF32_CFLAGS
 
_CS_POSIX_V7_ILP32_OFF32_CFLAGS


	)

640 
	m_CS_POSIX_V7_ILP32_OFF32_LDFLAGS
,

641 
	#_CS_POSIX_V7_ILP32_OFF32_LDFLAGS
 
_CS_POSIX_V7_ILP32_OFF32_LDFLAGS


	)

642 
	m_CS_POSIX_V7_ILP32_OFF32_LIBS
,

643 
	#_CS_POSIX_V7_ILP32_OFF32_LIBS
 
_CS_POSIX_V7_ILP32_OFF32_LIBS


	)

644 
	m_CS_POSIX_V7_ILP32_OFF32_LINTFLAGS
,

645 
	#_CS_POSIX_V7_ILP32_OFF32_LINTFLAGS
 
_CS_POSIX_V7_ILP32_OFF32_LINTFLAGS


	)

646 
	m_CS_POSIX_V7_ILP32_OFFBIG_CFLAGS
,

647 
	#_CS_POSIX_V7_ILP32_OFFBIG_CFLAGS
 
_CS_POSIX_V7_ILP32_OFFBIG_CFLAGS


	)

648 
	m_CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS
,

649 
	#_CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS
 
_CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS


	)

650 
	m_CS_POSIX_V7_ILP32_OFFBIG_LIBS
,

651 
	#_CS_POSIX_V7_ILP32_OFFBIG_LIBS
 
_CS_POSIX_V7_ILP32_OFFBIG_LIBS


	)

652 
	m_CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS
,

653 
	#_CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS
 
_CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS


	)

654 
	m_CS_POSIX_V7_LP64_OFF64_CFLAGS
,

655 
	#_CS_POSIX_V7_LP64_OFF64_CFLAGS
 
_CS_POSIX_V7_LP64_OFF64_CFLAGS


	)

656 
	m_CS_POSIX_V7_LP64_OFF64_LDFLAGS
,

657 
	#_CS_POSIX_V7_LP64_OFF64_LDFLAGS
 
_CS_POSIX_V7_LP64_OFF64_LDFLAGS


	)

658 
	m_CS_POSIX_V7_LP64_OFF64_LIBS
,

659 
	#_CS_POSIX_V7_LP64_OFF64_LIBS
 
_CS_POSIX_V7_LP64_OFF64_LIBS


	)

660 
	m_CS_POSIX_V7_LP64_OFF64_LINTFLAGS
,

661 
	#_CS_POSIX_V7_LP64_OFF64_LINTFLAGS
 
_CS_POSIX_V7_LP64_OFF64_LINTFLAGS


	)

662 
	m_CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS
,

663 
	#_CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS
 
_CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS


	)

664 
	m_CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS
,

665 
	#_CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS
 
_CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS


	)

666 
	m_CS_POSIX_V7_LPBIG_OFFBIG_LIBS
,

667 
	#_CS_POSIX_V7_LPBIG_OFFBIG_LIBS
 
_CS_POSIX_V7_LPBIG_OFFBIG_LIBS


	)

668 
	m_CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS
,

669 
	#_CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS
 
_CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS


	)

671 
	m_CS_V6_ENV
,

672 
	#_CS_V6_ENV
 
_CS_V6_ENV


	)

673 
	m_CS_V7_ENV


674 
	#_CS_V7_ENV
 
_CS_V7_ENV


	)

	@/usr/include/bits/environments.h

18 #iâdeà
_UNISTD_H


22 
	~<b™s/wÜdsize.h
>

42 #ià
__WORDSIZE
 == 64

56 
	#_POSIX_V7_LPBIG_OFFBIG
 -1

	)

57 
	#_POSIX_V6_LPBIG_OFFBIG
 -1

	)

58 
	#_XBS5_LPBIG_OFFBIG
 -1

	)

61 
	#_POSIX_V7_LP64_OFF64
 1

	)

62 
	#_POSIX_V6_LP64_OFF64
 1

	)

63 
	#_XBS5_LP64_OFF64
 1

	)

69 
	#_POSIX_V7_ILP32_OFFBIG
 1

	)

70 
	#_POSIX_V6_ILP32_OFFBIG
 1

	)

71 
	#_XBS5_ILP32_OFFBIG
 1

	)

73 #iâdeà
__x86_64__


75 
	#_POSIX_V7_ILP32_OFF32
 1

	)

76 
	#_POSIX_V6_ILP32_OFF32
 1

	)

77 
	#_XBS5_ILP32_OFF32
 1

	)

95 
	#__ILP32_OFF32_CFLAGS
 "-m32"

	)

96 
	#__ILP32_OFF32_LDFLAGS
 "-m32"

	)

97 #ià
defšed
 
__x86_64__
 && defšed 
__ILP32__


98 
	#__ILP32_OFFBIG_CFLAGS
 "-mx32"

	)

99 
	#__ILP32_OFFBIG_LDFLAGS
 "-mx32"

	)

101 
	#__ILP32_OFFBIG_CFLAGS
 "-m32 -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64"

	)

102 
	#__ILP32_OFFBIG_LDFLAGS
 "-m32"

	)

104 
	#__LP64_OFF64_CFLAGS
 "-m64"

	)

105 
	#__LP64_OFF64_LDFLAGS
 "-m64"

	)

	@/usr/include/bits/errno.h

19 #ifdeà
_ERRNO_H


21 #undeà
EDOM


22 #undeà
EILSEQ


23 #undeà
ERANGE


24 
	~<lšux/”ºo.h
>

27 
	#ENOTSUP
 
EOPNOTSUPP


	)

30 #iâdeà
ECANCELED


31 
	#ECANCELED
 125

	)

35 #iâdeà
EOWNERDEAD


36 
	#EOWNERDEAD
 130

	)

37 
	#ENOTRECOVERABLE
 131

	)

40 #iâdeà
ERFKILL


41 
	#ERFKILL
 132

	)

44 #iâdeà
EHWPOISON


45 
	#EHWPOISON
 133

	)

48 #iâdeà
__ASSEMBLER__


50 *
	$__”ºo_loÿtiÚ
 (è
__THROW
 
	`__©Œibu‹__
 ((
__cÚ¡__
));

52 #ià!
defšed
 
_LIBC
 || defšed 
_LIBC_REENTRANT


54 
	#”ºo
 (*
	`__”ºo_loÿtiÚ
 ())

	)

59 #ià!
defšed
 
_ERRNO_H
 && defšed 
__Ãed_Em©h


63 
	#EDOM
 33

	)

64 
	#EILSEQ
 84

	)

65 
	#ERANGE
 34

	)

	@/usr/include/bits/fcntl.h

19 #iâdeà
_FCNTL_H


23 #ifdeà
__x86_64__


24 
	#__O_LARGEFILE
 0

	)

27 #ifdeà
__x86_64__


29 
	#F_GETLK64
 5

	)

30 
	#F_SETLK64
 6

	)

31 
	#F_SETLKW64
 7

	)

35 
	sæock


37 
	ml_ty³
;

38 
	ml_wh’û
;

39 #iâdeà
__USE_FILE_OFFSET64


40 
__off_t
 
	ml_¡¬t
;

41 
__off_t
 
	ml_Ën
;

43 
__off64_t
 
	ml_¡¬t
;

44 
__off64_t
 
	ml_Ën
;

46 
__pid_t
 
	ml_pid
;

49 #ifdeà
__USE_LARGEFILE64


50 
	sæock64


52 
	ml_ty³
;

53 
	ml_wh’û
;

54 
__off64_t
 
	ml_¡¬t
;

55 
__off64_t
 
	ml_Ën
;

56 
__pid_t
 
	ml_pid
;

61 
	~<b™s/fúŽ-lšux.h
>

	@/usr/include/bits/fcntl2.h

19 #iâdef 
_FCNTL_H


25 #iâdeà
__USE_FILE_OFFSET64


26 
	$__Ý’_2
 (cÚ¡ *
__·th
, 
__oæag
è
	`__nÚnuÎ
 ((1));

27 
	`__REDIRECT
 (
__Ý’_®Ÿs
, (cÚ¡ *
__·th
, 
__oæag
, ...),

28 
Ý’
è
	`__nÚnuÎ
 ((1));

30 
	`__REDIRECT
 (
__Ý’_2
, (cÚ¡ *
__·th
, 
__oæag
),

31 
__Ý’64_2
è
	`__nÚnuÎ
 ((1));

32 
	`__REDIRECT
 (
__Ý’_®Ÿs
, (cÚ¡ *
__·th
, 
__oæag
, ...),

33 
Ý’64
è
	`__nÚnuÎ
 ((1));

35 
	`__”rÜdeþ
 (
__Ý’_too_mªy_¬gs
,

37 
	`__”rÜdeþ
 (
__Ý’_missšg_mode
,

40 
__fÜtify_funùiÚ
 

41 
	$Ý’
 (cÚ¡ *
__·th
, 
__oæag
, ...)

43 ià(
	`__va_¬g_·ck_Ën
 () > 1)

44 
	`__Ý’_too_mªy_¬gs
 ();

46 ià(
	`__bužtš_cÚ¡ªt_p
 (
__oæag
))

48 ià(
	`__OPEN_NEEDS_MODE
 (
__oæag
è&& 
	`__va_¬g_·ck_Ën
 () < 1)

50 
	`__Ý’_missšg_mode
 ();

51  
	`__Ý’_2
 (
__·th
, 
__oæag
);

53  
	`__Ý’_®Ÿs
 (
__·th
, 
__oæag
, 
	`__va_¬g_·ck
 ());

56 ià(
	`__va_¬g_·ck_Ën
 () < 1)

57  
	`__Ý’_2
 (
__·th
, 
__oæag
);

59  
	`__Ý’_®Ÿs
 (
__·th
, 
__oæag
, 
	`__va_¬g_·ck
 ());

60 
	}
}

63 #ifdeà
__USE_LARGEFILE64


64 
	$__Ý’64_2
 (cÚ¡ *
__·th
, 
__oæag
è
	`__nÚnuÎ
 ((1));

65 
	`__REDIRECT
 (
__Ý’64_®Ÿs
, (cÚ¡ *
__·th
, 
__oæag
,

66 ...), 
Ý’64
è
	`__nÚnuÎ
 ((1));

67 
	`__”rÜdeþ
 (
__Ý’64_too_mªy_¬gs
,

69 
	`__”rÜdeþ
 (
__Ý’64_missšg_mode
,

72 
__fÜtify_funùiÚ
 

73 
	$Ý’64
 (cÚ¡ *
__·th
, 
__oæag
, ...)

75 ià(
	`__va_¬g_·ck_Ën
 () > 1)

76 
	`__Ý’64_too_mªy_¬gs
 ();

78 ià(
	`__bužtš_cÚ¡ªt_p
 (
__oæag
))

80 ià(
	`__OPEN_NEEDS_MODE
 (
__oæag
è&& 
	`__va_¬g_·ck_Ën
 () < 1)

82 
	`__Ý’64_missšg_mode
 ();

83  
	`__Ý’64_2
 (
__·th
, 
__oæag
);

85  
	`__Ý’64_®Ÿs
 (
__·th
, 
__oæag
, 
	`__va_¬g_·ck
 ());

88 ià(
	`__va_¬g_·ck_Ën
 () < 1)

89  
	`__Ý’64_2
 (
__·th
, 
__oæag
);

91  
	`__Ý’64_®Ÿs
 (
__·th
, 
__oæag
, 
	`__va_¬g_·ck
 ());

92 
	}
}

96 #ifdeà
__USE_ATFILE


97 #iâdeà
__USE_FILE_OFFSET64


98 
	$__Ý’©_2
 (
__fd
, cÚ¡ *
__·th
, 
__oæag
)

99 
	`__nÚnuÎ
 ((2));

100 
	`__REDIRECT
 (
__Ý’©_®Ÿs
, (
__fd
, cÚ¡ *
__·th
,

101 
__oæag
, ...), 
Ý’©
)

102 
	`__nÚnuÎ
 ((2));

104 
	`__REDIRECT
 (
__Ý’©_2
, (
__fd
, cÚ¡ *
__·th
,

105 
__oæag
), 
__Ý’©64_2
)

106 
	`__nÚnuÎ
 ((2));

107 
	`__REDIRECT
 (
__Ý’©_®Ÿs
, (
__fd
, cÚ¡ *
__·th
,

108 
__oæag
, ...), 
Ý’©64
)

109 
	`__nÚnuÎ
 ((2));

111 
	`__”rÜdeþ
 (
__Ý’©_too_mªy_¬gs
,

113 
	`__”rÜdeþ
 (
__Ý’©_missšg_mode
,

116 
__fÜtify_funùiÚ
 

117 
	$Ý’©
 (
__fd
, cÚ¡ *
__·th
, 
__oæag
, ...)

119 ià(
	`__va_¬g_·ck_Ën
 () > 1)

120 
	`__Ý’©_too_mªy_¬gs
 ();

122 ià(
	`__bužtš_cÚ¡ªt_p
 (
__oæag
))

124 ià(
	`__OPEN_NEEDS_MODE
 (
__oæag
è&& 
	`__va_¬g_·ck_Ën
 () < 1)

126 
	`__Ý’©_missšg_mode
 ();

127  
	`__Ý’©_2
 (
__fd
, 
__·th
, 
__oæag
);

129  
	`__Ý’©_®Ÿs
 (
__fd
, 
__·th
, 
__oæag
, 
	`__va_¬g_·ck
 ());

132 ià(
	`__va_¬g_·ck_Ën
 () < 1)

133  
	`__Ý’©_2
 (
__fd
, 
__·th
, 
__oæag
);

135  
	`__Ý’©_®Ÿs
 (
__fd
, 
__·th
, 
__oæag
, 
	`__va_¬g_·ck
 ());

136 
	}
}

139 #ifdeà
__USE_LARGEFILE64


140 
	$__Ý’©64_2
 (
__fd
, cÚ¡ *
__·th
, 
__oæag
)

141 
	`__nÚnuÎ
 ((2));

142 
	`__REDIRECT
 (
__Ý’©64_®Ÿs
, (
__fd
, cÚ¡ *
__·th
,

143 
__oæag
, ...), 
Ý’©64
)

144 
	`__nÚnuÎ
 ((2));

145 
	`__”rÜdeþ
 (
__Ý’©64_too_mªy_¬gs
,

147 
	`__”rÜdeþ
 (
__Ý’©64_missšg_mode
,

150 
__fÜtify_funùiÚ
 

151 
	$Ý’©64
 (
__fd
, cÚ¡ *
__·th
, 
__oæag
, ...)

153 ià(
	`__va_¬g_·ck_Ën
 () > 1)

154 
	`__Ý’©64_too_mªy_¬gs
 ();

156 ià(
	`__bužtš_cÚ¡ªt_p
 (
__oæag
))

158 ià(
	`__OPEN_NEEDS_MODE
 (
__oæag
è&& 
	`__va_¬g_·ck_Ën
 () < 1)

160 
	`__Ý’©64_missšg_mode
 ();

161  
	`__Ý’©64_2
 (
__fd
, 
__·th
, 
__oæag
);

163  
	`__Ý’©64_®Ÿs
 (
__fd
, 
__·th
, 
__oæag
, 
	`__va_¬g_·ck
 ());

166 ià(
	`__va_¬g_·ck_Ën
 () < 1)

167  
	`__Ý’©64_2
 (
__fd
, 
__·th
, 
__oæag
);

169  
	`__Ý’©64_®Ÿs
 (
__fd
, 
__·th
, 
__oæag
, 
	`__va_¬g_·ck
 ());

170 
	}
}

	@/usr/include/bits/posix_opt.h

19 #iâdef 
_BITS_POSIX_OPT_H


20 
	#_BITS_POSIX_OPT_H
 1

	)

23 
	#_POSIX_JOB_CONTROL
 1

	)

26 
	#_POSIX_SAVED_IDS
 1

	)

29 
	#_POSIX_PRIORITY_SCHEDULING
 200809L

	)

32 
	#_POSIX_SYNCHRONIZED_IO
 200809L

	)

35 
	#_POSIX_FSYNC
 200809L

	)

38 
	#_POSIX_MAPPED_FILES
 200809L

	)

41 
	#_POSIX_MEMLOCK
 200809L

	)

44 
	#_POSIX_MEMLOCK_RANGE
 200809L

	)

47 
	#_POSIX_MEMORY_PROTECTION
 200809L

	)

50 
	#_POSIX_CHOWN_RESTRICTED
 0

	)

54 
	#_POSIX_VDISABLE
 '\0'

	)

57 
	#_POSIX_NO_TRUNC
 1

	)

60 
	#_XOPEN_REALTIME
 1

	)

63 
	#_XOPEN_REALTIME_THREADS
 1

	)

66 
	#_XOPEN_SHM
 1

	)

69 
	#_POSIX_THREADS
 200809L

	)

72 
	#_POSIX_REENTRANT_FUNCTIONS
 1

	)

73 
	#_POSIX_THREAD_SAFE_FUNCTIONS
 200809L

	)

76 
	#_POSIX_THREAD_PRIORITY_SCHEDULING
 200809L

	)

79 
	#_POSIX_THREAD_ATTR_STACKSIZE
 200809L

	)

82 
	#_POSIX_THREAD_ATTR_STACKADDR
 200809L

	)

85 
	#_POSIX_THREAD_PRIO_INHERIT
 200809L

	)

89 
	#_POSIX_THREAD_PRIO_PROTECT
 200809L

	)

91 #ifdeà
__USE_XOPEN2K8


93 
	#_POSIX_THREAD_ROBUST_PRIO_INHERIT
 200809L

	)

96 
	#_POSIX_THREAD_ROBUST_PRIO_PROTECT
 -1

	)

100 
	#_POSIX_SEMAPHORES
 200809L

	)

103 
	#_POSIX_REALTIME_SIGNALS
 200809L

	)

106 
	#_POSIX_ASYNCHRONOUS_IO
 200809L

	)

107 
	#_POSIX_ASYNC_IO
 1

	)

109 
	#_LFS_ASYNCHRONOUS_IO
 1

	)

111 
	#_POSIX_PRIORITIZED_IO
 200809L

	)

114 
	#_LFS64_ASYNCHRONOUS_IO
 1

	)

117 
	#_LFS_LARGEFILE
 1

	)

118 
	#_LFS64_LARGEFILE
 1

	)

119 
	#_LFS64_STDIO
 1

	)

122 
	#_POSIX_SHARED_MEMORY_OBJECTS
 200809L

	)

125 
	#_POSIX_CPUTIME
 0

	)

128 
	#_POSIX_THREAD_CPUTIME
 0

	)

131 
	#_POSIX_REGEXP
 1

	)

134 
	#_POSIX_READER_WRITER_LOCKS
 200809L

	)

137 
	#_POSIX_SHELL
 1

	)

140 
	#_POSIX_TIMEOUTS
 200809L

	)

143 
	#_POSIX_SPIN_LOCKS
 200809L

	)

146 
	#_POSIX_SPAWN
 200809L

	)

149 
	#_POSIX_TIMERS
 200809L

	)

152 
	#_POSIX_BARRIERS
 200809L

	)

155 
	#_POSIX_MESSAGE_PASSING
 200809L

	)

158 
	#_POSIX_THREAD_PROCESS_SHARED
 200809L

	)

161 
	#_POSIX_MONOTONIC_CLOCK
 0

	)

164 
	#_POSIX_CLOCK_SELECTION
 200809L

	)

167 
	#_POSIX_ADVISORY_INFO
 200809L

	)

170 
	#_POSIX_IPV6
 200809L

	)

173 
	#_POSIX_RAW_SOCKETS
 200809L

	)

176 
	#_POSIX2_CHAR_TERM
 200809L

	)

179 
	#_POSIX_SPORADIC_SERVER
 -1

	)

180 
	#_POSIX_THREAD_SPORADIC_SERVER
 -1

	)

183 
	#_POSIX_TRACE
 -1

	)

184 
	#_POSIX_TRACE_EVENT_FILTER
 -1

	)

185 
	#_POSIX_TRACE_INHERIT
 -1

	)

186 
	#_POSIX_TRACE_LOG
 -1

	)

189 
	#_POSIX_TYPED_MEMORY_OBJECTS
 -1

	)

	@/usr/include/bits/pthreadtypes.h

18 #iâdeà
_BITS_PTHREADTYPES_H


19 
	#_BITS_PTHREADTYPES_H
 1

	)

21 
	~<b™s/wÜdsize.h
>

23 #ifdeà
__x86_64__


24 #ià
__WORDSIZE
 == 64

25 
	#__SIZEOF_PTHREAD_ATTR_T
 56

	)

26 
	#__SIZEOF_PTHREAD_MUTEX_T
 40

	)

27 
	#__SIZEOF_PTHREAD_MUTEXATTR_T
 4

	)

28 
	#__SIZEOF_PTHREAD_COND_T
 48

	)

29 
	#__SIZEOF_PTHREAD_CONDATTR_T
 4

	)

30 
	#__SIZEOF_PTHREAD_RWLOCK_T
 56

	)

31 
	#__SIZEOF_PTHREAD_RWLOCKATTR_T
 8

	)

32 
	#__SIZEOF_PTHREAD_BARRIER_T
 32

	)

33 
	#__SIZEOF_PTHREAD_BARRIERATTR_T
 4

	)

35 
	#__SIZEOF_PTHREAD_ATTR_T
 32

	)

36 
	#__SIZEOF_PTHREAD_MUTEX_T
 32

	)

37 
	#__SIZEOF_PTHREAD_MUTEXATTR_T
 4

	)

38 
	#__SIZEOF_PTHREAD_COND_T
 48

	)

39 
	#__SIZEOF_PTHREAD_CONDATTR_T
 4

	)

40 
	#__SIZEOF_PTHREAD_RWLOCK_T
 44

	)

41 
	#__SIZEOF_PTHREAD_RWLOCKATTR_T
 8

	)

42 
	#__SIZEOF_PTHREAD_BARRIER_T
 20

	)

43 
	#__SIZEOF_PTHREAD_BARRIERATTR_T
 4

	)

46 
	#__SIZEOF_PTHREAD_ATTR_T
 36

	)

47 
	#__SIZEOF_PTHREAD_MUTEX_T
 24

	)

48 
	#__SIZEOF_PTHREAD_MUTEXATTR_T
 4

	)

49 
	#__SIZEOF_PTHREAD_COND_T
 48

	)

50 
	#__SIZEOF_PTHREAD_CONDATTR_T
 4

	)

51 
	#__SIZEOF_PTHREAD_RWLOCK_T
 32

	)

52 
	#__SIZEOF_PTHREAD_RWLOCKATTR_T
 8

	)

53 
	#__SIZEOF_PTHREAD_BARRIER_T
 20

	)

54 
	#__SIZEOF_PTHREAD_BARRIERATTR_T
 4

	)

60 
	t±h»ad_t
;

63 
	u±h»ad_©Œ_t


65 
	m__size
[
__SIZEOF_PTHREAD_ATTR_T
];

66 
	m__®ign
;

68 #iâdeà
__have_±h»ad_©Œ_t


69 
±h»ad_©Œ_t
 
	t±h»ad_©Œ_t
;

70 
	#__have_±h»ad_©Œ_t
 1

	)

74 #ifdeà
__x86_64__


75 
	s__±h»ad_š‹º®_li¡


77 
__±h»ad_š‹º®_li¡
 *
	m__´ev
;

78 
__±h»ad_š‹º®_li¡
 *
	m__Ãxt
;

79 } 
	t__±h»ad_li¡_t
;

81 
	s__±h»ad_š‹º®_¦i¡


83 
__±h»ad_š‹º®_¦i¡
 *
	m__Ãxt
;

84 } 
	t__±h»ad_¦i¡_t
;

92 
	s__±h»ad_mu‹x_s


94 
	m__lock
;

95 
	m__couÁ
;

96 
	m__owÃr
;

97 #ifdeà
__x86_64__


98 
	m__nu£rs
;

102 
	m__kšd
;

103 #ifdeà
__x86_64__


104 
	m__¥šs
;

105 
	m__–isiÚ
;

106 
__±h»ad_li¡_t
 
	m__li¡
;

107 
	#__PTHREAD_MUTEX_HAVE_PREV
 1

	)

109 
	#__PTHREAD_SPINS
 0, 0

	)

111 
	m__nu£rs
;

112 
__ex‹nsiÚ__
 union

116 
	m__e¥šs
;

117 
	m__–isiÚ
;

118 
	#__¥šs
 
__–isiÚ_d©a
.
__e¥šs


	)

119 
	#__–isiÚ
 
__–isiÚ_d©a
.
__–isiÚ


	)

120 
	#__PTHREAD_SPINS
 { 0, 0 }

	)

121 } 
	m__–isiÚ_d©a
;

122 
__±h»ad_¦i¡_t
 
	m__li¡
;

125 } 
	m__d©a
;

126 
	m__size
[
__SIZEOF_PTHREAD_MUTEX_T
];

127 
	m__®ign
;

128 } 
	t±h»ad_mu‹x_t
;

132 
	m__size
[
__SIZEOF_PTHREAD_MUTEXATTR_T
];

133 
	m__®ign
;

134 } 
	t±h»ad_mu‹x©Œ_t
;

143 
	m__lock
;

144 
	m__fu‹x
;

145 
__ex‹nsiÚ__
 
	m__tÙ®_£q
;

146 
__ex‹nsiÚ__
 
	m__wakeup_£q
;

147 
__ex‹nsiÚ__
 
	m__wok’_£q
;

148 *
	m__mu‹x
;

149 
	m__nwa™”s
;

150 
	m__brßdÿ¡_£q
;

151 } 
	m__d©a
;

152 
	m__size
[
__SIZEOF_PTHREAD_COND_T
];

153 
__ex‹nsiÚ__
 
	m__®ign
;

154 } 
	t±h»ad_cÚd_t
;

158 
	m__size
[
__SIZEOF_PTHREAD_CONDATTR_T
];

159 
	m__®ign
;

160 } 
	t±h»ad_cÚd©Œ_t
;

164 
	t±h»ad_key_t
;

168 
	t±h»ad_Úû_t
;

171 #ià
defšed
 
__USE_UNIX98
 || defšed 
__USE_XOPEN2K


176 #ifdeà
__x86_64__


179 
	m__lock
;

180 
	m__Ä_»ad”s
;

181 
	m__»ad”s_wakeup
;

182 
	m__wr™”_wakeup
;

183 
	m__Ä_»ad”s_queued
;

184 
	m__Ä_wr™”s_queued
;

185 
	m__wr™”
;

186 
	m__sh¬ed
;

187 sigÃd 
	m__rw–isiÚ
;

188 #ifdeà 
__ILP32__


189 
	m__·d1
[3];

190 
	#__PTHREAD_RWLOCK_ELISION_EXTRA
 0, { 0, 0, 0 }

	)

192 
	m__·d1
[7];

193 
	#__PTHREAD_RWLOCK_ELISION_EXTRA
 0, { 0, 0, 0, 0, 0, 0, 0 }

	)

195 
	m__·d2
;

198 
	m__æags
;

199 
	#__PTHREAD_RWLOCK_INT_FLAGS_SHARED
 1

	)

200 } 
	m__d©a
;

204 
	m__lock
;

205 
	m__Ä_»ad”s
;

206 
	m__»ad”s_wakeup
;

207 
	m__wr™”_wakeup
;

208 
	m__Ä_»ad”s_queued
;

209 
	m__Ä_wr™”s_queued
;

212 
	m__æags
;

213 
	m__sh¬ed
;

214 sigÃd 
	m__rw–isiÚ
;

215 
	#__PTHREAD_RWLOCK_ELISION_EXTRA
 0

	)

216 
	m__·d2
;

217 
	m__wr™”
;

218 } 
	m__d©a
;

220 
	m__size
[
__SIZEOF_PTHREAD_RWLOCK_T
];

221 
	m__®ign
;

222 } 
	t±h»ad_rwlock_t
;

226 
	m__size
[
__SIZEOF_PTHREAD_RWLOCKATTR_T
];

227 
	m__®ign
;

228 } 
	t±h»ad_rwlock©Œ_t
;

232 #ifdeà
__USE_XOPEN2K


234 vÞ©ž
	t±h»ad_¥šlock_t
;

241 
	m__size
[
__SIZEOF_PTHREAD_BARRIER_T
];

242 
	m__®ign
;

243 } 
	t±h»ad_b¬r›r_t
;

247 
	m__size
[
__SIZEOF_PTHREAD_BARRIERATTR_T
];

248 
	m__®ign
;

249 } 
	t±h»ad_b¬r›¿‰r_t
;

253 #iâdeà
__x86_64__


255 
	#__þ—nup_fù_©Œibu‹
 
	`__©Œibu‹__
 ((
	`__»g·rm__
 (1)))

	)

	@/usr/include/bits/sigaction.h

19 #iâdeà
_SIGNAL_H


24 
	ssigaùiÚ


27 #ifdeà
__USE_POSIX199309


31 
__sighªdËr_t
 
	m§_hªdËr
;

33 (*
	m§_sigaùiÚ
è(, 
	msigšfo_t
 *, *);

35 
	m__sigaùiÚ_hªdËr
;

36 
	#§_hªdËr
 
__sigaùiÚ_hªdËr
.
§_hªdËr


	)

37 
	#§_sigaùiÚ
 
__sigaùiÚ_hªdËr
.
§_sigaùiÚ


	)

39 
__sighªdËr_t
 
	m§_hªdËr
;

43 
__sig£t_t
 
	m§_mask
;

46 
	m§_æags
;

49 (*
	m§_»¡Ü”
) ();

53 
	#SA_NOCLDSTOP
 1

	)

54 
	#SA_NOCLDWAIT
 2

	)

55 
	#SA_SIGINFO
 4

	)

57 #ià
defšed
 
__USE_UNIX98
 || defšed 
__USE_MISC


58 
	#SA_ONSTACK
 0x08000000

	)

60 #ià
defšed
 
__USE_UNIX98
 || defšed 
__USE_XOPEN2K8


61 
	#SA_RESTART
 0x10000000

	)

62 
	#SA_NODEFER
 0x40000000

	)

64 
	#SA_RESETHAND
 0x80000000

	)

66 #ifdeà
__USE_MISC


67 
	#SA_INTERRUPT
 0x20000000

	)

70 
	#SA_NOMASK
 
SA_NODEFER


	)

71 
	#SA_ONESHOT
 
SA_RESETHAND


	)

72 
	#SA_STACK
 
SA_ONSTACK


	)

76 
	#SIG_BLOCK
 0

	)

77 
	#SIG_UNBLOCK
 1

	)

78 
	#SIG_SETMASK
 2

	)

	@/usr/include/bits/sigcontext.h

18 #iâdeà
_BITS_SIGCONTEXT_H


19 
	#_BITS_SIGCONTEXT_H
 1

	)

21 #ià!
defšed
 
_SIGNAL_H
 && !defšed 
_SYS_UCONTEXT_H


25 
	#FP_XSTATE_MAGIC1
 0x46505853U

	)

26 
	#FP_XSTATE_MAGIC2
 0x46505845U

	)

27 
	#FP_XSTATE_MAGIC2_SIZE
 (
FP_XSTATE_MAGIC2
)

	)

29 
	s_åx_sw_by‹s


31 
__ušt32_t
 
	mmagic1
;

32 
__ušt32_t
 
	mex‹nded_size
;

33 
__ušt64_t
 
	mx¡©e_bv
;

34 
__ušt32_t
 
	mx¡©e_size
;

35 
__ušt32_t
 
	m·ddšg
[7];

38 
	s_å»g


40 
	msignifiÿnd
[4];

41 
	mexpÚ’t
;

44 
	s_åx»g


46 
	msignifiÿnd
[4];

47 
	mexpÚ’t
;

48 
	m·ddšg
[3];

51 
	s_xmm»g


53 
__ušt32_t
 
	m–em’t
[4];

58 #iâdeà
__x86_64__


60 
	s_å¡©e


63 
__ušt32_t
 
	mcw
;

64 
__ušt32_t
 
	msw
;

65 
__ušt32_t
 
	mg
;

66 
__ušt32_t
 
	moff
;

67 
__ušt32_t
 
	mcs£l
;

68 
__ušt32_t
 
	md©aoff
;

69 
__ušt32_t
 
	md©a£l
;

70 
_å»g
 
	m_¡
[8];

71 
	m¡©us
;

72 
	mmagic
;

75 
__ušt32_t
 
	m_fx¤_’v
[6];

76 
__ušt32_t
 
	mmxc¤
;

77 
__ušt32_t
 
	m»£rved
;

78 
_åx»g
 
	m_fx¤_¡
[8];

79 
_xmm»g
 
	m_xmm
[8];

80 
__ušt32_t
 
	m·ddšg
[56];

83 #iâdeà
sigcÚ‹xt_¡ruù


88 
	#sigcÚ‹xt_¡ruù
 
sigcÚ‹xt


	)

91 
	#X86_FXSR_MAGIC
 0x0000

	)

93 
	ssigcÚ‹xt


95 
	mgs
, 
	m__gsh
;

96 
	mfs
, 
	m__fsh
;

97 
	mes
, 
	m__esh
;

98 
	mds
, 
	m__dsh
;

99 
	medi
;

100 
	mesi
;

101 
	mebp
;

102 
	me¥
;

103 
	mebx
;

104 
	medx
;

105 
	mecx
;

106 
	m—x
;

107 
	mŒ­no
;

108 
	m”r
;

109 
	me
;

110 
	mcs
, 
	m__csh
;

111 
	meæags
;

112 
	me¥_©_sigÇl
;

113 
	mss
, 
	m__ssh
;

114 
_å¡©e
 * 
	må¡©e
;

115 
	mÞdmask
;

116 
	mü2
;

121 
	s_å¡©e


124 
__ušt16_t
 
	mcwd
;

125 
__ušt16_t
 
	mswd
;

126 
__ušt16_t
 
	máw
;

127 
__ušt16_t
 
	mfÝ
;

128 
__ušt64_t
 
	mr
;

129 
__ušt64_t
 
	mrdp
;

130 
__ušt32_t
 
	mmxc¤
;

131 
__ušt32_t
 
	mmxü_mask
;

132 
_åx»g
 
	m_¡
[8];

133 
_xmm»g
 
	m_xmm
[16];

134 
__ušt32_t
 
	m·ddšg
[24];

137 
	ssigcÚ‹xt


139 
__ušt64_t
 
	mr8
;

140 
__ušt64_t
 
	mr9
;

141 
__ušt64_t
 
	mr10
;

142 
__ušt64_t
 
	mr11
;

143 
__ušt64_t
 
	mr12
;

144 
__ušt64_t
 
	mr13
;

145 
__ušt64_t
 
	mr14
;

146 
__ušt64_t
 
	mr15
;

147 
__ušt64_t
 
	mrdi
;

148 
__ušt64_t
 
	mrsi
;

149 
__ušt64_t
 
	mrbp
;

150 
__ušt64_t
 
	mrbx
;

151 
__ušt64_t
 
	mrdx
;

152 
__ušt64_t
 
	m¿x
;

153 
__ušt64_t
 
	mrcx
;

154 
__ušt64_t
 
	mr¥
;

155 
__ušt64_t
 
	mr
;

156 
__ušt64_t
 
	meæags
;

157 
	mcs
;

158 
	mgs
;

159 
	mfs
;

160 
	m__·d0
;

161 
__ušt64_t
 
	m”r
;

162 
__ušt64_t
 
	mŒ­no
;

163 
__ušt64_t
 
	mÞdmask
;

164 
__ušt64_t
 
	mü2
;

165 
__ex‹nsiÚ__
 union

167 
_å¡©e
 * 
	må¡©e
;

168 
__ušt64_t
 
	m__å¡©e_wÜd
;

170 
__ušt64_t
 
	m__»£rved1
 [8];

175 
	s_x§ve_hdr


177 
__ušt64_t
 
	mx¡©e_bv
;

178 
__ušt64_t
 
	m»£rved1
[2];

179 
__ušt64_t
 
	m»£rved2
[5];

182 
	s_ymmh_¡©e


184 
__ušt32_t
 
	mymmh_¥aû
[64];

187 
	s_x¡©e


189 
_å¡©e
 
	må¡©e
;

190 
_x§ve_hdr
 
	mx¡©e_hdr
;

191 
_ymmh_¡©e
 
	mymmh
;

	@/usr/include/bits/siginfo.h

19 #ià!
defšed
 
_SIGNAL_H
 && !defšed 
__Ãed_sigšfo_t
 \

20 && !
defšed
 
	g__Ãed_sigev’t_t


24 
	~<b™s/wÜdsize.h
>

26 #ià(!
defšed
 
__have_sigv®_t
 \

27 && (
defšed
 
	g_SIGNAL_H
 || defšed 
	g__Ãed_sigšfo_t
 \

28 || 
defšed
 
	g__Ãed_sigev’t_t
))

29 
	#__have_sigv®_t
 1

	)

32 
	usigv®


34 
	msiv®_št
;

35 *
	msiv®_±r
;

36 } 
	tsigv®_t
;

39 #ià(!
defšed
 
__have_sigšfo_t
 \

40 && (
defšed
 
	g_SIGNAL_H
 || defšed 
	g__Ãed_sigšfo_t
))

41 
	#__have_sigšfo_t
 1

	)

43 
	#__SI_MAX_SIZE
 128

	)

44 #ià
__WORDSIZE
 == 64

45 
	#__SI_PAD_SIZE
 ((
__SI_MAX_SIZE
 /  ()è- 4)

	)

47 
	#__SI_PAD_SIZE
 ((
__SI_MAX_SIZE
 /  ()è- 3)

	)

50 #ià
defšed
 
__x86_64__
 && 
__WORDSIZE
 == 32

55 
__þock_t
 
	t__©Œibu‹__
 ((
	t__®igÃd__
 (4))è
	t__sigchld_þock_t
;

56 
	#__SI_ALIGNMENT
 
	`__©Œibu‹__
 ((
	`__®igÃd__
 (8)))

	)

58 
__þock_t
 
	t__sigchld_þock_t
;

59 
	#__SI_ALIGNMENT


	)

64 
si_signo
;

65 
si_”ºo
;

67 
si_code
;

71 
_·d
[
__SI_PAD_SIZE
];

76 
__pid_t
 
si_pid
;

77 
__uid_t
 
si_uid
;

78 } 
_kžl
;

83 
si_tid
;

84 
si_ov”run
;

85 
sigv®_t
 
si_sigv®
;

86 } 
_tim”
;

91 
__pid_t
 
si_pid
;

92 
__uid_t
 
si_uid
;

93 
sigv®_t
 
si_sigv®
;

94 } 
_¹
;

99 
__pid_t
 
si_pid
;

100 
__uid_t
 
si_uid
;

101 
si_¡©us
;

102 
__sigchld_þock_t
 
si_utime
;

103 
__sigchld_þock_t
 
si_¡ime
;

104 } 
_sigchld
;

109 *
si_addr
;

110 
si_addr_lsb
;

113 *
_low”
;

114 *
_uµ”
;

115 } 
si_addr_bnd
;

116 } 
_sigçuÉ
;

121 
si_bªd
;

122 
si_fd
;

123 } 
_sigpÞl
;

128 *
_ÿÎ_addr
;

129 
_sysÿÎ
;

130 
_¬ch
;

131 } 
_sigsys
;

132 } 
_sif›lds
;

133 } 
	tsigšfo_t
 
	t__SI_ALIGNMENT
;

137 
	#si_pid
 
_sif›lds
.
_kžl
.
si_pid


	)

138 
	#si_uid
 
_sif›lds
.
_kžl
.
si_uid


	)

139 
	#si_tim”id
 
_sif›lds
.
_tim”
.
si_tid


	)

140 
	#si_ov”run
 
_sif›lds
.
_tim”
.
si_ov”run


	)

141 
	#si_¡©us
 
_sif›lds
.
_sigchld
.
si_¡©us


	)

142 
	#si_utime
 
_sif›lds
.
_sigchld
.
si_utime


	)

143 
	#si_¡ime
 
_sif›lds
.
_sigchld
.
si_¡ime


	)

144 
	#si_v®ue
 
_sif›lds
.
_¹
.
si_sigv®


	)

145 
	#si_št
 
_sif›lds
.
_¹
.
si_sigv®
.
siv®_št


	)

146 
	#si_±r
 
_sif›lds
.
_¹
.
si_sigv®
.
siv®_±r


	)

147 
	#si_addr
 
_sif›lds
.
_sigçuÉ
.
si_addr


	)

148 
	#si_addr_lsb
 
_sif›lds
.
_sigçuÉ
.
si_addr_lsb


	)

149 
	#si_low”
 
_sif›lds
.
_sigçuÉ
.
si_addr_bnd
.
_low”


	)

150 
	#si_uµ”
 
_sif›lds
.
_sigçuÉ
.
si_addr_bnd
.
_uµ”


	)

151 
	#si_bªd
 
_sif›lds
.
_sigpÞl
.
si_bªd


	)

152 
	#si_fd
 
_sif›lds
.
_sigpÞl
.
si_fd


	)

153 
	#si_ÿÎ_addr
 
_sif›lds
.
_sigsys
.
_ÿÎ_addr


	)

154 
	#si_sysÿÎ
 
_sif›lds
.
_sigsys
.
_sysÿÎ


	)

155 
	#si_¬ch
 
_sif›lds
.
_sigsys
.
_¬ch


	)

162 
SI_ASYNCNL
 = -60,

163 
	#SI_ASYNCNL
 
SI_ASYNCNL


	)

164 
SI_TKILL
 = -6,

165 
	#SI_TKILL
 
SI_TKILL


	)

166 
SI_SIGIO
,

167 
	#SI_SIGIO
 
SI_SIGIO


	)

168 
SI_ASYNCIO
,

169 
	#SI_ASYNCIO
 
SI_ASYNCIO


	)

170 
SI_MESGQ
,

171 
	#SI_MESGQ
 
SI_MESGQ


	)

172 
SI_TIMER
,

173 
	#SI_TIMER
 
SI_TIMER


	)

174 
SI_QUEUE
,

175 
	#SI_QUEUE
 
SI_QUEUE


	)

176 
SI_USER
,

177 
	#SI_USER
 
SI_USER


	)

178 
SI_KERNEL
 = 0x80

179 
	#SI_KERNEL
 
SI_KERNEL


	)

183 #ià
defšed
 
__USE_XOPEN_EXTENDED
 || defšed 
__USE_XOPEN2K8


187 
ILL_ILLOPC
 = 1,

188 
	#ILL_ILLOPC
 
ILL_ILLOPC


	)

189 
ILL_ILLOPN
,

190 
	#ILL_ILLOPN
 
ILL_ILLOPN


	)

191 
ILL_ILLADR
,

192 
	#ILL_ILLADR
 
ILL_ILLADR


	)

193 
ILL_ILLTRP
,

194 
	#ILL_ILLTRP
 
ILL_ILLTRP


	)

195 
ILL_PRVOPC
,

196 
	#ILL_PRVOPC
 
ILL_PRVOPC


	)

197 
ILL_PRVREG
,

198 
	#ILL_PRVREG
 
ILL_PRVREG


	)

199 
ILL_COPROC
,

200 
	#ILL_COPROC
 
ILL_COPROC


	)

201 
ILL_BADSTK


202 
	#ILL_BADSTK
 
ILL_BADSTK


	)

208 
FPE_INTDIV
 = 1,

209 
	#FPE_INTDIV
 
FPE_INTDIV


	)

210 
FPE_INTOVF
,

211 
	#FPE_INTOVF
 
FPE_INTOVF


	)

212 
FPE_FLTDIV
,

213 
	#FPE_FLTDIV
 
FPE_FLTDIV


	)

214 
FPE_FLTOVF
,

215 
	#FPE_FLTOVF
 
FPE_FLTOVF


	)

216 
FPE_FLTUND
,

217 
	#FPE_FLTUND
 
FPE_FLTUND


	)

218 
FPE_FLTRES
,

219 
	#FPE_FLTRES
 
FPE_FLTRES


	)

220 
FPE_FLTINV
,

221 
	#FPE_FLTINV
 
FPE_FLTINV


	)

222 
FPE_FLTSUB


223 
	#FPE_FLTSUB
 
FPE_FLTSUB


	)

229 
SEGV_MAPERR
 = 1,

230 
	#SEGV_MAPERR
 
SEGV_MAPERR


	)

231 
SEGV_ACCERR


232 
	#SEGV_ACCERR
 
SEGV_ACCERR


	)

238 
BUS_ADRALN
 = 1,

239 
	#BUS_ADRALN
 
BUS_ADRALN


	)

240 
BUS_ADRERR
,

241 
	#BUS_ADRERR
 
BUS_ADRERR


	)

242 
BUS_OBJERR
,

243 
	#BUS_OBJERR
 
BUS_OBJERR


	)

244 
BUS_MCEERR_AR
,

245 
	#BUS_MCEERR_AR
 
BUS_MCEERR_AR


	)

246 
BUS_MCEERR_AO


247 
	#BUS_MCEERR_AO
 
BUS_MCEERR_AO


	)

251 #ifdeà
__USE_XOPEN_EXTENDED


255 
TRAP_BRKPT
 = 1,

256 
	#TRAP_BRKPT
 
TRAP_BRKPT


	)

257 
TRAP_TRACE


258 
	#TRAP_TRACE
 
TRAP_TRACE


	)

262 #ià
defšed
 
__USE_XOPEN_EXTENDED
 || defšed 
__USE_XOPEN2K8


266 
CLD_EXITED
 = 1,

267 
	#CLD_EXITED
 
CLD_EXITED


	)

268 
CLD_KILLED
,

269 
	#CLD_KILLED
 
CLD_KILLED


	)

270 
CLD_DUMPED
,

271 
	#CLD_DUMPED
 
CLD_DUMPED


	)

272 
CLD_TRAPPED
,

273 
	#CLD_TRAPPED
 
CLD_TRAPPED


	)

274 
CLD_STOPPED
,

275 
	#CLD_STOPPED
 
CLD_STOPPED


	)

276 
CLD_CONTINUED


277 
	#CLD_CONTINUED
 
CLD_CONTINUED


	)

283 
POLL_IN
 = 1,

284 
	#POLL_IN
 
POLL_IN


	)

285 
POLL_OUT
,

286 
	#POLL_OUT
 
POLL_OUT


	)

287 
POLL_MSG
,

288 
	#POLL_MSG
 
POLL_MSG


	)

289 
POLL_ERR
,

290 
	#POLL_ERR
 
POLL_ERR


	)

291 
POLL_PRI
,

292 
	#POLL_PRI
 
POLL_PRI


	)

293 
POLL_HUP


294 
	#POLL_HUP
 
POLL_HUP


	)

298 #undeà
__Ãed_sigšfo_t


302 #ià(
defšed
 
_SIGNAL_H
 || defšed 
__Ãed_sigev’t_t
) \

303 && !
defšed
 
__have_sigev’t_t


304 
	#__have_sigev’t_t
 1

	)

307 
	#__SIGEV_MAX_SIZE
 64

	)

308 #ià
__WORDSIZE
 == 64

309 
	#__SIGEV_PAD_SIZE
 ((
__SIGEV_MAX_SIZE
 /  ()è- 4)

	)

311 
	#__SIGEV_PAD_SIZE
 ((
__SIGEV_MAX_SIZE
 /  ()è- 3)

	)

315 #iâdeà
__have_±h»ad_©Œ_t


316 
±h»ad_©Œ_t
 
	t±h»ad_©Œ_t
;

317 
	#__have_±h»ad_©Œ_t
 1

	)

320 
	ssigev’t


322 
sigv®_t
 
sigev_v®ue
;

323 
sigev_signo
;

324 
sigev_nÙify
;

328 
_·d
[
__SIGEV_PAD_SIZE
];

332 
__pid_t
 
_tid
;

336 (*
_funùiÚ
è(
sigv®_t
);

337 
±h»ad_©Œ_t
 *
_©Œibu‹
;

338 } 
_sigev_th»ad
;

339 } 
_sigev_un
;

340 } 
	tsigev’t_t
;

343 
	#sigev_nÙify_funùiÚ
 
_sigev_un
.
_sigev_th»ad
.
_funùiÚ


	)

344 
	#sigev_nÙify_©Œibu‹s
 
_sigev_un
.
_sigev_th»ad
.
_©Œibu‹


	)

349 
SIGEV_SIGNAL
 = 0,

350 
	#SIGEV_SIGNAL
 
SIGEV_SIGNAL


	)

351 
SIGEV_NONE
,

352 
	#SIGEV_NONE
 
SIGEV_NONE


	)

353 
SIGEV_THREAD
,

354 
	#SIGEV_THREAD
 
SIGEV_THREAD


	)

356 
SIGEV_THREAD_ID
 = 4

357 
	#SIGEV_THREAD_ID
 
SIGEV_THREAD_ID


	)

	@/usr/include/bits/signum.h

19 #ifdef 
_SIGNAL_H


22 
	#SIG_ERR
 ((
__sighªdËr_t
è-1è

	)

23 
	#SIG_DFL
 ((
__sighªdËr_t
è0è

	)

24 
	#SIG_IGN
 ((
__sighªdËr_t
è1è

	)

26 #ifdeà
__USE_UNIX98


27 
	#SIG_HOLD
 ((
__sighªdËr_t
è2è

	)

32 
	#SIGHUP
 1

	)

33 
	#SIGINT
 2

	)

34 
	#SIGQUIT
 3

	)

35 
	#SIGILL
 4

	)

36 
	#SIGTRAP
 5

	)

37 
	#SIGABRT
 6

	)

38 
	#SIGIOT
 6

	)

39 
	#SIGBUS
 7

	)

40 
	#SIGFPE
 8

	)

41 
	#SIGKILL
 9

	)

42 
	#SIGUSR1
 10

	)

43 
	#SIGSEGV
 11

	)

44 
	#SIGUSR2
 12

	)

45 
	#SIGPIPE
 13

	)

46 
	#SIGALRM
 14

	)

47 
	#SIGTERM
 15

	)

48 
	#SIGSTKFLT
 16

	)

49 
	#SIGCLD
 
SIGCHLD


	)

50 
	#SIGCHLD
 17

	)

51 
	#SIGCONT
 18

	)

52 
	#SIGSTOP
 19

	)

53 
	#SIGTSTP
 20

	)

54 
	#SIGTTIN
 21

	)

55 
	#SIGTTOU
 22

	)

56 
	#SIGURG
 23

	)

57 
	#SIGXCPU
 24

	)

58 
	#SIGXFSZ
 25

	)

59 
	#SIGVTALRM
 26

	)

60 
	#SIGPROF
 27

	)

61 
	#SIGWINCH
 28

	)

62 
	#SIGPOLL
 
SIGIO


	)

63 
	#SIGIO
 29

	)

64 
	#SIGPWR
 30

	)

65 
	#SIGSYS
 31

	)

66 
	#SIGUNUSED
 31

	)

68 
	#_NSIG
 65

	)

71 
	#SIGRTMIN
 (
	`__libc_cu¼’t_sig¹mš
 ())

	)

72 
	#SIGRTMAX
 (
	`__libc_cu¼’t_sig¹max
 ())

	)

76 
	#__SIGRTMIN
 32

	)

77 
	#__SIGRTMAX
 (
_NSIG
 - 1)

	)

	@/usr/include/bits/sigset.h

19 #iâdef 
_SIGSET_H_ty³s


20 
	#_SIGSET_H_ty³s
 1

	)

22 
	t__sig_©omic_t
;

26 
	#_SIGSET_NWORDS
 (1024 / (8 *  ()))

	)

29 
	m__v®
[
_SIGSET_NWORDS
];

30 } 
	t__sig£t_t
;

41 #ià!
defšed
 
_SIGSET_H_âs
 && defšed 
_SIGNAL_H


42 
	#_SIGSET_H_âs
 1

	)

44 #iâdeà
_EXTERN_INLINE


45 
	#_EXTERN_INLINE
 
__ex‹º_šlše


	)

49 
	#__sigmask
(
sig
) \

50 (((è1è<< (((
sig
è- 1è% (8 *  ())))

	)

53 
	#__sigwÜd
(
sig
è(((sigè- 1è/ (8 *  ()))

	)

55 #ià
defšed
 
__GNUC__
 && __GNUC__ >= 2

56 
	#__sigem±y£t
(
£t
) \

57 (
	`__ex‹nsiÚ__
 ({ 
__út
 = 
_SIGSET_NWORDS
; \

58 
sig£t_t
 *
__£t
 = (
£t
); \

59 --
__út
 >ð0è
__£t
->
__v®
[__cnt] = 0; \

60 0; }))

	)

61 
	#__sigfžl£t
(
£t
) \

62 (
	`__ex‹nsiÚ__
 ({ 
__út
 = 
_SIGSET_NWORDS
; \

63 
sig£t_t
 *
__£t
 = (
£t
); \

64 --
__út
 >ð0è
__£t
->
__v®
[__cnt] = ~0UL; \

65 0; }))

	)

67 #ifdeà
__USE_GNU


71 
	#__sigi£m±y£t
(
£t
) \

72 (
	`__ex‹nsiÚ__
 ({ 
__út
 = 
_SIGSET_NWORDS
; \

73 cÚ¡ 
sig£t_t
 *
__£t
 = (
£t
); \

74 
__»t
 = 
__£t
->
__v®
[--
__út
]; \

75 !
__»t
 && --
__út
 >= 0) \

76 
__»t
 = 
__£t
->
__v®
[
__út
]; \

77 
__»t
 =ð0; }))

	)

78 
	#__sigªd£t
(
de¡
, 
Ëá
, 
right
) \

79 (
	`__ex‹nsiÚ__
 ({ 
__út
 = 
_SIGSET_NWORDS
; \

80 
sig£t_t
 *
__de¡
 = (
de¡
); \

81 cÚ¡ 
sig£t_t
 *
__Ëá
 = (
Ëá
); \

82 cÚ¡ 
sig£t_t
 *
__right
 = (
right
); \

83 --
__út
 >= 0) \

84 
__de¡
->
__v®
[
__út
] = (
__Ëá
->__val[__cnt] \

85 & 
__right
->
__v®
[
__út
]); \

86 0; }))

	)

87 
	#__sigÜ£t
(
de¡
, 
Ëá
, 
right
) \

88 (
	`__ex‹nsiÚ__
 ({ 
__út
 = 
_SIGSET_NWORDS
; \

89 
sig£t_t
 *
__de¡
 = (
de¡
); \

90 cÚ¡ 
sig£t_t
 *
__Ëá
 = (
Ëá
); \

91 cÚ¡ 
sig£t_t
 *
__right
 = (
right
); \

92 --
__út
 >= 0) \

93 
__de¡
->
__v®
[
__út
] = (
__Ëá
->__val[__cnt] \

94 | 
__right
->
__v®
[
__út
]); \

95 0; }))

	)

102 
__sigismemb”
 (cÚ¡ 
__sig£t_t
 *, );

103 
__sigadd£t
 (
__sig£t_t
 *, );

104 
__sigd–£t
 (
__sig£t_t
 *, );

106 #ifdeà
__USE_EXTERN_INLINES


107 
	#__SIGSETFN
(
NAME
, 
BODY
, 
CONST
) \

108 
_EXTERN_INLINE
 \

109 
	`NAME
 (
CONST
 
__sig£t_t
 *
__£t
, 
__sig
) \

111 
__mask
 = 
	`__sigmask
 (
__sig
); \

112 
__wÜd
 = 
	`__sigwÜd
 (
__sig
); \

113  
BODY
; \

114 }

	)

116 
__SIGSETFN
 (
__sigismemb”
, (
__£t
->
__v®
[
__wÜd
] & 
__mask
) ? 1 : 0, const)

117 
__SIGSETFN
 (
__sigadd£t
, ((
__£t
->
__v®
[
__wÜd
] |ð
__mask
), 0), )

118 
__SIGSETFN
 (
__sigd–£t
, ((
__£t
->
__v®
[
__wÜd
] &ð~
__mask
), 0), )

120 #undeà
__SIGSETFN


	@/usr/include/bits/sigstack.h

19 #iâdeà
_SIGNAL_H


25 
	ssig¡ack


27 *
	mss_¥
;

28 
	mss_Ú¡ack
;

35 
	mSS_ONSTACK
 = 1,

36 
	#SS_ONSTACK
 
SS_ONSTACK


	)

37 
	mSS_DISABLE


38 
	#SS_DISABLE
 
SS_DISABLE


	)

42 
	#MINSIGSTKSZ
 2048

	)

45 
	#SIGSTKSZ
 8192

	)

49 
	ssig®t¡ack


51 *
	mss_¥
;

52 
	mss_æags
;

53 
size_t
 
	mss_size
;

54 } 
	t¡ack_t
;

	@/usr/include/bits/sigthread.h

19 #iâdeà
_BITS_SIGTHREAD_H


20 
	#_BITS_SIGTHREAD_H
 1

	)

22 #ià!
defšed
 
_SIGNAL_H
 && !defšed 
_PTHREAD_H


30 
	$±h»ad_sigmask
 (
__how
,

31 cÚ¡ 
__sig£t_t
 *
__»¡riù
 
__Ãwmask
,

32 
__sig£t_t
 *
__»¡riù
 
__Þdmask
)
__THROW
;

35 
	$±h»ad_kžl
 (
±h»ad_t
 
__th»adid
, 
__signo
è
__THROW
;

37 #ifdeà
__USE_GNU


39 
	$±h»ad_sigqueue
 (
±h»ad_t
 
__th»adid
, 
__signo
,

40 cÚ¡ 
sigv®
 
__v®ue
è
__THROW
;

	@/usr/include/bits/stat.h

18 #ià!
defšed
 
_SYS_STAT_H
 && !defšed 
_FCNTL_H


22 #iâdeà
_BITS_STAT_H


23 
	#_BITS_STAT_H
 1

	)

26 #iâdeà
__x86_64__


27 
	#_STAT_VER_LINUX_OLD
 1

	)

28 
	#_STAT_VER_KERNEL
 1

	)

29 
	#_STAT_VER_SVR4
 2

	)

30 
	#_STAT_VER_LINUX
 3

	)

33 
	#_MKNOD_VER_LINUX
 1

	)

34 
	#_MKNOD_VER_SVR4
 2

	)

35 
	#_MKNOD_VER
 
_MKNOD_VER_LINUX


	)

37 
	#_STAT_VER_KERNEL
 0

	)

38 
	#_STAT_VER_LINUX
 1

	)

41 
	#_MKNOD_VER_LINUX
 0

	)

44 
	#_STAT_VER
 
_STAT_VER_LINUX


	)

46 
	s¡©


48 
__dev_t
 
	m¡_dev
;

49 #iâdeà
__x86_64__


50 
	m__·d1
;

52 #ià
defšed
 
__x86_64__
 || !defšed 
__USE_FILE_OFFSET64


53 
__šo_t
 
	m¡_šo
;

55 
__šo_t
 
	m__¡_šo
;

57 #iâdeà
__x86_64__


58 
__mode_t
 
	m¡_mode
;

59 
__Æšk_t
 
	m¡_Æšk
;

61 
__Æšk_t
 
	m¡_Æšk
;

62 
__mode_t
 
	m¡_mode
;

64 
__uid_t
 
	m¡_uid
;

65 
__gid_t
 
	m¡_gid
;

66 #ifdeà
__x86_64__


67 
	m__·d0
;

69 
__dev_t
 
	m¡_rdev
;

70 #iâdeà
__x86_64__


71 
	m__·d2
;

73 #ià
defšed
 
__x86_64__
 || !defšed 
__USE_FILE_OFFSET64


74 
__off_t
 
	m¡_size
;

76 
__off64_t
 
	m¡_size
;

78 
__blksize_t
 
	m¡_blksize
;

79 #ià
defšed
 
__x86_64__
 || !defšed 
__USE_FILE_OFFSET64


80 
__blkút_t
 
	m¡_blocks
;

82 
__blkút64_t
 
	m¡_blocks
;

84 #ifdeà
__USE_XOPEN2K8


91 
time¥ec
 
	m¡_©im
;

92 
time¥ec
 
	m¡_mtim
;

93 
time¥ec
 
	m¡_ùim
;

94 
	#¡_©ime
 
¡_©im
.
tv_£c


	)

95 
	#¡_mtime
 
¡_mtim
.
tv_£c


	)

96 
	#¡_ùime
 
¡_ùim
.
tv_£c


	)

98 
__time_t
 
	m¡_©ime
;

99 
__sysÿÎ_ulÚg_t
 
	m¡_©im’£c
;

100 
__time_t
 
	m¡_mtime
;

101 
__sysÿÎ_ulÚg_t
 
	m¡_mtim’£c
;

102 
__time_t
 
	m¡_ùime
;

103 
__sysÿÎ_ulÚg_t
 
	m¡_ùim’£c
;

105 #ifdeà
__x86_64__


106 
__sysÿÎ_¦Úg_t
 
	m__glibc_»£rved
[3];

108 #iâdeà
__USE_FILE_OFFSET64


109 
	m__glibc_»£rved4
;

110 
	m__glibc_»£rved5
;

112 
__šo64_t
 
	m¡_šo
;

117 #ifdeà
__USE_LARGEFILE64


119 
	s¡©64


121 
__dev_t
 
	m¡_dev
;

122 #ifdeà
__x86_64__


123 
__šo64_t
 
	m¡_šo
;

124 
__Æšk_t
 
	m¡_Æšk
;

125 
__mode_t
 
	m¡_mode
;

127 
	m__·d1
;

128 
__šo_t
 
	m__¡_šo
;

129 
__mode_t
 
	m¡_mode
;

130 
__Æšk_t
 
	m¡_Æšk
;

132 
__uid_t
 
	m¡_uid
;

133 
__gid_t
 
	m¡_gid
;

134 #ifdeà
__x86_64__


135 
	m__·d0
;

136 
__dev_t
 
	m¡_rdev
;

137 
__off_t
 
	m¡_size
;

139 
__dev_t
 
	m¡_rdev
;

140 
	m__·d2
;

141 
__off64_t
 
	m¡_size
;

143 
__blksize_t
 
	m¡_blksize
;

144 
__blkút64_t
 
	m¡_blocks
;

145 #ifdeà
__USE_XOPEN2K8


152 
time¥ec
 
	m¡_©im
;

153 
time¥ec
 
	m¡_mtim
;

154 
time¥ec
 
	m¡_ùim
;

156 
__time_t
 
	m¡_©ime
;

157 
__sysÿÎ_ulÚg_t
 
	m¡_©im’£c
;

158 
__time_t
 
	m¡_mtime
;

159 
__sysÿÎ_ulÚg_t
 
	m¡_mtim’£c
;

160 
__time_t
 
	m¡_ùime
;

161 
__sysÿÎ_ulÚg_t
 
	m¡_ùim’£c
;

163 #ifdeà
__x86_64__


164 
__sysÿÎ_¦Úg_t
 
	m__glibc_»£rved
[3];

166 
__šo64_t
 
	m¡_šo
;

172 
	#_STATBUF_ST_BLKSIZE


	)

173 
	#_STATBUF_ST_RDEV


	)

175 
	#_STATBUF_ST_NSEC


	)

179 
	#__S_IFMT
 0170000

	)

182 
	#__S_IFDIR
 0040000

	)

183 
	#__S_IFCHR
 0020000

	)

184 
	#__S_IFBLK
 0060000

	)

185 
	#__S_IFREG
 0100000

	)

186 
	#__S_IFIFO
 0010000

	)

187 
	#__S_IFLNK
 0120000

	)

188 
	#__S_IFSOCK
 0140000

	)

192 
	#__S_TYPEISMQ
(
buf
è((buf)->
¡_mode
 - (buf)->¡_mode)

	)

193 
	#__S_TYPEISSEM
(
buf
è((buf)->
¡_mode
 - (buf)->¡_mode)

	)

194 
	#__S_TYPEISSHM
(
buf
è((buf)->
¡_mode
 - (buf)->¡_mode)

	)

198 
	#__S_ISUID
 04000

	)

199 
	#__S_ISGID
 02000

	)

200 
	#__S_ISVTX
 01000

	)

201 
	#__S_IREAD
 0400

	)

202 
	#__S_IWRITE
 0200

	)

203 
	#__S_IEXEC
 0100

	)

205 #ifdeà
__USE_ATFILE


206 
	#UTIME_NOW
 ((1È<< 30è- 1l)

	)

207 
	#UTIME_OMIT
 ((1È<< 30è- 2l)

	)

	@/usr/include/bits/stdio-ldbl.h

19 #iâdeà
_STDIO_H


23 
__BEGIN_NAMESPACE_STD


24 
	$__LDBL_REDIR_DECL
 (
årštf
)

25 
	$__LDBL_REDIR_DECL
 (
´štf
)

26 
	$__LDBL_REDIR_DECL
 (
¥rštf
)

27 
	$__LDBL_REDIR_DECL
 (
vårštf
)

28 
	$__LDBL_REDIR_DECL
 (
v´štf
)

29 
	$__LDBL_REDIR_DECL
 (
v¥rštf
)

30 #ià
defšed
 
__USE_ISOC99
 && !defšed 
__USE_GNU
 \

31 && !
defšed
 
__REDIRECT
 \

32 && (
defšed
 
__STRICT_ANSI__
 || defšed 
__USE_XOPEN2K
)

33 
	$__LDBL_REDIR1_DECL
 (
fsÿnf
, 
__Ædbl___isoc99_fsÿnf
)

34 
	$__LDBL_REDIR1_DECL
 (
sÿnf
, 
__Ædbl___isoc99_sÿnf
)

35 
	$__LDBL_REDIR1_DECL
 (
ssÿnf
, 
__Ædbl___isoc99_ssÿnf
)

37 
	$__LDBL_REDIR_DECL
 (
fsÿnf
)

38 
	$__LDBL_REDIR_DECL
 (
sÿnf
)

39 
	$__LDBL_REDIR_DECL
 (
ssÿnf
)

41 
__END_NAMESPACE_STD


43 #ià
defšed
 
__USE_ISOC99
 || defšed 
__USE_UNIX98


44 
__BEGIN_NAMESPACE_C99


45 
	$__LDBL_REDIR_DECL
 (
¢´štf
)

46 
	$__LDBL_REDIR_DECL
 (
v¢´štf
)

47 
__END_NAMESPACE_C99


50 #ifdef 
__USE_ISOC99


51 
__BEGIN_NAMESPACE_C99


52 #ià!
defšed
 
__USE_GNU
 && !defšed 
__REDIRECT
 \

53 && (
defšed
 
__STRICT_ANSI__
 || defšed 
__USE_XOPEN2K
)

54 
	$__LDBL_REDIR1_DECL
 (
vfsÿnf
, 
__Ædbl___isoc99_vfsÿnf
)

55 
	$__LDBL_REDIR1_DECL
 (
vsÿnf
, 
__Ædbl___isoc99_vsÿnf
)

56 
	$__LDBL_REDIR1_DECL
 (
vssÿnf
, 
__Ædbl___isoc99_vssÿnf
)

58 
	$__LDBL_REDIR_DECL
 (
vfsÿnf
)

59 
	$__LDBL_REDIR_DECL
 (
vssÿnf
)

60 
	$__LDBL_REDIR_DECL
 (
vsÿnf
)

62 
__END_NAMESPACE_C99


65 #ifdeà
__USE_XOPEN2K8


66 
	$__LDBL_REDIR_DECL
 (
vd´štf
)

67 
	$__LDBL_REDIR_DECL
 (
d´štf
)

70 #ifdeà
__USE_GNU


71 
	$__LDBL_REDIR_DECL
 (
va¥rštf
)

72 
	$__LDBL_REDIR_DECL
 (
__a¥rštf
)

73 
	$__LDBL_REDIR_DECL
 (
a¥rštf
)

74 
	$__LDBL_REDIR_DECL
 (
ob¡ack_´štf
)

75 
	$__LDBL_REDIR_DECL
 (
ob¡ack_v´štf
)

78 #ià
__USE_FORTIFY_LEVEL
 > 0 && 
defšed
 
__fÜtify_funùiÚ


79 
	$__LDBL_REDIR_DECL
 (
__¥rštf_chk
)

80 
	$__LDBL_REDIR_DECL
 (
__v¥rštf_chk
)

81 #ià
defšed
 
__USE_ISOC99
 || defšed 
__USE_UNIX98


82 
	$__LDBL_REDIR_DECL
 (
__¢´štf_chk
)

83 
	$__LDBL_REDIR_DECL
 (
__v¢´štf_chk
)

85 #ià
__USE_FORTIFY_LEVEL
 > 1

86 
	$__LDBL_REDIR_DECL
 (
__årštf_chk
)

87 
	$__LDBL_REDIR_DECL
 (
__´štf_chk
)

88 
	$__LDBL_REDIR_DECL
 (
__vårštf_chk
)

89 
	$__LDBL_REDIR_DECL
 (
__v´štf_chk
)

90 #ifdeà
__USE_XOPEN2K8


91 
	$__LDBL_REDIR_DECL
 (
__d´štf_chk
)

92 
	$__LDBL_REDIR_DECL
 (
__vd´štf_chk
)

94 #ifdeà
__USE_GNU


95 
	$__LDBL_REDIR_DECL
 (
__a¥rštf_chk
)

96 
	$__LDBL_REDIR_DECL
 (
__va¥rštf_chk
)

97 
	$__LDBL_REDIR_DECL
 (
__ob¡ack_´štf_chk
)

98 
	$__LDBL_REDIR_DECL
 (
__ob¡ack_v´štf_chk
)

	@/usr/include/bits/stdio.h

19 #iâdeà
_STDIO_H


23 #iâdeà
__ex‹º_šlše


24 
	#__STDIO_INLINE
 
šlše


	)

26 
	#__STDIO_INLINE
 
__ex‹º_šlše


	)

30 #ifdeà
__USE_EXTERN_INLINES


33 #ià!(
__USE_FORTIFY_LEVEL
 > 0 && 
defšed
 
__fÜtify_funùiÚ
)

35 
__STDIO_INLINE
 

36 
	$v´štf
 (cÚ¡ *
__»¡riù
 
__fmt
, 
_G_va_li¡
 
__¬g
)

38  
	`vårštf
 (
¡dout
, 
__fmt
, 
__¬g
);

39 
	}
}

43 
__STDIO_INLINE
 

44 
	$g‘ch¬
 ()

46  
	`_IO_g‘c
 (
¡dš
);

47 
	}
}

50 #ifdeà
__USE_MISC


52 
__STDIO_INLINE
 

53 
	$fg‘c_uÆocked
 (
FILE
 *
__å
)

55  
	`_IO_g‘c_uÆocked
 (
__å
);

56 
	}
}

60 #ifdeà
__USE_POSIX


62 
__STDIO_INLINE
 

63 
	$g‘c_uÆocked
 (
FILE
 *
__å
)

65  
	`_IO_g‘c_uÆocked
 (
__å
);

66 
	}
}

69 
__STDIO_INLINE
 

70 
	$g‘ch¬_uÆocked
 ()

72  
	`_IO_g‘c_uÆocked
 (
¡dš
);

73 
	}
}

78 
__STDIO_INLINE
 

79 
	$putch¬
 (
__c
)

81  
	`_IO_putc
 (
__c
, 
¡dout
);

82 
	}
}

85 #ifdeà
__USE_MISC


87 
__STDIO_INLINE
 

88 
	$åutc_uÆocked
 (
__c
, 
FILE
 *
__¡»am
)

90  
	`_IO_putc_uÆocked
 (
__c
, 
__¡»am
);

91 
	}
}

95 #ifdeà
__USE_POSIX


97 
__STDIO_INLINE
 

98 
	$putc_uÆocked
 (
__c
, 
FILE
 *
__¡»am
)

100  
	`_IO_putc_uÆocked
 (
__c
, 
__¡»am
);

101 
	}
}

104 
__STDIO_INLINE
 

105 
	$putch¬_uÆocked
 (
__c
)

107  
	`_IO_putc_uÆocked
 (
__c
, 
¡dout
);

108 
	}
}

112 #ifdef 
__USE_GNU


114 
__STDIO_INLINE
 
_IO_ssize_t


115 
	$g‘lše
 (**
__lš•Œ
, 
size_t
 *
__n
, 
FILE
 *
__¡»am
)

117  
	`__g‘d–im
 (
__lš•Œ
, 
__n
, '\n', 
__¡»am
);

118 
	}
}

122 #ifdeà
__USE_MISC


124 
__STDIO_INLINE
 

125 
__NTH
 (
	$ãof_uÆocked
 (
FILE
 *
__¡»am
))

127  
	`_IO_ãof_uÆocked
 (
__¡»am
);

128 
	}
}

131 
__STDIO_INLINE
 

132 
__NTH
 (
	$ã¼Ü_uÆocked
 (
FILE
 *
__¡»am
))

134  
	`_IO_ã¼Ü_uÆocked
 (
__¡»am
);

135 
	}
}

141 #ià
defšed
 
__USE_MISC
 && defšed 
__GNUC__
 && defšed 
__OPTIMIZE__
 \

142 && !
defšed
 
	g__ýlu¥lus


144 
	#ä—d_uÆocked
(
±r
, 
size
, 
n
, 
¡»am
) \

145 (
	`__ex‹nsiÚ__
 ((
	`__bužtš_cÚ¡ªt_p
 (
size
è&& __bužtš_cÚ¡ªt_°(
n
) \

146 && (
size_t
è(
size
è* (size_tè(
n
) <= 8 \

147 && (
size_t
è(
size
) != 0) \

148 ? ({ *
__±r
 = (*è(
±r
); \

149 
FILE
 *
__¡»am
 = (
¡»am
); \

150 
size_t
 
__út
; \

151 
__út
 = (
size_t
è(
size
è* (size_tè(
n
); \

152 
__út
 > 0; --__cnt) \

154 
__c
 = 
	`_IO_g‘c_uÆocked
 (
__¡»am
); \

155 ià(
__c
 =ð
EOF
) \

157 *
__±r
++ = 
__c
; \

159 ((
size_t
è(
size
è* (size_tè(
n
è- 
__út
) \

160 / (
size_t
è(
size
); }) \

161 : (((
	`__bužtš_cÚ¡ªt_p
 (
size
è&& (
size_t
) (size) == 0) \

162 || (
	`__bužtš_cÚ¡ªt_p
 (
n
è&& (
size_t
) (n) == 0)) \

164 ? ((è(
±r
), (è(
¡»am
), (è(
size
), \

165 (è(
n
), (
size_t
) 0) \

166 : 
	`ä—d_uÆocked
 (
±r
, 
size
, 
n
, 
¡»am
))))

	)

168 
	#fwr™e_uÆocked
(
±r
, 
size
, 
n
, 
¡»am
) \

169 (
	`__ex‹nsiÚ__
 ((
	`__bužtš_cÚ¡ªt_p
 (
size
è&& __bužtš_cÚ¡ªt_°(
n
) \

170 && (
size_t
è(
size
è* (size_tè(
n
) <= 8 \

171 && (
size_t
è(
size
) != 0) \

172 ? ({ cÚ¡ *
__±r
 = (cÚ¡ *è(
±r
); \

173 
FILE
 *
__¡»am
 = (
¡»am
); \

174 
size_t
 
__út
; \

175 
__út
 = (
size_t
è(
size
è* (size_tè(
n
); \

176 
__út
 > 0; --__cnt) \

177 ià(
	`_IO_putc_uÆocked
 (*
__±r
++, 
__¡»am
è=ð
EOF
) \

179 ((
size_t
è(
size
è* (size_tè(
n
è- 
__út
) \

180 / (
size_t
è(
size
); }) \

181 : (((
	`__bužtš_cÚ¡ªt_p
 (
size
è&& (
size_t
) (size) == 0) \

182 || (
	`__bužtš_cÚ¡ªt_p
 (
n
è&& (
size_t
) (n) == 0)) \

184 ? ((è(
±r
), (è(
¡»am
), (è(
size
), \

185 (è(
n
), (
size_t
) 0) \

186 : 
	`fwr™e_uÆocked
 (
±r
, 
size
, 
n
, 
¡»am
))))

	)

190 #undeà
__STDIO_INLINE


	@/usr/include/bits/stdio2.h

19 #iâdeà
_STDIO_H


23 
	$__¥rštf_chk
 (*
__»¡riù
 
__s
, 
__æag
, 
size_t
 
__¦’
,

24 cÚ¡ *
__»¡riù
 
__fÜm©
, ...è
__THROW
;

25 
	$__v¥rštf_chk
 (*
__»¡riù
 
__s
, 
__æag
, 
size_t
 
__¦’
,

26 cÚ¡ *
__»¡riù
 
__fÜm©
,

27 
_G_va_li¡
 
__­
è
__THROW
;

29 #ifdeà
__va_¬g_·ck


30 
__fÜtify_funùiÚ
 

31 
	`__NTH
 (
	$¥rštf
 (*
__»¡riù
 
__s
, cÚ¡ *__»¡riù 
__fmt
, ...))

33  
	`__bužtš___¥rštf_chk
 (
__s
, 
__USE_FORTIFY_LEVEL
 - 1,

34 
	`__bos
 (
__s
), 
__fmt
, 
	`__va_¬g_·ck
 ());

35 
	}
}

36 #–ià!
defšed
 
__ýlu¥lus


37 
	#¥rštf
(
¡r
, ...) \

38 
	`__bužtš___¥rštf_chk
 (
¡r
, 
__USE_FORTIFY_LEVEL
 - 1, 
	`__bos
 (str), \

39 
__VA_ARGS__
)

	)

42 
__fÜtify_funùiÚ
 

43 
__NTH
 (
	$v¥rštf
 (*
__»¡riù
 
__s
, cÚ¡ *__»¡riù 
__fmt
,

44 
_G_va_li¡
 
__­
))

46  
	`__bužtš___v¥rštf_chk
 (
__s
, 
__USE_FORTIFY_LEVEL
 - 1,

47 
	`__bos
 (
__s
), 
__fmt
, 
__­
);

48 
	}
}

50 #ià
defšed
 
__USE_ISOC99
 || defšed 
__USE_UNIX98


52 
	$__¢´štf_chk
 (*
__»¡riù
 
__s
, 
size_t
 
__n
, 
__æag
,

53 
size_t
 
__¦’
, cÚ¡ *
__»¡riù
 
__fÜm©
,

54 ...è
__THROW
;

55 
	$__v¢´štf_chk
 (*
__»¡riù
 
__s
, 
size_t
 
__n
, 
__æag
,

56 
size_t
 
__¦’
, cÚ¡ *
__»¡riù
 
__fÜm©
,

57 
_G_va_li¡
 
__­
è
__THROW
;

59 #ifdeà
__va_¬g_·ck


60 
__fÜtify_funùiÚ
 

61 
	`__NTH
 (
	$¢´štf
 (*
__»¡riù
 
__s
, 
size_t
 
__n
,

62 cÚ¡ *
__»¡riù
 
__fmt
, ...))

64  
	`__bužtš___¢´štf_chk
 (
__s
, 
__n
, 
__USE_FORTIFY_LEVEL
 - 1,

65 
	`__bos
 (
__s
), 
__fmt
, 
	`__va_¬g_·ck
 ());

66 
	}
}

67 #–ià!
defšed
 
__ýlu¥lus


68 
	#¢´štf
(
¡r
, 
Ën
, ...) \

69 
	`__bužtš___¢´štf_chk
 (
¡r
, 
Ën
, 
__USE_FORTIFY_LEVEL
 - 1, 
	`__bos
 (str), \

70 
__VA_ARGS__
)

	)

73 
__fÜtify_funùiÚ
 

74 
__NTH
 (
	$v¢´štf
 (*
__»¡riù
 
__s
, 
size_t
 
__n
,

75 cÚ¡ *
__»¡riù
 
__fmt
, 
_G_va_li¡
 
__­
))

77  
	`__bužtš___v¢´štf_chk
 (
__s
, 
__n
, 
__USE_FORTIFY_LEVEL
 - 1,

78 
	`__bos
 (
__s
), 
__fmt
, 
__­
);

79 
	}
}

83 #ià
__USE_FORTIFY_LEVEL
 > 1

85 
__årštf_chk
 (
FILE
 *
__»¡riù
 
__¡»am
, 
__æag
,

86 cÚ¡ *
__»¡riù
 
__fÜm©
, ...);

87 
__´štf_chk
 (
__æag
, cÚ¡ *
__»¡riù
 
__fÜm©
, ...);

88 
__vårštf_chk
 (
FILE
 *
__»¡riù
 
__¡»am
, 
__æag
,

89 cÚ¡ *
__»¡riù
 
__fÜm©
, 
_G_va_li¡
 
__­
);

90 
__v´štf_chk
 (
__æag
, cÚ¡ *
__»¡riù
 
__fÜm©
,

91 
_G_va_li¡
 
__­
);

93 #ifdeà
__va_¬g_·ck


94 
__fÜtify_funùiÚ
 

95 
	$årštf
 (
FILE
 *
__»¡riù
 
__¡»am
, cÚ¡ *__»¡riù 
__fmt
, ...)

97  
	`__årštf_chk
 (
__¡»am
, 
__USE_FORTIFY_LEVEL
 - 1, 
__fmt
,

98 
	`__va_¬g_·ck
 ());

99 
	}
}

101 
__fÜtify_funùiÚ
 

102 
	$´štf
 (cÚ¡ *
__»¡riù
 
__fmt
, ...)

104  
	`__´štf_chk
 (
__USE_FORTIFY_LEVEL
 - 1, 
__fmt
, 
	`__va_¬g_·ck
 ());

105 
	}
}

106 #–ià!
defšed
 
__ýlu¥lus


107 
	#´štf
(...) \

108 
	`__´štf_chk
 (
__USE_FORTIFY_LEVEL
 - 1, 
__VA_ARGS__
)

	)

109 
	#årštf
(
¡»am
, ...) \

110 
	`__årštf_chk
 (
¡»am
, 
__USE_FORTIFY_LEVEL
 - 1, 
__VA_ARGS__
)

	)

113 
__fÜtify_funùiÚ
 

114 
	$v´štf
 (cÚ¡ *
__»¡riù
 
__fmt
, 
_G_va_li¡
 
__­
)

116 #ifdeà
__USE_EXTERN_INLINES


117  
	`__vårštf_chk
 (
¡dout
, 
__USE_FORTIFY_LEVEL
 - 1, 
__fmt
, 
__­
);

119  
	`__v´štf_chk
 (
__USE_FORTIFY_LEVEL
 - 1, 
__fmt
, 
__­
);

121 
	}
}

123 
__fÜtify_funùiÚ
 

124 
	$vårštf
 (
FILE
 *
__»¡riù
 
__¡»am
,

125 cÚ¡ *
__»¡riù
 
__fmt
, 
_G_va_li¡
 
__­
)

127  
	`__vårštf_chk
 (
__¡»am
, 
__USE_FORTIFY_LEVEL
 - 1, 
__fmt
, 
__­
);

128 
	}
}

130 #ifdeà
__USE_XOPEN2K8


131 
	$__d´štf_chk
 (
__fd
, 
__æag
, cÚ¡ *
__»¡riù
 
__fmt
,

132 ...è
	`__©Œibu‹__
 ((
	`__fÜm©__
 (
__´štf__
, 3, 4)));

133 
	$__vd´štf_chk
 (
__fd
, 
__æag
,

134 cÚ¡ *
__»¡riù
 
__fmt
, 
_G_va_li¡
 
__¬g
)

135 
	`__©Œibu‹__
 ((
	`__fÜm©__
 (
__´štf__
, 3, 0)));

137 #ifdeà
__va_¬g_·ck


138 
__fÜtify_funùiÚ
 

139 
	$d´štf
 (
__fd
, cÚ¡ *
__»¡riù
 
__fmt
, ...)

141  
	`__d´štf_chk
 (
__fd
, 
__USE_FORTIFY_LEVEL
 - 1, 
__fmt
,

142 
	`__va_¬g_·ck
 ());

143 
	}
}

144 #–ià!
defšed
 
__ýlu¥lus


145 
	#d´štf
(
fd
, ...) \

146 
	`__d´štf_chk
 (
fd
, 
__USE_FORTIFY_LEVEL
 - 1, 
__VA_ARGS__
)

	)

149 
__fÜtify_funùiÚ
 

150 
	$vd´štf
 (
__fd
, cÚ¡ *
__»¡riù
 
__fmt
, 
_G_va_li¡
 
__­
)

152  
	`__vd´štf_chk
 (
__fd
, 
__USE_FORTIFY_LEVEL
 - 1, 
__fmt
, 
__­
);

153 
	}
}

156 #ifdeà
__USE_GNU


158 
	$__a¥rštf_chk
 (**
__»¡riù
 
__±r
, 
__æag
,

159 cÚ¡ *
__»¡riù
 
__fmt
, ...)

160 
__THROW
 
	`__©Œibu‹__
 ((
	$__fÜm©__
 (
__´štf__
, 3, 4))è
__wur
;

161 
	$__va¥rštf_chk
 (**
__»¡riù
 
__±r
, 
__æag
,

162 cÚ¡ *
__»¡riù
 
__fmt
, 
_G_va_li¡
 
__¬g
)

163 
__THROW
 
	`__©Œibu‹__
 ((
	$__fÜm©__
 (
__´štf__
, 3, 0))è
__wur
;

164 
	$__ob¡ack_´štf_chk
 (
ob¡ack
 *
__»¡riù
 
__ob¡ack
,

165 
__æag
, cÚ¡ *
__»¡riù
 
__fÜm©
,

167 
__THROW
 
	`__©Œibu‹__
 ((
	`__fÜm©__
 (
__´štf__
, 3, 4)));

168 
	$__ob¡ack_v´štf_chk
 (
ob¡ack
 *
__»¡riù
 
__ob¡ack
,

169 
__æag
,

170 cÚ¡ *
__»¡riù
 
__fÜm©
,

171 
_G_va_li¡
 
__¬gs
)

172 
__THROW
 
	`__©Œibu‹__
 ((
	`__fÜm©__
 (
__´štf__
, 3, 0)));

174 #ifdeà
__va_¬g_·ck


175 
__fÜtify_funùiÚ
 

176 
	`__NTH
 (
	$a¥rštf
 (**
__»¡riù
 
__±r
, cÚ¡ *__»¡riù 
__fmt
, ...))

178  
	`__a¥rštf_chk
 (
__±r
, 
__USE_FORTIFY_LEVEL
 - 1, 
__fmt
,

179 
	`__va_¬g_·ck
 ());

180 
	}
}

182 
__fÜtify_funùiÚ
 

183 
__NTH
 (
	$__a¥rštf
 (**
__»¡riù
 
__±r
, cÚ¡ *__»¡riù 
__fmt
,

186  
	`__a¥rštf_chk
 (
__±r
, 
__USE_FORTIFY_LEVEL
 - 1, 
__fmt
,

187 
	`__va_¬g_·ck
 ());

188 
	}
}

190 
__fÜtify_funùiÚ
 

191 
__NTH
 (
	$ob¡ack_´štf
 (
ob¡ack
 *
__»¡riù
 
__ob¡ack
,

192 cÚ¡ *
__»¡riù
 
__fmt
, ...))

194  
	`__ob¡ack_´štf_chk
 (
__ob¡ack
, 
__USE_FORTIFY_LEVEL
 - 1, 
__fmt
,

195 
	`__va_¬g_·ck
 ());

196 
	}
}

197 #–ià!
defšed
 
__ýlu¥lus


198 
	#a¥rštf
(
±r
, ...) \

199 
	`__a¥rštf_chk
 (
±r
, 
__USE_FORTIFY_LEVEL
 - 1, 
__VA_ARGS__
)

	)

200 
	#__a¥rštf
(
±r
, ...) \

201 
	`__a¥rštf_chk
 (
±r
, 
__USE_FORTIFY_LEVEL
 - 1, 
__VA_ARGS__
)

	)

202 
	#ob¡ack_´štf
(
ob¡ack
, ...) \

203 
	`__ob¡ack_´štf_chk
 (
ob¡ack
, 
__USE_FORTIFY_LEVEL
 - 1, 
__VA_ARGS__
)

	)

206 
__fÜtify_funùiÚ
 

207 
__NTH
 (
	$va¥rštf
 (**
__»¡riù
 
__±r
, cÚ¡ *__»¡riù 
__fmt
,

208 
_G_va_li¡
 
__­
))

210  
	`__va¥rštf_chk
 (
__±r
, 
__USE_FORTIFY_LEVEL
 - 1, 
__fmt
, 
__­
);

211 
	}
}

213 
__fÜtify_funùiÚ
 

214 
__NTH
 (
	$ob¡ack_v´štf
 (
ob¡ack
 *
__»¡riù
 
__ob¡ack
,

215 cÚ¡ *
__»¡riù
 
__fmt
, 
_G_va_li¡
 
__­
))

217  
	`__ob¡ack_v´štf_chk
 (
__ob¡ack
, 
__USE_FORTIFY_LEVEL
 - 1, 
__fmt
,

218 
__­
);

219 
	}
}

225 #ià!
defšed
 
__USE_ISOC11
 \

226 || (
defšed
 
	g__ýlu¥lus
 && __ýlu¥lu <ð201103L && !defšed 
__USE_GNU
)

227 *
	$__g‘s_chk
 (*
__¡r
, 
size_t
è
__wur
;

228 *
	`__REDIRECT
 (
__g‘s_w¬n
, (*
__¡r
), 
g‘s
)

229 
__wur
 
	`__w¬Ç‰r
 ("please use fgets or getline instead, gets can't "

232 
__fÜtify_funùiÚ
 
__wur
 *

233 
	$g‘s
 (*
__¡r
)

235 ià(
	`__bos
 (
__¡r
è!ð(
size_t
) -1)

236  
	`__g‘s_chk
 (
__¡r
, 
	`__bos
 (__str));

237  
	`__g‘s_w¬n
 (
__¡r
);

238 
	}
}

241 *
	$__fg‘s_chk
 (*
__»¡riù
 
__s
, 
size_t
 
__size
, 
__n
,

242 
FILE
 *
__»¡riù
 
__¡»am
è
__wur
;

243 *
	`__REDIRECT
 (
__fg‘s_®Ÿs
,

244 (*
__»¡riù
 
__s
, 
__n
,

245 
FILE
 *
__»¡riù
 
__¡»am
), 
fg‘s
è
__wur
;

246 *
	`__REDIRECT
 (
__fg‘s_chk_w¬n
,

247 (*
__»¡riù
 
__s
, 
size_t
 
__size
, 
__n
,

248 
FILE
 *
__»¡riù
 
__¡»am
), 
__fg‘s_chk
)

249 
__wur
 
	`__w¬Ç‰r
 ("fgets called with bigger sizehan†ength "

252 
__fÜtify_funùiÚ
 
__wur
 *

253 
	$fg‘s
 (*
__»¡riù
 
__s
, 
__n
, 
FILE
 *__»¡riù 
__¡»am
)

255 ià(
	`__bos
 (
__s
è!ð(
size_t
) -1)

257 ià(!
	`__bužtš_cÚ¡ªt_p
 (
__n
) || __n <= 0)

258  
	`__fg‘s_chk
 (
__s
, 
	`__bos
 (__s), 
__n
, 
__¡»am
);

260 ià((
size_t
è
__n
 > 
	`__bos
 (
__s
))

261  
	`__fg‘s_chk_w¬n
 (
__s
, 
	`__bos
 (__s), 
__n
, 
__¡»am
);

263  
	`__fg‘s_®Ÿs
 (
__s
, 
__n
, 
__¡»am
);

264 
	}
}

266 
size_t
 
	$__ä—d_chk
 (*
__»¡riù
 
__±r
, 
size_t
 
__±¾’
,

267 
size_t
 
__size
, size_ˆ
__n
,

268 
FILE
 *
__»¡riù
 
__¡»am
è
__wur
;

269 
size_t
 
	`__REDIRECT
 (
__ä—d_®Ÿs
,

270 (*
__»¡riù
 
__±r
, 
size_t
 
__size
,

271 
size_t
 
__n
, 
FILE
 *
__»¡riù
 
__¡»am
),

272 
ä—d
è
__wur
;

273 
size_t
 
	`__REDIRECT
 (
__ä—d_chk_w¬n
,

274 (*
__»¡riù
 
__±r
, 
size_t
 
__±¾’
,

275 
size_t
 
__size
, size_ˆ
__n
,

276 
FILE
 *
__»¡riù
 
__¡»am
),

277 
__ä—d_chk
)

278 
__wur
 
	`__w¬Ç‰r
 ("fread called with bigger size *‚membhan†ength "

281 
__fÜtify_funùiÚ
 
__wur
 
size_t


282 
	$ä—d
 (*
__»¡riù
 
__±r
, 
size_t
 
__size
, size_ˆ
__n
,

283 
FILE
 *
__»¡riù
 
__¡»am
)

285 ià(
	`__bos0
 (
__±r
è!ð(
size_t
) -1)

287 ià(!
	`__bužtš_cÚ¡ªt_p
 (
__size
)

288 || !
	`__bužtš_cÚ¡ªt_p
 (
__n
)

289 || (
__size
 | 
__n
è>ð(((
size_t
) 1) << (8 *  (size_t) / 2)))

290  
	`__ä—d_chk
 (
__±r
, 
	`__bos0
 (__±r), 
__size
, 
__n
, 
__¡»am
);

292 ià(
__size
 * 
__n
 > 
	`__bos0
 (
__±r
))

293  
	`__ä—d_chk_w¬n
 (
__±r
, 
	`__bos0
 (__±r), 
__size
, 
__n
, 
__¡»am
);

295  
	`__ä—d_®Ÿs
 (
__±r
, 
__size
, 
__n
, 
__¡»am
);

296 
	}
}

298 #ifdeà
__USE_GNU


299 *
	$__fg‘s_uÆocked_chk
 (*
__»¡riù
 
__s
, 
size_t
 
__size
,

300 
__n
, 
FILE
 *
__»¡riù
 
__¡»am
è
__wur
;

301 *
	`__REDIRECT
 (
__fg‘s_uÆocked_®Ÿs
,

302 (*
__»¡riù
 
__s
, 
__n
,

303 
FILE
 *
__»¡riù
 
__¡»am
), 
fg‘s_uÆocked
è
__wur
;

304 *
	`__REDIRECT
 (
__fg‘s_uÆocked_chk_w¬n
,

305 (*
__»¡riù
 
__s
, 
size_t
 
__size
, 
__n
,

306 
FILE
 *
__»¡riù
 
__¡»am
), 
__fg‘s_uÆocked_chk
)

307 
__wur
 
	`__w¬Ç‰r
 ("fgets_unlocked called with bigger sizehan†ength "

310 
__fÜtify_funùiÚ
 
__wur
 *

311 
	$fg‘s_uÆocked
 (*
__»¡riù
 
__s
, 
__n
, 
FILE
 *__»¡riù 
__¡»am
)

313 ià(
	`__bos
 (
__s
è!ð(
size_t
) -1)

315 ià(!
	`__bužtš_cÚ¡ªt_p
 (
__n
) || __n <= 0)

316  
	`__fg‘s_uÆocked_chk
 (
__s
, 
	`__bos
 (__s), 
__n
, 
__¡»am
);

318 ià((
size_t
è
__n
 > 
	`__bos
 (
__s
))

319  
	`__fg‘s_uÆocked_chk_w¬n
 (
__s
, 
	`__bos
 (__s), 
__n
, 
__¡»am
);

321  
	`__fg‘s_uÆocked_®Ÿs
 (
__s
, 
__n
, 
__¡»am
);

322 
	}
}

325 #ifdeà
__USE_MISC


326 #undeà
ä—d_uÆocked


327 
size_t
 
	$__ä—d_uÆocked_chk
 (*
__»¡riù
 
__±r
, 
size_t
 
__±¾’
,

328 
size_t
 
__size
, size_ˆ
__n
,

329 
FILE
 *
__»¡riù
 
__¡»am
è
__wur
;

330 
size_t
 
	`__REDIRECT
 (
__ä—d_uÆocked_®Ÿs
,

331 (*
__»¡riù
 
__±r
, 
size_t
 
__size
,

332 
size_t
 
__n
, 
FILE
 *
__»¡riù
 
__¡»am
),

333 
ä—d_uÆocked
è
__wur
;

334 
size_t
 
	`__REDIRECT
 (
__ä—d_uÆocked_chk_w¬n
,

335 (*
__»¡riù
 
__±r
, 
size_t
 
__±¾’
,

336 
size_t
 
__size
, size_ˆ
__n
,

337 
FILE
 *
__»¡riù
 
__¡»am
),

338 
__ä—d_uÆocked_chk
)

339 
__wur
 
	`__w¬Ç‰r
 ("fread_unlocked called with bigger size *‚membhan "

342 
__fÜtify_funùiÚ
 
__wur
 
size_t


343 
	$ä—d_uÆocked
 (*
__»¡riù
 
__±r
, 
size_t
 
__size
, size_ˆ
__n
,

344 
FILE
 *
__»¡riù
 
__¡»am
)

346 ià(
	`__bos0
 (
__±r
è!ð(
size_t
) -1)

348 ià(!
	`__bužtš_cÚ¡ªt_p
 (
__size
)

349 || !
	`__bužtš_cÚ¡ªt_p
 (
__n
)

350 || (
__size
 | 
__n
è>ð(((
size_t
) 1) << (8 *  (size_t) / 2)))

351  
	`__ä—d_uÆocked_chk
 (
__±r
, 
	`__bos0
 (__±r), 
__size
, 
__n
,

352 
__¡»am
);

354 ià(
__size
 * 
__n
 > 
	`__bos0
 (
__±r
))

355  
	`__ä—d_uÆocked_chk_w¬n
 (
__±r
, 
	`__bos0
 (__±r), 
__size
, 
__n
,

356 
__¡»am
);

359 #ifdeà
__USE_EXTERN_INLINES


360 ià(
	`__bužtš_cÚ¡ªt_p
 (
__size
)

361 && 
	`__bužtš_cÚ¡ªt_p
 (
__n
)

362 && (
__size
 | 
__n
è< (((
size_t
) 1) << (8 *  (size_t) / 2))

363 && 
__size
 * 
__n
 <= 8)

365 
size_t
 
__út
 = 
__size
 * 
__n
;

366 *
__ýŒ
 = (*è
__±r
;

367 ià(
__út
 == 0)

370 ; 
__út
 > 0; --__cnt)

372 
__c
 = 
	`_IO_g‘c_uÆocked
 (
__¡»am
);

373 ià(
__c
 =ð
EOF
)

375 *
__ýŒ
++ = 
__c
;

377  (
__ýŒ
 - (*è
__±r
è/ 
__size
;

380  
	`__ä—d_uÆocked_®Ÿs
 (
__±r
, 
__size
, 
__n
, 
__¡»am
);

381 
	}
}

	@/usr/include/bits/stdio_lim.h

18 #ià!
defšed
 
_STDIO_H
 && !defšed 
__Ãed_FOPEN_MAX
 && !defšed 
__Ãed_IOV_MAX


22 #ifdeà
_STDIO_H


23 
	#L_tm²am
 20

	)

24 
	#TMP_MAX
 238328

	)

25 
	#FILENAME_MAX
 4096

	)

27 #ifdeà
__USE_POSIX


28 
	#L_ù”mid
 9

	)

29 #ià!
defšed
 
__USE_XOPEN2K
 || defšed 
__USE_GNU


30 
	#L_cu£rid
 9

	)

35 #ià
defšed
 
__Ãed_FOPEN_MAX
 || defšed 
_STDIO_H


36 #undeà
FOPEN_MAX


37 
	#FOPEN_MAX
 16

	)

40 #ià
defšed
 
__Ãed_IOV_MAX
 && !defšed 
IOV_MAX


41 
	#IOV_MAX
 1024

	)

	@/usr/include/bits/stdlib-bsearch.h

19 
__ex‹º_šlše
 *

20 
	$b£¬ch
 (cÚ¡ *
__key
, cÚ¡ *
__ba£
, 
size_t
 
__nmemb
, size_ˆ
__size
,

21 
__com·r_â_t
 
__com·r
)

23 
size_t
 
__l
, 
__u
, 
__idx
;

24 cÚ¡ *
__p
;

25 
__com·risÚ
;

27 
__l
 = 0;

28 
__u
 = 
__nmemb
;

29 
__l
 < 
__u
)

31 
__idx
 = (
__l
 + 
__u
) / 2;

32 
__p
 = (*è(((cÚ¡ *è
__ba£
è+ (
__idx
 * 
__size
));

33 
__com·risÚ
 = (*
__com·r
è(
__key
, 
__p
);

34 ià(
__com·risÚ
 < 0)

35 
__u
 = 
__idx
;

36 ià(
__com·risÚ
 > 0)

37 
__l
 = 
__idx
 + 1;

39  (*è
__p
;

42  
NULL
;

43 
	}
}

	@/usr/include/bits/stdlib-float.h

19 #iâdeà
_STDLIB_H


23 #ifdeà
__USE_EXTERN_INLINES


24 
__BEGIN_NAMESPACE_STD


25 
__ex‹º_šlše
 

26 
__NTH
 (
	$©of
 (cÚ¡ *
__ÅŒ
))

28  
	`¡¹od
 (
__ÅŒ
, (**è
NULL
);

29 
	}
}

30 
	g__END_NAMESPACE_STD


	@/usr/include/bits/stdlib-ldbl.h

19 #iâdeà
_STDLIB_H


23 #ifdef 
__USE_ISOC99


24 
__BEGIN_NAMESPACE_C99


25 
	$__LDBL_REDIR1_DECL
 (
¡¹Þd
, 
¡¹od
)

26 
__END_NAMESPACE_C99


29 #ifdeà
__USE_GNU


30 
	$__LDBL_REDIR1_DECL
 (
¡¹Þd_l
, 
¡¹od_l
)

33 #ifdeà
__USE_MISC


34 
	$__LDBL_REDIR1_DECL
 (
qecvt
, 
ecvt
)

35 
	$__LDBL_REDIR1_DECL
 (
qfcvt
, 
fcvt
)

36 
	$__LDBL_REDIR1_DECL
 (
qgcvt
, 
gcvt
)

37 
	$__LDBL_REDIR1_DECL
 (
qecvt_r
, 
ecvt_r
)

38 
	$__LDBL_REDIR1_DECL
 (
qfcvt_r
, 
fcvt_r
)

	@/usr/include/bits/stdlib.h

19 #iâdeà
_STDLIB_H


23 *
	$__»®·th_chk
 (cÚ¡ *
__»¡riù
 
__Çme
,

24 *
__»¡riù
 
__»sÞved
,

25 
size_t
 
__»sÞvedËn
è
__THROW
 
__wur
;

26 *
	`__REDIRECT_NTH
 (
__»®·th_®Ÿs
,

27 (cÚ¡ *
__»¡riù
 
__Çme
,

28 *
__»¡riù
 
__»sÞved
), 
»®·th
è
__wur
;

29 *
	`__REDIRECT_NTH
 (
__»®·th_chk_w¬n
,

30 (cÚ¡ *
__»¡riù
 
__Çme
,

31 *
__»¡riù
 
__»sÞved
,

32 
size_t
 
__»sÞvedËn
), 
__»®·th_chk
è
__wur


33 
	`__w¬Ç‰r
 ("second‡rgument of„ealpath must beƒither NULL or‡t "

36 
__fÜtify_funùiÚ
 
__wur
 *

37 
	`__NTH
 (
	$»®·th
 (cÚ¡ *
__»¡riù
 
__Çme
, *__»¡riù 
__»sÞved
))

39 ià(
	`__bos
 (
__»sÞved
è!ð(
size_t
) -1)

41 #ià
defšed
 
_LIBC_LIMITS_H_
 && defšed 
PATH_MAX


42 ià(
	`__bos
 (
__»sÞved
è< 
PATH_MAX
)

43  
	`__»®·th_chk_w¬n
 (
__Çme
, 
__»sÞved
, 
	`__bos
 (__resolved));

45  
	`__»®·th_chk
 (
__Çme
, 
__»sÞved
, 
	`__bos
 (__resolved));

48  
	`__»®·th_®Ÿs
 (
__Çme
, 
__»sÞved
);

49 
	}
}

52 
	$__±¢ame_r_chk
 (
__fd
, *
__buf
, 
size_t
 
__buæ’
,

53 
size_t
 
__Ä—l
è
__THROW
 
	`__nÚnuÎ
 ((2));

54 
	`__REDIRECT_NTH
 (
__±¢ame_r_®Ÿs
, (
__fd
, *
__buf
,

55 
size_t
 
__buæ’
), 
±¢ame_r
)

56 
	`__nÚnuÎ
 ((2));

57 
	`__REDIRECT_NTH
 (
__±¢ame_r_chk_w¬n
,

58 (
__fd
, *
__buf
, 
size_t
 
__buæ’
,

59 
size_t
 
__Ä—l
), 
__±¢ame_r_chk
)

60 
	`__nÚnuÎ
 ((2)è
	`__w¬Ç‰r
 ("ptsname_r called with buflen biggerhan "

63 
__fÜtify_funùiÚ
 

64 
	`__NTH
 (
	$±¢ame_r
 (
__fd
, *
__buf
, 
size_t
 
__buæ’
))

66 ià(
	`__bos
 (
__buf
è!ð(
size_t
) -1)

68 ià(!
	`__bužtš_cÚ¡ªt_p
 (
__buæ’
))

69  
	`__±¢ame_r_chk
 (
__fd
, 
__buf
, 
__buæ’
, 
	`__bos
 (__buf));

70 ià(
__buæ’
 > 
	`__bos
 (
__buf
))

71  
	`__±¢ame_r_chk_w¬n
 (
__fd
, 
__buf
, 
__buæ’
, 
	`__bos
 (__buf));

73  
	`__±¢ame_r_®Ÿs
 (
__fd
, 
__buf
, 
__buæ’
);

74 
	}
}

77 
	$__wùomb_chk
 (*
__s
, 
wch¬_t
 
__wch¬
, 
size_t
 
__buæ’
)

78 
__THROW
 
__wur
;

79 
	`__REDIRECT_NTH
 (
__wùomb_®Ÿs
, (*
__s
, 
wch¬_t
 
__wch¬
),

80 
wùomb
è
__wur
;

82 
__fÜtify_funùiÚ
 
__wur
 

83 
	`__NTH
 (
	$wùomb
 (*
__s
, 
wch¬_t
 
__wch¬
))

88 
	#__STDLIB_MB_LEN_MAX
 16

	)

89 #ià
defšed
 
MB_LEN_MAX
 && MB_LEN_MAX !ð
__STDLIB_MB_LEN_MAX


92 ià(
	`__bos
 (
__s
è!ð(
size_t
è-1 && 
__STDLIB_MB_LEN_MAX
 > __bos (__s))

93  
	`__wùomb_chk
 (
__s
, 
__wch¬
, 
	`__bos
 (__s));

94  
	`__wùomb_®Ÿs
 (
__s
, 
__wch¬
);

95 
	}
}

98 
size_t
 
	$__mb¡owcs_chk
 (
wch¬_t
 *
__»¡riù
 
__d¡
,

99 cÚ¡ *
__»¡riù
 
__¤c
,

100 
size_t
 
__Ën
, size_ˆ
__d¡Ën
è
__THROW
;

101 
size_t
 
	`__REDIRECT_NTH
 (
__mb¡owcs_®Ÿs
,

102 (
wch¬_t
 *
__»¡riù
 
__d¡
,

103 cÚ¡ *
__»¡riù
 
__¤c
,

104 
size_t
 
__Ën
), 
mb¡owcs
);

105 
size_t
 
	`__REDIRECT_NTH
 (
__mb¡owcs_chk_w¬n
,

106 (
wch¬_t
 *
__»¡riù
 
__d¡
,

107 cÚ¡ *
__»¡riù
 
__¤c
,

108 
size_t
 
__Ën
, size_ˆ
__d¡Ën
), 
__mb¡owcs_chk
)

109 
	`__w¬Ç‰r
 ("mbstowcs called with dst buffer smallerhan†en "

112 
__fÜtify_funùiÚ
 
size_t


113 
	`__NTH
 (
	$mb¡owcs
 (
wch¬_t
 *
__»¡riù
 
__d¡
, cÚ¡ *__»¡riù 
__¤c
,

114 
size_t
 
__Ën
))

116 ià(
	`__bos
 (
__d¡
è!ð(
size_t
) -1)

118 ià(!
	`__bužtš_cÚ¡ªt_p
 (
__Ën
))

119  
	`__mb¡owcs_chk
 (
__d¡
, 
__¤c
, 
__Ën
,

120 
	`__bos
 (
__d¡
è/  (
wch¬_t
));

122 ià(
__Ën
 > 
	`__bos
 (
__d¡
è/  (
wch¬_t
))

123  
	`__mb¡owcs_chk_w¬n
 (
__d¡
, 
__¤c
, 
__Ën
,

124 
	`__bos
 (
__d¡
è/  (
wch¬_t
));

126  
	`__mb¡owcs_®Ÿs
 (
__d¡
, 
__¤c
, 
__Ën
);

127 
	}
}

130 
size_t
 
	$__wc¡ombs_chk
 (*
__»¡riù
 
__d¡
,

131 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__¤c
,

132 
size_t
 
__Ën
, size_ˆ
__d¡Ën
è
__THROW
;

133 
size_t
 
	`__REDIRECT_NTH
 (
__wc¡ombs_®Ÿs
,

134 (*
__»¡riù
 
__d¡
,

135 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__¤c
,

136 
size_t
 
__Ën
), 
wc¡ombs
);

137 
size_t
 
	`__REDIRECT_NTH
 (
__wc¡ombs_chk_w¬n
,

138 (*
__»¡riù
 
__d¡
,

139 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__¤c
,

140 
size_t
 
__Ën
, size_ˆ
__d¡Ën
), 
__wc¡ombs_chk
)

141 
	`__w¬Ç‰r
 ("wcstombs called with dst buffer smallerhan†en");

143 
__fÜtify_funùiÚ
 
size_t


144 
	`__NTH
 (
	$wc¡ombs
 (*
__»¡riù
 
__d¡
, cÚ¡ 
wch¬_t
 *__»¡riù 
__¤c
,

145 
size_t
 
__Ën
))

147 ià(
	`__bos
 (
__d¡
è!ð(
size_t
) -1)

149 ià(!
	`__bužtš_cÚ¡ªt_p
 (
__Ën
))

150  
	`__wc¡ombs_chk
 (
__d¡
, 
__¤c
, 
__Ën
, 
	`__bos
 (__dst));

151 ià(
__Ën
 > 
	`__bos
 (
__d¡
))

152  
	`__wc¡ombs_chk_w¬n
 (
__d¡
, 
__¤c
, 
__Ën
, 
	`__bos
 (__dst));

154  
	`__wc¡ombs_®Ÿs
 (
__d¡
, 
__¤c
, 
__Ën
);

155 
	}
}

	@/usr/include/bits/string.h

19 #iâdeà
_STRING_H


24 
	#_STRING_INLINE_uÇligÃd
 1

	)

27 
	#_HAVE_STRING_ARCH_mempýy
 1

	)

31 #ià!
defšed
 
__x86_64__
 && (defšed 
__i486__
 || defšed 
__³Áium__
 \

32 || 
defšed
 
	g__³Áium´o__
 || defšed 
	g__³Áium4__
 \

33 || 
defšed
 
	g__nocÚa__
 || defšed 
	g__©om__
 \

34 || 
defšed
 
	g__cÜe2__
 || defšed 
	g__cÜei7__
 \

35 || 
defšed
 
	g__§ndybridge__
 || defšed 
	g__hasw–l__
 \

36 || 
defšed
 
	g__bÚÃÎ__
 || defšed 
	g__sžv”mÚt__
 \

37 || 
defšed
 
	g__k6__
 || defšed 
	g__geode__
 \

38 || 
defšed
 
	g__k8__
 || defšed 
	g__©hlÚ__
 \

39 || 
defšed
 
	g__amdçm10__
 || defšed 
	g__bdv”1__
 \

40 || 
defšed
 
	g__bdv”2__
 || defšed 
	g__bdv”3__
 \

41 || 
defšed
 
	g__bdv”4__
 || defšed 
	g__btv”1__
 \

42 || 
defšed
 
	g__btv”2__
)

46 #ià!
defšed
 
__NO_STRING_INLINES
 && defšed 
__USE_STRING_INLINES
 \

47 && 
defšed
 
	g__GNUC__
 && __GNUC__ >= 2

49 #iâdeà
__STRING_INLINE


50 #iâdeà
__ex‹º_šlše


51 
	#__STRING_INLINE
 
šlše


	)

53 
	#__STRING_INLINE
 
__ex‹º_šlše


	)

58 
	#__STRING_SMALL_GET16
(
¤c
, 
idx
) \

59 ((((cÚ¡ *è(
¤c
))[
idx
 + 1] << 8) \

60 | ((cÚ¡ *è(
¤c
))[
idx
])

	)

61 
	#__STRING_SMALL_GET32
(
¤c
, 
idx
) \

62 (((((cÚ¡ *è(
¤c
))[
idx
 + 3] << 8 \

63 | ((cÚ¡ *è(
¤c
))[
idx
 + 2]) << 8 \

64 | ((cÚ¡ *è(
¤c
))[
idx
 + 1]) << 8 \

65 | ((cÚ¡ *è(
¤c
))[
idx
])

	)

69 
	#_HAVE_STRING_ARCH_memýy
 1

	)

70 
	#memýy
(
de¡
, 
¤c
, 
n
) \

71 (
	`__ex‹nsiÚ__
 (
	`__bužtš_cÚ¡ªt_p
 (
n
) \

72 ? 
	`__memýy_c
 ((
de¡
), (
¤c
), (
n
)) \

73 : 
	`__memýy_g
 ((
de¡
), (
¤c
), (
n
))))

	)

74 
	#__memýy_c
(
de¡
, 
¤c
, 
n
) \

75 ((
n
) == 0 \

76 ? (
de¡
) \

77 : (((
n
) % 4 == 0) \

78 ? 
	`__memýy_by4
 (
de¡
, 
¤c
, 
n
) \

79 : (((
n
) % 2 == 0) \

80 ? 
	`__memýy_by2
 (
de¡
, 
¤c
, 
n
) \

81 : 
	`__memýy_g
 (
de¡
, 
¤c
, 
n
))))

	)

83 
__STRING_INLINE
 *
__memýy_by4
 (*
__de¡
, cÚ¡ *
__¤c
,

84 
size_t
 
__n
);

86 
__STRING_INLINE
 *

87 
	$__memýy_by4
 (*
__de¡
, cÚ¡ *
__¤c
, 
size_t
 
__n
)

89 
__d0
, 
__d1
;

90 *
__tmp
 = 
__de¡
;

91 
__asm__
 
__vÞ©že__


99 : "=&r" (
__d0
), "=&r" (
__tmp
), "=&r" (
__¤c
), "=&r" (
__d1
)

100 : "1" (
__tmp
), "2" (
__¤c
), "3" (
__n
 / 4)

102  
__de¡
;

103 
	}
}

105 
__STRING_INLINE
 *
__memýy_by2
 (*
__de¡
, cÚ¡ *
__¤c
,

106 
size_t
 
__n
);

108 
__STRING_INLINE
 *

109 
	$__memýy_by2
 (*
__de¡
, cÚ¡ *
__¤c
, 
size_t
 
__n
)

111 
__d0
, 
__d1
;

112 *
__tmp
 = 
__de¡
;

113 
__asm__
 
__vÞ©že__


126 : "=&q" (
__d0
), "=&r" (
__tmp
), "=&r" (
__¤c
), "=&r" (
__d1
)

127 : "1" (
__tmp
), "2" (
__¤c
), "3" (
__n
 / 2)

129  
__de¡
;

130 
	}
}

132 
__STRING_INLINE
 *
__memýy_g
 (*
__de¡
, cÚ¡ *
__¤c
, 
size_t
 
__n
);

134 
__STRING_INLINE
 *

135 
	$__memýy_g
 (*
__de¡
, cÚ¡ *
__¤c
, 
size_t
 
__n
)

137 
__d0
, 
__d1
, 
__d2
;

138 *
__tmp
 = 
__de¡
;

139 
__asm__
 
__vÞ©že__


150 : "=&c" (
__d0
), "=&D" (
__d1
), "=&S" (
__d2
),

151 "=m" ( *(¡ruù { 
__ex‹nsiÚ__
 
__x
[
__n
]; } *)
__de¡
)

152 : "0" (
__n
), "1" (
__tmp
), "2" (
__¤c
),

153 "m" ( *(¡ruù { 
__ex‹nsiÚ__
 
__x
[
__n
]; } *)
__¤c
)

155  
__de¡
;

156 
	}
}

158 
	#_HAVE_STRING_ARCH_memmove
 1

	)

159 #iâdeà
_FORCE_INLINES


162 
	#memmove
(
de¡
, 
¤c
, 
n
è
	`__memmove_g
 (de¡, src,‚)

	)

164 
__STRING_INLINE
 *
	$__memmove_g
 (*, cÚ¡ *, 
size_t
)

165 
	`__asm__
 ("memmove");

167 
__STRING_INLINE
 *

168 
	$__memmove_g
 (*
__de¡
, cÚ¡ *
__¤c
, 
size_t
 
__n
)

170 
__d0
, 
__d1
, 
__d2
;

171 *
__tmp
 = 
__de¡
;

172 ià(
__de¡
 < 
__¤c
)

173 
__asm__
 
__vÞ©že__


176 : "=&c" (
__d0
), "=&S" (
__d1
), "=&D" (
__d2
),

177 "=m" ( *(¡ruù { 
__ex‹nsiÚ__
 
__x
[
__n
]; } *)
__de¡
)

178 : "0" (
__n
), "1" (
__¤c
), "2" (
__tmp
),

179 "m" ( *(¡ruù { 
__ex‹nsiÚ__
 
__x
[
__n
]; } *)
__¤c
));

181 
__asm__
 
__vÞ©že__


187 : "=&c" (
__d0
), "=&S" (
__d1
), "=&D" (
__d2
),

188 "=m" ( *(¡ruù { 
__ex‹nsiÚ__
 
__x
[
__n
]; } *)
__de¡
)

189 : "0" (
__n
), "1" (__À+ (cÚ¡ *è
__¤c
),

190 "2" (
__n
 + (*è
__tmp
),

191 "m" ( *(¡ruù { 
__ex‹nsiÚ__
 
__x
[
__n
]; } *)
__¤c
));

192  
__de¡
;

193 
	}
}

197 
	#_HAVE_STRING_ARCH_memcmp
 1

	)

198 #iâdeà
_FORCE_INLINES


199 #iâdeà
__PIC__


201 
__STRING_INLINE
 

202 
	$memcmp
 (cÚ¡ *
__s1
, cÚ¡ *
__s2
, 
size_t
 
__n
)

204 
__d0
, 
__d1
, 
__d2
;

205 
__»s
;

206 
__asm__
 
__vÞ©že__


214 : "=&a" (
__»s
), "=&S" (
__d0
), "=&D" (
__d1
), "=&c" (
__d2
)

215 : "0" (0), "1" (
__s1
), "2" (
__s2
), "3" (
__n
),

216 "m" ( *(¡ruù { 
__ex‹nsiÚ__
 
__x
[
__n
]; } *)
__s1
),

217 "m" ( *(¡ruù { 
__ex‹nsiÚ__
 
__x
[
__n
]; } *)
__s2
)

219  
__»s
;

220 
	}
}

225 
	#_HAVE_STRING_ARCH_mem£t
 1

	)

226 
	#_USE_STRING_ARCH_mem£t
 1

	)

227 
	#mem£t
(
s
, 
c
, 
n
) \

228 (
	`__ex‹nsiÚ__
 (
	`__bužtš_cÚ¡ªt_p
 (
n
) && (n) <= 16 \

229 ? ((
n
) == 1 \

230 ? 
	`__mem£t_c1
 ((
s
), (
c
)) \

231 : 
	`__mem£t_gc
 ((
s
), (
c
), (
n
))) \

232 : (
	`__bužtš_cÚ¡ªt_p
 (
c
) \

233 ? (
	`__bužtš_cÚ¡ªt_p
 (
n
) \

234 ? 
	`__mem£t_cú
 ((
s
), (
c
), (
n
)) \

235 : 
	`mem£t
 ((
s
), (
c
), (
n
))) \

236 : (
	`__bužtš_cÚ¡ªt_p
 (
n
) \

237 ? 
	`__mem£t_gú
 ((
s
), (
c
), (
n
)) \

238 : 
	`mem£t
 ((
s
), (
c
), (
n
))))))

	)

240 
	#__mem£t_c1
(
s
, 
c
è({ *
__s
 = (s); \

241 *((*è
__s
èð(è(
c
); \

242 
__s
; })

	)

244 
	#__mem£t_gc
(
s
, 
c
, 
n
) \

245 ({ *
__s
 = (
s
); \

247 
__ui
; \

248 
__usi
; \

249 
__uc
; \

250 } *
__u
 = 
__s
; \

251 
__c
 = ((è((è(
c
))) * 0x01010101; \

257 ià((
n
) == 3 || (n) >= 5) \

258 
__asm__
 
	`__vÞ©že__
 ("" : "ô" (
__c
) : "0" (__c)); \

261 
n
) \

264 
__u
->
__ui
 = 
__c
; \

265 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4); \

267 
__u
->
__ui
 = 
__c
; \

268 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4); \

270 
__u
->
__ui
 = 
__c
; \

271 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4); \

273 
__u
->
__usi
 = (è
__c
; \

274 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 2); \

275 
__u
->
__uc
 = (è
__c
; \

279 
__u
->
__ui
 = 
__c
; \

280 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4); \

282 
__u
->
__ui
 = 
__c
; \

283 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4); \

285 
__u
->
__ui
 = 
__c
; \

286 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4); \

288 
__u
->
__usi
 = (è
__c
; \

292 
__u
->
__ui
 = 
__c
; \

293 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4); \

295 
__u
->
__ui
 = 
__c
; \

296 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4); \

298 
__u
->
__ui
 = 
__c
; \

299 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4); \

301 
__u
->
__uc
 = (è
__c
; \

305 
__u
->
__ui
 = 
__c
; \

306 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4); \

308 
__u
->
__ui
 = 
__c
; \

309 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4); \

311 
__u
->
__ui
 = 
__c
; \

312 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4); \

314 
__u
->
__ui
 = 
__c
; \

319 
__s
; })

	)

321 
	#__mem£t_cú
(
s
, 
c
, 
n
) \

322 (((
n
) % 4 == 0) \

323 ? 
	`__mem£t_cú_by4
 (
s
, ((è((è(
c
))) * 0x01010101,\

324 
n
) \

325 : (((
n
) % 2 == 0) \

326 ? 
	`__mem£t_cú_by2
 (
s
, \

327 ((è((è(
c
))) * 0x01010101,\

328 
n
) \

329 : 
	`mem£t
 (
s
, 
c
, 
n
)))

	)

331 
__STRING_INLINE
 *
__mem£t_cú_by4
 (*
__s
, 
__c
,

332 
size_t
 
__n
);

334 
__STRING_INLINE
 *

335 
	$__mem£t_cú_by4
 (*
__s
, 
__c
, 
size_t
 
__n
)

337 *
__tmp
 = 
__s
;

338 
__d0
;

339 #ifdeà
__i686__


340 
__asm__
 
__vÞ©že__


343 : "=&a" (
__c
), "=&D" (
__tmp
), "=&c" (
__d0
),

344 "=m" ( *(¡ruù { 
__ex‹nsiÚ__
 
__x
[
__n
]; } *)
__s
)

345 : "0" ((è
__c
), "1" (
__tmp
), "2" (
__n
 / 4)

348 
__asm__
 
__vÞ©že__


354 : "=&r" (
__c
), "=&r" (
__tmp
), "=&r" (
__d0
),

355 "=m" ( *(¡ruù { 
__ex‹nsiÚ__
 
__x
[
__n
]; } *)
__s
)

356 : "0" ((è
__c
), "1" (
__tmp
), "2" (
__n
 / 4)

359  
__s
;

360 
	}
}

362 
__STRING_INLINE
 *
__mem£t_cú_by2
 (*
__s
, 
__c
,

363 
size_t
 
__n
);

365 
__STRING_INLINE
 *

366 
	$__mem£t_cú_by2
 (*
__s
, 
__c
, 
size_t
 
__n
)

368 
__d0
, 
__d1
;

369 *
__tmp
 = 
__s
;

370 #ifdeà
__i686__


371 
__asm__
 
__vÞ©že__


375 : "=&a" (
__d0
), "=&D" (
__tmp
), "=&c" (
__d1
),

376 "=m" ( *(¡ruù { 
__ex‹nsiÚ__
 
__x
[
__n
]; } *)
__s
)

377 : "0" ((è
__c
), "1" (
__tmp
), "2" (
__n
 / 4)

380 
__asm__
 
__vÞ©že__


386 : "=&q" (
__d0
), "=&r" (
__tmp
), "=&r" (
__d1
),

387 "=m" ( *(¡ruù { 
__ex‹nsiÚ__
 
__x
[
__n
]; } *)
__s
)

388 : "0" ((è
__c
), "1" (
__tmp
), "2" (
__n
 / 4)

391  
__s
;

392 
	}
}

394 
	#__mem£t_gú
(
s
, 
c
, 
n
) \

395 (((
n
) % 4 == 0) \

396 ? 
	`__mem£t_gú_by4
 (
s
, 
c
, 
n
) \

397 : (((
n
) % 2 == 0) \

398 ? 
	`__mem£t_gú_by2
 (
s
, 
c
, 
n
) \

399 : 
	`mem£t
 (
s
, 
c
, 
n
)))

	)

401 
__STRING_INLINE
 *
__mem£t_gú_by4
 (*
__s
, 
__c
, 
size_t
 
__n
);

403 
__STRING_INLINE
 *

404 
	$__mem£t_gú_by4
 (*
__s
, 
__c
, 
size_t
 
__n
)

406 *
__tmp
 = 
__s
;

407 
__d0
;

408 
__asm__
 
__vÞ©že__


418 : "=&q" (
__c
), "=&r" (
__tmp
), "=&r" (
__d0
),

419 "=m" ( *(¡ruù { 
__ex‹nsiÚ__
 
__x
[
__n
]; } *)
__s
)

420 : "0" ((è
__c
), "1" (
__tmp
), "2" (
__n
 / 4)

422  
__s
;

423 
	}
}

425 
__STRING_INLINE
 *
__mem£t_gú_by2
 (*
__s
, 
__c
, 
size_t
 
__n
);

427 
__STRING_INLINE
 *

428 
	$__mem£t_gú_by2
 (*
__s
, 
__c
, 
size_t
 
__n
)

430 
__d0
, 
__d1
;

431 *
__tmp
 = 
__s
;

432 
__asm__
 
__vÞ©že__


443 : "=&q" (
__d0
), "=&r" (
__tmp
), "=&r" (
__d1
),

444 "=m" ( *(¡ruù { 
__ex‹nsiÚ__
 
__x
[
__n
]; } *)
__s
)

445 : "0" ((è
__c
), "1" (
__tmp
), "2" (
__n
 / 4)

447  
__s
;

448 
	}
}

452 
	#_HAVE_STRING_ARCH_memchr
 1

	)

453 #iâdeà
_FORCE_INLINES


454 
__STRING_INLINE
 *

455 
	$memchr
 (cÚ¡ *
__s
, 
__c
, 
size_t
 
__n
)

457 
__d0
;

458 #ifdeà
__i686__


459 
__d1
;

461 *
__»s
;

462 ià(
__n
 == 0)

463  
NULL
;

464 #ifdeà
__i686__


465 
__asm__
 
__vÞ©že__


469 : "=D" (
__»s
), "=&c" (
__d0
), "=&r" (
__d1
)

470 : "a" (
__c
), "0" (
__s
), "1" (
__n
), "2" (1),

471 "m" ( *(¡ruù { 
__ex‹nsiÚ__
 
__x
[
__n
]; } *)
__s
)

474 
__asm__
 
__vÞ©že__


480 : "=D" (
__»s
), "=&c" (
__d0
)

481 : "a" (
__c
), "0" (
__s
), "1" (
__n
),

482 "m" ( *(¡ruù { 
__ex‹nsiÚ__
 
__x
[
__n
]; } *)
__s
)

485  
__»s
 - 1;

486 
	}
}

489 
	#_HAVE_STRING_ARCH_memrchr
 1

	)

490 #iâdeà
_FORCE_INLINES


491 
__STRING_INLINE
 *
__memrchr
 (cÚ¡ *
__s
, 
__c
, 
size_t
 
__n
);

493 
__STRING_INLINE
 *

494 
	$__memrchr
 (cÚ¡ *
__s
, 
__c
, 
size_t
 
__n
)

496 
__d0
;

497 #ifdeà
__i686__


498 
__d1
;

500 *
__»s
;

501 ià(
__n
 == 0)

502  
NULL
;

503 #ifdeà
__i686__


504 
__asm__
 
__vÞ©že__


510 : "=D" (
__»s
), "=&c" (
__d0
), "=&r" (
__d1
)

511 : "a" (
__c
), "0" (
__s
 + 
__n
 - 1), "1" (__n), "2" (-1),

512 "m" ( *(¡ruù { 
__ex‹nsiÚ__
 
__x
[
__n
]; } *)
__s
)

515 
__asm__
 
__vÞ©že__


522 : "=D" (
__»s
), "=&c" (
__d0
)

523 : "a" (
__c
), "0" (
__s
 + 
__n
 - 1), "1" (__n),

524 "m" ( *(¡ruù { 
__ex‹nsiÚ__
 
__x
[
__n
]; } *)
__s
)

527  
__»s
;

528 
	}
}

529 #ifdeà
__USE_GNU


530 
	#memrchr
(
s
, 
c
, 
n
è
	`__memrchr
 ((s), (c), (n))

	)

535 
	#_HAVE_STRING_ARCH_¿wmemchr
 1

	)

536 
__STRING_INLINE
 *
__¿wmemchr
 (cÚ¡ *
__s
, 
__c
);

538 #iâdeà
_FORCE_INLINES


539 
__STRING_INLINE
 *

540 
	$__¿wmemchr
 (cÚ¡ *
__s
, 
__c
)

542 
__d0
;

543 *
__»s
;

544 
__asm__
 
__vÞ©že__


547 : "=D" (
__»s
), "=&c" (
__d0
)

548 : "a" (
__c
), "0" (
__s
), "1" (0xffffffff),

549 "m" ( *(¡ruù { 
__x
[0xfffffff]; } *)
__s
)

551  
__»s
 - 1;

552 
	}
}

553 #ifdeà
__USE_GNU


554 
__STRING_INLINE
 *

555 
	$¿wmemchr
 (cÚ¡ *
__s
, 
__c
)

557  
	`__¿wmemchr
 (
__s
, 
__c
);

558 
	}
}

564 
	#_HAVE_STRING_ARCH_¡¾’
 1

	)

565 
	#¡¾’
(
¡r
) \

566 (
	`__ex‹nsiÚ__
 (
	`__bužtš_cÚ¡ªt_p
 (
¡r
) \

567 ? 
	`__bužtš_¡¾’
 (
¡r
) \

568 : 
	`__¡¾’_g
 (
¡r
)))

	)

569 
__STRING_INLINE
 
size_t
 
__¡¾’_g
 (cÚ¡ *
__¡r
);

571 
__STRING_INLINE
 
size_t


572 
	$__¡¾’_g
 (cÚ¡ *
__¡r
)

574 
__dummy
;

575 cÚ¡ *
__tmp
 = 
__¡r
;

576 
__asm__
 
__vÞ©že__


582 : "ô" (
__tmp
), "=&q" (
__dummy
)

583 : "0" (
__¡r
),

584 "m" ( *(¡ruù { 
__x
[0xfffffff]; } *)
__¡r
)

586  
__tmp
 - 
__¡r
 - 1;

587 
	}
}

591 
	#_HAVE_STRING_ARCH_¡rýy
 1

	)

592 
	#¡rýy
(
de¡
, 
¤c
) \

593 (
	`__ex‹nsiÚ__
 (
	`__bužtš_cÚ¡ªt_p
 (
¤c
) \

594 ? ( ((
¤c
)[0]è=ð1 && 
	`¡¾’
 (src) + 1 <= 8 \

595 ? 
	`__¡rýy_a_sm®l
 ((
de¡
), (
¤c
), 
	`¡¾’
 (src) + 1) \

596 : (*è
	`memýy
 ((*è(
de¡
), \

597 (cÚ¡ *è(
¤c
), \

598 
	`¡¾’
 (
¤c
) + 1)) \

599 : 
	`__¡rýy_g
 ((
de¡
), (
¤c
))))

	)

601 
	#__¡rýy_a_sm®l
(
de¡
, 
¤c
, 
¤þ’
) \

602 (
	`__ex‹nsiÚ__
 ({ *
__de¡
 = (
de¡
); \

604 
__ui
; \

605 
__usi
; \

606 
__uc
; \

607 
__c
; \

608 } *
__u
 = (*è
__de¡
; \

609 
¤þ’
) \

612 
__u
->
__uc
 = '\0'; \

615 
__u
->
__usi
 = 
	`__STRING_SMALL_GET16
 (
¤c
, 0); \

618 
__u
->
__usi
 = 
	`__STRING_SMALL_GET16
 (
¤c
, 0); \

619 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 2); \

620 
__u
->
__uc
 = '\0'; \

623 
__u
->
__ui
 = 
	`__STRING_SMALL_GET32
 (
¤c
, 0); \

626 
__u
->
__ui
 = 
	`__STRING_SMALL_GET32
 (
¤c
, 0); \

627 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4); \

628 
__u
->
__uc
 = '\0'; \

631 
__u
->
__ui
 = 
	`__STRING_SMALL_GET32
 (
¤c
, 0); \

632 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4); \

633 
__u
->
__usi
 = 
	`__STRING_SMALL_GET16
 (
¤c
, 4); \

636 
__u
->
__ui
 = 
	`__STRING_SMALL_GET32
 (
¤c
, 0); \

637 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4); \

638 
__u
->
__usi
 = 
	`__STRING_SMALL_GET16
 (
¤c
, 4); \

639 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 2); \

640 
__u
->
__uc
 = '\0'; \

643 
__u
->
__ui
 = 
	`__STRING_SMALL_GET32
 (
¤c
, 0); \

644 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4); \

645 
__u
->
__ui
 = 
	`__STRING_SMALL_GET32
 (
¤c
, 4); \

648 (*è
__de¡
; }))

	)

650 
__STRING_INLINE
 *
__¡rýy_g
 (*
__de¡
, cÚ¡ *
__¤c
);

652 
__STRING_INLINE
 *

653 
	$__¡rýy_g
 (*
__de¡
, cÚ¡ *
__¤c
)

655 *
__tmp
 = 
__de¡
;

656 
__dummy
;

657 
__asm__
 
__vÞ©že__


666 : "=&r" (
__¤c
), "=&r" (
__tmp
), "=&q" (
__dummy
),

667 "=m" ( *(¡ruù { 
__x
[0xfffffff]; } *)
__de¡
)

668 : "0" (
__¤c
), "1" (
__tmp
),

669 "m" ( *(¡ruù { 
__x
[0xfffffff]; } *)
__¤c
)

671  
__de¡
;

672 
	}
}

675 #ifdeà
__USE_GNU


676 
	#_HAVE_STRING_ARCH_¡pýy
 1

	)

678 
	#__¡pýy
(
de¡
, 
¤c
) \

679 (
	`__ex‹nsiÚ__
 (
	`__bužtš_cÚ¡ªt_p
 (
¤c
) \

680 ? (
	`¡¾’
 (
¤c
) + 1 <= 8 \

681 ? 
	`__¡pýy_a_sm®l
 ((
de¡
), (
¤c
), 
	`¡¾’
 (src) + 1) \

682 : 
	`__¡pýy_c
 ((
de¡
), (
¤c
), 
	`¡¾’
 (src) + 1)) \

683 : 
	`__¡pýy_g
 ((
de¡
), (
¤c
))))

	)

684 
	#__¡pýy_c
(
de¡
, 
¤c
, 
¤þ’
) \

685 ((
¤þ’
) % 4 == 0 \

686 ? 
	`__mempýy_by4
 (
de¡
, 
¤c
, 
¤þ’
) - 1 \

687 : ((
¤þ’
) % 2 == 0 \

688 ? 
	`__mempýy_by2
 (
de¡
, 
¤c
, 
¤þ’
) - 1 \

689 : 
	`__mempýy_byn
 (
de¡
, 
¤c
, 
¤þ’
è- 1))

	)

692 
	#¡pýy
(
de¡
, 
¤c
è
	`__¡pýy
 ((de¡), (¤c))

	)

694 
	#__¡pýy_a_sm®l
(
de¡
, 
¤c
, 
¤þ’
) \

695 (
	`__ex‹nsiÚ__
 ({ union { \

696 
__ui
; \

697 
__usi
; \

698 
__uc
; \

699 
__c
; \

700 } *
__u
 = (*è(
de¡
); \

701 
¤þ’
) \

704 
__u
->
__uc
 = '\0'; \

707 
__u
->
__usi
 = 
	`__STRING_SMALL_GET16
 (
¤c
, 0); \

708 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 1); \

711 
__u
->
__usi
 = 
	`__STRING_SMALL_GET16
 (
¤c
, 0); \

712 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 2); \

713 
__u
->
__uc
 = '\0'; \

716 
__u
->
__ui
 = 
	`__STRING_SMALL_GET32
 (
¤c
, 0); \

717 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 3); \

720 
__u
->
__ui
 = 
	`__STRING_SMALL_GET32
 (
¤c
, 0); \

721 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4); \

722 
__u
->
__uc
 = '\0'; \

725 
__u
->
__ui
 = 
	`__STRING_SMALL_GET32
 (
¤c
, 0); \

726 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4); \

727 
__u
->
__usi
 = 
	`__STRING_SMALL_GET16
 (
¤c
, 4); \

728 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 1); \

731 
__u
->
__ui
 = 
	`__STRING_SMALL_GET32
 (
¤c
, 0); \

732 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4); \

733 
__u
->
__usi
 = 
	`__STRING_SMALL_GET16
 (
¤c
, 4); \

734 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 2); \

735 
__u
->
__uc
 = '\0'; \

738 
__u
->
__ui
 = 
	`__STRING_SMALL_GET32
 (
¤c
, 0); \

739 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4); \

740 
__u
->
__ui
 = 
	`__STRING_SMALL_GET32
 (
¤c
, 4); \

741 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 3); \

744 (*è
__u
; }))

	)

746 
__STRING_INLINE
 *
__mempýy_by4
 (*
__de¡
, cÚ¡ *
__¤c
,

747 
size_t
 
__¤þ’
);

749 
__STRING_INLINE
 *

750 
	$__mempýy_by4
 (*
__de¡
, cÚ¡ *
__¤c
, 
size_t
 
__¤þ’
)

752 *
__tmp
 = 
__de¡
;

753 
__d0
, 
__d1
;

754 
__asm__
 
__vÞ©že__


762 : "=&r" (
__d0
), "ô" (
__tmp
), "=&r" (
__¤c
), "=&r" (
__d1
)

763 : "1" (
__tmp
), "2" (
__¤c
), "3" (
__¤þ’
 / 4)

765  
__tmp
;

766 
	}
}

768 
__STRING_INLINE
 *
__mempýy_by2
 (*
__de¡
, cÚ¡ *
__¤c
,

769 
size_t
 
__¤þ’
);

771 
__STRING_INLINE
 *

772 
	$__mempýy_by2
 (*
__de¡
, cÚ¡ *
__¤c
, 
size_t
 
__¤þ’
)

774 *
__tmp
 = 
__de¡
;

775 
__d0
, 
__d1
;

776 
__asm__
 
__vÞ©že__


789 : "=&q" (
__d0
), "ô" (
__tmp
), "=&r" (
__¤c
), "=&r" (
__d1
),

790 "=m" ( *(¡ruù { 
__ex‹nsiÚ__
 
__x
[
__¤þ’
]; } *)
__de¡
)

791 : "1" (
__tmp
), "2" (
__¤c
), "3" (
__¤þ’
 / 2),

792 "m" ( *(¡ruù { 
__ex‹nsiÚ__
 
__x
[
__¤þ’
]; } *)
__¤c
)

794  
__tmp
 + 2;

795 
	}
}

797 
__STRING_INLINE
 *
__mempýy_byn
 (*
__de¡
, cÚ¡ *
__¤c
,

798 
size_t
 
__¤þ’
);

800 
__STRING_INLINE
 *

801 
	$__mempýy_byn
 (*
__de¡
, cÚ¡ *
__¤c
, 
size_t
 
__¤þ’
)

803 
__d0
, 
__d1
;

804 *
__tmp
 = 
__de¡
;

805 
__asm__
 
__vÞ©že__


816 : "=D" (
__tmp
), "=&c" (
__d0
), "=&S" (
__d1
),

817 "=m" ( *(¡ruù { 
__ex‹nsiÚ__
 
__x
[
__¤þ’
]; } *)
__de¡
)

818 : "0" (
__tmp
), "1" (
__¤þ’
), "2" (
__¤c
),

819 "m" ( *(¡ruù { 
__ex‹nsiÚ__
 
__x
[
__¤þ’
]; } *)
__¤c
)

821  
__tmp
;

822 
	}
}

824 
__STRING_INLINE
 *
__¡pýy_g
 (*
__de¡
, cÚ¡ *
__¤c
);

826 
__STRING_INLINE
 *

827 
	$__¡pýy_g
 (*
__de¡
, cÚ¡ *
__¤c
)

829 *
__tmp
 = 
__de¡
;

830 
__dummy
;

831 
__asm__
 
__vÞ©že__


840 : "=&r" (
__¤c
), "ô" (
__tmp
), "=&q" (
__dummy
),

841 "=m" ( *(¡ruù { 
__x
[0xfffffff]; } *)
__de¡
)

842 : "0" (
__¤c
), "1" (
__tmp
),

843 "m" ( *(¡ruù { 
__x
[0xfffffff]; } *)
__¤c
)

845  
__tmp
 - 1;

846 
	}
}

851 
	#_HAVE_STRING_ARCH_¡ºýy
 1

	)

852 
	#¡ºýy
(
de¡
, 
¤c
, 
n
) \

853 (
	`__ex‹nsiÚ__
 (
	`__bužtš_cÚ¡ªt_p
 (
¤c
) \

854 ? ((
	`¡¾’
 (
¤c
è+ 1 >ð((
size_t
è(
n
)) \

855 ? (*è
	`memýy
 ((*è(
de¡
), \

856 (cÚ¡ *è(
¤c
), 
n
) \

857 : 
	`__¡ºýy_cg
 ((
de¡
), (
¤c
), 
	`¡¾’
 (¤cè+ 1, 
n
))) \

858 : 
	`__¡ºýy_gg
 ((
de¡
), (
¤c
), 
n
)))

	)

859 
	#__¡ºýy_cg
(
de¡
, 
¤c
, 
¤þ’
, 
n
) \

860 (((
¤þ’
) % 4 == 0) \

861 ? 
	`__¡ºýy_by4
 (
de¡
, 
¤c
, 
¤þ’
, 
n
) \

862 : (((
¤þ’
) % 2 == 0) \

863 ? 
	`__¡ºýy_by2
 (
de¡
, 
¤c
, 
¤þ’
, 
n
) \

864 : 
	`__¡ºýy_byn
 (
de¡
, 
¤c
, 
¤þ’
, 
n
)))

	)

866 
__STRING_INLINE
 *
__¡ºýy_by4
 (*
__de¡
, cÚ¡ 
__¤c
[],

867 
size_t
 
__¤þ’
, size_ˆ
__n
);

869 
__STRING_INLINE
 *

870 
	$__¡ºýy_by4
 (*
__de¡
, cÚ¡ 
__¤c
[], 
size_t
 
__¤þ’
, size_ˆ
__n
)

872 *
__tmp
 = 
__de¡
;

873 
__dummy1
, 
__dummy2
;

874 
__asm__
 
__vÞ©že__


882 : "=&r" (
__dummy1
), "ô" (
__tmp
), "=&r" (
__¤c
), "=&r" (
__dummy2
),

883 "=m" ( *(¡ruù { 
__ex‹nsiÚ__
 
__x
[
__¤þ’
]; } *)
__de¡
)

884 : "1" (
__tmp
), "2" (
__¤c
), "3" (
__¤þ’
 / 4),

885 "m" ( *(¡ruù { 
__ex‹nsiÚ__
 
__x
[
__¤þ’
]; } *)
__¤c
)

887 (è
	`mem£t
 (
__tmp
, '\0', 
__n
 - 
__¤þ’
);

888  
__de¡
;

889 
	}
}

891 
__STRING_INLINE
 *
__¡ºýy_by2
 (*
__de¡
, cÚ¡ 
__¤c
[],

892 
size_t
 
__¤þ’
, size_ˆ
__n
);

894 
__STRING_INLINE
 *

895 
	$__¡ºýy_by2
 (*
__de¡
, cÚ¡ 
__¤c
[], 
size_t
 
__¤þ’
, size_ˆ
__n
)

897 *
__tmp
 = 
__de¡
;

898 
__dummy1
, 
__dummy2
;

899 
__asm__
 
__vÞ©že__


912 : "=&q" (
__dummy1
), "ô" (
__tmp
), "=&r" (
__¤c
), "=&r" (
__dummy2
),

913 "=m" ( *(¡ruù { 
__ex‹nsiÚ__
 
__x
[
__¤þ’
]; } *)
__de¡
)

914 : "1" (
__tmp
), "2" (
__¤c
), "3" (
__¤þ’
 / 2),

915 "m" ( *(¡ruù { 
__ex‹nsiÚ__
 
__x
[
__¤þ’
]; } *)
__¤c
)

917 (è
	`mem£t
 (
__tmp
 + 2, '\0', 
__n
 - 
__¤þ’
);

918  
__de¡
;

919 
	}
}

921 
__STRING_INLINE
 *
__¡ºýy_byn
 (*
__de¡
, cÚ¡ 
__¤c
[],

922 
size_t
 
__¤þ’
, size_ˆ
__n
);

924 
__STRING_INLINE
 *

925 
	$__¡ºýy_byn
 (*
__de¡
, cÚ¡ 
__¤c
[], 
size_t
 
__¤þ’
, size_ˆ
__n
)

927 
__d0
, 
__d1
;

928 *
__tmp
 = 
__de¡
;

929 
__asm__
 
__vÞ©že__


940 : "=D" (
__tmp
), "=&c" (
__d0
), "=&S" (
__d1
),

941 "=m" ( *(¡ruù { 
__ex‹nsiÚ__
 
__x
[
__¤þ’
]; } *)
__de¡
)

942 : "1" (
__¤þ’
), "0" (
__tmp
),"2" (
__¤c
),

943 "m" ( *(¡ruù { 
__ex‹nsiÚ__
 
__x
[
__¤þ’
]; } *)
__¤c
)

945 (è
	`mem£t
 (
__tmp
, '\0', 
__n
 - 
__¤þ’
);

946  
__de¡
;

947 
	}
}

949 
__STRING_INLINE
 *
__¡ºýy_gg
 (*
__de¡
, cÚ¡ *
__¤c
,

950 
size_t
 
__n
);

952 
__STRING_INLINE
 *

953 
	$__¡ºýy_gg
 (*
__de¡
, cÚ¡ *
__¤c
, 
size_t
 
__n
)

955 *
__tmp
 = 
__de¡
;

956 
__dummy
;

957 ià(
__n
 > 0)

958 
__asm__
 
__vÞ©že__


974 : "=&r" (
__¤c
), "=&r" (
__tmp
), "=&q" (
__dummy
), "=&r" (
__n
)

975 : "0" (
__¤c
), "1" (
__tmp
), "3" (
__n
)

978  
__de¡
;

979 
	}
}

983 
	#_HAVE_STRING_ARCH_¡rÿt
 1

	)

984 
	#¡rÿt
(
de¡
, 
¤c
) \

985 (
	`__ex‹nsiÚ__
 (
	`__bužtš_cÚ¡ªt_p
 (
¤c
) \

986 ? 
	`__¡rÿt_c
 ((
de¡
), (
¤c
), 
	`¡¾’
 (src) + 1) \

987 : 
	`__¡rÿt_g
 ((
de¡
), (
¤c
))))

	)

989 
__STRING_INLINE
 *
__¡rÿt_c
 (*
__de¡
, cÚ¡ 
__¤c
[],

990 
size_t
 
__¤þ’
);

992 
__STRING_INLINE
 *

993 
	$__¡rÿt_c
 (*
__de¡
, cÚ¡ 
__¤c
[], 
size_t
 
__¤þ’
)

995 #ifdeà
__i686__


996 
__d0
;

997 *
__tmp
;

998 
__asm__
 
__vÞ©že__


1000 : "=D" (
__tmp
), "=&c" (
__d0
),

1001 "=m" ( *(¡ruù { 
__x
[0xfffffff]; } *)
__de¡
)

1002 : "0" (
__de¡
), "1" (0xffffffff), "a" (0),

1003 "m" ( *(¡ruù { 
__ex‹nsiÚ__
 
__x
[
__¤þ’
]; } *)
__¤c
)

1005 --
__tmp
;

1007 *
__tmp
 = 
__de¡
;

1008 
__asm__
 
__vÞ©že__


1014 : "ô" (
__tmp
),

1015 "=m" ( *(¡ruù { 
__x
[0xfffffff]; } *)
__de¡
)

1016 : "0" (
__tmp
),

1017 "m" ( *(¡ruù { 
__ex‹nsiÚ__
 
__x
[
__¤þ’
]; } *)
__¤c
)

1020 (è
	`memýy
 (
__tmp
, 
__¤c
, 
__¤þ’
);

1021  
__de¡
;

1022 
	}
}

1024 
__STRING_INLINE
 *
__¡rÿt_g
 (*
__de¡
, cÚ¡ *
__¤c
);

1026 
__STRING_INLINE
 *

1027 
	$__¡rÿt_g
 (*
__de¡
, cÚ¡ *
__¤c
)

1029 *
__tmp
 = 
__de¡
;

1030 
__dummy
;

1031 
__asm__
 
__vÞ©že__


1044 : "=&q" (
__dummy
), "=&r" (
__tmp
), "=&r" (
__¤c
),

1045 "=m" ( *(¡ruù { 
__x
[0xfffffff]; } *)
__de¡
)

1046 : "1" (
__tmp
), "2" (
__¤c
),

1047 "m" ( *(¡ruù { 
__x
[0xfffffff]; } *)
__¤c
)

1049  
__de¡
;

1050 
	}
}

1054 
	#_HAVE_STRING_ARCH_¡ºÿt
 1

	)

1055 
	#¡ºÿt
(
de¡
, 
¤c
, 
n
) \

1056 (
	`__ex‹nsiÚ__
 ({ *
__de¡
 = (
de¡
); \

1057 
	`__bužtš_cÚ¡ªt_p
 (
¤c
è&& __bužtš_cÚ¡ªt_°(
n
) \

1058 ? (
	`¡¾’
 (
¤c
è< ((
size_t
è(
n
)) \

1059 ? 
	`¡rÿt
 (
__de¡
, (
¤c
)) \

1060 : (*(*)
	`__mempýy
 (
	`¡rchr
 (
__de¡
, '\0'), \

1061 (cÚ¡ *è(
¤c
), \

1062 (
n
)èð0, 
__de¡
)) \

1063 : 
	`__¡ºÿt_g
 (
__de¡
, (
¤c
), (
n
)); }))

	)

1065 
__STRING_INLINE
 *
__¡ºÿt_g
 (*
__de¡
, cÚ¡ 
__¤c
[],

1066 
size_t
 
__n
);

1068 
__STRING_INLINE
 *

1069 
	$__¡ºÿt_g
 (*
__de¡
, cÚ¡ 
__¤c
[], 
size_t
 
__n
)

1071 *
__tmp
 = 
__de¡
;

1072 
__dummy
;

1073 #ifdeà
__i686__


1074 
__asm__
 
__vÞ©že__


1088 : "=&a" (
__dummy
), "=&D" (
__tmp
), "=&S" (
__¤c
), "=&c" (
__n
)

1089 : "g" (
__n
), "0" (0), "1" (
__tmp
), "2" (
__¤c
), "3" (0xffffffff)

1092 --
__tmp
;

1093 
__asm__
 
__vÞ©že__


1110 : "=&q" (
__dummy
), "=&r" (
__tmp
), "=&r" (
__¤c
), "=&r" (
__n
)

1111 : "1" (
__tmp
), "2" (
__¤c
), "3" (
__n
)

1114  
__de¡
;

1115 
	}
}

1119 
	#_HAVE_STRING_ARCH_¡rcmp
 1

	)

1120 
	#¡rcmp
(
s1
, 
s2
) \

1121 (
	`__ex‹nsiÚ__
 (
	`__bužtš_cÚ¡ªt_p
 (
s1
è&& __bužtš_cÚ¡ªt_°(
s2
) \

1122 && ( ((
s1
)[0]è!ð1 || 
	`¡¾’
 (s1) >= 4) \

1123 && ( ((
s2
)[0]è!ð1 || 
	`¡¾’
 (s2) >= 4) \

1124 ? 
	`memcmp
 ((cÚ¡ *è(
s1
), (cÚ¡ *è(
s2
), \

1125 (
	`¡¾’
 (
s1
è< sŒËÀ(
s2
) \

1126 ? 
	`¡¾’
 (
s1
è: sŒËÀ(
s2
)) + 1) \

1127 : (
	`__bužtš_cÚ¡ªt_p
 (
s1
) &&  ((s1)[0]) == 1 \

1128 &&  ((
s2
)[0]è=ð1 && 
	`¡¾’
 (
s1
) < 4 \

1129 ? (
	`__bužtš_cÚ¡ªt_p
 (
s2
) &&  ((s2)[0]) == 1 \

1130 ? 
	`__¡rcmp_cc
 ((cÚ¡ *è(
s1
), \

1131 (cÚ¡ *è(
s2
), \

1132 
	`¡¾’
 (
s1
)) \

1133 : 
	`__¡rcmp_cg
 ((cÚ¡ *è(
s1
), \

1134 (cÚ¡ *è(
s2
), \

1135 
	`¡¾’
 (
s1
))) \

1136 : (
	`__bužtš_cÚ¡ªt_p
 (
s2
è&&  ((
s1
)[0]) == 1 \

1137 &&  ((
s2
)[0]è=ð1 && 
	`¡¾’
 (s2) < 4 \

1138 ? (
	`__bužtš_cÚ¡ªt_p
 (
s1
) \

1139 ? 
	`__¡rcmp_cc
 ((cÚ¡ *è(
s1
), \

1140 (cÚ¡ *è(
s2
), \

1141 
	`¡¾’
 (
s2
)) \

1142 : 
	`__¡rcmp_gc
 ((cÚ¡ *è(
s1
), \

1143 (cÚ¡ *è(
s2
), \

1144 
	`¡¾’
 (
s2
))) \

1145 : 
	`__¡rcmp_gg
 ((
s1
), (
s2
))))))

	)

1147 
	#__¡rcmp_cc
(
s1
, 
s2
, 
l
) \

1148 (
	`__ex‹nsiÚ__
 ({ 
__»suÉ
 = (
s1
)[0] - (
s2
)[0]; \

1149 ià(
l
 > 0 && 
__»suÉ
 == 0) \

1151 
__»suÉ
 = (
s1
)[1] - (
s2
)[1]; \

1152 ià(
l
 > 1 && 
__»suÉ
 == 0) \

1154 
__»suÉ
 = (
s1
)[2] - (
s2
)[2]; \

1155 ià(
l
 > 2 && 
__»suÉ
 == 0) \

1156 
__»suÉ
 = (
s1
)[3] - (
s2
)[3]; \

1159 
__»suÉ
; }))

	)

1161 
	#__¡rcmp_cg
(
s1
, 
s2
, 
l1
) \

1162 (
	`__ex‹nsiÚ__
 ({ cÚ¡ *
__s2
 = (
s2
); \

1163 
__»suÉ
 = (
s1
)[0] - 
__s2
[0]; \

1164 ià(
l1
 > 0 && 
__»suÉ
 == 0) \

1166 
__»suÉ
 = (
s1
)[1] - 
__s2
[1]; \

1167 ià(
l1
 > 1 && 
__»suÉ
 == 0) \

1169 
__»suÉ
 = (
s1
)[2] - 
__s2
[2]; \

1170 ià(
l1
 > 2 && 
__»suÉ
 == 0) \

1171 
__»suÉ
 = (
s1
)[3] - 
__s2
[3]; \

1174 
__»suÉ
; }))

	)

1176 
	#__¡rcmp_gc
(
s1
, 
s2
, 
l2
) \

1177 (
	`__ex‹nsiÚ__
 ({ cÚ¡ *
__s1
 = (
s1
); \

1178 
__»suÉ
 = 
__s1
[0] - (
s2
)[0]; \

1179 ià(
l2
 > 0 && 
__»suÉ
 == 0) \

1181 
__»suÉ
 = 
__s1
[1] - (
s2
)[1]; \

1182 ià(
l2
 > 1 && 
__»suÉ
 == 0) \

1184 
__»suÉ
 = 
__s1
[2] - (
s2
)[2]; \

1185 ià(
l2
 > 2 && 
__»suÉ
 == 0) \

1186 
__»suÉ
 = 
__s1
[3] - (
s2
)[3]; \

1189 
__»suÉ
; }))

	)

1191 
__STRING_INLINE
 
__¡rcmp_gg
 (cÚ¡ *
__s1
, cÚ¡ *
__s2
);

1193 
__STRING_INLINE
 

1194 
	$__¡rcmp_gg
 (cÚ¡ *
__s1
, cÚ¡ *
__s2
)

1196 
__»s
;

1197 
__asm__
 
__vÞ©že__


1213 : "=q" (
__»s
), "=&r" (
__s1
), "=&r" (
__s2
)

1214 : "1" (
__s1
), "2" (
__s2
),

1215 "m" ( *(¡ruù { 
__x
[0xfffffff]; } *)
__s1
),

1216 "m" ( *(¡ruù { 
__x
[0xfffffff]; } *)
__s2
)

1218  
__»s
;

1219 
	}
}

1223 
	#_HAVE_STRING_ARCH_¡ºcmp
 1

	)

1224 
	#¡ºcmp
(
s1
, 
s2
, 
n
) \

1225 (
	`__ex‹nsiÚ__
 (
	`__bužtš_cÚ¡ªt_p
 (
s1
è&& 
	`¡¾’
 (s1è< ((
size_t
è(
n
)) \

1226 ? 
	`¡rcmp
 ((
s1
), (
s2
)) \

1227 : (
	`__bužtš_cÚ¡ªt_p
 (
s2
è&& 
	`¡¾’
 (s2è< ((
size_t
è(
n
))\

1228 ? 
	`¡rcmp
 ((
s1
), (
s2
)) \

1229 : 
	`__¡ºcmp_g
 ((
s1
), (
s2
), (
n
)))))

	)

1231 
__STRING_INLINE
 
__¡ºcmp_g
 (cÚ¡ *
__s1
, cÚ¡ *
__s2
,

1232 
size_t
 
__n
);

1234 
__STRING_INLINE
 

1235 
	$__¡ºcmp_g
 (cÚ¡ *
__s1
, cÚ¡ *
__s2
, 
size_t
 
__n
)

1237 
__»s
;

1238 
__asm__
 
__vÞ©že__


1257 : "=q" (
__»s
), "=&r" (
__s1
), "=&r" (
__s2
), "=&r" (
__n
)

1258 : "1" (
__s1
), "2" (
__s2
), "3" (
__n
),

1259 "m" ( *(¡ruù { 
__ex‹nsiÚ__
 
__x
[
__n
]; } *)
__s1
),

1260 "m" ( *(¡ruù { 
__ex‹nsiÚ__
 
__x
[
__n
]; } *)
__s2
)

1262  
__»s
;

1263 
	}
}

1267 
	#_HAVE_STRING_ARCH_¡rchr
 1

	)

1268 
	#_USE_STRING_ARCH_¡rchr
 1

	)

1269 
	#¡rchr
(
s
, 
c
) \

1270 (
	`__ex‹nsiÚ__
 (
	`__bužtš_cÚ¡ªt_p
 (
c
) \

1271 ? ((
c
) == '\0' \

1272 ? (*è
	`__¿wmemchr
 ((
s
), (
c
)) \

1273 : 
	`__¡rchr_c
 ((
s
), ((
c
) & 0xff) << 8)) \

1274 : 
	`__¡rchr_g
 ((
s
), (
c
))))

	)

1276 
__STRING_INLINE
 *
__¡rchr_c
 (cÚ¡ *
__s
, 
__c
);

1278 
__STRING_INLINE
 *

1279 
	$__¡rchr_c
 (cÚ¡ *
__s
, 
__c
)

1281 
__d0
;

1282 *
__»s
;

1283 
__asm__
 
__vÞ©že__


1293 : "ô" (
__»s
), "=&a" (
__d0
)

1294 : "0" (
__s
), "1" (
__c
),

1295 "m" ( *(¡ruù { 
__x
[0xfffffff]; } *)
__s
)

1297  
__»s
;

1298 
	}
}

1300 
__STRING_INLINE
 *
__¡rchr_g
 (cÚ¡ *
__s
, 
__c
);

1302 
__STRING_INLINE
 *

1303 
	$__¡rchr_g
 (cÚ¡ *
__s
, 
__c
)

1305 
__d0
;

1306 *
__»s
;

1307 
__asm__
 
__vÞ©že__


1318 : "ô" (
__»s
), "=&a" (
__d0
)

1319 : "0" (
__s
), "1" (
__c
),

1320 "m" ( *(¡ruù { 
__x
[0xfffffff]; } *)
__s
)

1322  
__»s
;

1323 
	}
}

1327 
	#_HAVE_STRING_ARCH_¡rchºul
 1

	)

1328 
	#__¡rchºul
(
s
, 
c
) \

1329 (
	`__ex‹nsiÚ__
 (
	`__bužtš_cÚ¡ªt_p
 (
c
) \

1330 ? ((
c
) == '\0' \

1331 ? (*è
	`__¿wmemchr
 ((
s
), 
c
) \

1332 : 
	`__¡rchºul_c
 ((
s
), ((
c
) & 0xff) << 8)) \

1333 : 
	`__¡rchºul_g
 ((
s
), 
c
)))

	)

1335 
__STRING_INLINE
 *
__¡rchºul_c
 (cÚ¡ *
__s
, 
__c
);

1337 
__STRING_INLINE
 *

1338 
	$__¡rchºul_c
 (cÚ¡ *
__s
, 
__c
)

1340 
__d0
;

1341 *
__»s
;

1342 
__asm__
 
__vÞ©že__


1352 : "ô" (
__»s
), "=&a" (
__d0
)

1353 : "0" (
__s
), "1" (
__c
),

1354 "m" ( *(¡ruù { 
__x
[0xfffffff]; } *)
__s
)

1356  
__»s
;

1357 
	}
}

1359 
__STRING_INLINE
 *
__¡rchºul_g
 (cÚ¡ *
__s
, 
__c
);

1361 
__STRING_INLINE
 *

1362 
	$__¡rchºul_g
 (cÚ¡ *
__s
, 
__c
)

1364 
__d0
;

1365 *
__»s
;

1366 
__asm__
 
__vÞ©že__


1377 : "ô" (
__»s
), "=&a" (
__d0
)

1378 : "0" (
__s
), "1" (
__c
),

1379 "m" ( *(¡ruù { 
__x
[0xfffffff]; } *)
__s
)

1381  
__»s
;

1382 
	}
}

1383 #ifdeà
__USE_GNU


1384 
	#¡rchºul
(
s
, 
c
è
	`__¡rchºul
 ((s), (c))

	)

1388 #ià
defšed
 
__USE_MISC
 || defšed 
__USE_XOPEN_EXTENDED


1390 
	#_HAVE_STRING_ARCH_šdex
 1

	)

1391 
	#šdex
(
s
, 
c
) \

1392 (
	`__ex‹nsiÚ__
 (
	`__bužtš_cÚ¡ªt_p
 (
c
) \

1393 ? 
	`__¡rchr_c
 ((
s
), ((
c
) & 0xff) << 8) \

1394 : 
	`__¡rchr_g
 ((
s
), (
c
))))

	)

1399 
	#_HAVE_STRING_ARCH_¡¼chr
 1

	)

1400 
	#¡¼chr
(
s
, 
c
) \

1401 (
	`__ex‹nsiÚ__
 (
	`__bužtš_cÚ¡ªt_p
 (
c
) \

1402 ? 
	`__¡¼chr_c
 ((
s
), ((
c
) & 0xff) << 8) \

1403 : 
	`__¡¼chr_g
 ((
s
), (
c
))))

	)

1405 #ifdeà
__i686__


1406 
__STRING_INLINE
 *
__¡¼chr_c
 (cÚ¡ *
__s
, 
__c
);

1408 
__STRING_INLINE
 *

1409 
	$__¡¼chr_c
 (cÚ¡ *
__s
, 
__c
)

1411 
__d0
, 
__d1
;

1412 *
__»s
;

1413 
__asm__
 
__vÞ©že__


1421 : "=d" (
__»s
), "=&S" (
__d0
), "=&a" (
__d1
)

1422 : "0" (1), "1" (
__s
), "2" (
__c
),

1423 "m" ( *(¡ruù { 
__x
[0xfffffff]; } *)
__s
)

1425  
__»s
 - 1;

1426 
	}
}

1428 
__STRING_INLINE
 *
__¡¼chr_g
 (cÚ¡ *
__s
, 
__c
);

1430 
__STRING_INLINE
 *

1431 
	$__¡¼chr_g
 (cÚ¡ *
__s
, 
__c
)

1433 
__d0
, 
__d1
;

1434 *
__»s
;

1435 
__asm__
 
__vÞ©že__


1444 : "=d" (
__»s
), "=&S" (
__d0
), "=&a" (
__d1
)

1445 : "0" (1), "1" (
__s
), "2" (
__c
),

1446 "m" ( *(¡ruù { 
__x
[0xfffffff]; } *)
__s
)

1448  
__»s
 - 1;

1449 
	}
}

1451 
__STRING_INLINE
 *
__¡¼chr_c
 (cÚ¡ *
__s
, 
__c
);

1453 
__STRING_INLINE
 *

1454 
	$__¡¼chr_c
 (cÚ¡ *
__s
, 
__c
)

1456 
__d0
, 
__d1
;

1457 *
__»s
;

1458 
__asm__
 
__vÞ©že__


1468 : "=d" (
__»s
), "=&S" (
__d0
), "=&a" (
__d1
)

1469 : "0" (0), "1" (
__s
), "2" (
__c
),

1470 "m" ( *(¡ruù { 
__x
[0xfffffff]; } *)
__s
)

1472  
__»s
;

1473 
	}
}

1475 
__STRING_INLINE
 *
__¡¼chr_g
 (cÚ¡ *
__s
, 
__c
);

1477 
__STRING_INLINE
 *

1478 
	$__¡¼chr_g
 (cÚ¡ *
__s
, 
__c
)

1480 
__d0
, 
__d1
;

1481 *
__»s
;

1482 
__asm__
 
__vÞ©že__


1493 : "ô" (
__»s
), "=&S" (
__d0
), "=&a" (
__d1
)

1494 : "0" (0), "1" (
__s
), "2" (
__c
),

1495 "m" ( *(¡ruù { 
__x
[0xfffffff]; } *)
__s
)

1497  
__»s
;

1498 
	}
}

1502 #ià
defšed
 
__USE_MISC
 || defšed 
__USE_XOPEN_EXTENDED


1504 
	#_HAVE_STRING_ARCH_ršdex
 1

	)

1505 
	#ršdex
(
s
, 
c
) \

1506 (
	`__ex‹nsiÚ__
 (
	`__bužtš_cÚ¡ªt_p
 (
c
) \

1507 ? 
	`__¡¼chr_c
 ((
s
), ((
c
) & 0xff) << 8) \

1508 : 
	`__¡¼chr_g
 ((
s
), (
c
))))

	)

1514 
	#_HAVE_STRING_ARCH_¡rc¥n
 1

	)

1515 
	#¡rc¥n
(
s
, 
»jeù
) \

1516 (
	`__ex‹nsiÚ__
 (
	`__bužtš_cÚ¡ªt_p
 (
»jeù
) &&  ((reject)[0]) == 1 \

1517 ? ((
»jeù
)[0] == '\0' \

1518 ? 
	`¡¾’
 (
s
) \

1519 : ((
»jeù
)[1] == '\0' \

1520 ? 
	`__¡rc¥n_c1
 ((
s
), (((
»jeù
)[0] << 8) & 0xff00)) \

1521 : 
	`__¡rc¥n_cg
 ((
s
), (
»jeù
), 
	`¡¾’
 (reject)))) \

1522 : 
	`__¡rc¥n_g
 ((
s
), (
»jeù
))))

	)

1524 
__STRING_INLINE
 
size_t
 
__¡rc¥n_c1
 (cÚ¡ *
__s
, 
__»jeù
);

1526 #iâdeà
_FORCE_INLINES


1527 
__STRING_INLINE
 
size_t


1528 
	$__¡rc¥n_c1
 (cÚ¡ *
__s
, 
__»jeù
)

1530 
__d0
;

1531 *
__»s
;

1532 
__asm__
 
__vÞ©že__


1541 : "ô" (
__»s
), "=&a" (
__d0
)

1542 : "0" (
__s
), "1" (
__»jeù
),

1543 "m" ( *(¡ruù { 
__x
[0xfffffff]; } *)
__s
)

1545  (
__»s
 - 1è- 
__s
;

1546 
	}
}

1549 
__STRING_INLINE
 
size_t
 
__¡rc¥n_cg
 (cÚ¡ *
__s
, cÚ¡ 
__»jeù
[],

1550 
size_t
 
__»jeù_Ën
);

1552 
__STRING_INLINE
 
size_t


1553 
	$__¡rc¥n_cg
 (cÚ¡ *
__s
, cÚ¡ 
__»jeù
[], 
size_t
 
__»jeù_Ën
)

1555 
__d0
, 
__d1
, 
__d2
;

1556 cÚ¡ *
__»s
;

1557 
__asm__
 
__vÞ©že__


1568 : "=S" (
__»s
), "=&a" (
__d0
), "=&c" (
__d1
), "=&D" (
__d2
)

1569 : "0" (
__s
), "d" (
__»jeù
), "g" (
__»jeù_Ën
)

1571  (
__»s
 - 1è- 
__s
;

1572 
	}
}

1574 
__STRING_INLINE
 
size_t
 
__¡rc¥n_g
 (cÚ¡ *
__s
, cÚ¡ *
__»jeù
);

1575 #ifdeà
__PIC__


1577 
__STRING_INLINE
 
size_t


1578 
	$__¡rc¥n_g
 (cÚ¡ *
__s
, cÚ¡ *
__»jeù
)

1580 
__d0
, 
__d1
, 
__d2
;

1581 cÚ¡ *
__»s
;

1582 
__asm__
 
__vÞ©že__


1599 : "=S" (
__»s
), "=&a" (
__d0
), "=&c" (
__d1
), "=&D" (
__d2
)

1600 : "r" (
__»jeù
), "0" (
__s
), "1" (0), "2" (0xffffffff)

1602  (
__»s
 - 1è- 
__s
;

1603 
	}
}

1605 
__STRING_INLINE
 
size_t


1606 
	$__¡rc¥n_g
 (cÚ¡ *
__s
, cÚ¡ *
__»jeù
)

1608 
__d0
, 
__d1
, 
__d2
, 
__d3
;

1609 cÚ¡ *
__»s
;

1610 
__asm__
 
__vÞ©že__


1624 : "=S" (
__»s
), "=&a" (
__d0
), "=&c" (
__d1
), "=&D" (
__d2
), "=&d" (
__d3
)

1625 : "0" (
__s
), "1" (0), "2" (0xffffffff), "3" (
__»jeù
), "b" (__reject)

1628  (
__»s
 - 1è- 
__s
;

1629 
	}
}

1635 
	#_HAVE_STRING_ARCH_¡r¥n
 1

	)

1636 
	#¡r¥n
(
s
, 
acû±
) \

1637 (
	`__ex‹nsiÚ__
 (
	`__bužtš_cÚ¡ªt_p
 (
acû±
) &&  ((accept)[0]) == 1 \

1638 ? ((
acû±
)[0] == '\0' \

1639 ? ((è(
s
), 0) \

1640 : ((
acû±
)[1] == '\0' \

1641 ? 
	`__¡r¥n_c1
 ((
s
), (((
acû±
)[0] << 8 ) & 0xff00)) \

1642 : 
	`__¡r¥n_cg
 ((
s
), (
acû±
), 
	`¡¾’
 (accept)))) \

1643 : 
	`__¡r¥n_g
 ((
s
), (
acû±
))))

	)

1645 #iâdeà
_FORCE_INLINES


1646 
__STRING_INLINE
 
size_t
 
__¡r¥n_c1
 (cÚ¡ *
__s
, 
__acû±
);

1648 
__STRING_INLINE
 
size_t


1649 
	$__¡r¥n_c1
 (cÚ¡ *
__s
, 
__acû±
)

1651 
__d0
;

1652 *
__»s
;

1654 
__asm__
 
__vÞ©že__


1660 : "ô" (
__»s
), "=&q" (
__d0
)

1661 : "0" (
__s
), "1" (
__acû±
),

1662 "m" ( *(¡ruù { 
__x
[0xfffffff]; } *)
__s
)

1664  (
__»s
 - 1è- 
__s
;

1665 
	}
}

1668 
__STRING_INLINE
 
size_t
 
__¡r¥n_cg
 (cÚ¡ *
__s
, cÚ¡ 
__acû±
[],

1669 
size_t
 
__acû±_Ën
);

1671 
__STRING_INLINE
 
size_t


1672 
	$__¡r¥n_cg
 (cÚ¡ *
__s
, cÚ¡ 
__acû±
[], 
size_t
 
__acû±_Ën
)

1674 
__d0
, 
__d1
, 
__d2
;

1675 cÚ¡ *
__»s
;

1676 
__asm__
 
__vÞ©že__


1687 : "=S" (
__»s
), "=&a" (
__d0
), "=&c" (
__d1
), "=&D" (
__d2
)

1688 : "0" (
__s
), "g" (
__acû±
), "g" (
__acû±_Ën
),

1691 "m" ( *(¡ruù { 
__x
[0xfffffff]; } *)
__s
),

1692 "m" ( *(¡ruù { 
__ex‹nsiÚ__
 
__x
[
__acû±_Ën
]; } *)
__acû±
)

1694  (
__»s
 - 1è- 
__s
;

1695 
	}
}

1697 
__STRING_INLINE
 
size_t
 
__¡r¥n_g
 (cÚ¡ *
__s
, cÚ¡ *
__acû±
);

1698 #ifdeà
__PIC__


1700 
__STRING_INLINE
 
size_t


1701 
	$__¡r¥n_g
 (cÚ¡ *
__s
, cÚ¡ *
__acû±
)

1703 
__d0
, 
__d1
, 
__d2
;

1704 cÚ¡ *
__»s
;

1705 
__asm__
 
__vÞ©že__


1721 : "=S" (
__»s
), "=&a" (
__d0
), "=&c" (
__d1
), "=&D" (
__d2
)

1722 : "d" (
__acû±
), "0" (
__s
), "1" (0), "2" (0xffffffff), "3" (__accept)

1724  (
__»s
 - 1è- 
__s
;

1725 
	}
}

1727 
__STRING_INLINE
 
size_t


1728 
	$__¡r¥n_g
 (cÚ¡ *
__s
, cÚ¡ *
__acû±
)

1730 
__d0
, 
__d1
, 
__d2
, 
__d3
;

1731 cÚ¡ *
__»s
;

1732 
__asm__
 
__vÞ©že__


1746 : "=S" (
__»s
), "=&a" (
__d0
), "=&c" (
__d1
), "=&D" (
__d2
), "=&d" (
__d3
)

1747 : "0" (
__s
), "1" (0), "2" (0xffffffff), "3" (
__acû±
), "b" (__accept)

1749  (
__»s
 - 1è- 
__s
;

1750 
	}
}

1755 
	#_HAVE_STRING_ARCH_¡½brk
 1

	)

1756 
	#¡½brk
(
s
, 
acû±
) \

1757 (
	`__ex‹nsiÚ__
 (
	`__bužtš_cÚ¡ªt_p
 (
acû±
) &&  ((accept)[0]) == 1 \

1758 ? ((
acû±
)[0] == '\0' \

1759 ? ((è(
s
), (*) 0) \

1760 : ((
acû±
)[1] == '\0' \

1761 ? 
	`¡rchr
 ((
s
), (
acû±
)[0]) \

1762 : 
	`__¡½brk_cg
 ((
s
), (
acû±
), 
	`¡¾’
 (accept)))) \

1763 : 
	`__¡½brk_g
 ((
s
), (
acû±
))))

	)

1765 
__STRING_INLINE
 *
__¡½brk_cg
 (cÚ¡ *
__s
, cÚ¡ 
__acû±
[],

1766 
size_t
 
__acû±_Ën
);

1768 
__STRING_INLINE
 *

1769 
	$__¡½brk_cg
 (cÚ¡ *
__s
, cÚ¡ 
__acû±
[], 
size_t
 
__acû±_Ën
)

1771 
__d0
, 
__d1
, 
__d2
;

1772 *
__»s
;

1773 
__asm__
 
__vÞ©že__


1788 : "=S" (
__»s
), "=&a" (
__d0
), "=&c" (
__d1
), "=&D" (
__d2
)

1789 : "0" (
__s
), "d" (
__acû±
), "g" (
__acû±_Ën
)

1791  
__»s
;

1792 
	}
}

1794 
__STRING_INLINE
 *
__¡½brk_g
 (cÚ¡ *
__s
, cÚ¡ *
__acû±
);

1795 #ifdeà
__PIC__


1797 
__STRING_INLINE
 *

1798 
	$__¡½brk_g
 (cÚ¡ *
__s
, cÚ¡ *
__acû±
)

1800 
__d0
, 
__d1
, 
__d2
;

1801 *
__»s
;

1802 
__asm__
 
__vÞ©že__


1823 : "=S" (
__»s
), "=&a" (
__d0
), "=&c" (
__d1
), "=&D" (
__d2
)

1824 : "d" (
__acû±
), "0" (
__s
), "1" (0), "2" (0xffffffff)

1826  
__»s
;

1827 
	}
}

1829 
__STRING_INLINE
 *

1830 
	$__¡½brk_g
 (cÚ¡ *
__s
, cÚ¡ *
__acû±
)

1832 
__d0
, 
__d1
, 
__d2
, 
__d3
;

1833 *
__»s
;

1834 
__asm__
 
__vÞ©že__


1853 : "=S" (
__»s
), "=&a" (
__d0
), "=&c" (
__d1
), "=&d" (
__d2
), "=&D" (
__d3
)

1854 : "0" (
__s
), "1" (0), "2" (0xffffffff), "b" (
__acû±
)

1856  
__»s
;

1857 
	}
}

1862 
	#_HAVE_STRING_ARCH_¡r¡r
 1

	)

1863 
	#¡r¡r
(
hay¡ack
, 
ÃedË
) \

1864 (
	`__ex‹nsiÚ__
 (
	`__bužtš_cÚ¡ªt_p
 (
ÃedË
) &&  ((needle)[0]) == 1 \

1865 ? ((
ÃedË
)[0] == '\0' \

1866 ? (
hay¡ack
) \

1867 : ((
ÃedË
)[1] == '\0' \

1868 ? 
	`¡rchr
 ((
hay¡ack
), (
ÃedË
)[0]) \

1869 : 
	`__¡r¡r_cg
 ((
hay¡ack
), (
ÃedË
), \

1870 
	`¡¾’
 (
ÃedË
)))) \

1871 : 
	`__¡r¡r_g
 ((
hay¡ack
), (
ÃedË
))))

	)

1875 
__STRING_INLINE
 *
__¡r¡r_cg
 (cÚ¡ *
__hay¡ack
,

1876 cÚ¡ 
__ÃedË
[],

1877 
size_t
 
__ÃedË_Ën
);

1879 
__STRING_INLINE
 *

1880 
	$__¡r¡r_cg
 (cÚ¡ *
__hay¡ack
, cÚ¡ 
__ÃedË
[],

1881 
size_t
 
__ÃedË_Ën
)

1883 
__d0
, 
__d1
, 
__d2
;

1884 *
__»s
;

1885 
__asm__
 
__vÞ©že__


1898 : "=&a" (
__»s
), "=&S" (
__d0
), "=&D" (
__d1
), "=&c" (
__d2
)

1899 : "g" (
__ÃedË_Ën
), "1" (
__hay¡ack
), "d" (
__ÃedË
)

1901  
__»s
;

1902 
	}
}

1904 
__STRING_INLINE
 *
__¡r¡r_g
 (cÚ¡ *
__hay¡ack
,

1905 cÚ¡ *
__ÃedË
);

1906 #ifdeà
__PIC__


1908 
__STRING_INLINE
 *

1909 
	$__¡r¡r_g
 (cÚ¡ *
__hay¡ack
, cÚ¡ *
__ÃedË
)

1911 
__d0
, 
__d1
, 
__d2
;

1912 *
__»s
;

1913 
__asm__
 
__vÞ©že__


1932 : "=&a" (
__»s
), "=&c" (
__d0
), "=&S" (
__d1
), "=&D" (
__d2
)

1933 : "0" (0), "1" (0xffffffff), "2" (
__hay¡ack
), "3" (
__ÃedË
),

1934 "d" (
__ÃedË
)

1936  
__»s
;

1937 
	}
}

1939 
__STRING_INLINE
 *

1940 
	$__¡r¡r_g
 (cÚ¡ *
__hay¡ack
, cÚ¡ *
__ÃedË
)

1942 
__d0
, 
__d1
, 
__d2
, 
__d3
;

1943 *
__»s
;

1944 
__asm__
 
__vÞ©že__


1961 : "=&a" (
__»s
), "=&c" (
__d0
), "=&S" (
__d1
), "=&D" (
__d2
), "=&d" (
__d3
)

1962 : "0" (0), "1" (0xffffffff), "2" (
__hay¡ack
), "3" (
__ÃedË
),

1963 "b" (
__ÃedË
)

1965  
__»s
;

1966 
	}
}

1972 #ià
defšed
 
__USE_MISC
 || defšed 
__USE_XOPEN_EXTENDED


1973 #ifdeà
__i686__


1974 
	#_HAVE_STRING_ARCH_ffs
 1

	)

1975 
	#ffs
(
wÜd
è(
	`__bužtš_cÚ¡ªt_p
 (word) \

1976 ? 
	`__bužtš_ffs
 (
wÜd
) \

1977 : ({ 
__út
, 
__tmp
; \

1978 
__asm__
 
__vÞ©že__
 \

1981 : "=&r" (
__út
), "ô" (
__tmp
) \

1982 : "rm" (
wÜd
), "1" (-1)); \

1983 
__út
 + 1; }))

	)

1985 #iâdeà
ff¦


1986 
	#ff¦
(
wÜd
è
	`ffs
(wÜd)

	)

1991 #iâdeà
_FORCE_INLINES


1992 #undeà
__STRING_INLINE


	@/usr/include/bits/string2.h

20 #iâdeà
_STRING_H


24 #iâdeà
__NO_STRING_INLINES


41 #iâdeà
__STRING_INLINE


42 #ifdeà
__ýlu¥lus


43 
	#__STRING_INLINE
 
šlše


	)

45 
	#__STRING_INLINE
 
__ex‹º_šlše


	)

49 #ià
_STRING_INLINE_uÇligÃd


51 
	~<’dŸn.h
>

52 
	~<b™s/ty³s.h
>

54 #ià
__BYTE_ORDER
 =ð
__LITTLE_ENDIAN


55 
	#__STRING2_SMALL_GET16
(
¤c
, 
idx
) \

56 (((cÚ¡ *è(cÚ¡ *è(
¤c
))[
idx
 + 1] << 8 \

57 | ((cÚ¡ *è(cÚ¡ *è(
¤c
))[
idx
])

	)

58 
	#__STRING2_SMALL_GET32
(
¤c
, 
idx
) \

59 (((((cÚ¡ *è(cÚ¡ *è(
¤c
))[
idx
 + 3] << 8 \

60 | ((cÚ¡ *è(cÚ¡ *è(
¤c
))[
idx
 + 2]) << 8 \

61 | ((cÚ¡ *è(cÚ¡ *è(
¤c
))[
idx
 + 1]) << 8 \

62 | ((cÚ¡ *è(cÚ¡ *è(
¤c
))[
idx
])

	)

64 
	#__STRING2_SMALL_GET16
(
¤c
, 
idx
) \

65 (((cÚ¡ *è(cÚ¡ *è(
¤c
))[
idx
] << 8 \

66 | ((cÚ¡ *è(cÚ¡ *è(
¤c
))[
idx
 + 1])

	)

67 
	#__STRING2_SMALL_GET32
(
¤c
, 
idx
) \

68 (((((cÚ¡ *è(cÚ¡ *è(
¤c
))[
idx
] << 8 \

69 | ((cÚ¡ *è(cÚ¡ *è(
¤c
))[
idx
 + 1]) << 8 \

70 | ((cÚ¡ *è(cÚ¡ *è(
¤c
))[
idx
 + 2]) << 8 \

71 | ((cÚ¡ *è(cÚ¡ *è(
¤c
))[
idx
 + 3])

	)

76 
	#__STRING2_COPY_TYPE
(
N
) \

77 ¡ruù { 
__¬r
[
N
]; } \

78 
	t__©Œibu‹__
 ((
	t__·cked__
)è
	t__STRING2_COPY_ARR
##
	tN


	)

79 
	t__STRING2_COPY_TYPE
 (2);

80 
__STRING2_COPY_TYPE
 (3);

81 
__STRING2_COPY_TYPE
 (4);

82 
__STRING2_COPY_TYPE
 (5);

83 
__STRING2_COPY_TYPE
 (6);

84 
__STRING2_COPY_TYPE
 (7);

85 
__STRING2_COPY_TYPE
 (8);

86 #undeà
__STRING2_COPY_TYPE


92 
	#__¡ršg2_1b±r_p
(
__x
) \

93 ((
size_t
)(cÚ¡ *)((
__x
è+ 1è- (size_t)(cÚ¡ *)(__xè=ð1)

	)

96 #ià!
defšed
 
_HAVE_STRING_ARCH_mem£t


97 #ià!
__GNUC_PREREQ
 (3, 0)

98 #ià
_STRING_INLINE_uÇligÃd


99 
	#mem£t
(
s
, 
c
, 
n
) \

100 (
	`__ex‹nsiÚ__
 (
	`__bužtš_cÚ¡ªt_p
 (
n
) && (n) <= 16 \

101 ? ((
n
) == 1 \

102 ? 
	`__mem£t_1
 (
s
, 
c
) \

103 : 
	`__mem£t_gc
 (
s
, 
c
, 
n
)) \

104 : (
	`__bužtš_cÚ¡ªt_p
 (
c
) && (c) == '\0' \

105 ? ({ *
__s
 = (
s
); 
	`__bz”o
 (__s, 
n
); __s; }) \

106 : 
	`mem£t
 (
s
, 
c
, 
n
))))

	)

108 
	#__mem£t_1
(
s
, 
c
è({ *
__s
 = (s); \

109 *((
__ušt8_t
 *è
__s
èð(__ušt8_tè
c
; __s; })

	)

111 
	#__mem£t_gc
(
s
, 
c
, 
n
) \

112 ({ *
__s
 = (
s
); \

114 
__ui
; \

115 
__usi
; \

116 
__uc
; \

117 } *
__u
 = 
__s
; \

118 
__ušt8_t
 
__c
 = (__ušt8_tè(
c
); \

121 (è(
n
)) \

124 
__u
->
__ui
 = 
__c
 * 0x01010101; \

125 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4); \

127 
__u
->
__ui
 = 
__c
 * 0x01010101; \

128 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4); \

130 
__u
->
__ui
 = 
__c
 * 0x01010101; \

131 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4); \

133 
__u
->
__usi
 = (è
__c
 * 0x0101; \

134 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 2); \

135 
__u
->
__uc
 = (è
__c
; \

139 
__u
->
__ui
 = 
__c
 * 0x01010101; \

140 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4); \

142 
__u
->
__ui
 = 
__c
 * 0x01010101; \

143 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4); \

145 
__u
->
__ui
 = 
__c
 * 0x01010101; \

146 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4); \

148 
__u
->
__usi
 = (è
__c
 * 0x0101; \

152 
__u
->
__ui
 = 
__c
 * 0x01010101; \

153 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4); \

155 
__u
->
__ui
 = 
__c
 * 0x01010101; \

156 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4); \

158 
__u
->
__ui
 = 
__c
 * 0x01010101; \

159 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4); \

161 
__u
->
__uc
 = (è
__c
; \

165 
__u
->
__ui
 = 
__c
 * 0x01010101; \

166 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4); \

168 
__u
->
__ui
 = 
__c
 * 0x01010101; \

169 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4); \

171 
__u
->
__ui
 = 
__c
 * 0x01010101; \

172 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4); \

174 
__u
->
__ui
 = 
__c
 * 0x01010101; \

179 
__s
; })

	)

181 
	#mem£t
(
s
, 
c
, 
n
) \

182 (
	`__ex‹nsiÚ__
 (
	`__bužtš_cÚ¡ªt_p
 (
c
) && (c) == '\0' \

183 ? ({ *
__s
 = (
s
); 
	`__bz”o
 (__s, 
n
); __s; }) \

184 : 
	`mem£t
 (
s
, 
c
, 
n
)))

	)

193 #ià
__GNUC_PREREQ
 (2, 91)

194 
	#__bz”o
(
s
, 
n
è
	`__bužtš_mem£t
 (s, '\0',‚)

	)

202 #ifdeà
__USE_GNU


203 #ià!
defšed
 
_HAVE_STRING_ARCH_mempýy
 || defšed 
_FORCE_INLINES


204 #iâdeà
_HAVE_STRING_ARCH_mempýy


205 #ià
__GNUC_PREREQ
 (3, 4)

206 
	#__mempýy
(
de¡
, 
¤c
, 
n
è
	`__bužtš_mempýy
 (de¡, src,‚)

	)

207 #–ià
__GNUC_PREREQ
 (3, 0)

208 
	#__mempýy
(
de¡
, 
¤c
, 
n
) \

209 (
	`__ex‹nsiÚ__
 (
	`__bužtš_cÚ¡ªt_p
 (
¤c
è&& __bužtš_cÚ¡ªt_°(
n
) \

210 && 
	`__¡ršg2_1b±r_p
 (
¤c
è&& 
n
 <= 8 \

211 ? 
	`__bužtš_memýy
 (
de¡
, 
¤c
, 
n
) + (n) \

212 : 
	`__mempýy
 (
de¡
, 
¤c
, 
n
)))

	)

214 
	#__mempýy
(
de¡
, 
¤c
, 
n
) \

215 (
	`__ex‹nsiÚ__
 (
	`__bužtš_cÚ¡ªt_p
 (
¤c
è&& __bužtš_cÚ¡ªt_°(
n
) \

216 && 
	`__¡ršg2_1b±r_p
 (
¤c
è&& 
n
 <= 8 \

217 ? 
	`__mempýy_sm®l
 (
de¡
, 
	`__mempýy_¬gs
 (
¤c
), 
n
) \

218 : 
	`__mempýy
 (
de¡
, 
¤c
, 
n
)))

	)

222 
	#mempýy
(
de¡
, 
¤c
, 
n
è
	`__mempýy
 (de¡, src,‚)

	)

225 #ià!
__GNUC_PREREQ
 (3, 0è|| 
defšed
 
_FORCE_INLINES


226 #ià
_STRING_INLINE_uÇligÃd


227 #iâdeà
_FORCE_INLINES


228 
	#__mempýy_¬gs
(
¤c
) \

229 ((cÚ¡ *è(
¤c
))[0], ((const *) (src))[2], \

230 ((cÚ¡ *è(
¤c
))[4], ((const *) (src))[6], \

231 
__ex‹nsiÚ__
 
	`__STRING2_SMALL_GET16
 (
¤c
, 0), \

232 
__ex‹nsiÚ__
 
	`__STRING2_SMALL_GET16
 (
¤c
, 4), \

233 
__ex‹nsiÚ__
 
	`__STRING2_SMALL_GET32
 (
¤c
, 0), \

234 
__ex‹nsiÚ__
 
	`__STRING2_SMALL_GET32
 (
¤c
, 4)

	)

236 
__STRING_INLINE
 *
__mempýy_sm®l
 (*, , , , ,

237 
__ušt16_t
, __ušt16_t, 
__ušt32_t
,

238 
__ušt32_t
, 
size_t
);

239 
__STRING_INLINE
 *

240 
	$__mempýy_sm®l
 (*
__de¡1
,

241 
__¤c0_1
, 
__¤c2_1
, 
__¤c4_1
, 
__¤c6_1
,

242 
__ušt16_t
 
__¤c0_2
, __ušt16_ˆ
__¤c4_2
,

243 
__ušt32_t
 
__¤c0_4
, __ušt32_ˆ
__¤c4_4
,

244 
size_t
 
__¤þ’
)

247 
__ušt32_t
 
__ui
;

248 
__ušt16_t
 
__usi
;

249 
__uc
;

250 
__c
;

251 } *
__u
 = 
__de¡1
;

252 (è
__¤þ’
)

255 
__u
->
__c
 = 
__¤c0_1
;

256 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 1);

259 
__u
->
__usi
 = 
__¤c0_2
;

260 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 2);

263 
__u
->
__usi
 = 
__¤c0_2
;

264 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 2);

265 
__u
->
__c
 = 
__¤c2_1
;

266 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 1);

269 
__u
->
__ui
 = 
__¤c0_4
;

270 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4);

273 
__u
->
__ui
 = 
__¤c0_4
;

274 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4);

275 
__u
->
__c
 = 
__¤c4_1
;

276 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 1);

279 
__u
->
__ui
 = 
__¤c0_4
;

280 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4);

281 
__u
->
__usi
 = 
__¤c4_2
;

282 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 2);

285 
__u
->
__ui
 = 
__¤c0_4
;

286 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4);

287 
__u
->
__usi
 = 
__¤c4_2
;

288 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 2);

289 
__u
->
__c
 = 
__¤c6_1
;

290 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 1);

293 
__u
->
__ui
 = 
__¤c0_4
;

294 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4);

295 
__u
->
__ui
 = 
__¤c4_4
;

296 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4);

299  (*è
__u
;

300 
	}
}

302 #iâdeà
_FORCE_INLINES


303 
	#__mempýy_¬gs
(
¤c
) \

304 ((cÚ¡ *è(
¤c
))[0], \

305 
	`__ex‹nsiÚ__
 ((
__STRING2_COPY_ARR2
) \

306 { { ((cÚ¡ *è(
¤c
))[0], ((const *) (src))[1] } }), \

307 
	`__ex‹nsiÚ__
 ((
__STRING2_COPY_ARR3
) \

308 { { ((cÚ¡ *è(
¤c
))[0], ((const *) (src))[1], \

309 ((cÚ¡ *è(
¤c
))[2] } }), \

310 
	`__ex‹nsiÚ__
 ((
__STRING2_COPY_ARR4
) \

311 { { ((cÚ¡ *è(
¤c
))[0], ((const *) (src))[1], \

312 ((cÚ¡ *è(
¤c
))[2], ((const *) (src))[3] } }), \

313 
	`__ex‹nsiÚ__
 ((
__STRING2_COPY_ARR5
) \

314 { { ((cÚ¡ *è(
¤c
))[0], ((const *) (src))[1], \

315 ((cÚ¡ *è(
¤c
))[2], ((const *) (src))[3], \

316 ((cÚ¡ *è(
¤c
))[4] } }), \

317 
	`__ex‹nsiÚ__
 ((
__STRING2_COPY_ARR6
) \

318 { { ((cÚ¡ *è(
¤c
))[0], ((const *) (src))[1], \

319 ((cÚ¡ *è(
¤c
))[2], ((const *) (src))[3], \

320 ((cÚ¡ *è(
¤c
))[4], ((const *) (src))[5] } }), \

321 
	`__ex‹nsiÚ__
 ((
__STRING2_COPY_ARR7
) \

322 { { ((cÚ¡ *è(
¤c
))[0], ((const *) (src))[1], \

323 ((cÚ¡ *è(
¤c
))[2], ((const *) (src))[3], \

324 ((cÚ¡ *è(
¤c
))[4], ((const *) (src))[5], \

325 ((cÚ¡ *è(
¤c
))[6] } }), \

326 
	`__ex‹nsiÚ__
 ((
__STRING2_COPY_ARR8
) \

327 { { ((cÚ¡ *è(
¤c
))[0], ((const *) (src))[1], \

328 ((cÚ¡ *è(
¤c
))[2], ((const *) (src))[3], \

329 ((cÚ¡ *è(
¤c
))[4], ((const *) (src))[5], \

330 ((cÚ¡ *è(
¤c
))[6], ((cÚ¡ *è(¤c))[7] } })

	)

332 
__STRING_INLINE
 *
__mempýy_sm®l
 (*, , 
__STRING2_COPY_ARR2
,

333 
__STRING2_COPY_ARR3
,

334 
__STRING2_COPY_ARR4
,

335 
__STRING2_COPY_ARR5
,

336 
__STRING2_COPY_ARR6
,

337 
__STRING2_COPY_ARR7
,

338 
__STRING2_COPY_ARR8
, 
size_t
);

339 
__STRING_INLINE
 *

340 
	$__mempýy_sm®l
 (*
__de¡
, 
__¤c1
,

341 
__STRING2_COPY_ARR2
 
__¤c2
, 
__STRING2_COPY_ARR3
 
__¤c3
,

342 
__STRING2_COPY_ARR4
 
__¤c4
, 
__STRING2_COPY_ARR5
 
__¤c5
,

343 
__STRING2_COPY_ARR6
 
__¤c6
, 
__STRING2_COPY_ARR7
 
__¤c7
,

344 
__STRING2_COPY_ARR8
 
__¤c8
, 
size_t
 
__¤þ’
)

347 
__c
;

348 
__STRING2_COPY_ARR2
 
__sÿ2
;

349 
__STRING2_COPY_ARR3
 
__sÿ3
;

350 
__STRING2_COPY_ARR4
 
__sÿ4
;

351 
__STRING2_COPY_ARR5
 
__sÿ5
;

352 
__STRING2_COPY_ARR6
 
__sÿ6
;

353 
__STRING2_COPY_ARR7
 
__sÿ7
;

354 
__STRING2_COPY_ARR8
 
__sÿ8
;

355 } *
__u
 = 
__de¡
;

356 (è
__¤þ’
)

359 
__u
->
__c
 = 
__¤c1
;

362 
__ex‹nsiÚ__
 
__u
->
__sÿ2
 = 
__¤c2
;

365 
__ex‹nsiÚ__
 
__u
->
__sÿ3
 = 
__¤c3
;

368 
__ex‹nsiÚ__
 
__u
->
__sÿ4
 = 
__¤c4
;

371 
__ex‹nsiÚ__
 
__u
->
__sÿ5
 = 
__¤c5
;

374 
__ex‹nsiÚ__
 
__u
->
__sÿ6
 = 
__¤c6
;

377 
__ex‹nsiÚ__
 
__u
->
__sÿ7
 = 
__¤c7
;

380 
__ex‹nsiÚ__
 
__u
->
__sÿ8
 = 
__¤c8
;

383  
	`__ex‹nsiÚ__
 ((*è
__u
 + 
__¤þ’
);

384 
	}
}

392 #iâdeà
_HAVE_STRING_ARCH_¡rchr


393 *
__¿wmemchr
 (cÚ¡ *
__s
, 
__c
);

394 #ià
__GNUC_PREREQ
 (3, 2)

395 
	#¡rchr
(
s
, 
c
) \

396 (
	`__ex‹nsiÚ__
 (
	`__bužtš_cÚ¡ªt_p
 (
c
è&& !__bužtš_cÚ¡ªt_°(
s
) \

397 && (
c
) == '\0' \

398 ? (*è
	`__¿wmemchr
 (
s
, 
c
) \

399 : 
	`__bužtš_¡rchr
 (
s
, 
c
)))

	)

401 
	#¡rchr
(
s
, 
c
) \

402 (
	`__ex‹nsiÚ__
 (
	`__bužtš_cÚ¡ªt_p
 (
c
) && (c) == '\0' \

403 ? (*è
	`__¿wmemchr
 (
s
, 
c
) \

404 : 
	`¡rchr
 (
s
, 
c
)))

	)

410 #ià(!
defšed
 
_HAVE_STRING_ARCH_¡rýy
 && !
__GNUC_PREREQ
 (3, 0)) \

411 || 
defšed
 
	g_FORCE_INLINES


412 #ià!
defšed
 
_HAVE_STRING_ARCH_¡rýy
 && !
__GNUC_PREREQ
 (3, 0)

413 
	#¡rýy
(
de¡
, 
¤c
) \

414 (
	`__ex‹nsiÚ__
 (
	`__bužtš_cÚ¡ªt_p
 (
¤c
) \

415 ? (
	`__¡ršg2_1b±r_p
 (
¤c
è&& 
	`¡¾’
 (src) + 1 <= 8 \

416 ? 
	`__¡rýy_sm®l
 (
de¡
, 
	`__¡rýy_¬gs
 (
¤c
), \

417 
	`¡¾’
 (
¤c
) + 1) \

418 : (*è
	`memýy
 (
de¡
, 
¤c
, 
	`¡¾’
 (src) + 1)) \

419 : 
	`¡rýy
 (
de¡
, 
¤c
)))

	)

422 #ià
_STRING_INLINE_uÇligÃd


423 #iâdeà
_FORCE_INLINES


424 
	#__¡rýy_¬gs
(
¤c
) \

425 
__ex‹nsiÚ__
 
	`__STRING2_SMALL_GET16
 (
¤c
, 0), \

426 
__ex‹nsiÚ__
 
	`__STRING2_SMALL_GET16
 (
¤c
, 4), \

427 
__ex‹nsiÚ__
 
	`__STRING2_SMALL_GET32
 (
¤c
, 0), \

428 
__ex‹nsiÚ__
 
	`__STRING2_SMALL_GET32
 (
¤c
, 4)

	)

430 
__STRING_INLINE
 *
__¡rýy_sm®l
 (*, 
__ušt16_t
, __uint16_t,

431 
__ušt32_t
, __ušt32_t, 
size_t
);

432 
__STRING_INLINE
 *

433 
	$__¡rýy_sm®l
 (*
__de¡
,

434 
__ušt16_t
 
__¤c0_2
, __ušt16_ˆ
__¤c4_2
,

435 
__ušt32_t
 
__¤c0_4
, __ušt32_ˆ
__¤c4_4
,

436 
size_t
 
__¤þ’
)

439 
__ušt32_t
 
__ui
;

440 
__ušt16_t
 
__usi
;

441 
__uc
;

442 } *
__u
 = (*è
__de¡
;

443 (è
__¤þ’
)

446 
__u
->
__uc
 = '\0';

449 
__u
->
__usi
 = 
__¤c0_2
;

452 
__u
->
__usi
 = 
__¤c0_2
;

453 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 2);

454 
__u
->
__uc
 = '\0';

457 
__u
->
__ui
 = 
__¤c0_4
;

460 
__u
->
__ui
 = 
__¤c0_4
;

461 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4);

462 
__u
->
__uc
 = '\0';

465 
__u
->
__ui
 = 
__¤c0_4
;

466 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4);

467 
__u
->
__usi
 = 
__¤c4_2
;

470 
__u
->
__ui
 = 
__¤c0_4
;

471 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4);

472 
__u
->
__usi
 = 
__¤c4_2
;

473 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 2);

474 
__u
->
__uc
 = '\0';

477 
__u
->
__ui
 = 
__¤c0_4
;

478 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4);

479 
__u
->
__ui
 = 
__¤c4_4
;

482  
__de¡
;

483 
	}
}

485 #iâdeà
_FORCE_INLINES


486 
	#__¡rýy_¬gs
(
¤c
) \

487 
	`__ex‹nsiÚ__
 ((
__STRING2_COPY_ARR2
) \

488 { { ((cÚ¡ *è(
¤c
))[0], '\0' } }), \

489 
	`__ex‹nsiÚ__
 ((
__STRING2_COPY_ARR3
) \

490 { { ((cÚ¡ *è(
¤c
))[0], ((const *) (src))[1], \

492 
	`__ex‹nsiÚ__
 ((
__STRING2_COPY_ARR4
) \

493 { { ((cÚ¡ *è(
¤c
))[0], ((const *) (src))[1], \

494 ((cÚ¡ *è(
¤c
))[2], '\0' } }), \

495 
	`__ex‹nsiÚ__
 ((
__STRING2_COPY_ARR5
) \

496 { { ((cÚ¡ *è(
¤c
))[0], ((const *) (src))[1], \

497 ((cÚ¡ *è(
¤c
))[2], ((const *) (src))[3], \

499 
	`__ex‹nsiÚ__
 ((
__STRING2_COPY_ARR6
) \

500 { { ((cÚ¡ *è(
¤c
))[0], ((const *) (src))[1], \

501 ((cÚ¡ *è(
¤c
))[2], ((const *) (src))[3], \

502 ((cÚ¡ *è(
¤c
))[4], '\0' } }), \

503 
	`__ex‹nsiÚ__
 ((
__STRING2_COPY_ARR7
) \

504 { { ((cÚ¡ *è(
¤c
))[0], ((const *) (src))[1], \

505 ((cÚ¡ *è(
¤c
))[2], ((const *) (src))[3], \

506 ((cÚ¡ *è(
¤c
))[4], ((const *) (src))[5], \

508 
	`__ex‹nsiÚ__
 ((
__STRING2_COPY_ARR8
) \

509 { { ((cÚ¡ *è(
¤c
))[0], ((const *) (src))[1], \

510 ((cÚ¡ *è(
¤c
))[2], ((const *) (src))[3], \

511 ((cÚ¡ *è(
¤c
))[4], ((const *) (src))[5], \

512 ((cÚ¡ *è(
¤c
))[6], '\0' } })

	)

514 
__STRING_INLINE
 *
__¡rýy_sm®l
 (*, 
__STRING2_COPY_ARR2
,

515 
__STRING2_COPY_ARR3
,

516 
__STRING2_COPY_ARR4
,

517 
__STRING2_COPY_ARR5
,

518 
__STRING2_COPY_ARR6
,

519 
__STRING2_COPY_ARR7
,

520 
__STRING2_COPY_ARR8
, 
size_t
);

521 
__STRING_INLINE
 *

522 
	$__¡rýy_sm®l
 (*
__de¡
,

523 
__STRING2_COPY_ARR2
 
__¤c2
, 
__STRING2_COPY_ARR3
 
__¤c3
,

524 
__STRING2_COPY_ARR4
 
__¤c4
, 
__STRING2_COPY_ARR5
 
__¤c5
,

525 
__STRING2_COPY_ARR6
 
__¤c6
, 
__STRING2_COPY_ARR7
 
__¤c7
,

526 
__STRING2_COPY_ARR8
 
__¤c8
, 
size_t
 
__¤þ’
)

529 
__c
;

530 
__STRING2_COPY_ARR2
 
__sÿ2
;

531 
__STRING2_COPY_ARR3
 
__sÿ3
;

532 
__STRING2_COPY_ARR4
 
__sÿ4
;

533 
__STRING2_COPY_ARR5
 
__sÿ5
;

534 
__STRING2_COPY_ARR6
 
__sÿ6
;

535 
__STRING2_COPY_ARR7
 
__sÿ7
;

536 
__STRING2_COPY_ARR8
 
__sÿ8
;

537 } *
__u
 = (*è
__de¡
;

538 (è
__¤þ’
)

541 
__u
->
__c
 = '\0';

544 
__ex‹nsiÚ__
 
__u
->
__sÿ2
 = 
__¤c2
;

547 
__ex‹nsiÚ__
 
__u
->
__sÿ3
 = 
__¤c3
;

550 
__ex‹nsiÚ__
 
__u
->
__sÿ4
 = 
__¤c4
;

553 
__ex‹nsiÚ__
 
__u
->
__sÿ5
 = 
__¤c5
;

556 
__ex‹nsiÚ__
 
__u
->
__sÿ6
 = 
__¤c6
;

559 
__ex‹nsiÚ__
 
__u
->
__sÿ7
 = 
__¤c7
;

562 
__ex‹nsiÚ__
 
__u
->
__sÿ8
 = 
__¤c8
;

565  
__de¡
;

566 
	}
}

572 #ifdeà
__USE_GNU


573 #ià!
defšed
 
_HAVE_STRING_ARCH_¡pýy
 || defšed 
_FORCE_INLINES


574 #iâdeà
_HAVE_STRING_ARCH_¡pýy


575 #ià
__GNUC_PREREQ
 (3, 4)

576 
	#__¡pýy
(
de¡
, 
¤c
è
	`__bužtš_¡pýy
 (de¡, src)

	)

577 #–ià
__GNUC_PREREQ
 (3, 0)

578 
	#__¡pýy
(
de¡
, 
¤c
) \

579 (
	`__ex‹nsiÚ__
 (
	`__bužtš_cÚ¡ªt_p
 (
¤c
) \

580 ? (
	`__¡ršg2_1b±r_p
 (
¤c
è&& 
	`¡¾’
 (src) + 1 <= 8 \

581 ? 
	`__bužtš_¡rýy
 (
de¡
, 
¤c
è+ 
	`¡¾’
 (src) \

582 : ((*è(
__mempýy
è(
de¡
, 
¤c
, 
	`¡¾’
 (src) + 1) \

584 : 
	`__¡pýy
 (
de¡
, 
¤c
)))

	)

586 
	#__¡pýy
(
de¡
, 
¤c
) \

587 (
	`__ex‹nsiÚ__
 (
	`__bužtš_cÚ¡ªt_p
 (
¤c
) \

588 ? (
	`__¡ršg2_1b±r_p
 (
¤c
è&& 
	`¡¾’
 (src) + 1 <= 8 \

589 ? 
	`__¡pýy_sm®l
 (
de¡
, 
	`__¡pýy_¬gs
 (
¤c
), \

590 
	`¡¾’
 (
¤c
) + 1) \

591 : ((*è(
__mempýy
è(
de¡
, 
¤c
, 
	`¡¾’
 (src) + 1) \

593 : 
	`__¡pýy
 (
de¡
, 
¤c
)))

	)

597 
	#¡pýy
(
de¡
, 
¤c
è
	`__¡pýy
 (de¡, src)

	)

600 #ià!
__GNUC_PREREQ
 (3, 0è|| 
defšed
 
_FORCE_INLINES


601 #ià
_STRING_INLINE_uÇligÃd


602 #iâdeà
_FORCE_INLINES


603 
	#__¡pýy_¬gs
(
¤c
) \

604 
__ex‹nsiÚ__
 
	`__STRING2_SMALL_GET16
 (
¤c
, 0), \

605 
__ex‹nsiÚ__
 
	`__STRING2_SMALL_GET16
 (
¤c
, 4), \

606 
__ex‹nsiÚ__
 
	`__STRING2_SMALL_GET32
 (
¤c
, 0), \

607 
__ex‹nsiÚ__
 
	`__STRING2_SMALL_GET32
 (
¤c
, 4)

	)

609 
__STRING_INLINE
 *
__¡pýy_sm®l
 (*, 
__ušt16_t
, __uint16_t,

610 
__ušt32_t
, __ušt32_t, 
size_t
);

611 
__STRING_INLINE
 *

612 
	$__¡pýy_sm®l
 (*
__de¡
,

613 
__ušt16_t
 
__¤c0_2
, __ušt16_ˆ
__¤c4_2
,

614 
__ušt32_t
 
__¤c0_4
, __ušt32_ˆ
__¤c4_4
,

615 
size_t
 
__¤þ’
)

618 
__ui
;

619 
__usi
;

620 
__uc
;

621 
__c
;

622 } *
__u
 = (*è
__de¡
;

623 (è
__¤þ’
)

626 
__u
->
__uc
 = '\0';

629 
__u
->
__usi
 = 
__¤c0_2
;

630 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 1);

633 
__u
->
__usi
 = 
__¤c0_2
;

634 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 2);

635 
__u
->
__uc
 = '\0';

638 
__u
->
__ui
 = 
__¤c0_4
;

639 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 3);

642 
__u
->
__ui
 = 
__¤c0_4
;

643 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4);

644 
__u
->
__uc
 = '\0';

647 
__u
->
__ui
 = 
__¤c0_4
;

648 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4);

649 
__u
->
__usi
 = 
__¤c4_2
;

650 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 1);

653 
__u
->
__ui
 = 
__¤c0_4
;

654 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4);

655 
__u
->
__usi
 = 
__¤c4_2
;

656 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 2);

657 
__u
->
__uc
 = '\0';

660 
__u
->
__ui
 = 
__¤c0_4
;

661 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 4);

662 
__u
->
__ui
 = 
__¤c4_4
;

663 
__u
 = 
	`__ex‹nsiÚ__
 ((*) __u + 3);

666  &
__u
->
__c
;

667 
	}
}

669 #iâdeà
_FORCE_INLINES


670 
	#__¡pýy_¬gs
(
¤c
) \

671 
	`__ex‹nsiÚ__
 ((
__STRING2_COPY_ARR2
) \

672 { { ((cÚ¡ *è(
¤c
))[0], '\0' } }), \

673 
	`__ex‹nsiÚ__
 ((
__STRING2_COPY_ARR3
) \

674 { { ((cÚ¡ *è(
¤c
))[0], ((const *) (src))[1], \

676 
	`__ex‹nsiÚ__
 ((
__STRING2_COPY_ARR4
) \

677 { { ((cÚ¡ *è(
¤c
))[0], ((const *) (src))[1], \

678 ((cÚ¡ *è(
¤c
))[2], '\0' } }), \

679 
	`__ex‹nsiÚ__
 ((
__STRING2_COPY_ARR5
) \

680 { { ((cÚ¡ *è(
¤c
))[0], ((const *) (src))[1], \

681 ((cÚ¡ *è(
¤c
))[2], ((const *) (src))[3], \

683 
	`__ex‹nsiÚ__
 ((
__STRING2_COPY_ARR6
) \

684 { { ((cÚ¡ *è(
¤c
))[0], ((const *) (src))[1], \

685 ((cÚ¡ *è(
¤c
))[2], ((const *) (src))[3], \

686 ((cÚ¡ *è(
¤c
))[4], '\0' } }), \

687 
	`__ex‹nsiÚ__
 ((
__STRING2_COPY_ARR7
) \

688 { { ((cÚ¡ *è(
¤c
))[0], ((const *) (src))[1], \

689 ((cÚ¡ *è(
¤c
))[2], ((const *) (src))[3], \

690 ((cÚ¡ *è(
¤c
))[4], ((const *) (src))[5], \

692 
	`__ex‹nsiÚ__
 ((
__STRING2_COPY_ARR8
) \

693 { { ((cÚ¡ *è(
¤c
))[0], ((const *) (src))[1], \

694 ((cÚ¡ *è(
¤c
))[2], ((const *) (src))[3], \

695 ((cÚ¡ *è(
¤c
))[4], ((const *) (src))[5], \

696 ((cÚ¡ *è(
¤c
))[6], '\0' } })

	)

698 
__STRING_INLINE
 *
__¡pýy_sm®l
 (*, 
__STRING2_COPY_ARR2
,

699 
__STRING2_COPY_ARR3
,

700 
__STRING2_COPY_ARR4
,

701 
__STRING2_COPY_ARR5
,

702 
__STRING2_COPY_ARR6
,

703 
__STRING2_COPY_ARR7
,

704 
__STRING2_COPY_ARR8
, 
size_t
);

705 
__STRING_INLINE
 *

706 
	$__¡pýy_sm®l
 (*
__de¡
,

707 
__STRING2_COPY_ARR2
 
__¤c2
, 
__STRING2_COPY_ARR3
 
__¤c3
,

708 
__STRING2_COPY_ARR4
 
__¤c4
, 
__STRING2_COPY_ARR5
 
__¤c5
,

709 
__STRING2_COPY_ARR6
 
__¤c6
, 
__STRING2_COPY_ARR7
 
__¤c7
,

710 
__STRING2_COPY_ARR8
 
__¤c8
, 
size_t
 
__¤þ’
)

713 
__c
;

714 
__STRING2_COPY_ARR2
 
__sÿ2
;

715 
__STRING2_COPY_ARR3
 
__sÿ3
;

716 
__STRING2_COPY_ARR4
 
__sÿ4
;

717 
__STRING2_COPY_ARR5
 
__sÿ5
;

718 
__STRING2_COPY_ARR6
 
__sÿ6
;

719 
__STRING2_COPY_ARR7
 
__sÿ7
;

720 
__STRING2_COPY_ARR8
 
__sÿ8
;

721 } *
__u
 = (*è
__de¡
;

722 (è
__¤þ’
)

725 
__u
->
__c
 = '\0';

728 
__ex‹nsiÚ__
 
__u
->
__sÿ2
 = 
__¤c2
;

731 
__ex‹nsiÚ__
 
__u
->
__sÿ3
 = 
__¤c3
;

734 
__ex‹nsiÚ__
 
__u
->
__sÿ4
 = 
__¤c4
;

737 
__ex‹nsiÚ__
 
__u
->
__sÿ5
 = 
__¤c5
;

740 
__ex‹nsiÚ__
 
__u
->
__sÿ6
 = 
__¤c6
;

743 
__ex‹nsiÚ__
 
__u
->
__sÿ7
 = 
__¤c7
;

746 
__ex‹nsiÚ__
 
__u
->
__sÿ8
 = 
__¤c8
;

749  
__de¡
 + 
__¤þ’
 - 1;

750 
	}
}

758 #iâdeà
_HAVE_STRING_ARCH_¡ºýy


759 #ià
__GNUC_PREREQ
 (3, 2)

760 
	#¡ºýy
(
de¡
, 
¤c
, 
n
è
	`__bužtš_¡ºýy
 (de¡, src,‚)

	)

762 
	#¡ºýy
(
de¡
, 
¤c
, 
n
) \

763 (
	`__ex‹nsiÚ__
 (
	`__bužtš_cÚ¡ªt_p
 (
¤c
è&& __bužtš_cÚ¡ªt_°(
n
) \

764 ? (
	`¡¾’
 (
¤c
è+ 1 >ð((
size_t
è(
n
)) \

765 ? (*è
	`memýy
 (
de¡
, 
¤c
, 
n
) \

766 : 
	`¡ºýy
 (
de¡
, 
¤c
, 
n
)) \

767 : 
	`¡ºýy
 (
de¡
, 
¤c
, 
n
)))

	)

773 #iâdeà
_HAVE_STRING_ARCH_¡ºÿt


774 #ifdeà
_USE_STRING_ARCH_¡rchr


775 
	#¡ºÿt
(
de¡
, 
¤c
, 
n
) \

776 (
	`__ex‹nsiÚ__
 ({ *
__de¡
 = (
de¡
); \

777 
	`__bužtš_cÚ¡ªt_p
 (
¤c
è&& __bužtš_cÚ¡ªt_°(
n
) \

778 ? (
	`¡¾’
 (
¤c
è< ((
size_t
è(
n
)) \

779 ? 
	`¡rÿt
 (
__de¡
, 
¤c
) \

780 : (*((*è
	`__mempýy
 (
	`¡rchr
 (
__de¡
, '\0'), \

781 
¤c
, 
n
)èð'\0', 
__de¡
)) \

782 : 
	`¡ºÿt
 (
de¡
, 
¤c
, 
n
); }))

	)

783 #–ià
__GNUC_PREREQ
 (3, 2)

784 
	#¡ºÿt
(
de¡
, 
¤c
, 
n
è
	`__bužtš_¡ºÿt
 (de¡, src,‚)

	)

786 
	#¡ºÿt
(
de¡
, 
¤c
, 
n
) \

787 (
	`__ex‹nsiÚ__
 (
	`__bužtš_cÚ¡ªt_p
 (
¤c
è&& __bužtš_cÚ¡ªt_°(
n
) \

788 ? (
	`¡¾’
 (
¤c
è< ((
size_t
è(
n
)) \

789 ? 
	`¡rÿt
 (
de¡
, 
¤c
) \

790 : 
	`¡ºÿt
 (
de¡
, 
¤c
, 
n
)) \

791 : 
	`¡ºÿt
 (
de¡
, 
¤c
, 
n
)))

	)

797 #iâdeà
_HAVE_STRING_ARCH_¡rcmp


798 #ià
__GNUC_PREREQ
 (3, 2)

799 
	#¡rcmp
(
s1
, 
s2
) \

800 
__ex‹nsiÚ__
 \

801 ({ 
size_t
 
__s1_Ën
, 
__s2_Ën
; \

802 (
	`__bužtš_cÚ¡ªt_p
 (
s1
è&& __bužtš_cÚ¡ªt_°(
s2
) \

803 && (
__s1_Ën
 = 
	`__bužtš_¡¾’
 (
s1
), 
__s2_Ën
 = __bužtš_¡¾’ (
s2
), \

804 (!
	`__¡ršg2_1b±r_p
 (
s1
è|| 
__s1_Ën
 >= 4) \

805 && (!
	`__¡ršg2_1b±r_p
 (
s2
è|| 
__s2_Ën
 >= 4)) \

806 ? 
	`__bužtš_¡rcmp
 (
s1
, 
s2
) \

807 : (
	`__bužtš_cÚ¡ªt_p
 (
s1
è&& 
	`__¡ršg2_1b±r_p
 (s1) \

808 && (
__s1_Ën
 = 
	`__bužtš_¡¾’
 (
s1
), __s1_len < 4) \

809 ? (
	`__bužtš_cÚ¡ªt_p
 (
s2
è&& 
	`__¡ršg2_1b±r_p
 (s2) \

810 ? 
	`__bužtš_¡rcmp
 (
s1
, 
s2
) \

811 : 
	`__¡rcmp_cg
 (
s1
, 
s2
, 
__s1_Ën
)) \

812 : (
	`__bužtš_cÚ¡ªt_p
 (
s2
è&& 
	`__¡ršg2_1b±r_p
 (s2) \

813 && (
__s2_Ën
 = 
	`__bužtš_¡¾’
 (
s2
), __s2_len < 4) \

814 ? (
	`__bužtš_cÚ¡ªt_p
 (
s1
è&& 
	`__¡ršg2_1b±r_p
 (s1) \

815 ? 
	`__bužtš_¡rcmp
 (
s1
, 
s2
) \

816 : 
	`__¡rcmp_gc
 (
s1
, 
s2
, 
__s2_Ën
)) \

817 : 
	`__bužtš_¡rcmp
 (
s1
, 
s2
)))); })

	)

819 
	#¡rcmp
(
s1
, 
s2
) \

820 
__ex‹nsiÚ__
 \

821 ({ 
size_t
 
__s1_Ën
, 
__s2_Ën
; \

822 (
	`__bužtš_cÚ¡ªt_p
 (
s1
è&& __bužtš_cÚ¡ªt_°(
s2
) \

823 && (
__s1_Ën
 = 
	`¡¾’
 (
s1
), 
__s2_Ën
 = sŒËÀ(
s2
), \

824 (!
	`__¡ršg2_1b±r_p
 (
s1
è|| 
__s1_Ën
 >= 4) \

825 && (!
	`__¡ršg2_1b±r_p
 (
s2
è|| 
__s2_Ën
 >= 4)) \

826 ? 
	`memcmp
 ((cÚ¡ *è(
s1
), (cÚ¡ *è(
s2
), \

827 (
__s1_Ën
 < 
__s2_Ën
 ? __s1_len : __s2_len) + 1) \

828 : (
	`__bužtš_cÚ¡ªt_p
 (
s1
è&& 
	`__¡ršg2_1b±r_p
 (s1) \

829 && (
__s1_Ën
 = 
	`¡¾’
 (
s1
), __s1_len < 4) \

830 ? (
	`__bužtš_cÚ¡ªt_p
 (
s2
è&& 
	`__¡ršg2_1b±r_p
 (s2) \

831 ? 
	`__¡rcmp_cc
 (
s1
, 
s2
, 
__s1_Ën
) \

832 : 
	`__¡rcmp_cg
 (
s1
, 
s2
, 
__s1_Ën
)) \

833 : (
	`__bužtš_cÚ¡ªt_p
 (
s2
è&& 
	`__¡ršg2_1b±r_p
 (s2) \

834 && (
__s2_Ën
 = 
	`¡¾’
 (
s2
), __s2_len < 4) \

835 ? (
	`__bužtš_cÚ¡ªt_p
 (
s1
è&& 
	`__¡ršg2_1b±r_p
 (s1) \

836 ? 
	`__¡rcmp_cc
 (
s1
, 
s2
, 
__s2_Ën
) \

837 : 
	`__¡rcmp_gc
 (
s1
, 
s2
, 
__s2_Ën
)) \

838 : 
	`¡rcmp
 (
s1
, 
s2
)))); })

	)

841 
	#__¡rcmp_cc
(
s1
, 
s2
, 
l
) \

842 (
	`__ex‹nsiÚ__
 ({ 
__»suÉ
 = \

843 (((cÚ¡ *è(cÚ¡ *è(
s1
))[0] \

844 - ((cÚ¡ *è(cÚ¡ *)(
s2
))[0]); \

845 ià(
l
 > 0 && 
__»suÉ
 == 0) \

847 
__»suÉ
 = (((const *) \

848 (cÚ¡ *è(
s1
))[1] \

850 (cÚ¡ *è(
s2
))[1]); \

851 ià(
l
 > 1 && 
__»suÉ
 == 0) \

853 
__»suÉ
 = \

855 (cÚ¡ *è(
s1
))[2] \

857 (cÚ¡ *è(
s2
))[2]); \

858 ià(
l
 > 2 && 
__»suÉ
 == 0) \

859 
__»suÉ
 = \

861 (cÚ¡ *è(
s1
))[3] \

863 (cÚ¡ *è(
s2
))[3]); \

866 
__»suÉ
; }))

	)

868 
	#__¡rcmp_cg
(
s1
, 
s2
, 
l1
) \

869 (
	`__ex‹nsiÚ__
 ({ cÚ¡ *
__s2
 = \

870 (cÚ¡ *è(cÚ¡ *è(
s2
); \

871 
__»suÉ
 = \

872 (((cÚ¡ *è(cÚ¡ *è(
s1
))[0] \

873 - 
__s2
[0]); \

874 ià(
l1
 > 0 && 
__»suÉ
 == 0) \

876 
__»suÉ
 = (((const *) \

877 (cÚ¡ *è(
s1
))[1] - 
__s2
[1]); \

878 ià(
l1
 > 1 && 
__»suÉ
 == 0) \

880 
__»suÉ
 = (((const *) \

881 (cÚ¡ *è(
s1
))[2] - 
__s2
[2]); \

882 ià(
l1
 > 2 && 
__»suÉ
 == 0) \

883 
__»suÉ
 = (((const *) \

884 (cÚ¡ *è(
s1
))[3] \

885 - 
__s2
[3]); \

888 
__»suÉ
; }))

	)

890 
	#__¡rcmp_gc
(
s1
, 
s2
, 
l2
è(- 
	`__¡rcmp_cg
 (s2, s1,†2))

	)

895 #iâdeà
_HAVE_STRING_ARCH_¡ºcmp


896 
	#¡ºcmp
(
s1
, 
s2
, 
n
) \

897 (
	`__ex‹nsiÚ__
 (
	`__bužtš_cÚ¡ªt_p
 (
n
) \

898 && ((
	`__bužtš_cÚ¡ªt_p
 (
s1
) \

899 && 
	`¡¾’
 (
s1
è< ((
size_t
è(
n
))) \

900 || (
	`__bužtš_cÚ¡ªt_p
 (
s2
) \

901 && 
	`¡¾’
 (
s2
è< ((
size_t
è(
n
)))) \

902 ? 
	`¡rcmp
 (
s1
, 
s2
è: 
	`¡ºcmp
 (s1, s2, 
n
)))

	)

908 #ià!
defšed
 
_HAVE_STRING_ARCH_¡rc¥n
 || defšed 
_FORCE_INLINES


909 #iâdeà
_HAVE_STRING_ARCH_¡rc¥n


910 #ià
__GNUC_PREREQ
 (3, 2)

911 
	#¡rc¥n
(
s
, 
»jeù
) \

912 
__ex‹nsiÚ__
 \

913 ({ 
__r0
, 
__r1
, 
__r2
; \

914 (
	`__bužtš_cÚ¡ªt_p
 (
»jeù
è&& 
	`__¡ršg2_1b±r_p
 (reject) \

915 ? ((
	`__bužtš_cÚ¡ªt_p
 (
s
è&& 
	`__¡ršg2_1b±r_p
 (s)) \

916 ? 
	`__bužtš_¡rc¥n
 (
s
, 
»jeù
) \

917 : ((
__r0
 = ((cÚ¡ *è(
»jeù
))[0], __r0 == '\0') \

918 ? 
	`¡¾’
 (
s
) \

919 : ((
__r1
 = ((cÚ¡ *è(
»jeù
))[1], __r1 == '\0') \

920 ? 
	`__¡rc¥n_c1
 (
s
, 
__r0
) \

921 : ((
__r2
 = ((cÚ¡ *è(
»jeù
))[2], __r2 == '\0') \

922 ? 
	`__¡rc¥n_c2
 (
s
, 
__r0
, 
__r1
) \

923 : (((cÚ¡ *è(
»jeù
))[3] == '\0' \

924 ? 
	`__¡rc¥n_c3
 (
s
, 
__r0
, 
__r1
, 
__r2
) \

925 : 
	`__bužtš_¡rc¥n
 (
s
, 
»jeù
)))))) \

926 : 
	`__bužtš_¡rc¥n
 (
s
, 
»jeù
)); })

	)

928 
	#¡rc¥n
(
s
, 
»jeù
) \

929 
__ex‹nsiÚ__
 \

930 ({ 
__r0
, 
__r1
, 
__r2
; \

931 (
	`__bužtš_cÚ¡ªt_p
 (
»jeù
è&& 
	`__¡ršg2_1b±r_p
 (reject) \

932 ? ((
__r0
 = ((cÚ¡ *è(
»jeù
))[0], __r0 == '\0') \

933 ? 
	`¡¾’
 (
s
) \

934 : ((
__r1
 = ((cÚ¡ *è(
»jeù
))[1], __r1 == '\0') \

935 ? 
	`__¡rc¥n_c1
 (
s
, 
__r0
) \

936 : ((
__r2
 = ((cÚ¡ *è(
»jeù
))[2], __r2 == '\0') \

937 ? 
	`__¡rc¥n_c2
 (
s
, 
__r0
, 
__r1
) \

938 : (((cÚ¡ *è(
»jeù
))[3] == '\0' \

939 ? 
	`__¡rc¥n_c3
 (
s
, 
__r0
, 
__r1
, 
__r2
) \

940 : 
	`¡rc¥n
 (
s
, 
»jeù
))))) \

941 : 
	`¡rc¥n
 (
s
, 
»jeù
)); })

	)

945 
__STRING_INLINE
 
size_t
 
__¡rc¥n_c1
 (cÚ¡ *
__s
, 
__»jeù
);

946 
__STRING_INLINE
 
size_t


947 
	$__¡rc¥n_c1
 (cÚ¡ *
__s
, 
__»jeù
)

949 
size_t
 
__»suÉ
 = 0;

950 
__s
[
__»suÉ
] !ð'\0' && __s[__»suÉ] !ð
__»jeù
)

951 ++
__»suÉ
;

952  
__»suÉ
;

953 
	}
}

955 
__STRING_INLINE
 
size_t
 
__¡rc¥n_c2
 (cÚ¡ *
__s
, 
__»jeù1
,

956 
__»jeù2
);

957 
__STRING_INLINE
 
size_t


958 
	$__¡rc¥n_c2
 (cÚ¡ *
__s
, 
__»jeù1
, 
__»jeù2
)

960 
size_t
 
__»suÉ
 = 0;

961 
__s
[
__»suÉ
] !ð'\0' && __s[__»suÉ] !ð
__»jeù1


962 && 
__s
[
__»suÉ
] !ð
__»jeù2
)

963 ++
__»suÉ
;

964  
__»suÉ
;

965 
	}
}

967 
__STRING_INLINE
 
size_t
 
__¡rc¥n_c3
 (cÚ¡ *
__s
, 
__»jeù1
,

968 
__»jeù2
, 
__»jeù3
);

969 
__STRING_INLINE
 
size_t


970 
	$__¡rc¥n_c3
 (cÚ¡ *
__s
, 
__»jeù1
, 
__»jeù2
,

971 
__»jeù3
)

973 
size_t
 
__»suÉ
 = 0;

974 
__s
[
__»suÉ
] !ð'\0' && __s[__»suÉ] !ð
__»jeù1


975 && 
__s
[
__»suÉ
] !ð
__»jeù2
 && __s[__»suÉ] !ð
__»jeù3
)

976 ++
__»suÉ
;

977  
__»suÉ
;

978 
	}
}

984 #ià!
defšed
 
_HAVE_STRING_ARCH_¡r¥n
 || defšed 
_FORCE_INLINES


985 #iâdeà
_HAVE_STRING_ARCH_¡r¥n


986 #ià
__GNUC_PREREQ
 (3, 2)

987 
	#¡r¥n
(
s
, 
acû±
) \

988 
__ex‹nsiÚ__
 \

989 ({ 
__a0
, 
__a1
, 
__a2
; \

990 (
	`__bužtš_cÚ¡ªt_p
 (
acû±
è&& 
	`__¡ršg2_1b±r_p
 (accept) \

991 ? ((
	`__bužtš_cÚ¡ªt_p
 (
s
è&& 
	`__¡ršg2_1b±r_p
 (s)) \

992 ? 
	`__bužtš_¡r¥n
 (
s
, 
acû±
) \

993 : ((
__a0
 = ((cÚ¡ *è(
acû±
))[0], __a0 == '\0') \

994 ? ((è(
s
), (
size_t
) 0) \

995 : ((
__a1
 = ((cÚ¡ *è(
acû±
))[1], __a1 == '\0') \

996 ? 
	`__¡r¥n_c1
 (
s
, 
__a0
) \

997 : ((
__a2
 = ((cÚ¡ *è(
acû±
))[2], __a2 == '\0') \

998 ? 
	`__¡r¥n_c2
 (
s
, 
__a0
, 
__a1
) \

999 : (((cÚ¡ *è(
acû±
))[3] == '\0' \

1000 ? 
	`__¡r¥n_c3
 (
s
, 
__a0
, 
__a1
, 
__a2
) \

1001 : 
	`__bužtš_¡r¥n
 (
s
, 
acû±
)))))) \

1002 : 
	`__bužtš_¡r¥n
 (
s
, 
acû±
)); })

	)

1004 
	#¡r¥n
(
s
, 
acû±
) \

1005 
__ex‹nsiÚ__
 \

1006 ({ 
__a0
, 
__a1
, 
__a2
; \

1007 (
	`__bužtš_cÚ¡ªt_p
 (
acû±
è&& 
	`__¡ršg2_1b±r_p
 (accept) \

1008 ? ((
__a0
 = ((cÚ¡ *è(
acû±
))[0], __a0 == '\0') \

1009 ? ((è(
s
), (
size_t
) 0) \

1010 : ((
__a1
 = ((cÚ¡ *è(
acû±
))[1], __a1 == '\0') \

1011 ? 
	`__¡r¥n_c1
 (
s
, 
__a0
) \

1012 : ((
__a2
 = ((cÚ¡ *è(
acû±
))[2], __a2 == '\0') \

1013 ? 
	`__¡r¥n_c2
 (
s
, 
__a0
, 
__a1
) \

1014 : (((cÚ¡ *è(
acû±
))[3] == '\0' \

1015 ? 
	`__¡r¥n_c3
 (
s
, 
__a0
, 
__a1
, 
__a2
) \

1016 : 
	`¡r¥n
 (
s
, 
acû±
))))) \

1017 : 
	`¡r¥n
 (
s
, 
acû±
)); })

	)

1021 
__STRING_INLINE
 
size_t
 
__¡r¥n_c1
 (cÚ¡ *
__s
, 
__acû±
);

1022 
__STRING_INLINE
 
size_t


1023 
	$__¡r¥n_c1
 (cÚ¡ *
__s
, 
__acû±
)

1025 
size_t
 
__»suÉ
 = 0;

1027 
__s
[
__»suÉ
] =ð
__acû±
)

1028 ++
__»suÉ
;

1029  
__»suÉ
;

1030 
	}
}

1032 
__STRING_INLINE
 
size_t
 
__¡r¥n_c2
 (cÚ¡ *
__s
, 
__acû±1
,

1033 
__acû±2
);

1034 
__STRING_INLINE
 
size_t


1035 
	$__¡r¥n_c2
 (cÚ¡ *
__s
, 
__acû±1
, 
__acû±2
)

1037 
size_t
 
__»suÉ
 = 0;

1039 
__s
[
__»suÉ
] =ð
__acû±1
 || __s[__»suÉ] =ð
__acû±2
)

1040 ++
__»suÉ
;

1041  
__»suÉ
;

1042 
	}
}

1044 
__STRING_INLINE
 
size_t
 
__¡r¥n_c3
 (cÚ¡ *
__s
, 
__acû±1
,

1045 
__acû±2
, 
__acû±3
);

1046 
__STRING_INLINE
 
size_t


1047 
	$__¡r¥n_c3
 (cÚ¡ *
__s
, 
__acû±1
, 
__acû±2
, 
__acû±3
)

1049 
size_t
 
__»suÉ
 = 0;

1051 
__s
[
__»suÉ
] =ð
__acû±1
 || __s[__»suÉ] =ð
__acû±2


1052 || 
__s
[
__»suÉ
] =ð
__acû±3
)

1053 ++
__»suÉ
;

1054  
__»suÉ
;

1055 
	}
}

1060 #ià!
defšed
 
_HAVE_STRING_ARCH_¡½brk
 || defšed 
_FORCE_INLINES


1061 #iâdeà
_HAVE_STRING_ARCH_¡½brk


1062 #ià
__GNUC_PREREQ
 (3, 2)

1063 
	#¡½brk
(
s
, 
acû±
) \

1064 
__ex‹nsiÚ__
 \

1065 ({ 
__a0
, 
__a1
, 
__a2
; \

1066 (
	`__bužtš_cÚ¡ªt_p
 (
acû±
è&& 
	`__¡ršg2_1b±r_p
 (accept) \

1067 ? ((
	`__bužtš_cÚ¡ªt_p
 (
s
è&& 
	`__¡ršg2_1b±r_p
 (s)) \

1068 ? 
	`__bužtš_¡½brk
 (
s
, 
acû±
) \

1069 : ((
__a0
 = ((cÚ¡ *è(
acû±
))[0], __a0 == '\0') \

1070 ? ((è(
s
), (*è
NULL
) \

1071 : ((
__a1
 = ((cÚ¡ *è(
acû±
))[1], __a1 == '\0') \

1072 ? 
	`__bužtš_¡rchr
 (
s
, 
__a0
) \

1073 : ((
__a2
 = ((cÚ¡ *è(
acû±
))[2], __a2 == '\0') \

1074 ? 
	`__¡½brk_c2
 (
s
, 
__a0
, 
__a1
) \

1075 : (((cÚ¡ *è(
acû±
))[3] == '\0' \

1076 ? 
	`__¡½brk_c3
 (
s
, 
__a0
, 
__a1
, 
__a2
) \

1077 : 
	`__bužtš_¡½brk
 (
s
, 
acû±
)))))) \

1078 : 
	`__bužtš_¡½brk
 (
s
, 
acû±
)); })

	)

1080 
	#¡½brk
(
s
, 
acû±
) \

1081 
__ex‹nsiÚ__
 \

1082 ({ 
__a0
, 
__a1
, 
__a2
; \

1083 (
	`__bužtš_cÚ¡ªt_p
 (
acû±
è&& 
	`__¡ršg2_1b±r_p
 (accept) \

1084 ? ((
__a0
 = ((cÚ¡ *è(
acû±
))[0], __a0 == '\0') \

1085 ? ((è(
s
), (*è
NULL
) \

1086 : ((
__a1
 = ((cÚ¡ *è(
acû±
))[1], __a1 == '\0') \

1087 ? 
	`¡rchr
 (
s
, 
__a0
) \

1088 : ((
__a2
 = ((cÚ¡ *è(
acû±
))[2], __a2 == '\0') \

1089 ? 
	`__¡½brk_c2
 (
s
, 
__a0
, 
__a1
) \

1090 : (((cÚ¡ *è(
acû±
))[3] == '\0' \

1091 ? 
	`__¡½brk_c3
 (
s
, 
__a0
, 
__a1
, 
__a2
) \

1092 : 
	`¡½brk
 (
s
, 
acû±
))))) \

1093 : 
	`¡½brk
 (
s
, 
acû±
)); })

	)

1097 
__STRING_INLINE
 *
__¡½brk_c2
 (cÚ¡ *
__s
, 
__acû±1
,

1098 
__acû±2
);

1099 
__STRING_INLINE
 *

1100 
	$__¡½brk_c2
 (cÚ¡ *
__s
, 
__acû±1
, 
__acû±2
)

1103 *
__s
 !ð'\0' && *__ !ð
__acû±1
 && *__ !ð
__acû±2
)

1104 ++
__s
;

1105  *
__s
 =ð'\0' ? 
NULL
 : (*è(
size_t
) __s;

1106 
	}
}

1108 
__STRING_INLINE
 *
__¡½brk_c3
 (cÚ¡ *
__s
, 
__acû±1
,

1109 
__acû±2
, 
__acû±3
);

1110 
__STRING_INLINE
 *

1111 
	$__¡½brk_c3
 (cÚ¡ *
__s
, 
__acû±1
, 
__acû±2
, 
__acû±3
)

1114 *
__s
 !ð'\0' && *__ !ð
__acû±1
 && *__ !ð
__acû±2


1115 && *
__s
 !ð
__acû±3
)

1116 ++
__s
;

1117  *
__s
 =ð'\0' ? 
NULL
 : (*è(
size_t
) __s;

1118 
	}
}

1124 #ià!
defšed
 
_HAVE_STRING_ARCH_¡r¡r
 && !
__GNUC_PREREQ
 (2, 97)

1125 
	#¡r¡r
(
hay¡ack
, 
ÃedË
) \

1126 (
	`__ex‹nsiÚ__
 (
	`__bužtš_cÚ¡ªt_p
 (
ÃedË
è&& 
	`__¡ršg2_1b±r_p
 (needle) \

1127 ? (((cÚ¡ *è(
ÃedË
))[0] == '\0' \

1128 ? (*è(
size_t
è(
hay¡ack
) \

1129 : (((cÚ¡ *è(
ÃedË
))[1] == '\0' \

1130 ? 
	`¡rchr
 (
hay¡ack
, \

1131 ((cÚ¡ *è(
ÃedË
))[0]) \

1132 : 
	`¡r¡r
 (
hay¡ack
, 
ÃedË
))) \

1133 : 
	`¡r¡r
 (
hay¡ack
, 
ÃedË
)))

	)

1137 #ià!
defšed
 
_HAVE_STRING_ARCH_¡¹ok_r
 || defšed 
_FORCE_INLINES


1138 #iâdeà
_HAVE_STRING_ARCH_¡¹ok_r


1139 
	#__¡¹ok_r
(
s
, 
£p
, 
Ãx
) \

1140 (
	`__ex‹nsiÚ__
 (
	`__bužtš_cÚ¡ªt_p
 (
£p
è&& 
	`__¡ršg2_1b±r_p
 (sep) \

1141 && ((cÚ¡ *è(
£p
))[0] != '\0' \

1142 && ((cÚ¡ *è(
£p
))[1] == '\0' \

1143 ? 
	`__¡¹ok_r_1c
 (
s
, ((cÚ¡ *è(
£p
))[0], 
Ãx
) \

1144 : 
	`__¡¹ok_r
 (
s
, 
£p
, 
Ãx
)))

	)

1147 
__STRING_INLINE
 *
__¡¹ok_r_1c
 (*
__s
, 
__£p
, **
__Ãx
);

1148 
__STRING_INLINE
 *

1149 
	$__¡¹ok_r_1c
 (*
__s
, 
__£p
, **
__Ãx
)

1151 *
__»suÉ
;

1152 ià(
__s
 =ð
NULL
)

1153 
__s
 = *
__Ãx
;

1154 *
__s
 =ð
__£p
)

1155 ++
__s
;

1156 
__»suÉ
 = 
NULL
;

1157 ià(*
__s
 != '\0')

1159 
__»suÉ
 = 
__s
++;

1160 *
__s
 != '\0')

1161 ià(*
__s
++ =ð
__£p
)

1163 
__s
[-1] = '\0';

1167 *
__Ãx
 = 
__s
;

1168  
__»suÉ
;

1169 
	}
}

1170 #ifdeà
__USE_POSIX


1171 
	#¡¹ok_r
(
s
, 
£p
, 
Ãx
è
	`__¡¹ok_r
 (s, s•,‚ex)

	)

1176 #ià!
defšed
 
_HAVE_STRING_ARCH_¡r£p
 || defšed 
_FORCE_INLINES


1177 #iâdeà
_HAVE_STRING_ARCH_¡r£p


1179 *
__¡r£p_g
 (**
__¡ršgp
, cÚ¡ *
__d–im
);

1180 
	#__¡r£p
(
s
, 
»jeù
) \

1181 
__ex‹nsiÚ__
 \

1182 ({ 
__r0
, 
__r1
, 
__r2
; \

1183 (
	`__bužtš_cÚ¡ªt_p
 (
»jeù
è&& 
	`__¡ršg2_1b±r_p
 (reject) \

1184 && (
__r0
 = ((cÚ¡ *è(
»jeù
))[0], \

1185 ((cÚ¡ *è(
»jeù
))[0] != '\0') \

1186 ? ((
__r1
 = ((cÚ¡ *è(
»jeù
))[1], \

1187 ((cÚ¡ *è(
»jeù
))[1] == '\0') \

1188 ? 
	`__¡r£p_1c
 (
s
, 
__r0
) \

1189 : ((
__r2
 = ((cÚ¡ *è(
»jeù
))[2], __r2 == '\0') \

1190 ? 
	`__¡r£p_2c
 (
s
, 
__r0
, 
__r1
) \

1191 : (((cÚ¡ *è(
»jeù
))[3] == '\0' \

1192 ? 
	`__¡r£p_3c
 (
s
, 
__r0
, 
__r1
, 
__r2
) \

1193 : 
	`__¡r£p_g
 (
s
, 
»jeù
)))) \

1194 : 
	`__¡r£p_g
 (
s
, 
»jeù
)); })

	)

1197 
__STRING_INLINE
 *
__¡r£p_1c
 (**
__s
, 
__»jeù
);

1198 
__STRING_INLINE
 *

1199 
	$__¡r£p_1c
 (**
__s
, 
__»jeù
)

1201 *
__»tv®
 = *
__s
;

1202 ià(
__»tv®
 !ð
NULL
 && (*
__s
 = 
	`¡rchr
 (__»tv®, 
__»jeù
)) != NULL)

1203 *(*
__s
)++ = '\0';

1204  
__»tv®
;

1205 
	}
}

1207 
__STRING_INLINE
 *
__¡r£p_2c
 (**
__s
, 
__»jeù1
, 
__»jeù2
);

1208 
__STRING_INLINE
 *

1209 
	$__¡r£p_2c
 (**
__s
, 
__»jeù1
, 
__»jeù2
)

1211 *
__»tv®
 = *
__s
;

1212 ià(
__»tv®
 !ð
NULL
)

1214 *
__ý
 = 
__»tv®
;

1217 ià(*
__ý
 == '\0')

1219 
__ý
 = 
NULL
;

1222 ià(*
__ý
 =ð
__»jeù1
 || *__ý =ð
__»jeù2
)

1224 *
__ý
++ = '\0';

1227 ++
__ý
;

1229 *
__s
 = 
__ý
;

1231  
__»tv®
;

1232 
	}
}

1234 
__STRING_INLINE
 *
__¡r£p_3c
 (**
__s
, 
__»jeù1
, 
__»jeù2
,

1235 
__»jeù3
);

1236 
__STRING_INLINE
 *

1237 
	$__¡r£p_3c
 (**
__s
, 
__»jeù1
, 
__»jeù2
, 
__»jeù3
)

1239 *
__»tv®
 = *
__s
;

1240 ià(
__»tv®
 !ð
NULL
)

1242 *
__ý
 = 
__»tv®
;

1245 ià(*
__ý
 == '\0')

1247 
__ý
 = 
NULL
;

1250 ià(*
__ý
 =ð
__»jeù1
 || *__ý =ð
__»jeù2
 || *__ý =ð
__»jeù3
)

1252 *
__ý
++ = '\0';

1255 ++
__ý
;

1257 *
__s
 = 
__ý
;

1259  
__»tv®
;

1260 
	}
}

1261 #ifdeà
__USE_MISC


1262 
	#¡r£p
(
s
, 
»jeù
è
	`__¡r£p
 (s,„ejeù)

	)

1269 #ifdeà
__USE_MISC


1271 #ià!
defšed
 
_HAVE_STRING_ARCH_¡rdup
 || !defšed 
_HAVE_STRING_ARCH_¡ºdup


1272 
	#__Ãed_m®loc_ªd_ÿÎoc


	)

1273 
	~<¡dlib.h
>

1276 #iâdeà
_HAVE_STRING_ARCH_¡rdup


1278 *
	$__¡rdup
 (cÚ¡ *
__¡ršg
è
__THROW
 
__©Œibu‹_m®loc__
;

1279 
	#__¡rdup
(
s
) \

1280 (
	`__ex‹nsiÚ__
 (
	`__bužtš_cÚ¡ªt_p
 (
s
è&& 
	`__¡ršg2_1b±r_p
 (s) \

1281 ? (((cÚ¡ *è(
s
))[0] == '\0' \

1282 ? (*è
	`ÿÎoc
 ((
size_t
) 1, (size_t) 1) \

1283 : ({ 
size_t
 
__Ën
 = 
	`¡¾’
 (
s
) + 1; \

1284 *
__»tv®
 = (*è
	`m®loc
 (
__Ën
); \

1285 ià(
__»tv®
 !ð
NULL
) \

1286 
__»tv®
 = (*è
	`memýy
 (__»tv®, 
s
, 
__Ën
); \

1287 
__»tv®
; 
	}
})) \

1288 : 
	`__¡rdup
 (
s
)))

	)

1290 #ià
defšed
 
__USE_XOPEN_EXTENDED
 || defšed 
__USE_XOPEN2K8


1291 
	#¡rdup
(
s
è
	`__¡rdup
 (s)

	)

1295 #iâdeà
_HAVE_STRING_ARCH_¡ºdup


1297 *
	$__¡ºdup
 (cÚ¡ *
__¡ršg
, 
size_t
 
__n
)

1298 
__THROW
 
__©Œibu‹_m®loc__
;

1299 
	#__¡ºdup
(
s
, 
n
) \

1300 (
	`__ex‹nsiÚ__
 (
	`__bužtš_cÚ¡ªt_p
 (
s
è&& 
	`__¡ršg2_1b±r_p
 (s) \

1301 ? (((cÚ¡ *è(
s
))[0] == '\0' \

1302 ? (*è
	`ÿÎoc
 ((
size_t
) 1, (size_t) 1) \

1303 : ({ 
size_t
 
__Ën
 = 
	`¡¾’
 (
s
) + 1; \

1304 
size_t
 
__n
 = (
n
); \

1305 *
__»tv®
; \

1306 ià(
__n
 < 
__Ën
) \

1307 
__Ën
 = 
__n
 + 1; \

1308 
__»tv®
 = (*è
	`m®loc
 (
__Ën
); \

1309 ià(
__»tv®
 !ð
NULL
) \

1311 
__»tv®
[
__Ën
 - 1] = '\0'; \

1312 
__»tv®
 = (*è
	`memýy
 (__»tv®, 
s
, \

1313 
__Ën
 - 1); \

1315 
__»tv®
; 
	}
})) \

1316 : 
	`__¡ºdup
 (
s
, 
n
)))

	)

1318 #ifdeà
__USE_XOPEN2K8


1319 
	#¡ºdup
(
s
, 
n
è
	`__¡ºdup
 (s,‚)

	)

1325 #iâdeà
_FORCE_INLINES


1326 #undeà
__STRING_INLINE


	@/usr/include/bits/string3.h

18 #iâdeà
_STRING_H


22 #ià!
__GNUC_PREREQ
 (5,0)

23 
__w¬ndeþ
 (
__w¬n_mem£t_z”o_Ën
,

27 #iâdeà
__ýlu¥lus


31 #undeà
memýy


32 #undeà
memmove


33 #undeà
mem£t


34 #undeà
¡rÿt


35 #undeà
¡rýy


36 #undeà
¡ºÿt


37 #undeà
¡ºýy


38 #ifdeà
__USE_GNU


39 #undeà
mempýy


40 #undeà
¡pýy


42 #ifdeà
__USE_MISC


43 #undeà
bcÝy


44 #undeà
bz”o


49 
__fÜtify_funùiÚ
 *

50 
__NTH
 (
	$memýy
 (*
__»¡riù
 
__de¡
, cÚ¡ *__»¡riù 
__¤c
,

51 
size_t
 
__Ën
))

53  
	`__bužtš___memýy_chk
 (
__de¡
, 
__¤c
, 
__Ën
, 
	`__bos0
 (__dest));

54 
	}
}

56 
__fÜtify_funùiÚ
 *

57 
__NTH
 (
	$memmove
 (*
__de¡
, cÚ¡ *
__¤c
, 
size_t
 
__Ën
))

59  
	`__bužtš___memmove_chk
 (
__de¡
, 
__¤c
, 
__Ën
, 
	`__bos0
 (__dest));

60 
	}
}

62 #ifdeà
__USE_GNU


63 
__fÜtify_funùiÚ
 *

64 
__NTH
 (
	$mempýy
 (*
__»¡riù
 
__de¡
, cÚ¡ *__»¡riù 
__¤c
,

65 
size_t
 
__Ën
))

67  
	`__bužtš___mempýy_chk
 (
__de¡
, 
__¤c
, 
__Ën
, 
	`__bos0
 (__dest));

68 
	}
}

77 
__fÜtify_funùiÚ
 *

78 
__NTH
 (
	$mem£t
 (*
__de¡
, 
__ch
, 
size_t
 
__Ën
))

82 #ià!
	`__GNUC_PREREQ
 (5,0)

83 ià(
	`__bužtš_cÚ¡ªt_p
 (
__Ën
) && __len == 0

84 && (!
	`__bužtš_cÚ¡ªt_p
 (
__ch
) || __ch != 0))

86 
	`__w¬n_mem£t_z”o_Ën
 ();

87  
__de¡
;

90  
	`__bužtš___mem£t_chk
 (
__de¡
, 
__ch
, 
__Ën
, 
	`__bos0
 (__dest));

91 
	}
}

93 #ifdeà
__USE_MISC


94 
__fÜtify_funùiÚ
 

95 
__NTH
 (
	$bcÝy
 (cÚ¡ *
__¤c
, *
__de¡
, 
size_t
 
__Ën
))

97 (è
	`__bužtš___memmove_chk
 (
__de¡
, 
__¤c
, 
__Ën
, 
	`__bos0
 (__dest));

98 
	}
}

100 
__fÜtify_funùiÚ
 

101 
__NTH
 (
	$bz”o
 (*
__de¡
, 
size_t
 
__Ën
))

103 (è
	`__bužtš___mem£t_chk
 (
__de¡
, '\0', 
__Ën
, 
	`__bos0
 (__dest));

104 
	}
}

107 
__fÜtify_funùiÚ
 *

108 
__NTH
 (
	$¡rýy
 (*
__»¡riù
 
__de¡
, cÚ¡ *__»¡riù 
__¤c
))

110  
	`__bužtš___¡rýy_chk
 (
__de¡
, 
__¤c
, 
	`__bos
 (__dest));

111 
	}
}

113 #ifdeà
__USE_GNU


114 
__fÜtify_funùiÚ
 *

115 
__NTH
 (
	$¡pýy
 (*
__»¡riù
 
__de¡
, cÚ¡ *__»¡riù 
__¤c
))

117  
	`__bužtš___¡pýy_chk
 (
__de¡
, 
__¤c
, 
	`__bos
 (__dest));

118 
	}
}

122 
__fÜtify_funùiÚ
 *

123 
__NTH
 (
	$¡ºýy
 (*
__»¡riù
 
__de¡
, cÚ¡ *__»¡riù 
__¤c
,

124 
size_t
 
__Ën
))

126  
	`__bužtš___¡ºýy_chk
 (
__de¡
, 
__¤c
, 
__Ën
, 
	`__bos
 (__dest));

127 
	}
}

130 *
	$__¡²ýy_chk
 (*
__de¡
, cÚ¡ *
__¤c
, 
size_t
 
__n
,

131 
size_t
 
__de¡Ën
è
__THROW
;

132 *
	`__REDIRECT_NTH
 (
__¡²ýy_®Ÿs
, (*
__de¡
, cÚ¡ *
__¤c
,

133 
size_t
 
__n
), 
¡²ýy
);

135 
__fÜtify_funùiÚ
 *

136 
	`__NTH
 (
	$¡²ýy
 (*
__de¡
, cÚ¡ *
__¤c
, 
size_t
 
__n
))

138 ià(
	`__bos
 (
__de¡
è!ð(
size_t
) -1

139 && (!
	`__bužtš_cÚ¡ªt_p
 (
__n
è|| __À> 
	`__bos
 (
__de¡
)))

140  
	`__¡²ýy_chk
 (
__de¡
, 
__¤c
, 
__n
, 
	`__bos
 (__dest));

141  
	`__¡²ýy_®Ÿs
 (
__de¡
, 
__¤c
, 
__n
);

142 
	}
}

145 
__fÜtify_funùiÚ
 *

146 
__NTH
 (
	$¡rÿt
 (*
__»¡riù
 
__de¡
, cÚ¡ *__»¡riù 
__¤c
))

148  
	`__bužtš___¡rÿt_chk
 (
__de¡
, 
__¤c
, 
	`__bos
 (__dest));

149 
	}
}

152 
__fÜtify_funùiÚ
 *

153 
__NTH
 (
	$¡ºÿt
 (*
__»¡riù
 
__de¡
, cÚ¡ *__»¡riù 
__¤c
,

154 
size_t
 
__Ën
))

156  
	`__bužtš___¡ºÿt_chk
 (
__de¡
, 
__¤c
, 
__Ën
, 
	`__bos
 (__dest));

157 
	}
}

	@/usr/include/bits/sys_errlist.h

19 #iâdeà
_STDIO_H


25 #ifdeà 
__USE_MISC


26 
sys_Ã¼
;

27 cÚ¡ *cÚ¡ 
sys_”¾i¡
[];

29 #ifdeà 
__USE_GNU


30 
_sys_Ã¼
;

31 cÚ¡ *cÚ¡ 
_sys_”¾i¡
[];

	@/usr/include/bits/termios.h

19 #iâdeà
_TERMIOS_H


23 
	tcc_t
;

24 
	t¥“d_t
;

25 
	ttcæag_t
;

27 
	#NCCS
 32

	)

28 
	s‹rmios


30 
tcæag_t
 
	mc_iæag
;

31 
tcæag_t
 
	mc_oæag
;

32 
tcæag_t
 
	mc_cæag
;

33 
tcæag_t
 
	mc_læag
;

34 
cc_t
 
	mc_lše
;

35 
cc_t
 
	mc_cc
[
NCCS
];

36 
¥“d_t
 
	mc_i¥“d
;

37 
¥“d_t
 
	mc_o¥“d
;

38 
	#_HAVE_STRUCT_TERMIOS_C_ISPEED
 1

	)

39 
	#_HAVE_STRUCT_TERMIOS_C_OSPEED
 1

	)

43 
	#VINTR
 0

	)

44 
	#VQUIT
 1

	)

45 
	#VERASE
 2

	)

46 
	#VKILL
 3

	)

47 
	#VEOF
 4

	)

48 
	#VTIME
 5

	)

49 
	#VMIN
 6

	)

50 
	#VSWTC
 7

	)

51 
	#VSTART
 8

	)

52 
	#VSTOP
 9

	)

53 
	#VSUSP
 10

	)

54 
	#VEOL
 11

	)

55 
	#VREPRINT
 12

	)

56 
	#VDISCARD
 13

	)

57 
	#VWERASE
 14

	)

58 
	#VLNEXT
 15

	)

59 
	#VEOL2
 16

	)

62 
	#IGNBRK
 0000001

	)

63 
	#BRKINT
 0000002

	)

64 
	#IGNPAR
 0000004

	)

65 
	#PARMRK
 0000010

	)

66 
	#INPCK
 0000020

	)

67 
	#ISTRIP
 0000040

	)

68 
	#INLCR
 0000100

	)

69 
	#IGNCR
 0000200

	)

70 
	#ICRNL
 0000400

	)

71 
	#IUCLC
 0001000

	)

72 
	#IXON
 0002000

	)

73 
	#IXANY
 0004000

	)

74 
	#IXOFF
 0010000

	)

75 
	#IMAXBEL
 0020000

	)

76 
	#IUTF8
 0040000

	)

79 
	#OPOST
 0000001

	)

80 
	#OLCUC
 0000002

	)

81 
	#ONLCR
 0000004

	)

82 
	#OCRNL
 0000010

	)

83 
	#ONOCR
 0000020

	)

84 
	#ONLRET
 0000040

	)

85 
	#OFILL
 0000100

	)

86 
	#OFDEL
 0000200

	)

87 #ià
defšed
 
__USE_MISC
 || defšed 
__USE_XOPEN


88 
	#NLDLY
 0000400

	)

89 
	#NL0
 0000000

	)

90 
	#NL1
 0000400

	)

91 
	#CRDLY
 0003000

	)

92 
	#CR0
 0000000

	)

93 
	#CR1
 0001000

	)

94 
	#CR2
 0002000

	)

95 
	#CR3
 0003000

	)

96 
	#TABDLY
 0014000

	)

97 
	#TAB0
 0000000

	)

98 
	#TAB1
 0004000

	)

99 
	#TAB2
 0010000

	)

100 
	#TAB3
 0014000

	)

101 
	#BSDLY
 0020000

	)

102 
	#BS0
 0000000

	)

103 
	#BS1
 0020000

	)

104 
	#FFDLY
 0100000

	)

105 
	#FF0
 0000000

	)

106 
	#FF1
 0100000

	)

109 
	#VTDLY
 0040000

	)

110 
	#VT0
 0000000

	)

111 
	#VT1
 0040000

	)

113 #ifdeà
__USE_MISC


114 
	#XTABS
 0014000

	)

118 #ifdeà
__USE_MISC


119 
	#CBAUD
 0010017

	)

121 
	#B0
 0000000

	)

122 
	#B50
 0000001

	)

123 
	#B75
 0000002

	)

124 
	#B110
 0000003

	)

125 
	#B134
 0000004

	)

126 
	#B150
 0000005

	)

127 
	#B200
 0000006

	)

128 
	#B300
 0000007

	)

129 
	#B600
 0000010

	)

130 
	#B1200
 0000011

	)

131 
	#B1800
 0000012

	)

132 
	#B2400
 0000013

	)

133 
	#B4800
 0000014

	)

134 
	#B9600
 0000015

	)

135 
	#B19200
 0000016

	)

136 
	#B38400
 0000017

	)

137 #ifdeà
__USE_MISC


138 
	#EXTA
 
B19200


	)

139 
	#EXTB
 
B38400


	)

141 
	#CSIZE
 0000060

	)

142 
	#CS5
 0000000

	)

143 
	#CS6
 0000020

	)

144 
	#CS7
 0000040

	)

145 
	#CS8
 0000060

	)

146 
	#CSTOPB
 0000100

	)

147 
	#CREAD
 0000200

	)

148 
	#PARENB
 0000400

	)

149 
	#PARODD
 0001000

	)

150 
	#HUPCL
 0002000

	)

151 
	#CLOCAL
 0004000

	)

152 #ifdeà
__USE_MISC


153 
	#CBAUDEX
 0010000

	)

155 
	#B57600
 0010001

	)

156 
	#B115200
 0010002

	)

157 
	#B230400
 0010003

	)

158 
	#B460800
 0010004

	)

159 
	#B500000
 0010005

	)

160 
	#B576000
 0010006

	)

161 
	#B921600
 0010007

	)

162 
	#B1000000
 0010010

	)

163 
	#B1152000
 0010011

	)

164 
	#B1500000
 0010012

	)

165 
	#B2000000
 0010013

	)

166 
	#B2500000
 0010014

	)

167 
	#B3000000
 0010015

	)

168 
	#B3500000
 0010016

	)

169 
	#B4000000
 0010017

	)

170 
	#__MAX_BAUD
 
B4000000


	)

171 #ifdeà
__USE_MISC


172 
	#CIBAUD
 002003600000

	)

173 
	#CMSPAR
 010000000000

	)

174 
	#CRTSCTS
 020000000000

	)

178 
	#ISIG
 0000001

	)

179 
	#ICANON
 0000002

	)

180 #ià
defšed
 
__USE_MISC
 || defšed 
__USE_XOPEN


181 
	#XCASE
 0000004

	)

183 
	#ECHO
 0000010

	)

184 
	#ECHOE
 0000020

	)

185 
	#ECHOK
 0000040

	)

186 
	#ECHONL
 0000100

	)

187 
	#NOFLSH
 0000200

	)

188 
	#TOSTOP
 0000400

	)

189 #ifdeà
__USE_MISC


190 
	#ECHOCTL
 0001000

	)

191 
	#ECHOPRT
 0002000

	)

192 
	#ECHOKE
 0004000

	)

193 
	#FLUSHO
 0010000

	)

194 
	#PENDIN
 0040000

	)

196 
	#IEXTEN
 0100000

	)

197 #ifdeà
__USE_MISC


198 
	#EXTPROC
 0200000

	)

202 
	#TCOOFF
 0

	)

203 
	#TCOON
 1

	)

204 
	#TCIOFF
 2

	)

205 
	#TCION
 3

	)

208 
	#TCIFLUSH
 0

	)

209 
	#TCOFLUSH
 1

	)

210 
	#TCIOFLUSH
 2

	)

213 
	#TCSANOW
 0

	)

214 
	#TCSADRAIN
 1

	)

215 
	#TCSAFLUSH
 2

	)

218 
	#_IOT_‹rmios
 \

219 
	`_IOT
 (
	`_IOTS
 (
cæag_t
), 4, _IOTS (
cc_t
), 
NCCS
, _IOTS (
¥“d_t
), 2)

	)

	@/usr/include/bits/time.h

23 #ià
defšed
 
__Ãed_timev®
 || defšed 
__USE_GNU


24 #iâdeà
_STRUCT_TIMEVAL


25 
	#_STRUCT_TIMEVAL
 1

	)

26 
	~<b™s/ty³s.h
>

30 
	stimev®


32 
__time_t
 
	mtv_£c
;

33 
__su£cÚds_t
 
	mtv_u£c
;

38 #iâdeà
__Ãed_timev®


39 #iâdeà
_BITS_TIME_H


40 
	#_BITS_TIME_H
 1

	)

48 
	#CLOCKS_PER_SEC
 ((
þock_t
è1000000)

	)

50 #ià(!
defšed
 
__STRICT_ANSI__
 || defšed 
__USE_POSIX
) \

51 && !
defšed
 
	g__USE_XOPEN2K


54 
	~<b™s/ty³s.h
>

55 
__syscÚf
 ();

56 
	#CLK_TCK
 ((
__þock_t
è
	`__syscÚf
 (2)è

	)

59 #ifdeà
__USE_POSIX199309


61 
	#CLOCK_REALTIME
 0

	)

63 
	#CLOCK_MONOTONIC
 1

	)

65 
	#CLOCK_PROCESS_CPUTIME_ID
 2

	)

67 
	#CLOCK_THREAD_CPUTIME_ID
 3

	)

69 
	#CLOCK_MONOTONIC_RAW
 4

	)

71 
	#CLOCK_REALTIME_COARSE
 5

	)

73 
	#CLOCK_MONOTONIC_COARSE
 6

	)

75 
	#CLOCK_BOOTTIME
 7

	)

77 
	#CLOCK_REALTIME_ALARM
 8

	)

79 
	#CLOCK_BOOTTIME_ALARM
 9

	)

81 
	#CLOCK_TAI
 11

	)

84 
	#TIMER_ABSTIME
 1

	)

87 #ifdeà
__USE_GNU


88 
	~<b™s/timex.h
>

90 
__BEGIN_DECLS


93 
	$þock_adjtime
 (
__þockid_t
 
__þock_id
, 
timex
 *
__utx
è
__THROW
;

95 
__END_DECLS


101 #undeà
__Ãed_timev®


	@/usr/include/bits/types.h

23 #iâdef 
_BITS_TYPES_H


24 
	#_BITS_TYPES_H
 1

	)

26 
	~<ã©u»s.h
>

27 
	~<b™s/wÜdsize.h
>

30 
	t__u_ch¬
;

31 
	t__u_shÜt
;

32 
	t__u_št
;

33 
	t__u_lÚg
;

36 sigÃd 
	t__št8_t
;

37 
	t__ušt8_t
;

38 sigÃd 
	t__št16_t
;

39 
	t__ušt16_t
;

40 sigÃd 
	t__št32_t
;

41 
	t__ušt32_t
;

42 #ià
__WORDSIZE
 == 64

43 sigÃd 
	t__št64_t
;

44 
	t__ušt64_t
;

46 
__ex‹nsiÚ__
 sigÃd 
	t__št64_t
;

47 
__ex‹nsiÚ__
 
	t__ušt64_t
;

51 #ià
__WORDSIZE
 == 64

52 
	t__quad_t
;

53 
	t__u_quad_t
;

55 
__ex‹nsiÚ__
 
	t__quad_t
;

56 
__ex‹nsiÚ__
 
	t__u_quad_t
;

89 
	#__S16_TYPE
 

	)

90 
	#__U16_TYPE
 

	)

91 
	#__S32_TYPE
 

	)

92 
	#__U32_TYPE
 

	)

93 
	#__SLONGWORD_TYPE
 

	)

94 
	#__ULONGWORD_TYPE
 

	)

95 #ià
__WORDSIZE
 == 32

96 
	#__SQUAD_TYPE
 
__quad_t


	)

97 
	#__UQUAD_TYPE
 
__u_quad_t


	)

98 
	#__SWORD_TYPE
 

	)

99 
	#__UWORD_TYPE
 

	)

100 
	#__SLONG32_TYPE
 

	)

101 
	#__ULONG32_TYPE
 

	)

102 
	#__S64_TYPE
 
__quad_t


	)

103 
	#__U64_TYPE
 
__u_quad_t


	)

106 
	#__STD_TYPE
 
__ex‹nsiÚ__
 

	)

107 #–ià
__WORDSIZE
 == 64

108 
	t__SQUAD_TYPE
 

	)

109 
	t__UQUAD_TYPE
 

	)

110 
	t__SWORD_TYPE
 

	)

111 
	t__UWORD_TYPE
 

	)

112 
	t__SLONG32_TYPE
 

	)

113 
	t__ULONG32_TYPE
 

	)

114 
	t__S64_TYPE
 

	)

115 
	t__U64_TYPE
 

	)

117 
	t__STD_TYPE
 

	)

121 
	~<b™s/ty³sizes.h
>

124 
__STD_TYPE
 
	t__DEV_T_TYPE
 
	t__dev_t
;

125 
__STD_TYPE
 
__UID_T_TYPE
 
	g__uid_t
;

126 
__STD_TYPE
 
__GID_T_TYPE
 
	g__gid_t
;

127 
__STD_TYPE
 
__INO_T_TYPE
 
	g__šo_t
;

128 
__STD_TYPE
 
__INO64_T_TYPE
 
	g__šo64_t
;

129 
__STD_TYPE
 
__MODE_T_TYPE
 
	g__mode_t
;

130 
__STD_TYPE
 
__NLINK_T_TYPE
 
	g__Æšk_t
;

131 
__STD_TYPE
 
__OFF_T_TYPE
 
	g__off_t
;

132 
__STD_TYPE
 
__OFF64_T_TYPE
 
	g__off64_t
;

133 
__STD_TYPE
 
__PID_T_TYPE
 
	g__pid_t
;

134 
__STD_TYPE
 
__FSID_T_TYPE
 
	g__fsid_t
;

135 
__STD_TYPE
 
__CLOCK_T_TYPE
 
	g__þock_t
;

136 
__STD_TYPE
 
__RLIM_T_TYPE
 
	g__¾im_t
;

137 
__STD_TYPE
 
__RLIM64_T_TYPE
 
	g__¾im64_t
;

138 
__STD_TYPE
 
__ID_T_TYPE
 
	g__id_t
;

139 
__STD_TYPE
 
__TIME_T_TYPE
 
	g__time_t
;

140 
__STD_TYPE
 
__USECONDS_T_TYPE
 
	g__u£cÚds_t
;

141 
__STD_TYPE
 
__SUSECONDS_T_TYPE
 
	g__su£cÚds_t
;

143 
__STD_TYPE
 
__DADDR_T_TYPE
 
	g__daddr_t
;

144 
__STD_TYPE
 
__KEY_T_TYPE
 
	g__key_t
;

147 
__STD_TYPE
 
__CLOCKID_T_TYPE
 
	g__þockid_t
;

150 
__STD_TYPE
 
__TIMER_T_TYPE
 
	g__tim”_t
;

153 
__STD_TYPE
 
__BLKSIZE_T_TYPE
 
	g__blksize_t
;

158 
__STD_TYPE
 
__BLKCNT_T_TYPE
 
	g__blkút_t
;

159 
__STD_TYPE
 
__BLKCNT64_T_TYPE
 
	g__blkút64_t
;

162 
__STD_TYPE
 
__FSBLKCNT_T_TYPE
 
	g__fsblkút_t
;

163 
__STD_TYPE
 
__FSBLKCNT64_T_TYPE
 
	g__fsblkút64_t
;

166 
__STD_TYPE
 
__FSFILCNT_T_TYPE
 
	g__fsfžút_t
;

167 
__STD_TYPE
 
__FSFILCNT64_T_TYPE
 
	g__fsfžút64_t
;

170 
__STD_TYPE
 
__FSWORD_T_TYPE
 
	g__fswÜd_t
;

172 
__STD_TYPE
 
__SSIZE_T_TYPE
 
	g__ssize_t
;

175 
__STD_TYPE
 
__SYSCALL_SLONG_TYPE
 
	g__sysÿÎ_¦Úg_t
;

177 
__STD_TYPE
 
__SYSCALL_ULONG_TYPE
 
	g__sysÿÎ_ulÚg_t
;

181 
__off64_t
 
	t__loff_t
;

182 
__quad_t
 *
	t__qaddr_t
;

183 *
	t__ÿddr_t
;

186 
__STD_TYPE
 
__SWORD_TYPE
 
	g__šŒ_t
;

189 
__STD_TYPE
 
__U32_TYPE
 
	g__sockËn_t
;

192 #undeà
__STD_TYPE


	@/usr/include/bits/unistd.h

19 #iâdeà
_UNISTD_H


23 
ssize_t
 
	$__»ad_chk
 (
__fd
, *
__buf
, 
size_t
 
__nby‹s
,

24 
size_t
 
__buæ’
è
__wur
;

25 
ssize_t
 
	`__REDIRECT
 (
__»ad_®Ÿs
, (
__fd
, *
__buf
,

26 
size_t
 
__nby‹s
), 
»ad
è
__wur
;

27 
ssize_t
 
	`__REDIRECT
 (
__»ad_chk_w¬n
,

28 (
__fd
, *
__buf
, 
size_t
 
__nby‹s
,

29 
size_t
 
__buæ’
), 
__»ad_chk
)

30 
__wur
 
	`__w¬Ç‰r
 ("read called with bigger†engthhan size of "

33 
__fÜtify_funùiÚ
 
__wur
 
ssize_t


34 
	$»ad
 (
__fd
, *
__buf
, 
size_t
 
__nby‹s
)

36 ià(
	`__bos0
 (
__buf
è!ð(
size_t
) -1)

38 ià(!
	`__bužtš_cÚ¡ªt_p
 (
__nby‹s
))

39  
	`__»ad_chk
 (
__fd
, 
__buf
, 
__nby‹s
, 
	`__bos0
 (__buf));

41 ià(
__nby‹s
 > 
	`__bos0
 (
__buf
))

42  
	`__»ad_chk_w¬n
 (
__fd
, 
__buf
, 
__nby‹s
, 
	`__bos0
 (__buf));

44  
	`__»ad_®Ÿs
 (
__fd
, 
__buf
, 
__nby‹s
);

45 
	}
}

47 #ifdeà
__USE_UNIX98


48 
ssize_t
 
	$__´—d_chk
 (
__fd
, *
__buf
, 
size_t
 
__nby‹s
,

49 
__off_t
 
__off£t
, 
size_t
 
__bufsize
è
__wur
;

50 
ssize_t
 
	$__´—d64_chk
 (
__fd
, *
__buf
, 
size_t
 
__nby‹s
,

51 
__off64_t
 
__off£t
, 
size_t
 
__bufsize
è
__wur
;

52 
ssize_t
 
	`__REDIRECT
 (
__´—d_®Ÿs
,

53 (
__fd
, *
__buf
, 
size_t
 
__nby‹s
,

54 
__off_t
 
__off£t
), 
´—d
è
__wur
;

55 
ssize_t
 
	`__REDIRECT
 (
__´—d64_®Ÿs
,

56 (
__fd
, *
__buf
, 
size_t
 
__nby‹s
,

57 
__off64_t
 
__off£t
), 
´—d64
è
__wur
;

58 
ssize_t
 
	`__REDIRECT
 (
__´—d_chk_w¬n
,

59 (
__fd
, *
__buf
, 
size_t
 
__nby‹s
,

60 
__off_t
 
__off£t
, 
size_t
 
__bufsize
), 
__´—d_chk
)

61 
__wur
 
	`__w¬Ç‰r
 ("pread called with bigger†engthhan size of "

63 
ssize_t
 
	`__REDIRECT
 (
__´—d64_chk_w¬n
,

64 (
__fd
, *
__buf
, 
size_t
 
__nby‹s
,

65 
__off64_t
 
__off£t
, 
size_t
 
__bufsize
),

66 
__´—d64_chk
)

67 
__wur
 
	`__w¬Ç‰r
 ("pread64 called with bigger†engthhan size of "

70 #iâdeà
__USE_FILE_OFFSET64


71 
__fÜtify_funùiÚ
 
__wur
 
ssize_t


72 
	$´—d
 (
__fd
, *
__buf
, 
size_t
 
__nby‹s
, 
__off_t
 
__off£t
)

74 ià(
	`__bos0
 (
__buf
è!ð(
size_t
) -1)

76 ià(!
	`__bužtš_cÚ¡ªt_p
 (
__nby‹s
))

77  
	`__´—d_chk
 (
__fd
, 
__buf
, 
__nby‹s
, 
__off£t
, 
	`__bos0
 (__buf));

79 iàÐ
__nby‹s
 > 
	`__bos0
 (
__buf
))

80  
	`__´—d_chk_w¬n
 (
__fd
, 
__buf
, 
__nby‹s
, 
__off£t
,

81 
	`__bos0
 (
__buf
));

83  
	`__´—d_®Ÿs
 (
__fd
, 
__buf
, 
__nby‹s
, 
__off£t
);

84 
	}
}

86 
__fÜtify_funùiÚ
 
__wur
 
ssize_t


87 
	$´—d
 (
__fd
, *
__buf
, 
size_t
 
__nby‹s
, 
__off64_t
 
__off£t
)

89 ià(
	`__bos0
 (
__buf
è!ð(
size_t
) -1)

91 ià(!
	`__bužtš_cÚ¡ªt_p
 (
__nby‹s
))

92  
	`__´—d64_chk
 (
__fd
, 
__buf
, 
__nby‹s
, 
__off£t
, 
	`__bos0
 (__buf));

94 iàÐ
__nby‹s
 > 
	`__bos0
 (
__buf
))

95  
	`__´—d64_chk_w¬n
 (
__fd
, 
__buf
, 
__nby‹s
, 
__off£t
,

96 
	`__bos0
 (
__buf
));

99  
	`__´—d64_®Ÿs
 (
__fd
, 
__buf
, 
__nby‹s
, 
__off£t
);

100 
	}
}

103 #ifdeà
__USE_LARGEFILE64


104 
__fÜtify_funùiÚ
 
__wur
 
ssize_t


105 
	$´—d64
 (
__fd
, *
__buf
, 
size_t
 
__nby‹s
, 
__off64_t
 
__off£t
)

107 ià(
	`__bos0
 (
__buf
è!ð(
size_t
) -1)

109 ià(!
	`__bužtš_cÚ¡ªt_p
 (
__nby‹s
))

110  
	`__´—d64_chk
 (
__fd
, 
__buf
, 
__nby‹s
, 
__off£t
, 
	`__bos0
 (__buf));

112 iàÐ
__nby‹s
 > 
	`__bos0
 (
__buf
))

113  
	`__´—d64_chk_w¬n
 (
__fd
, 
__buf
, 
__nby‹s
, 
__off£t
,

114 
	`__bos0
 (
__buf
));

117  
	`__´—d64_®Ÿs
 (
__fd
, 
__buf
, 
__nby‹s
, 
__off£t
);

118 
	}
}

122 #ià
defšed
 
__USE_XOPEN_EXTENDED
 || defšed 
__USE_XOPEN2K


123 
ssize_t
 
	$__»adlšk_chk
 (cÚ¡ *
__»¡riù
 
__·th
,

124 *
__»¡riù
 
__buf
, 
size_t
 
__Ën
,

125 
size_t
 
__buæ’
)

126 
__THROW
 
	`__nÚnuÎ
 ((1, 2)è
__wur
;

127 
ssize_t
 
	`__REDIRECT_NTH
 (
__»adlšk_®Ÿs
,

128 (cÚ¡ *
__»¡riù
 
__·th
,

129 *
__»¡riù
 
__buf
, 
size_t
 
__Ën
), 
»adlšk
)

130 
	`__nÚnuÎ
 ((1, 2)è
__wur
;

131 
ssize_t
 
	`__REDIRECT_NTH
 (
__»adlšk_chk_w¬n
,

132 (cÚ¡ *
__»¡riù
 
__·th
,

133 *
__»¡riù
 
__buf
, 
size_t
 
__Ën
,

134 
size_t
 
__buæ’
), 
__»adlšk_chk
)

135 
	`__nÚnuÎ
 ((1, 2)è
__wur
 
	`__w¬Ç‰r
 ("readlink called with bigger†ength "

138 
__fÜtify_funùiÚ
 
	`__nÚnuÎ
 ((1, 2)è
__wur
 
ssize_t


139 
	`__NTH
 (
	$»adlšk
 (cÚ¡ *
__»¡riù
 
__·th
, *__»¡riù 
__buf
,

140 
size_t
 
__Ën
))

142 ià(
	`__bos
 (
__buf
è!ð(
size_t
) -1)

144 ià(!
	`__bužtš_cÚ¡ªt_p
 (
__Ën
))

145  
	`__»adlšk_chk
 (
__·th
, 
__buf
, 
__Ën
, 
	`__bos
 (__buf));

147 iàÐ
__Ën
 > 
	`__bos
 (
__buf
))

148  
	`__»adlšk_chk_w¬n
 (
__·th
, 
__buf
, 
__Ën
, 
	`__bos
 (__buf));

150  
	`__»adlšk_®Ÿs
 (
__·th
, 
__buf
, 
__Ën
);

151 
	}
}

154 #ifdeà
__USE_ATFILE


155 
ssize_t
 
	$__»adlšk©_chk
 (
__fd
, cÚ¡ *
__»¡riù
 
__·th
,

156 *
__»¡riù
 
__buf
, 
size_t
 
__Ën
,

157 
size_t
 
__buæ’
)

158 
__THROW
 
	`__nÚnuÎ
 ((2, 3)è
__wur
;

159 
ssize_t
 
	`__REDIRECT_NTH
 (
__»adlšk©_®Ÿs
,

160 (
__fd
, cÚ¡ *
__»¡riù
 
__·th
,

161 *
__»¡riù
 
__buf
, 
size_t
 
__Ën
),

162 
»adlšk©
)

163 
	`__nÚnuÎ
 ((2, 3)è
__wur
;

164 
ssize_t
 
	`__REDIRECT_NTH
 (
__»adlšk©_chk_w¬n
,

165 (
__fd
, cÚ¡ *
__»¡riù
 
__·th
,

166 *
__»¡riù
 
__buf
, 
size_t
 
__Ën
,

167 
size_t
 
__buæ’
), 
__»adlšk©_chk
)

168 
	`__nÚnuÎ
 ((2, 3)è
__wur
 
	`__w¬Ç‰r
 ("readlinkat called with bigger "

172 
__fÜtify_funùiÚ
 
	`__nÚnuÎ
 ((2, 3)è
__wur
 
ssize_t


173 
	`__NTH
 (
	$»adlšk©
 (
__fd
, cÚ¡ *
__»¡riù
 
__·th
,

174 *
__»¡riù
 
__buf
, 
size_t
 
__Ën
))

176 ià(
	`__bos
 (
__buf
è!ð(
size_t
) -1)

178 ià(!
	`__bužtš_cÚ¡ªt_p
 (
__Ën
))

179  
	`__»adlšk©_chk
 (
__fd
, 
__·th
, 
__buf
, 
__Ën
, 
	`__bos
 (__buf));

181 ià(
__Ën
 > 
	`__bos
 (
__buf
))

182  
	`__»adlšk©_chk_w¬n
 (
__fd
, 
__·th
, 
__buf
, 
__Ën
,

183 
	`__bos
 (
__buf
));

185  
	`__»adlšk©_®Ÿs
 (
__fd
, 
__·th
, 
__buf
, 
__Ën
);

186 
	}
}

189 *
	$__g‘cwd_chk
 (*
__buf
, 
size_t
 
__size
, size_ˆ
__buæ’
)

190 
__THROW
 
__wur
;

191 *
	`__REDIRECT_NTH
 (
__g‘cwd_®Ÿs
,

192 (*
__buf
, 
size_t
 
__size
), 
g‘cwd
è
__wur
;

193 *
	`__REDIRECT_NTH
 (
__g‘cwd_chk_w¬n
,

194 (*
__buf
, 
size_t
 
__size
, size_ˆ
__buæ’
),

195 
__g‘cwd_chk
)

196 
__wur
 
	`__w¬Ç‰r
 ("getcwd caller with bigger†engthhan size of "

199 
__fÜtify_funùiÚ
 
__wur
 *

200 
	`__NTH
 (
	$g‘cwd
 (*
__buf
, 
size_t
 
__size
))

202 ià(
	`__bos
 (
__buf
è!ð(
size_t
) -1)

204 ià(!
	`__bužtš_cÚ¡ªt_p
 (
__size
))

205  
	`__g‘cwd_chk
 (
__buf
, 
__size
, 
	`__bos
 (__buf));

207 ià(
__size
 > 
	`__bos
 (
__buf
))

208  
	`__g‘cwd_chk_w¬n
 (
__buf
, 
__size
, 
	`__bos
 (__buf));

210  
	`__g‘cwd_®Ÿs
 (
__buf
, 
__size
);

211 
	}
}

213 #ià
defšed
 
__USE_MISC
 || defšed 
__USE_XOPEN_EXTENDED


214 *
	$__g‘wd_chk
 (*
__buf
, 
size_t
 
buæ’
)

215 
__THROW
 
	`__nÚnuÎ
 ((1)è
__wur
;

216 *
	`__REDIRECT_NTH
 (
__g‘wd_w¬n
, (*
__buf
), 
g‘wd
)

217 
	`__nÚnuÎ
 ((1)è
__wur
 
	`__w¬Ç‰r
 ("please use getcwd instead,‡s getwd "

220 
__fÜtify_funùiÚ
 
	`__nÚnuÎ
 ((1)è
__©Œibu‹_d•»ÿ‹d__
 
__wur
 *

221 
	`__NTH
 (
	$g‘wd
 (*
__buf
))

223 ià(
	`__bos
 (
__buf
è!ð(
size_t
) -1)

224  
	`__g‘wd_chk
 (
__buf
, 
	`__bos
 (__buf));

225  
	`__g‘wd_w¬n
 (
__buf
);

226 
	}
}

229 
size_t
 
	$__cÚf¡r_chk
 (
__Çme
, *
__buf
, 
size_t
 
__Ën
,

230 
size_t
 
__buæ’
è
__THROW
;

231 
size_t
 
	`__REDIRECT_NTH
 (
__cÚf¡r_®Ÿs
, (
__Çme
, *
__buf
,

232 
size_t
 
__Ën
), 
cÚf¡r
);

233 
size_t
 
	`__REDIRECT_NTH
 (
__cÚf¡r_chk_w¬n
,

234 (
__Çme
, *
__buf
, 
size_t
 
__Ën
,

235 
size_t
 
__buæ’
), 
__cÚf¡r_chk
)

236 
	`__w¬Ç‰r
 ("confstr called with bigger†engthhan size of destination "

239 
__fÜtify_funùiÚ
 
size_t


240 
	`__NTH
 (
	$cÚf¡r
 (
__Çme
, *
__buf
, 
size_t
 
__Ën
))

242 ià(
	`__bos
 (
__buf
è!ð(
size_t
) -1)

244 ià(!
	`__bužtš_cÚ¡ªt_p
 (
__Ën
))

245  
	`__cÚf¡r_chk
 (
__Çme
, 
__buf
, 
__Ën
, 
	`__bos
 (__buf));

247 ià(
	`__bos
 (
__buf
è< 
__Ën
)

248  
	`__cÚf¡r_chk_w¬n
 (
__Çme
, 
__buf
, 
__Ën
, 
	`__bos
 (__buf));

250  
	`__cÚf¡r_®Ÿs
 (
__Çme
, 
__buf
, 
__Ën
);

251 
	}
}

254 
	$__g‘groups_chk
 (
__size
, 
__gid_t
 
__li¡
[], 
size_t
 
__li¡Ën
)

255 
__THROW
 
__wur
;

256 
	`__REDIRECT_NTH
 (
__g‘groups_®Ÿs
, (
__size
, 
__gid_t
 
__li¡
[]),

257 
g‘groups
è
__wur
;

258 
	`__REDIRECT_NTH
 (
__g‘groups_chk_w¬n
,

259 (
__size
, 
__gid_t
 
__li¡
[], 
size_t
 
__li¡Ën
),

260 
__g‘groups_chk
)

261 
__wur
 
	`__w¬Ç‰r
 ("getgroups called with bigger group counthan what "

264 
__fÜtify_funùiÚ
 

265 
	`__NTH
 (
	$g‘groups
 (
__size
, 
__gid_t
 
__li¡
[]))

267 ià(
	`__bos
 (
__li¡
è!ð(
size_t
) -1)

269 ià(!
	`__bužtš_cÚ¡ªt_p
 (
__size
) || __size < 0)

270  
	`__g‘groups_chk
 (
__size
, 
__li¡
, 
	`__bos
 (__list));

272 ià(
__size
 *  (
__gid_t
è> 
	`__bos
 (
__li¡
))

273  
	`__g‘groups_chk_w¬n
 (
__size
, 
__li¡
, 
	`__bos
 (__list));

275  
	`__g‘groups_®Ÿs
 (
__size
, 
__li¡
);

276 
	}
}

279 
	$__‰yÇme_r_chk
 (
__fd
, *
__buf
, 
size_t
 
__buæ’
,

280 
size_t
 
__Ä—l
è
__THROW
 
	`__nÚnuÎ
 ((2));

281 
	`__REDIRECT_NTH
 (
__‰yÇme_r_®Ÿs
, (
__fd
, *
__buf
,

282 
size_t
 
__buæ’
), 
‰yÇme_r
)

283 
	`__nÚnuÎ
 ((2));

284 
	`__REDIRECT_NTH
 (
__‰yÇme_r_chk_w¬n
,

285 (
__fd
, *
__buf
, 
size_t
 
__buæ’
,

286 
size_t
 
__Ä—l
), 
__‰yÇme_r_chk
)

287 
	`__nÚnuÎ
 ((2)è
	`__w¬Ç‰r
 ("ttyname_r called with bigger buflenhan "

290 
__fÜtify_funùiÚ
 

291 
	`__NTH
 (
	$‰yÇme_r
 (
__fd
, *
__buf
, 
size_t
 
__buæ’
))

293 ià(
	`__bos
 (
__buf
è!ð(
size_t
) -1)

295 ià(!
	`__bužtš_cÚ¡ªt_p
 (
__buæ’
))

296  
	`__‰yÇme_r_chk
 (
__fd
, 
__buf
, 
__buæ’
, 
	`__bos
 (__buf));

298 ià(
__buæ’
 > 
	`__bos
 (
__buf
))

299  
	`__‰yÇme_r_chk_w¬n
 (
__fd
, 
__buf
, 
__buæ’
, 
	`__bos
 (__buf));

301  
	`__‰yÇme_r_®Ÿs
 (
__fd
, 
__buf
, 
__buæ’
);

302 
	}
}

305 #ià
defšed
 
__USE_REENTRANT
 || defšed 
__USE_POSIX199506


306 
	$__g‘logš_r_chk
 (*
__buf
, 
size_t
 
__buæ’
, size_ˆ
__Ä—l
)

307 
	`__nÚnuÎ
 ((1));

308 
	`__REDIRECT
 (
__g‘logš_r_®Ÿs
, (*
__buf
, 
size_t
 
__buæ’
),

309 
g‘logš_r
è
	`__nÚnuÎ
 ((1));

310 
	`__REDIRECT
 (
__g‘logš_r_chk_w¬n
,

311 (*
__buf
, 
size_t
 
__buæ’
, size_ˆ
__Ä—l
),

312 
__g‘logš_r_chk
)

313 
	`__nÚnuÎ
 ((1)è
	`__w¬Ç‰r
 ("getlogin_r called with bigger buflenhan "

316 
__fÜtify_funùiÚ
 

317 
	$g‘logš_r
 (*
__buf
, 
size_t
 
__buæ’
)

319 ià(
	`__bos
 (
__buf
è!ð(
size_t
) -1)

321 ià(!
	`__bužtš_cÚ¡ªt_p
 (
__buæ’
))

322  
	`__g‘logš_r_chk
 (
__buf
, 
__buæ’
, 
	`__bos
 (__buf));

324 ià(
__buæ’
 > 
	`__bos
 (
__buf
))

325  
	`__g‘logš_r_chk_w¬n
 (
__buf
, 
__buæ’
, 
	`__bos
 (__buf));

327  
	`__g‘logš_r_®Ÿs
 (
__buf
, 
__buæ’
);

328 
	}
}

332 #ià
defšed
 
__USE_MISC
 || defšed 
__USE_UNIX98


333 
	$__g‘ho¡Çme_chk
 (*
__buf
, 
size_t
 
__buæ’
, size_ˆ
__Ä—l
)

334 
__THROW
 
	`__nÚnuÎ
 ((1));

335 
	`__REDIRECT_NTH
 (
__g‘ho¡Çme_®Ÿs
, (*
__buf
, 
size_t
 
__buæ’
),

336 
g‘ho¡Çme
è
	`__nÚnuÎ
 ((1));

337 
	`__REDIRECT_NTH
 (
__g‘ho¡Çme_chk_w¬n
,

338 (*
__buf
, 
size_t
 
__buæ’
, size_ˆ
__Ä—l
),

339 
__g‘ho¡Çme_chk
)

340 
	`__nÚnuÎ
 ((1)è
	`__w¬Ç‰r
 ("gethostname called with bigger buflenhan "

343 
__fÜtify_funùiÚ
 

344 
	`__NTH
 (
	$g‘ho¡Çme
 (*
__buf
, 
size_t
 
__buæ’
))

346 ià(
	`__bos
 (
__buf
è!ð(
size_t
) -1)

348 ià(!
	`__bužtš_cÚ¡ªt_p
 (
__buæ’
))

349  
	`__g‘ho¡Çme_chk
 (
__buf
, 
__buæ’
, 
	`__bos
 (__buf));

351 ià(
__buæ’
 > 
	`__bos
 (
__buf
))

352  
	`__g‘ho¡Çme_chk_w¬n
 (
__buf
, 
__buæ’
, 
	`__bos
 (__buf));

354  
	`__g‘ho¡Çme_®Ÿs
 (
__buf
, 
__buæ’
);

355 
	}
}

359 #ià
defšed
 
__USE_MISC
 || (defšed 
__USE_XOPEN
 && !defšed 
__USE_UNIX98
)

360 
	$__g‘domašÇme_chk
 (*
__buf
, 
size_t
 
__buæ’
, size_ˆ
__Ä—l
)

361 
__THROW
 
	`__nÚnuÎ
 ((1)è
__wur
;

362 
	`__REDIRECT_NTH
 (
__g‘domašÇme_®Ÿs
, (*
__buf
,

363 
size_t
 
__buæ’
),

364 
g‘domašÇme
è
	`__nÚnuÎ
 ((1)è
__wur
;

365 
	`__REDIRECT_NTH
 (
__g‘domašÇme_chk_w¬n
,

366 (*
__buf
, 
size_t
 
__buæ’
, size_ˆ
__Ä—l
),

367 
__g‘domašÇme_chk
)

368 
	`__nÚnuÎ
 ((1)è
__wur
 
	`__w¬Ç‰r
 ("getdomainname called with bigger "

372 
__fÜtify_funùiÚ
 

373 
	`__NTH
 (
	$g‘domašÇme
 (*
__buf
, 
size_t
 
__buæ’
))

375 ià(
	`__bos
 (
__buf
è!ð(
size_t
) -1)

377 ià(!
	`__bužtš_cÚ¡ªt_p
 (
__buæ’
))

378  
	`__g‘domašÇme_chk
 (
__buf
, 
__buæ’
, 
	`__bos
 (__buf));

380 ià(
__buæ’
 > 
	`__bos
 (
__buf
))

381  
	`__g‘domašÇme_chk_w¬n
 (
__buf
, 
__buæ’
, 
	`__bos
 (__buf));

383  
	`__g‘domašÇme_®Ÿs
 (
__buf
, 
__buæ’
);

384 
	}
}

	@/usr/include/bits/utsname.h

18 #iâdeà
_SYS_UTSNAME_H


23 
	#_UTSNAME_LENGTH
 65

	)

28 
	#_UTSNAME_DOMAIN_LENGTH
 
_UTSNAME_LENGTH


	)

	@/usr/include/bits/waitflags.h

19 #ià!
defšed
 
_SYS_WAIT_H
 && !defšed 
_STDLIB_H


25 
	#WNOHANG
 1

	)

26 
	#WUNTRACED
 2

	)

29 
	#WSTOPPED
 2

	)

30 
	#WEXITED
 4

	)

31 
	#WCONTINUED
 8

	)

32 
	#WNOWAIT
 0x01000000

	)

34 
	#__WNOTHREAD
 0x20000000

	)

36 
	#__WALL
 0x40000000

	)

37 
	#__WCLONE
 0x80000000

	)

40 #ià
defšed
 
__USE_XOPEN
 || defšed 
__USE_XOPEN2K8


41 #iâdeà
__ENUM_IDTYPE_T


42 
	#__ENUM_IDTYPE_T
 1

	)

46 #undeà
P_ALL


47 #undeà
P_PID


48 #undeà
P_PGID


52 
	mP_ALL
,

53 
	mP_PID
,

54 
	mP_PGID


55 } 
	tidty³_t
;

	@/usr/include/bits/waitstatus.h

19 #ià!
defšed
 
_SYS_WAIT_H
 && !defšed 
_STDLIB_H


28 
	#__WEXITSTATUS
(
¡©us
è(((¡©usè& 0xff00è>> 8)

	)

31 
	#__WTERMSIG
(
¡©us
è((¡©usè& 0x7f)

	)

34 
	#__WSTOPSIG
(
¡©us
è
	`__WEXITSTATUS
(¡©us)

	)

37 
	#__WIFEXITED
(
¡©us
è(
	`__WTERMSIG
(¡©usè=ð0)

	)

40 
	#__WIFSIGNALED
(
¡©us
) \

41 (((sigÃd è(((
¡©us
è& 0x7fè+ 1è>> 1è> 0)

	)

44 
	#__WIFSTOPPED
(
¡©us
è(((¡©usè& 0xffè=ð0x7f)

	)

48 #ifdeà
WCONTINUED


49 
	#__WIFCONTINUED
(
¡©us
è((¡©usè=ð
__W_CONTINUED
)

	)

53 
	#__WCOREDUMP
(
¡©us
è((¡©usè& 
__WCOREFLAG
)

	)

56 
	#__W_EXITCODE
(
»t
, 
sig
è(Ô‘è<< 8 | (sig))

	)

57 
	#__W_STOPCODE
(
sig
è((sigè<< 8 | 0x7f)

	)

58 
	#__W_CONTINUED
 0xffff

	)

59 
	#__WCOREFLAG
 0x80

	)

62 #ifdef 
__USE_MISC


64 
	~<’dŸn.h
>

66 
	uwa™


68 
	mw_¡©us
;

71 #if 
__BYTE_ORDER
 =ð
__LITTLE_ENDIAN


72 
	m__w_‹rmsig
:7;

73 
	m__w_cÜedump
:1;

74 
	m__w_»tcode
:8;

77 #if 
__BYTE_ORDER
 =ð
__BIG_ENDIAN


79 
	m__w_»tcode
:8;

80 
	m__w_cÜedump
:1;

81 
	m__w_‹rmsig
:7;

83 } 
	m__wa™_‹rmš©ed
;

86 #if 
__BYTE_ORDER
 =ð
__LITTLE_ENDIAN


87 
	m__w_¡Ýv®
:8;

88 
	m__w_¡Ýsig
:8;

91 #if 
__BYTE_ORDER
 =ð
__BIG_ENDIAN


93 
	m__w_¡Ýsig
:8;

94 
	m__w_¡Ýv®
:8;

96 } 
	m__wa™_¡Ý³d
;

99 
	#w_‹rmsig
 
__wa™_‹rmš©ed
.
__w_‹rmsig


	)

100 
	#w_cÜedump
 
__wa™_‹rmš©ed
.
__w_cÜedump


	)

101 
	#w_»tcode
 
__wa™_‹rmš©ed
.
__w_»tcode


	)

102 
	#w_¡Ýsig
 
__wa™_¡Ý³d
.
__w_¡Ýsig


	)

103 
	#w_¡Ýv®
 
__wa™_¡Ý³d
.
__w_¡Ýv®


	)

	@/usr/include/endian.h

18 #iâdef 
_ENDIAN_H


19 
	#_ENDIAN_H
 1

	)

21 
	~<ã©u»s.h
>

31 
	#__LITTLE_ENDIAN
 1234

	)

32 
	#__BIG_ENDIAN
 4321

	)

33 
	#__PDP_ENDIAN
 3412

	)

36 
	~<b™s/’dŸn.h
>

40 #iâdeà
__FLOAT_WORD_ORDER


41 
	#__FLOAT_WORD_ORDER
 
__BYTE_ORDER


	)

44 #ifdef 
__USE_MISC


45 
	#LITTLE_ENDIAN
 
__LITTLE_ENDIAN


	)

46 
	#BIG_ENDIAN
 
__BIG_ENDIAN


	)

47 
	#PDP_ENDIAN
 
__PDP_ENDIAN


	)

48 
	#BYTE_ORDER
 
__BYTE_ORDER


	)

51 #ià
__BYTE_ORDER
 =ð
__LITTLE_ENDIAN


52 
	#__LONG_LONG_PAIR
(
HI
, 
LO
èLO, 
	)
HI

53 #–ià
__BYTE_ORDER
 =ð
__BIG_ENDIAN


54 
	#__LONG_LONG_PAIR
(
HI
, 
LO
èHI, 
	)
LO

58 #ià
defšed
 
__USE_MISC
 && !defšed 
__ASSEMBLER__


60 
	~<b™s/by‹sw­.h
>

62 #ià
__BYTE_ORDER
 =ð
__LITTLE_ENDIAN


63 
	#htobe16
(
x
è
	`__bsw­_16
 (x)

	)

64 
	#htÞe16
(
x
è(x)

	)

65 
	#be16toh
(
x
è
	`__bsw­_16
 (x)

	)

66 
	#Ë16toh
(
x
è(x)

	)

68 
	#htobe32
(
x
è
	`__bsw­_32
 (x)

	)

69 
	#htÞe32
(
x
è(x)

	)

70 
	#be32toh
(
x
è
	`__bsw­_32
 (x)

	)

71 
	#Ë32toh
(
x
è(x)

	)

73 
	#htobe64
(
x
è
	`__bsw­_64
 (x)

	)

74 
	#htÞe64
(
x
è(x)

	)

75 
	#be64toh
(
x
è
	`__bsw­_64
 (x)

	)

76 
	#Ë64toh
(
x
è(x)

	)

79 
	#htobe16
(
x
è(x)

	)

80 
	#htÞe16
(
x
è
	`__bsw­_16
 (x)

	)

81 
	#be16toh
(
x
è(x)

	)

82 
	#Ë16toh
(
x
è
	`__bsw­_16
 (x)

	)

84 
	#htobe32
(
x
è(x)

	)

85 
	#htÞe32
(
x
è
	`__bsw­_32
 (x)

	)

86 
	#be32toh
(
x
è(x)

	)

87 
	#Ë32toh
(
x
è
	`__bsw­_32
 (x)

	)

89 
	#htobe64
(
x
è(x)

	)

90 
	#htÞe64
(
x
è
	`__bsw­_64
 (x)

	)

91 
	#be64toh
(
x
è(x)

	)

92 
	#Ë64toh
(
x
è
	`__bsw­_64
 (x)

	)

	@/usr/include/features.h

18 #iâdef 
_FEATURES_H


19 
	#_FEATURES_H
 1

	)

97 #undeà
__USE_ISOC11


98 #undeà
__USE_ISOC99


99 #undeà
__USE_ISOC95


100 #undeà
__USE_ISOCXX11


101 #undeà
__USE_POSIX


102 #undeà
__USE_POSIX2


103 #undeà
__USE_POSIX199309


104 #undeà
__USE_POSIX199506


105 #undeà
__USE_XOPEN


106 #undeà
__USE_XOPEN_EXTENDED


107 #undeà
__USE_UNIX98


108 #undeà
__USE_XOPEN2K


109 #undeà
__USE_XOPEN2KXSI


110 #undeà
__USE_XOPEN2K8


111 #undeà
__USE_XOPEN2K8XSI


112 #undeà
__USE_LARGEFILE


113 #undeà
__USE_LARGEFILE64


114 #undeà
__USE_FILE_OFFSET64


115 #undeà
__USE_MISC


116 #undeà
__USE_ATFILE


117 #undeà
__USE_GNU


118 #undeà
__USE_REENTRANT


119 #undeà
__USE_FORTIFY_LEVEL


120 #undeà
__KERNEL_STRICT_NAMES


124 #iâdeà
_LOOSE_KERNEL_NAMES


125 
	#__KERNEL_STRICT_NAMES


	)

135 #ià
defšed
 
__GNUC__
 && defšed 
__GNUC_MINOR__


136 
	#__GNUC_PREREQ
(
maj
, 
mš
) \

137 ((
__GNUC__
 << 16è+ 
__GNUC_MINOR__
 >ð((
maj
è<< 16è+ (
mš
))

	)

139 
	#__GNUC_PREREQ
(
maj
, 
mš
è0

	)

146 #ià(
defšed
 
_BSD_SOURCE
 || defšed 
_SVID_SOURCE
) \

147 && !
defšed
 
	g_DEFAULT_SOURCE


152 #undeà
_DEFAULT_SOURCE


153 
	#_DEFAULT_SOURCE
 1

	)

157 #ifdeà
_GNU_SOURCE


158 #undeà
_ISOC95_SOURCE


159 
	#_ISOC95_SOURCE
 1

	)

160 #undeà
_ISOC99_SOURCE


161 
	#_ISOC99_SOURCE
 1

	)

162 #undeà
_ISOC11_SOURCE


163 
	#_ISOC11_SOURCE
 1

	)

164 #undeà
_POSIX_SOURCE


165 
	#_POSIX_SOURCE
 1

	)

166 #undeà
_POSIX_C_SOURCE


167 
	#_POSIX_C_SOURCE
 200809L

	)

168 #undeà
_XOPEN_SOURCE


169 
	#_XOPEN_SOURCE
 700

	)

170 #undeà
_XOPEN_SOURCE_EXTENDED


171 
	#_XOPEN_SOURCE_EXTENDED
 1

	)

172 #undeà
_LARGEFILE64_SOURCE


173 
	#_LARGEFILE64_SOURCE
 1

	)

174 #undeà
_DEFAULT_SOURCE


175 
	#_DEFAULT_SOURCE
 1

	)

176 #undeà
_ATFILE_SOURCE


177 
	#_ATFILE_SOURCE
 1

	)

182 #ià(
defšed
 
_DEFAULT_SOURCE
 \

183 || (!
defšed
 
	g__STRICT_ANSI__
 \

184 && !
defšed
 
	g_ISOC99_SOURCE
 \

185 && !
defšed
 
	g_POSIX_SOURCE
 && !defšed 
	g_POSIX_C_SOURCE
 \

186 && !
defšed
 
	g_XOPEN_SOURCE
))

187 #undeà
_DEFAULT_SOURCE


188 
	#_DEFAULT_SOURCE
 1

	)

192 #ià(
defšed
 
_ISOC11_SOURCE
 \

193 || (
defšed
 
	g__STDC_VERSION__
 && __STDC_VERSION__ >= 201112L))

194 
	#__USE_ISOC11
 1

	)

198 #ià(
defšed
 
_ISOC99_SOURCE
 || defšed 
_ISOC11_SOURCE
 \

199 || (
defšed
 
__STDC_VERSION__
 && __STDC_VERSION__ >= 199901L))

200 
	#__USE_ISOC99
 1

	)

204 #ià(
defšed
 
_ISOC99_SOURCE
 || defšed 
_ISOC11_SOURCE
 \

205 || (
defšed
 
__STDC_VERSION__
 && __STDC_VERSION__ >= 199409L))

206 
	#__USE_ISOC95
 1

	)

213 #ià((
defšed
 
__ýlu¥lus
 && __cplusplus >= 201103L) \

214 || 
defšed
 
__GXX_EXPERIMENTAL_CXX0X__
)

215 
	#__USE_ISOCXX11
 1

	)

221 #ifdeà
_DEFAULT_SOURCE


222 #ià!
defšed
 
_POSIX_SOURCE
 && !defšed 
_POSIX_C_SOURCE


223 
	#__USE_POSIX_IMPLICITLY
 1

	)

225 #undeà
_POSIX_SOURCE


226 
	#_POSIX_SOURCE
 1

	)

227 #undeà
_POSIX_C_SOURCE


228 
	#_POSIX_C_SOURCE
 200809L

	)

230 #ià((!
defšed
 
__STRICT_ANSI__
 \

231 || (
defšed
 
_XOPEN_SOURCE
 && (_XOPEN_SOURCE - 0) >= 500)) \

232 && !
defšed
 
_POSIX_SOURCE
 && !defšed 
_POSIX_C_SOURCE
)

233 
	#_POSIX_SOURCE
 1

	)

234 #ià
defšed
 
_XOPEN_SOURCE
 && (_XOPEN_SOURCE - 0) < 500

235 
	#_POSIX_C_SOURCE
 2

	)

236 #–ià
defšed
 
_XOPEN_SOURCE
 && (_XOPEN_SOURCE - 0) < 600

237 
	#_POSIX_C_SOURCE
 199506L

	)

238 #–ià
defšed
 
_XOPEN_SOURCE
 && (_XOPEN_SOURCE - 0) < 700

239 
	#_POSIX_C_SOURCE
 200112L

	)

241 
	#_POSIX_C_SOURCE
 200809L

	)

243 
	#__USE_POSIX_IMPLICITLY
 1

	)

246 #ià(
defšed
 
_POSIX_SOURCE
 \

247 || (
defšed
 
_POSIX_C_SOURCE
 && _POSIX_C_SOURCE >= 1) \

248 || 
defšed
 
_XOPEN_SOURCE
)

249 
	#__USE_POSIX
 1

	)

252 #ià
defšed
 
_POSIX_C_SOURCE
 && _POSIX_C_SOURCE >ð2 || defšed 
_XOPEN_SOURCE


253 
	#__USE_POSIX2
 1

	)

256 #ià
defšed
 
_POSIX_C_SOURCE
 && (_POSIX_C_SOURCE - 0) >= 199309L

257 
	#__USE_POSIX199309
 1

	)

260 #ià
defšed
 
_POSIX_C_SOURCE
 && (_POSIX_C_SOURCE - 0) >= 199506L

261 
	#__USE_POSIX199506
 1

	)

264 #ià
defšed
 
_POSIX_C_SOURCE
 && (_POSIX_C_SOURCE - 0) >= 200112L

265 
	#__USE_XOPEN2K
 1

	)

266 #undeà
__USE_ISOC95


267 
	#__USE_ISOC95
 1

	)

268 #undeà
__USE_ISOC99


269 
	#__USE_ISOC99
 1

	)

272 #ià
defšed
 
_POSIX_C_SOURCE
 && (_POSIX_C_SOURCE - 0) >= 200809L

273 
	#__USE_XOPEN2K8
 1

	)

274 #undeà
_ATFILE_SOURCE


275 
	#_ATFILE_SOURCE
 1

	)

278 #ifdef 
_XOPEN_SOURCE


279 
	#__USE_XOPEN
 1

	)

280 #ià(
_XOPEN_SOURCE
 - 0) >= 500

281 
	#__USE_XOPEN_EXTENDED
 1

	)

282 
	#__USE_UNIX98
 1

	)

283 #undeà
_LARGEFILE_SOURCE


284 
	#_LARGEFILE_SOURCE
 1

	)

285 #ià(
_XOPEN_SOURCE
 - 0) >= 600

286 #ià(
_XOPEN_SOURCE
 - 0) >= 700

287 
	#__USE_XOPEN2K8
 1

	)

288 
	#__USE_XOPEN2K8XSI
 1

	)

290 
	#__USE_XOPEN2K
 1

	)

291 
	#__USE_XOPEN2KXSI
 1

	)

292 #undeà
__USE_ISOC95


293 
	#__USE_ISOC95
 1

	)

294 #undeà
__USE_ISOC99


295 
	#__USE_ISOC99
 1

	)

298 #ifdeà
_XOPEN_SOURCE_EXTENDED


299 
	#__USE_XOPEN_EXTENDED
 1

	)

304 #ifdeà
_LARGEFILE_SOURCE


305 
	#__USE_LARGEFILE
 1

	)

308 #ifdeà
_LARGEFILE64_SOURCE


309 
	#__USE_LARGEFILE64
 1

	)

312 #ià
defšed
 
_FILE_OFFSET_BITS
 && _FILE_OFFSET_BITS == 64

313 
	#__USE_FILE_OFFSET64
 1

	)

316 #ià
defšed
 
_DEFAULT_SOURCE


317 
	#__USE_MISC
 1

	)

320 #ifdef 
_ATFILE_SOURCE


321 
	#__USE_ATFILE
 1

	)

324 #ifdef 
_GNU_SOURCE


325 
	#__USE_GNU
 1

	)

328 #ià
defšed
 
_REENTRANT
 || defšed 
_THREAD_SAFE


329 
	#__USE_REENTRANT
 1

	)

332 #ià
defšed
 
_FORTIFY_SOURCE
 && _FORTIFY_SOURCE > 0 \

333 && 
__GNUC_PREREQ
 (4, 1è&& 
defšed
 
	g__OPTIMIZE__
 && __OPTIMIZE__ > 0

334 #ià
_FORTIFY_SOURCE
 > 1

335 
	#__USE_FORTIFY_LEVEL
 2

	)

337 
	#__USE_FORTIFY_LEVEL
 1

	)

340 
	#__USE_FORTIFY_LEVEL
 0

	)

345 
	~<¡dc-´edef.h
>

353 #undeà
__GNU_LIBRARY__


354 
	#__GNU_LIBRARY__
 6

	)

358 
	#__GLIBC__
 2

	)

359 
	#__GLIBC_MINOR__
 23

	)

361 
	#__GLIBC_PREREQ
(
maj
, 
mš
) \

362 ((
__GLIBC__
 << 16è+ 
__GLIBC_MINOR__
 >ð((
maj
è<< 16è+ (
mš
))

	)

365 #iâdeà
__ASSEMBLER__


366 #iâdeà
_SYS_CDEFS_H


367 
	~<sys/cdefs.h
>

372 #ià
defšed
 
__USE_FILE_OFFSET64
 && !defšed 
__REDIRECT


373 
	#__USE_LARGEFILE
 1

	)

374 
	#__USE_LARGEFILE64
 1

	)

380 #ià
__GNUC_PREREQ
 (2, 7è&& 
defšed
 
__OPTIMIZE__
 \

381 && !
defšed
 
	g__OPTIMIZE_SIZE__
 && !defšed 
	g__NO_INLINE__
 \

382 && 
defšed
 
	g__ex‹º_šlše


383 
	#__USE_EXTERN_INLINES
 1

	)

391 
	~<gnu/¡ubs.h
>

	@/usr/include/getopt.h

19 #iâdeà
_GETOPT_H


21 #iâdeà
__Ãed_g‘Ýt


22 
	#_GETOPT_H
 1

	)

32 #ià!
defšed
 
__GNU_LIBRARY__


33 
	~<ùy³.h
>

36 #iâdeà
__THROW


37 #iâdeà
__GNUC_PREREQ


38 
	#__GNUC_PREREQ
(
maj
, 
mš
è(0)

	)

40 #ià
defšed
 
__ýlu¥lus
 && 
__GNUC_PREREQ
 (2,8)

41 
	#__THROW
 
	`throw
 ()

	)

43 
	#__THROW


	)

47 #ifdef 
__ýlu¥lus


57 *
Ýrg
;

71 
Ýtšd
;

76 
Ý‹¼
;

80 
ÝtÝt
;

82 #iâdeà
__Ãed_g‘Ýt


104 
	sÝtiÚ


106 cÚ¡ *
	gÇme
;

109 
	ghas_¬g
;

110 *
	gæag
;

111 
	gv®
;

116 
	#no_¬gum’t
 0

	)

117 
	#»quœed_¬gum’t
 1

	)

118 
	#ÝtiÚ®_¬gum’t
 2

	)

146 #ifdeà
__GNU_LIBRARY__


150 
g‘Ýt
 (
___¬gc
, *cÚ¡ *
___¬gv
, cÚ¡ *
__shÜtÝts
)

151 
__THROW
;

153 #ià
defšed
 
__Ãed_g‘Ýt
 && defšed 
__USE_POSIX2
 \

154 && !
defšed
 
	g__USE_POSIX_IMPLICITLY
 && !defšed 
	g__USE_GNU


158 #ifdeà
__REDIRECT


159 
__REDIRECT_NTH
 (
g‘Ýt
, (
___¬gc
, *cÚ¡ *
___¬gv
,

160 cÚ¡ *
__shÜtÝts
),

161 
__posix_g‘Ýt
);

163 
__posix_g‘Ýt
 (
___¬gc
, *cÚ¡ *
___¬gv
,

164 cÚ¡ *
__shÜtÝts
è
__THROW
;

165 
	#g‘Ýt
 
__posix_g‘Ýt


	)

169 
g‘Ýt
 ();

172 #iâdeà
__Ãed_g‘Ýt


173 
g‘Ýt_lÚg
 (
___¬gc
, *cÚ¡ *
___¬gv
,

174 cÚ¡ *
__shÜtÝts
,

175 cÚ¡ 
ÝtiÚ
 *
__lÚgÝts
, *
__lÚgšd
)

176 
__THROW
;

177 
g‘Ýt_lÚg_Úly
 (
___¬gc
, *cÚ¡ *
___¬gv
,

178 cÚ¡ *
__shÜtÝts
,

179 cÚ¡ 
ÝtiÚ
 *
__lÚgÝts
, *
__lÚgšd
)

180 
__THROW
;

184 #ifdef 
__ýlu¥lus


189 #undeà
__Ãed_g‘Ýt


	@/usr/include/libio.h

28 #iâdeà
_IO_STDIO_H


29 
	#_IO_STDIO_H


	)

31 
	~<_G_cÚfig.h
>

33 
	#_IO_åos_t
 
_G_åos_t


	)

34 
	#_IO_åos64_t
 
_G_åos64_t


	)

35 
	#_IO_size_t
 
size_t


	)

36 
	#_IO_ssize_t
 
__ssize_t


	)

37 
	#_IO_off_t
 
__off_t


	)

38 
	#_IO_off64_t
 
__off64_t


	)

39 
	#_IO_pid_t
 
__pid_t


	)

40 
	#_IO_uid_t
 
__uid_t


	)

41 
	#_IO_icÚv_t
 
_G_icÚv_t


	)

42 
	#_IO_HAVE_ST_BLKSIZE
 
_G_HAVE_ST_BLKSIZE


	)

43 
	#_IO_BUFSIZ
 
_G_BUFSIZ


	)

44 
	#_IO_va_li¡
 
_G_va_li¡


	)

45 
	#_IO_wšt_t
 
wšt_t


	)

48 
	#__Ãed___va_li¡


	)

49 
	~<¡d¬g.h
>

50 #ifdeà
__GNUC_VA_LIST


51 #undeà
_IO_va_li¡


52 
	#_IO_va_li¡
 
__gnuc_va_li¡


	)

55 #iâdeà
__P


56 
	~<sys/cdefs.h
>

59 
	#_IO_UNIFIED_JUMPTABLES
 1

	)

61 #iâdeà
EOF


62 
	#EOF
 (-1)

	)

64 #iâdeà
NULL


65 #ià
defšed
 
__GNUG__
 && \

66 (
	g__GNUC__
 > 2 || (__GNUC__ =ð2 && 
__GNUC_MINOR__
 >= 8))

67 
	#NULL
 (
__nuÎ
)

	)

69 #ià!
defšed
(
__ýlu¥lus
)

70 
	#NULL
 ((*)0)

	)

72 
	#NULL
 (0)

	)

77 
	#_IOS_INPUT
 1

	)

78 
	#_IOS_OUTPUT
 2

	)

79 
	#_IOS_ATEND
 4

	)

80 
	#_IOS_APPEND
 8

	)

81 
	#_IOS_TRUNC
 16

	)

82 
	#_IOS_NOCREATE
 32

	)

83 
	#_IOS_NOREPLACE
 64

	)

84 
	#_IOS_BIN
 128

	)

92 
	#_IO_MAGIC
 0xFBAD0000

	)

93 
	#_OLD_STDIO_MAGIC
 0xFABC0000

	)

94 
	#_IO_MAGIC_MASK
 0xFFFF0000

	)

95 
	#_IO_USER_BUF
 1

	)

96 
	#_IO_UNBUFFERED
 2

	)

97 
	#_IO_NO_READS
 4

	)

98 
	#_IO_NO_WRITES
 8

	)

99 
	#_IO_EOF_SEEN
 0x10

	)

100 
	#_IO_ERR_SEEN
 0x20

	)

101 
	#_IO_DELETE_DONT_CLOSE
 0x40

	)

102 
	#_IO_LINKED
 0x80

	)

103 
	#_IO_IN_BACKUP
 0x100

	)

104 
	#_IO_LINE_BUF
 0x200

	)

105 
	#_IO_TIED_PUT_GET
 0x400

	)

106 
	#_IO_CURRENTLY_PUTTING
 0x800

	)

107 
	#_IO_IS_APPENDING
 0x1000

	)

108 
	#_IO_IS_FILEBUF
 0x2000

	)

109 
	#_IO_BAD_SEEN
 0x4000

	)

110 
	#_IO_USER_LOCK
 0x8000

	)

112 
	#_IO_FLAGS2_MMAP
 1

	)

113 
	#_IO_FLAGS2_NOTCANCEL
 2

	)

114 #ifdeà
_LIBC


115 
	#_IO_FLAGS2_FORTIFY
 4

	)

117 
	#_IO_FLAGS2_USER_WBUF
 8

	)

118 #ifdeà
_LIBC


119 
	#_IO_FLAGS2_SCANF_STD
 16

	)

120 
	#_IO_FLAGS2_NOCLOSE
 32

	)

121 
	#_IO_FLAGS2_CLOEXEC
 64

	)

125 
	#_IO_SKIPWS
 01

	)

126 
	#_IO_LEFT
 02

	)

127 
	#_IO_RIGHT
 04

	)

128 
	#_IO_INTERNAL
 010

	)

129 
	#_IO_DEC
 020

	)

130 
	#_IO_OCT
 040

	)

131 
	#_IO_HEX
 0100

	)

132 
	#_IO_SHOWBASE
 0200

	)

133 
	#_IO_SHOWPOINT
 0400

	)

134 
	#_IO_UPPERCASE
 01000

	)

135 
	#_IO_SHOWPOS
 02000

	)

136 
	#_IO_SCIENTIFIC
 04000

	)

137 
	#_IO_FIXED
 010000

	)

138 
	#_IO_UNITBUF
 020000

	)

139 
	#_IO_STDIO
 040000

	)

140 
	#_IO_DONT_CLOSE
 0100000

	)

141 
	#_IO_BOOLALPHA
 0200000

	)

144 
_IO_jump_t
; 
	g_IO_FILE
;

147 #ifdeà
_IO_MTSAFE_IO


150 
	t_IO_lock_t
;

156 
	s_IO_m¬k”
 {

157 
_IO_m¬k”
 *
	m_Ãxt
;

158 
_IO_FILE
 *
	m_sbuf
;

162 
	m_pos
;

164 
£t_¡»ampos
(
¡»ampos
 
¥
è{ 
	m_¥os
 = sp; }

165 
£t_off£t
(
off£t
è{ 
	m_pos
 = off£t; 
	m_¥os
 = (
¡»ampos
)(-2); }

166 
	mpublic
:

167 
¡»amm¬k”
(
¡»ambuf
 *
sb
);

168 ~
¡»amm¬k”
();

169 
§všg
(è{  
	m_¥os
 == -2; }

170 
d–
(
¡»amm¬k”
&);

171 
d–
();

176 
	e__codecvt_»suÉ


178 
	m__codecvt_ok
,

179 
	m__codecvt_·¹Ÿl
,

180 
	m__codecvt_”rÜ
,

181 
	m__codecvt_nocÚv


184 #ià
defšed
 
_LIBC
 || defšed 
_GLIBCPP_USE_WCHAR_T


187 
	s_IO_codecvt


189 (*
	m__codecvt_de¡r
è(
	m_IO_codecvt
 *);

190 
__codecvt_»suÉ
 (*
__codecvt_do_out
è(
	m_IO_codecvt
 *,

191 
	m__mb¡©e_t
 *,

192 cÚ¡ 
	mwch¬_t
 *,

193 cÚ¡ 
	mwch¬_t
 *,

194 cÚ¡ 
	mwch¬_t
 **, *,

196 
__codecvt_»suÉ
 (*
__codecvt_do_unshiá
è(
	m_IO_codecvt
 *,

197 
	m__mb¡©e_t
 *, *,

199 
__codecvt_»suÉ
 (*
__codecvt_do_š
è(
	m_IO_codecvt
 *,

200 
	m__mb¡©e_t
 *,

202 cÚ¡ **, 
	mwch¬_t
 *,

203 
	mwch¬_t
 *, wchar_t **);

204 (*
	m__codecvt_do_’codšg
è(
	m_IO_codecvt
 *);

205 (*
	m__codecvt_do_®ways_nocÚv
è(
	m_IO_codecvt
 *);

206 (*
	m__codecvt_do_Ëngth
è(
	m_IO_codecvt
 *, 
	m__mb¡©e_t
 *,

207 cÚ¡ *, cÚ¡ *, 
	m_IO_size_t
);

208 (*
	m__codecvt_do_max_Ëngth
è(
	m_IO_codecvt
 *);

210 
_IO_icÚv_t
 
	m__cd_š
;

211 
_IO_icÚv_t
 
	m__cd_out
;

215 
	s_IO_wide_d©a


217 
wch¬_t
 *
	m_IO_»ad_±r
;

218 
wch¬_t
 *
	m_IO_»ad_’d
;

219 
wch¬_t
 *
	m_IO_»ad_ba£
;

220 
wch¬_t
 *
	m_IO_wr™e_ba£
;

221 
wch¬_t
 *
	m_IO_wr™e_±r
;

222 
wch¬_t
 *
	m_IO_wr™e_’d
;

223 
wch¬_t
 *
	m_IO_buf_ba£
;

224 
wch¬_t
 *
	m_IO_buf_’d
;

226 
wch¬_t
 *
	m_IO_§ve_ba£
;

227 
wch¬_t
 *
	m_IO_backup_ba£
;

229 
wch¬_t
 *
	m_IO_§ve_’d
;

231 
__mb¡©e_t
 
	m_IO_¡©e
;

232 
__mb¡©e_t
 
	m_IO_Ï¡_¡©e
;

233 
_IO_codecvt
 
	m_codecvt
;

235 
wch¬_t
 
	m_shÜtbuf
[1];

237 cÚ¡ 
_IO_jump_t
 *
	m_wide_vbË
;

241 
	s_IO_FILE
 {

242 
	m_æags
;

243 
	#_IO_fže_æags
 
_æags


	)

247 * 
	m_IO_»ad_±r
;

248 * 
	m_IO_»ad_’d
;

249 * 
	m_IO_»ad_ba£
;

250 * 
	m_IO_wr™e_ba£
;

251 * 
	m_IO_wr™e_±r
;

252 * 
	m_IO_wr™e_’d
;

253 * 
	m_IO_buf_ba£
;

254 * 
	m_IO_buf_’d
;

256 *
	m_IO_§ve_ba£
;

257 *
	m_IO_backup_ba£
;

258 *
	m_IO_§ve_’d
;

260 
_IO_m¬k”
 *
	m_m¬k”s
;

262 
_IO_FILE
 *
	m_chaš
;

264 
	m_fž’o
;

266 
	m_blksize
;

268 
	m_æags2
;

270 
_IO_off_t
 
	m_Þd_off£t
;

272 
	#__HAVE_COLUMN


	)

274 
	m_cur_cÞumn
;

275 sigÃd 
	m_vbË_off£t
;

276 
	m_shÜtbuf
[1];

280 
_IO_lock_t
 *
	m_lock
;

281 #ifdeà
_IO_USE_OLD_IO_FILE


284 
	s_IO_FILE_com¶‘e


286 
_IO_FILE
 
	m_fže
;

288 #ià
defšed
 
_G_IO_IO_FILE_VERSION
 && _G_IO_IO_FILE_VERSION == 0x20001

289 
_IO_off64_t
 
	m_off£t
;

290 #ià
defšed
 
_LIBC
 || defšed 
_GLIBCPP_USE_WCHAR_T


292 
_IO_codecvt
 *
	m_codecvt
;

293 
_IO_wide_d©a
 *
	m_wide_d©a
;

294 
_IO_FILE
 *
	m_ä“»s_li¡
;

295 *
	m_ä“»s_buf
;

297 *
	m__·d1
;

298 *
	m__·d2
;

299 *
	m__·d3
;

300 *
	m__·d4
;

302 
size_t
 
	m__·d5
;

303 
	m_mode
;

305 
	m_unu£d2
[15 *  (è- 4 *  (*è-  (
size_t
)];

309 #iâdeà
__ýlu¥lus


310 
_IO_FILE
 
	t_IO_FILE
;

313 
	g_IO_FILE_¶us
;

315 
_IO_FILE_¶us
 
_IO_2_1_¡dš_
;

316 
_IO_FILE_¶us
 
_IO_2_1_¡dout_
;

317 
_IO_FILE_¶us
 
_IO_2_1_¡d”r_
;

318 #iâdeà
_LIBC


319 
	#_IO_¡dš
 ((
_IO_FILE
*)(&
_IO_2_1_¡dš_
))

	)

320 
	#_IO_¡dout
 ((
_IO_FILE
*)(&
_IO_2_1_¡dout_
))

	)

321 
	#_IO_¡d”r
 ((
_IO_FILE
*)(&
_IO_2_1_¡d”r_
))

	)

323 
_IO_FILE
 *
_IO_¡dš
 
©Œibu‹_hidd’
;

324 
_IO_FILE
 *
_IO_¡dout
 
©Œibu‹_hidd’
;

325 
_IO_FILE
 *
_IO_¡d”r
 
©Œibu‹_hidd’
;

333 
__ssize_t
 
	t__io_»ad_â
 (*
	t__cook›
, *
	t__buf
, 
	tsize_t
 
	t__nby‹s
);

341 
__ssize_t
 
	t__io_wr™e_â
 (*
	t__cook›
, cÚ¡ *
	t__buf
,

342 
	tsize_t
 
	t__n
);

350 
	t__io_£ek_â
 (*
	t__cook›
, 
	t_IO_off64_t
 *
	t__pos
, 
	t__w
);

353 
	t__io_þo£_â
 (*
	t__cook›
);

356 #ifdeà
_GNU_SOURCE


358 
__io_»ad_â
 
	tcook›_»ad_funùiÚ_t
;

359 
__io_wr™e_â
 
	tcook›_wr™e_funùiÚ_t
;

360 
__io_£ek_â
 
	tcook›_£ek_funùiÚ_t
;

361 
__io_þo£_â
 
	tcook›_þo£_funùiÚ_t
;

366 
__io_»ad_â
 *
	m»ad
;

367 
__io_wr™e_â
 *
	mwr™e
;

368 
__io_£ek_â
 *
	m£ek
;

369 
__io_þo£_â
 *
	mþo£
;

370 } 
	t_IO_cook›_io_funùiÚs_t
;

371 
_IO_cook›_io_funùiÚs_t
 
	tcook›_io_funùiÚs_t
;

373 
	g_IO_cook›_fže
;

376 
_IO_cook›_š™
 (
_IO_cook›_fže
 *
__cfže
, 
__»ad_wr™e
,

377 *
__cook›
, 
_IO_cook›_io_funùiÚs_t
 
__âs
);

381 #ifdeà
__ýlu¥lus


385 
__und”æow
 (
_IO_FILE
 *);

386 
__uæow
 (
_IO_FILE
 *);

387 
__ov”æow
 (
_IO_FILE
 *, );

388 #ià
defšed
 
_LIBC
 || defšed 
_GLIBCPP_USE_WCHAR_T


389 
_IO_wšt_t
 
__wund”æow
 (
_IO_FILE
 *);

390 
_IO_wšt_t
 
__wuæow
 (
_IO_FILE
 *);

391 
_IO_wšt_t
 
__wov”æow
 (
_IO_FILE
 *, _IO_wint_t);

394 #ià 
__GNUC__
 >= 3

395 
	#_IO_BE
(
ex´
, 
»s
è
	`__bužtš_ex³ù
 (Óx´),„es)

	)

397 
	#_IO_BE
(
ex´
, 
»s
èÓx´)

	)

400 
	#_IO_g‘c_uÆocked
(
_å
) \

401 (
	`_IO_BE
 ((
_å
)->
_IO_»ad_±r
 >ð(_å)->
_IO_»ad_’d
, 0) \

402 ? 
	`__uæow
 (
_å
è: *(*è(_å)->
_IO_»ad_±r
++)

	)

403 
	#_IO_³ekc_uÆocked
(
_å
) \

404 (
	`_IO_BE
 ((
_å
)->
_IO_»ad_±r
 >ð(_å)->
_IO_»ad_’d
, 0) \

405 && 
	`__und”æow
 (
_å
è=ð
EOF
 ? EOF \

406 : *(*è(
_å
)->
_IO_»ad_±r
)

	)

407 
	#_IO_putc_uÆocked
(
_ch
, 
_å
) \

408 (
	`_IO_BE
 ((
_å
)->
_IO_wr™e_±r
 >ð(_å)->
_IO_wr™e_’d
, 0) \

409 ? 
	`__ov”æow
 (
_å
, (è(
_ch
)) \

410 : (è(*(
_å
)->
_IO_wr™e_±r
++ = (
_ch
)))

	)

412 #ià
defšed
 
_LIBC
 || defšed 
_GLIBCPP_USE_WCHAR_T


413 
	#_IO_g‘wc_uÆocked
(
_å
) \

414 (
	`_IO_BE
 ((
_å
)->
_wide_d©a
 =ð
NULL
 \

415 || ((
_å
)->
_wide_d©a
->
_IO_»ad_±r
 \

416 >ð(
_å
)->
_wide_d©a
->
_IO_»ad_’d
), 0) \

417 ? 
	`__wuæow
 (
_å
è: (
_IO_wšt_t
è*(_å)->
_wide_d©a
->
_IO_»ad_±r
++)

	)

418 
	#_IO_putwc_uÆocked
(
_wch
, 
_å
) \

419 (
	`_IO_BE
 ((
_å
)->
_wide_d©a
 =ð
NULL
 \

420 || ((
_å
)->
_wide_d©a
->
_IO_wr™e_±r
 \

421 >ð(
_å
)->
_wide_d©a
->
_IO_wr™e_’d
), 0) \

422 ? 
	`__wov”æow
 (
_å
, 
_wch
) \

423 : (
_IO_wšt_t
è(*(
_å
)->
_wide_d©a
->
_IO_wr™e_±r
++ = (
_wch
)))

	)

426 
	#_IO_ãof_uÆocked
(
__å
è(((__å)->
_æags
 & 
_IO_EOF_SEEN
è!ð0)

	)

427 
	#_IO_ã¼Ü_uÆocked
(
__å
è(((__å)->
_æags
 & 
_IO_ERR_SEEN
è!ð0)

	)

429 
_IO_g‘c
 (
_IO_FILE
 *
__å
);

430 
_IO_putc
 (
__c
, 
_IO_FILE
 *
__å
);

431 
_IO_ãof
 (
_IO_FILE
 *
__å
è
__THROW
;

432 
_IO_ã¼Ü
 (
_IO_FILE
 *
__å
è
__THROW
;

434 
_IO_³ekc_locked
 (
_IO_FILE
 *
__å
);

437 
	#_IO_PENDING_OUTPUT_COUNT
(
_å
) \

438 ((
_å
)->
_IO_wr™e_±r
 - (_å)->
_IO_wr™e_ba£
)

	)

440 
_IO_æockfže
 (
_IO_FILE
 *è
__THROW
;

441 
_IO_fuÆockfže
 (
_IO_FILE
 *è
__THROW
;

442 
_IO_árylockfže
 (
_IO_FILE
 *è
__THROW
;

444 #ifdeà
_IO_MTSAFE_IO


445 
	#_IO_³ekc
(
_å
è
	`_IO_³ekc_locked
 (_å)

	)

446 
	#_IO_æockfže
(
_å
) \

447 ià(((
_å
)->
_æags
 & 
_IO_USER_LOCK
è=ð0è
	`_IO_æockfže
 (_å)

	)

448 
	#_IO_fuÆockfže
(
_å
) \

449 ià(((
_å
)->
_æags
 & 
_IO_USER_LOCK
è=ð0è
	`_IO_fuÆockfže
 (_å)

	)

451 
	#_IO_³ekc
(
_å
è
	`_IO_³ekc_uÆocked
 (_å)

	)

452 
	#_IO_æockfže
(
_å
è

	)

453 
	#_IO_fuÆockfže
(
_å
è

	)

454 
	#_IO_árylockfže
(
_å
è

	)

455 
	#_IO_þ—nup_»giÚ_¡¬t
(
_fù
, 
_å
è

	)

456 
	#_IO_þ—nup_»giÚ_’d
(
_Do™
è

	)

459 
_IO_vfsÿnf
 (
_IO_FILE
 * 
__»¡riù
, const * __restrict,

460 
_IO_va_li¡
, *
__»¡riù
);

461 
_IO_vårštf
 (
_IO_FILE
 *
__»¡riù
, const *__restrict,

462 
_IO_va_li¡
);

463 
_IO_ssize_t
 
_IO_·dn
 (
_IO_FILE
 *, , _IO_ssize_t);

464 
_IO_size_t
 
_IO_sg‘n
 (
_IO_FILE
 *, *, _IO_size_t);

466 
_IO_off64_t
 
_IO_£ekoff
 (
_IO_FILE
 *, _IO_off64_t, , );

467 
_IO_off64_t
 
_IO_£ekpos
 (
_IO_FILE
 *, _IO_off64_t, );

469 
_IO_ä“_backup_¬—
 (
_IO_FILE
 *è
__THROW
;

471 #ià
defšed
 
_LIBC
 || defšed 
_GLIBCPP_USE_WCHAR_T


472 
_IO_wšt_t
 
_IO_g‘wc
 (
_IO_FILE
 *
__å
);

473 
_IO_wšt_t
 
_IO_putwc
 (
wch¬_t
 
__wc
, 
_IO_FILE
 *
__å
);

474 
_IO_fwide
 (
_IO_FILE
 *
__å
, 
__mode
è
__THROW
;

475 #ià
__GNUC__
 >= 2

478 #ià
defšed
 
_LIBC
 && defšed 
SHARED


479 
	~<shlib-com·t.h
>

480 #ià
SHLIB_COMPAT
 (
libc
, 
GLIBC_2_0
, 
GLIBC_2_1
)

481 
	#_IO_fwide_maybe_šcom·tibË
 \

482 (
	`__bužtš_ex³ù
 (&
_IO_¡dš_u£d
 =ð
NULL
, 0))

	)

483 cÚ¡ 
_IO_¡dš_u£d
;

484 
w—k_ex‹º
 (
_IO_¡dš_u£d
);

487 #iâdeà
_IO_fwide_maybe_šcom·tibË


488 
	#_IO_fwide_maybe_šcom·tibË
 (0)

	)

492 
	#_IO_fwide
(
__å
, 
__mode
) \

493 ({ 
__»suÉ
 = (
__mode
); \

494 ià(
__»suÉ
 < 0 && ! 
_IO_fwide_maybe_šcom·tibË
) \

496 ià((
__å
)->
_mode
 == 0) \

498 (
__å
)->
_mode
 = -1; \

499 
__»suÉ
 = (
__å
)->
_mode
; \

501 ià(
	`__bužtš_cÚ¡ªt_p
 (
__mode
) && (__mode) == 0) \

502 
__»suÉ
 = 
_IO_fwide_maybe_šcom·tibË
 ? -1 : (
__å
)->
_mode
; \

504 
__»suÉ
 = 
	`_IO_fwide
 (
__å
, __result); \

505 
__»suÉ
; })

	)

508 
_IO_vfwsÿnf
 (
_IO_FILE
 * 
__»¡riù
, cÚ¡ 
wch¬_t
 * __restrict,

509 
_IO_va_li¡
, *
__»¡riù
);

510 
_IO_vfw´štf
 (
_IO_FILE
 *
__»¡riù
, cÚ¡ 
wch¬_t
 *__restrict,

511 
_IO_va_li¡
);

512 
_IO_ssize_t
 
_IO_w·dn
 (
_IO_FILE
 *, 
wšt_t
, _IO_ssize_t);

513 
_IO_ä“_wbackup_¬—
 (
_IO_FILE
 *è
__THROW
;

516 #ifdeà
__LDBL_COMPAT


517 
	~<b™s/libio-ldbl.h
>

520 #ifdeà
__ýlu¥lus


	@/usr/include/linux/ioctl.h

1 #iâdeà
_LINUX_IOCTL_H


2 
	#_LINUX_IOCTL_H


	)

4 
	~<asm/ioùl.h
>

	@/usr/include/linux/limits.h

1 #iâdeà
_LINUX_LIMITS_H


2 
	#_LINUX_LIMITS_H


	)

4 
	#NR_OPEN
 1024

	)

6 
	#NGROUPS_MAX
 65536

	)

7 
	#ARG_MAX
 131072

	)

8 
	#LINK_MAX
 127

	)

9 
	#MAX_CANON
 255

	)

10 
	#MAX_INPUT
 255

	)

11 
	#NAME_MAX
 255

	)

12 
	#PATH_MAX
 4096

	)

13 
	#PIPE_BUF
 4096

	)

14 
	#XATTR_NAME_MAX
 255

	)

15 
	#XATTR_SIZE_MAX
 65536

	)

16 
	#XATTR_LIST_MAX
 65536

	)

18 
	#RTSIG_MAX
 32

	)

	@/usr/include/linux/sysinfo.h

1 #iâdeà
_LINUX_SYSINFO_H


2 
	#_LINUX_SYSINFO_H


	)

4 
	~<lšux/ty³s.h
>

6 
	#SI_LOAD_SHIFT
 16

	)

7 
	ssysšfo
 {

8 
__k”Ãl_lÚg_t
 
	mu±ime
;

9 
__k”Ãl_ulÚg_t
 
	mlßds
[3];

10 
__k”Ãl_ulÚg_t
 
	mtÙ®¿m
;

11 
__k”Ãl_ulÚg_t
 
	mä“¿m
;

12 
__k”Ãl_ulÚg_t
 
	msh¬ed¿m
;

13 
__k”Ãl_ulÚg_t
 
	mbufã¼am
;

14 
__k”Ãl_ulÚg_t
 
	mtÙ®sw­
;

15 
__k”Ãl_ulÚg_t
 
	mä“sw­
;

16 
__u16
 
	m´ocs
;

17 
__u16
 
	m·d
;

18 
__k”Ãl_ulÚg_t
 
	mtÙ®high
;

19 
__k”Ãl_ulÚg_t
 
	mä“high
;

20 
__u32
 
	mmem_un™
;

21 
	m_f
[20-2*(
__k”Ãl_ulÚg_t
)-(
__u32
)];

	@/usr/include/linux/types.h

1 #iâdeà
_LINUX_TYPES_H


2 
	#_LINUX_TYPES_H


	)

4 
	~<asm/ty³s.h
>

6 #iâdeà
__ASSEMBLY__


8 
	~<lšux/posix_ty³s.h
>

16 #ifdeà
__CHECKER__


17 
	#__b™wi£__
 
	`__©Œibu‹__
((
b™wi£
))

	)

19 
	#__b™wi£__


	)

21 #ifdeà
__CHECK_ENDIAN__


22 
	#__b™wi£
 
__b™wi£__


	)

24 
	#__b™wi£


	)

27 
__u16
 
	t__b™wi£
 
	t__Ë16
;

28 
__u16
 
	t__b™wi£
 
	t__be16
;

29 
__u32
 
	t__b™wi£
 
	t__Ë32
;

30 
__u32
 
	t__b™wi£
 
	t__be32
;

31 
__u64
 
	t__b™wi£
 
	t__Ë64
;

32 
__u64
 
	t__b™wi£
 
	t__be64
;

34 
__u16
 
	t__b™wi£
 
	t__sum16
;

35 
__u32
 
	t__b™wi£
 
	t__wsum
;

46 
	#__®igÃd_u64
 
__u64
 
	`__©Œibu‹__
((
	`®igÃd
(8)))

	)

47 
	#__®igÃd_be64
 
__be64
 
	`__©Œibu‹__
((
	`®igÃd
(8)))

	)

48 
	#__®igÃd_Ë64
 
__Ë64
 
	`__©Œibu‹__
((
	`®igÃd
(8)))

	)

	@/usr/include/sys/select.h

21 #iâdeà
_SYS_SELECT_H


22 
	#_SYS_SELECT_H
 1

	)

24 
	~<ã©u»s.h
>

27 
	~<b™s/ty³s.h
>

30 
	~<b™s/£Ëù.h
>

33 
	~<b™s/sig£t.h
>

35 #iâdeà
__sig£t_t_defšed


36 
	#__sig£t_t_defšed


	)

37 
__sig£t_t
 
	tsig£t_t
;

41 
	#__Ãed_time_t


	)

42 
	#__Ãed_time¥ec


	)

43 
	~<time.h
>

44 
	#__Ãed_timev®


	)

45 
	~<b™s/time.h
>

47 #iâdeà
__su£cÚds_t_defšed


48 
__su£cÚds_t
 
	tsu£cÚds_t
;

49 
	#__su£cÚds_t_defšed


	)

54 
	t__fd_mask
;

57 #undeà
__NFDBITS


59 
	#__NFDBITS
 (8 * (è (
__fd_mask
))

	)

60 
	#__FD_ELT
(
d
è((dè/ 
__NFDBITS
)

	)

61 
	#__FD_MASK
(
d
è((
__fd_mask
è(1UL << ((dè% 
__NFDBITS
)))

	)

68 #ifdeà
__USE_XOPEN


69 
__fd_mask
 
	mfds_b™s
[
__FD_SETSIZE
 / 
__NFDBITS
];

70 
	#__FDS_BITS
(
£t
è((£t)->
fds_b™s
)

	)

72 
__fd_mask
 
	m__fds_b™s
[
__FD_SETSIZE
 / 
__NFDBITS
];

73 
	#__FDS_BITS
(
£t
è((£t)->
__fds_b™s
)

	)

75 } 
	tfd_£t
;

78 
	#FD_SETSIZE
 
__FD_SETSIZE


	)

80 #ifdeà
__USE_MISC


82 
__fd_mask
 
	tfd_mask
;

85 
	#NFDBITS
 
__NFDBITS


	)

90 
	#FD_SET
(
fd
, 
fd£
è
	`__FD_SET
 (fd, fd£)

	)

91 
	#FD_CLR
(
fd
, 
fd£
è
	`__FD_CLR
 (fd, fd£)

	)

92 
	#FD_ISSET
(
fd
, 
fd£
è
	`__FD_ISSET
 (fd, fd£)

	)

93 
	#FD_ZERO
(
fd£
è
	`__FD_ZERO
 (fd£)

	)

96 
__BEGIN_DECLS


106 
£Ëù
 (
__nfds
, 
fd_£t
 *
__»¡riù
 
__»adfds
,

107 
fd_£t
 *
__»¡riù
 
__wr™efds
,

108 
fd_£t
 *
__»¡riù
 
__exû±fds
,

109 
timev®
 *
__»¡riù
 
__timeout
);

111 #ifdeà
__USE_XOPEN2K


118 
p£Ëù
 (
__nfds
, 
fd_£t
 *
__»¡riù
 
__»adfds
,

119 
fd_£t
 *
__»¡riù
 
__wr™efds
,

120 
fd_£t
 *
__»¡riù
 
__exû±fds
,

121 cÚ¡ 
time¥ec
 *
__»¡riù
 
__timeout
,

122 cÚ¡ 
__sig£t_t
 *
__»¡riù
 
__sigmask
);

127 #ià
__USE_FORTIFY_LEVEL
 > 0 && 
defšed
 
__GNUC__


128 
	~<b™s/£Ëù2.h
>

131 
	g__END_DECLS


	@/usr/include/sys/sysmacros.h

19 #iâdeà
_SYS_SYSMACROS_H


20 
	#_SYS_SYSMACROS_H
 1

	)

22 
	~<ã©u»s.h
>

24 
__BEGIN_DECLS


26 
__ex‹nsiÚ__


27 
	$gnu_dev_majÜ
 (
__dev
)

28 
__THROW
 
__©Œibu‹_cÚ¡__
;

29 
__ex‹nsiÚ__


30 
	$gnu_dev_mšÜ
 (
__dev
)

31 
__THROW
 
__©Œibu‹_cÚ¡__
;

32 
__ex‹nsiÚ__


33 
	$gnu_dev_makedev
 (
__majÜ
,

34 
__mšÜ
)

35 
__THROW
 
__©Œibu‹_cÚ¡__
;

37 #ifdeà
__USE_EXTERN_INLINES


38 
__ex‹nsiÚ__
 
__ex‹º_šlše
 
__©Œibu‹_cÚ¡__
 

39 
	`__NTH
 (
	$gnu_dev_majÜ
 (
__dev
))

41  ((
__dev
 >> 8) & 0xfff) | (() (__dev >> 32) & ~0xfff);

42 
	}
}

44 
__ex‹nsiÚ__
 
__ex‹º_šlše
 
__©Œibu‹_cÚ¡__
 

45 
__NTH
 (
	$gnu_dev_mšÜ
 (
__dev
))

47  (
__dev
 & 0xff) | (() (__dev >> 12) & ~0xff);

48 
	}
}

50 
__ex‹nsiÚ__
 
__ex‹º_šlše
 
__©Œibu‹_cÚ¡__
 

51 
__NTH
 (
	$gnu_dev_makedev
 (
__majÜ
, 
__mšÜ
))

53  ((
__mšÜ
 & 0xffè| ((
__majÜ
 & 0xfff) << 8)

54 | (((è(
__mšÜ
 & ~0xff)) << 12)

55 | (((è(
__majÜ
 & ~0xfff)) << 32));

56 
	}
}

58 
	g__END_DECLS


61 
	#majÜ
(
dev
è
	`gnu_dev_majÜ
 (dev)

	)

62 
	#mšÜ
(
dev
è
	`gnu_dev_mšÜ
 (dev)

	)

63 
	#makedev
(
maj
, 
mš
è
	`gnu_dev_makedev
 (maj, mš)

	)

	@/usr/include/sys/ttydefaults.h

40 #iâdeà
_SYS_TTYDEFAULTS_H_


41 
	#_SYS_TTYDEFAULTS_H_


	)

46 
	#TTYDEF_IFLAG
 (
BRKINT
 | 
ISTRIP
 | 
ICRNL
 | 
IMAXBEL
 | 
IXON
 | 
IXANY
)

	)

47 
	#TTYDEF_OFLAG
 (
OPOST
 | 
ONLCR
 | 
XTABS
)

	)

48 
	#TTYDEF_LFLAG
 (
ECHO
 | 
ICANON
 | 
ISIG
 | 
IEXTEN
 | 
ECHOE
|
ECHOKE
|
ECHOCTL
)

	)

49 
	#TTYDEF_CFLAG
 (
CREAD
 | 
CS7
 | 
PARENB
 | 
HUPCL
)

	)

50 
	#TTYDEF_SPEED
 (
B9600
)

	)

55 
	#CTRL
(
x
è(x&037)

	)

56 
	#CEOF
 
	`CTRL
('d')

	)

57 #ifdeà
_POSIX_VDISABLE


58 
	#CEOL
 
_POSIX_VDISABLE


	)

60 
	#CEOL
 '\0'

	)

62 
	#CERASE
 0177

	)

63 
	#CINTR
 
	`CTRL
('c')

	)

64 #ifdeà
_POSIX_VDISABLE


65 
	#CSTATUS
 
_POSIX_VDISABLE


	)

67 
	#CSTATUS
 '\0'

	)

69 
	#CKILL
 
	`CTRL
('u')

	)

70 
	#CMIN
 1

	)

71 
	#CQUIT
 034

	)

72 
	#CSUSP
 
	`CTRL
('z')

	)

73 
	#CTIME
 0

	)

74 
	#CDSUSP
 
	`CTRL
('y')

	)

75 
	#CSTART
 
	`CTRL
('q')

	)

76 
	#CSTOP
 
	`CTRL
('s')

	)

77 
	#CLNEXT
 
	`CTRL
('v')

	)

78 
	#CDISCARD
 
	`CTRL
('o')

	)

79 
	#CWERASE
 
	`CTRL
('w')

	)

80 
	#CREPRINT
 
	`CTRL
('r')

	)

81 
	#CEOT
 
CEOF


	)

83 
	#CBRK
 
CEOL


	)

84 
	#CRPRNT
 
CREPRINT


	)

85 
	#CFLUSH
 
CDISCARD


	)

93 #ifdeà
TTYDEFCHARS


94 
cc_t
 
	g‰ydefch¬s
[
NCCS
] = {

95 
CEOF
, 
CEOL
, CEOL, 
CERASE
, 
CWERASE
, 
CKILL
, 
CREPRINT
,

96 
_POSIX_VDISABLE
, 
CINTR
, 
CQUIT
, 
CSUSP
, 
CDSUSP
, 
CSTART
, 
CSTOP
, 
CLNEXT
,

97 
CDISCARD
, 
CMIN
, 
CTIME
, 
CSTATUS
, 
_POSIX_VDISABLE


99 #undeà
TTYDEFCHARS


	@/usr/include/sys/ucontext.h

18 #iâdeà
_SYS_UCONTEXT_H


19 
	#_SYS_UCONTEXT_H
 1

	)

21 
	~<ã©u»s.h
>

22 
	~<sigÇl.h
>

26 
	~<b™s/sigcÚ‹xt.h
>

28 #ifdeà
__x86_64__


31 
__ex‹nsiÚ__
 
	tg»g_t
;

34 
	#NGREG
 23

	)

37 
g»g_t
 
	tg»g£t_t
[
NGREG
];

39 #ifdeà
__USE_GNU


43 
	mREG_R8
 = 0,

44 
	#REG_R8
 
REG_R8


	)

45 
	mREG_R9
,

46 
	#REG_R9
 
REG_R9


	)

47 
	mREG_R10
,

48 
	#REG_R10
 
REG_R10


	)

49 
	mREG_R11
,

50 
	#REG_R11
 
REG_R11


	)

51 
	mREG_R12
,

52 
	#REG_R12
 
REG_R12


	)

53 
	mREG_R13
,

54 
	#REG_R13
 
REG_R13


	)

55 
	mREG_R14
,

56 
	#REG_R14
 
REG_R14


	)

57 
	mREG_R15
,

58 
	#REG_R15
 
REG_R15


	)

59 
	mREG_RDI
,

60 
	#REG_RDI
 
REG_RDI


	)

61 
	mREG_RSI
,

62 
	#REG_RSI
 
REG_RSI


	)

63 
	mREG_RBP
,

64 
	#REG_RBP
 
REG_RBP


	)

65 
	mREG_RBX
,

66 
	#REG_RBX
 
REG_RBX


	)

67 
	mREG_RDX
,

68 
	#REG_RDX
 
REG_RDX


	)

69 
	mREG_RAX
,

70 
	#REG_RAX
 
REG_RAX


	)

71 
	mREG_RCX
,

72 
	#REG_RCX
 
REG_RCX


	)

73 
	mREG_RSP
,

74 
	#REG_RSP
 
REG_RSP


	)

75 
	mREG_RIP
,

76 
	#REG_RIP
 
REG_RIP


	)

77 
	mREG_EFL
,

78 
	#REG_EFL
 
REG_EFL


	)

79 
	mREG_CSGSFS
,

80 
	#REG_CSGSFS
 
REG_CSGSFS


	)

81 
	mREG_ERR
,

82 
	#REG_ERR
 
REG_ERR


	)

83 
	mREG_TRAPNO
,

84 
	#REG_TRAPNO
 
REG_TRAPNO


	)

85 
	mREG_OLDMASK
,

86 
	#REG_OLDMASK
 
REG_OLDMASK


	)

87 
	mREG_CR2


88 
	#REG_CR2
 
REG_CR2


	)

92 
	s_libc_åx»g


94 
	msignifiÿnd
[4];

95 
	mexpÚ’t
;

96 
	m·ddšg
[3];

99 
	s_libc_xmm»g


101 
__ušt32_t
 
	m–em’t
[4];

104 
	s_libc_å¡©e


107 
__ušt16_t
 
	mcwd
;

108 
__ušt16_t
 
	mswd
;

109 
__ušt16_t
 
	máw
;

110 
__ušt16_t
 
	mfÝ
;

111 
__ušt64_t
 
	mr
;

112 
__ušt64_t
 
	mrdp
;

113 
__ušt32_t
 
	mmxc¤
;

114 
__ušt32_t
 
	mmxü_mask
;

115 
_libc_åx»g
 
	m_¡
[8];

116 
_libc_xmm»g
 
	m_xmm
[16];

117 
__ušt32_t
 
	m·ddšg
[24];

121 
_libc_å¡©e
 *
	tå»g£t_t
;

126 
g»g£t_t
 
	mg»gs
;

128 
å»g£t_t
 
	må»gs
;

129 
__ex‹nsiÚ__
 
	m__»£rved1
 [8];

130 } 
	tmcÚ‹xt_t
;

133 
	sucÚ‹xt


135 
	muc_æags
;

136 
ucÚ‹xt
 *
	muc_lšk
;

137 
¡ack_t
 
	muc_¡ack
;

138 
mcÚ‹xt_t
 
	muc_mcÚ‹xt
;

139 
__sig£t_t
 
	muc_sigmask
;

140 
_libc_å¡©e
 
	m__å»gs_mem
;

141 } 
	tucÚ‹xt_t
;

146 
	tg»g_t
;

149 
	#NGREG
 19

	)

152 
g»g_t
 
	tg»g£t_t
[
NGREG
];

154 #ifdeà
__USE_GNU


158 
	mREG_GS
 = 0,

159 
	#REG_GS
 
REG_GS


	)

160 
	mREG_FS
,

161 
	#REG_FS
 
REG_FS


	)

162 
	mREG_ES
,

163 
	#REG_ES
 
REG_ES


	)

164 
	mREG_DS
,

165 
	#REG_DS
 
REG_DS


	)

166 
	mREG_EDI
,

167 
	#REG_EDI
 
REG_EDI


	)

168 
	mREG_ESI
,

169 
	#REG_ESI
 
REG_ESI


	)

170 
	mREG_EBP
,

171 
	#REG_EBP
 
REG_EBP


	)

172 
	mREG_ESP
,

173 
	#REG_ESP
 
REG_ESP


	)

174 
	mREG_EBX
,

175 
	#REG_EBX
 
REG_EBX


	)

176 
	mREG_EDX
,

177 
	#REG_EDX
 
REG_EDX


	)

178 
	mREG_ECX
,

179 
	#REG_ECX
 
REG_ECX


	)

180 
	mREG_EAX
,

181 
	#REG_EAX
 
REG_EAX


	)

182 
	mREG_TRAPNO
,

183 
	#REG_TRAPNO
 
REG_TRAPNO


	)

184 
	mREG_ERR
,

185 
	#REG_ERR
 
REG_ERR


	)

186 
	mREG_EIP
,

187 
	#REG_EIP
 
REG_EIP


	)

188 
	mREG_CS
,

189 
	#REG_CS
 
REG_CS


	)

190 
	mREG_EFL
,

191 
	#REG_EFL
 
REG_EFL


	)

192 
	mREG_UESP
,

193 
	#REG_UESP
 
REG_UESP


	)

194 
	mREG_SS


195 
	#REG_SS
 
REG_SS


	)

200 
	s_libc_å»g


202 
	msignifiÿnd
[4];

203 
	mexpÚ’t
;

206 
	s_libc_å¡©e


208 
	mcw
;

209 
	msw
;

210 
	mg
;

211 
	moff
;

212 
	mcs£l
;

213 
	md©aoff
;

214 
	md©a£l
;

215 
_libc_å»g
 
	m_¡
[8];

216 
	m¡©us
;

220 
_libc_å¡©e
 *
	tå»g£t_t
;

225 
g»g£t_t
 
	mg»gs
;

228 
å»g£t_t
 
	må»gs
;

229 
	mÞdmask
;

230 
	mü2
;

231 } 
	tmcÚ‹xt_t
;

234 
	sucÚ‹xt


236 
	muc_æags
;

237 
ucÚ‹xt
 *
	muc_lšk
;

238 
¡ack_t
 
	muc_¡ack
;

239 
mcÚ‹xt_t
 
	muc_mcÚ‹xt
;

240 
__sig£t_t
 
	muc_sigmask
;

241 
_libc_å¡©e
 
	m__å»gs_mem
;

242 } 
	tucÚ‹xt_t
;

	@/usr/include/xlocale.h

20 #iâdeà
_XLOCALE_H


21 
	#_XLOCALE_H
 1

	)

27 
	s__loÿË_¡ruù


30 
__loÿË_d©a
 *
	m__loÿËs
[13];

33 cÚ¡ *
	m__ùy³_b
;

34 cÚ¡ *
	m__ùy³_tÞow”
;

35 cÚ¡ *
	m__ùy³_touµ”
;

38 cÚ¡ *
	m__Çmes
[13];

39 } *
	t__loÿË_t
;

42 
__loÿË_t
 
	tloÿË_t
;

	@/usr/include/_G_config.h

4 #iâdeà
_G_cÚfig_h


5 
	#_G_cÚfig_h
 1

	)

9 
	~<b™s/ty³s.h
>

10 
	#__Ãed_size_t


	)

11 #ià
defšed
 
_LIBC
 || defšed 
_GLIBCPP_USE_WCHAR_T


12 
	#__Ãed_wch¬_t


	)

14 
	#__Ãed_NULL


	)

15 
	~<¡ddef.h
>

16 
	#__Ãed_mb¡©e_t


	)

17 #ià
defšed
 
_LIBC
 || defšed 
_GLIBCPP_USE_WCHAR_T


18 
	#__Ãed_wšt_t


	)

20 
	~<wch¬.h
>

23 
__off_t
 
	m__pos
;

24 
__mb¡©e_t
 
	m__¡©e
;

25 } 
	t_G_åos_t
;

28 
__off64_t
 
	m__pos
;

29 
__mb¡©e_t
 
	m__¡©e
;

30 } 
	t_G_åos64_t
;

31 #ià
defšed
 
_LIBC
 || defšed 
_GLIBCPP_USE_WCHAR_T


32 
	~<gcÚv.h
>

35 
__gcÚv_šfo
 
	m__cd
;

38 
__gcÚv_šfo
 
	m__cd
;

39 
__gcÚv_¡•_d©a
 
	m__d©a
;

40 } 
	m__combšed
;

41 } 
	t_G_icÚv_t
;

46 
	#_G_va_li¡
 
__gnuc_va_li¡


	)

48 
	#_G_HAVE_MMAP
 1

	)

49 
	#_G_HAVE_MREMAP
 1

	)

51 
	#_G_IO_IO_FILE_VERSION
 0x20001

	)

54 
	#_G_HAVE_ST_BLKSIZE
 
	`defšed
 (
_STATBUF_ST_BLKSIZE
)

	)

56 
	#_G_BUFSIZ
 8192

	)

	@/usr/include/asm/ioctl.h

1 
	~<asm-g’”ic/ioùl.h
>

	@/usr/include/asm/types.h

1 #iâdeà
_ASM_X86_TYPES_H


2 
	#_ASM_X86_TYPES_H


	)

4 
	~<asm-g’”ic/ty³s.h
>

	@/usr/include/bits/byteswap.h

19 #ià!
defšed
 
_BYTESWAP_H
 && !defšed 
_NETINET_IN_H
 && !defšed 
_ENDIAN_H


23 #iâdeà
_BITS_BYTESWAP_H


24 
	#_BITS_BYTESWAP_H
 1

	)

26 
	~<ã©u»s.h
>

27 
	~<b™s/ty³s.h
>

28 
	~<b™s/wÜdsize.h
>

31 
	#__bsw­_cÚ¡ªt_16
(
x
) \

32 ((è((((
x
è>> 8è& 0xffè| (((xè& 0xffè<< 8)))

	)

35 
	~<b™s/by‹sw­-16.h
>

38 
	#__bsw­_cÚ¡ªt_32
(
x
) \

39 ((((
x
) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >> 8) | \

40 (((
x
è& 0x0000ff00è<< 8è| (((xè& 0x000000ffè<< 24))

	)

42 #ifdeà
__GNUC__


43 #ià
__GNUC_PREREQ
 (4, 3)

44 
__šlše
 

45 
	$__bsw­_32
 (
__bsx
)

47  
	`__bužtš_bsw­32
 (
__bsx
);

48 
	}
}

49 #–ià
__GNUC__
 >= 2

50 #ià
__WORDSIZE
 =ð64 || (
defšed
 
__i486__
 || defšed 
__³Áium__
 \

51 || 
defšed
 
	g__³Áium´o__
 || defšed 
	g__³Áium4__
 \

52 || 
defšed
 
	g__k8__
 || defšed 
	g__©hlÚ__
 \

53 || 
defšed
 
	g__k6__
 || defšed 
	g__nocÚa__
 \

54 || 
defšed
 
	g__cÜe2__
 || defšed 
	g__geode__
 \

55 || 
defšed
 
	g__amdçm10__
)

58 
	#__bsw­_32
(
x
) \

59 (
__ex‹nsiÚ__
 \

60 ({ 
__v
, 
__x
 = (
x
); \

61 ià(
	`__bužtš_cÚ¡ªt_p
 (
__x
)) \

62 
__v
 = 
	`__bsw­_cÚ¡ªt_32
 (
__x
); \

64 
	`__asm__
 ("bsw­ %0" : "ô" (
__v
è: "0" (
__x
)); \

65 
__v
; }))

	)

67 
	#__bsw­_32
(
x
) \

68 (
__ex‹nsiÚ__
 \

69 ({ 
__v
, 
__x
 = (
x
); \

70 ià(
	`__bužtš_cÚ¡ªt_p
 (
__x
)) \

71 
__v
 = 
	`__bsw­_cÚ¡ªt_32
 (
__x
); \

73 
	`__asm__
 ("rorw $8, %w0;" \

76 : "ô" (
__v
) \

77 : "0" (
__x
) \

79 
__v
; }))

	)

82 
	#__bsw­_32
(
x
) \

83 (
__ex‹nsiÚ__
 \

84 ({ 
__x
 = (
x
); 
	`__bsw­_cÚ¡ªt_32
 (__x); }))

	)

87 
__šlše
 

88 
	$__bsw­_32
 (
__bsx
)

90  
	`__bsw­_cÚ¡ªt_32
 (
__bsx
);

91 
	}
}

95 #ià
__GNUC_PREREQ
 (2, 0)

97 
	#__bsw­_cÚ¡ªt_64
(
x
) \

98 (
	`__ex‹nsiÚ__
 ((((
x
) & 0xff00000000000000ull) >> 56) \

99 | (((
x
) & 0x00ff000000000000ull) >> 40) \

100 | (((
x
) & 0x0000ff0000000000ull) >> 24) \

101 | (((
x
) & 0x000000ff00000000ull) >> 8) \

102 | (((
x
) & 0x00000000ff000000ull) << 8) \

103 | (((
x
) & 0x0000000000ff0000ull) << 24) \

104 | (((
x
) & 0x000000000000ff00ull) << 40) \

105 | (((
x
è& 0x00000000000000ffuÎè<< 56)))

	)

107 #ià
__GNUC_PREREQ
 (4, 3)

108 
__šlše
 
__ušt64_t


109 
	$__bsw­_64
 (
__ušt64_t
 
__bsx
)

111  
	`__bužtš_bsw­64
 (
__bsx
);

112 
	}
}

113 #–ià
__WORDSIZE
 == 64

114 
	#__bsw­_64
(
x
) \

115 (
__ex‹nsiÚ__
 \

116 ({ 
__ušt64_t
 
__v
, 
__x
 = (
x
); \

117 ià(
	`__bužtš_cÚ¡ªt_p
 (
__x
)) \

118 
__v
 = 
	`__bsw­_cÚ¡ªt_64
 (
__x
); \

120 
	`__asm__
 ("bsw­ %q0" : "ô" (
__v
è: "0" (
__x
)); \

121 
__v
; }))

	)

123 
	#__bsw­_64
(
x
) \

124 (
__ex‹nsiÚ__
 \

125 ({ uniÚ { 
__ex‹nsiÚ__
 
__ušt64_t
 
__Î
; \

126 
__l
[2]; } 
__w
, 
__r
; \

127 ià(
	`__bužtš_cÚ¡ªt_p
 (
x
)) \

128 
__r
.
__Î
 = 
	`__bsw­_cÚ¡ªt_64
 (
x
); \

131 
__w
.
__Î
 = (
x
); \

132 
__r
.
__l
[0] = 
	`__bsw­_32
 (
__w
.__l[1]); \

133 
__r
.
__l
[1] = 
	`__bsw­_32
 (
__w
.__l[0]); \

135 
__r
.
__Î
; }))

	)

138 
	#__bsw­_cÚ¡ªt_64
(
x
) \

139 ((((
x
) & 0xff00000000000000ull) >> 56) \

140 | (((
x
) & 0x00ff000000000000ull) >> 40) \

141 | (((
x
) & 0x0000ff0000000000ull) >> 24) \

142 | (((
x
) & 0x000000ff00000000ull) >> 8) \

143 | (((
x
) & 0x00000000ff000000ull) << 8) \

144 | (((
x
) & 0x0000000000ff0000ull) << 24) \

145 | (((
x
) & 0x000000000000ff00ull) << 40) \

146 | (((
x
è& 0x00000000000000ffuÎè<< 56))

	)

148 
__šlše
 
__ušt64_t


149 
	$__bsw­_64
 (
__ušt64_t
 
__bsx
)

151  
	`__bsw­_cÚ¡ªt_64
 (
__bsx
);

152 
	}
}

	@/usr/include/bits/endian.h

3 #iâdeà
_ENDIAN_H


7 
	#__BYTE_ORDER
 
__LITTLE_ENDIAN


	)

	@/usr/include/bits/fcntl-linux.h

19 #iâdef 
_FCNTL_H


37 #ifdeà
__USE_GNU


38 
	~<b™s/uio.h
>

42 
	#O_ACCMODE
 0003

	)

43 
	#O_RDONLY
 00

	)

44 
	#O_WRONLY
 01

	)

45 
	#O_RDWR
 02

	)

46 #iâdeà
O_CREAT


47 
	#O_CREAT
 0100

	)

49 #iâdeà
O_EXCL


50 
	#O_EXCL
 0200

	)

52 #iâdeà
O_NOCTTY


53 
	#O_NOCTTY
 0400

	)

55 #iâdeà
O_TRUNC


56 
	#O_TRUNC
 01000

	)

58 #iâdeà
O_APPEND


59 
	#O_APPEND
 02000

	)

61 #iâdeà
O_NONBLOCK


62 
	#O_NONBLOCK
 04000

	)

64 #iâdeà
O_NDELAY


65 
	#O_NDELAY
 
O_NONBLOCK


	)

67 #iâdeà
O_SYNC


68 
	#O_SYNC
 04010000

	)

70 
	#O_FSYNC
 
O_SYNC


	)

71 #iâdeà
O_ASYNC


72 
	#O_ASYNC
 020000

	)

74 #iâdeà
__O_LARGEFILE


75 
	#__O_LARGEFILE
 0100000

	)

78 #iâdeà
__O_DIRECTORY


79 
	#__O_DIRECTORY
 0200000

	)

81 #iâdeà
__O_NOFOLLOW


82 
	#__O_NOFOLLOW
 0400000

	)

84 #iâdeà
__O_CLOEXEC


85 
	#__O_CLOEXEC
 02000000

	)

87 #iâdeà
__O_DIRECT


88 
	#__O_DIRECT
 040000

	)

90 #iâdeà
__O_NOATIME


91 
	#__O_NOATIME
 01000000

	)

93 #iâdeà
__O_PATH


94 
	#__O_PATH
 010000000

	)

96 #iâdeà
__O_DSYNC


97 
	#__O_DSYNC
 010000

	)

99 #iâdeà
__O_TMPFILE


100 
	#__O_TMPFILE
 (020000000 | 
__O_DIRECTORY
)

	)

103 #iâdeà
F_GETLK


104 #iâdeà
__USE_FILE_OFFSET64


105 
	#F_GETLK
 5

	)

106 
	#F_SETLK
 6

	)

107 
	#F_SETLKW
 7

	)

109 
	#F_GETLK
 
F_GETLK64


	)

110 
	#F_SETLK
 
F_SETLK64


	)

111 
	#F_SETLKW
 
F_SETLKW64


	)

114 #iâdeà
F_GETLK64


115 
	#F_GETLK64
 12

	)

116 
	#F_SETLK64
 13

	)

117 
	#F_SETLKW64
 14

	)

131 #ifdeà
__USE_GNU


132 
	#F_OFD_GETLK
 36

	)

133 
	#F_OFD_SETLK
 37

	)

134 
	#F_OFD_SETLKW
 38

	)

137 #ifdeà
__USE_LARGEFILE64


138 
	#O_LARGEFILE
 
__O_LARGEFILE


	)

141 #ifdeà
__USE_XOPEN2K8


142 
	#O_DIRECTORY
 
__O_DIRECTORY


	)

143 
	#O_NOFOLLOW
 
__O_NOFOLLOW


	)

144 
	#O_CLOEXEC
 
__O_CLOEXEC


	)

147 #ifdeà
__USE_GNU


148 
	#O_DIRECT
 
__O_DIRECT


	)

149 
	#O_NOATIME
 
__O_NOATIME


	)

150 
	#O_PATH
 
__O_PATH


	)

151 
	#O_TMPFILE
 
__O_TMPFILE


	)

157 #ià
defšed
 
__USE_POSIX199309
 || defšed 
__USE_UNIX98


158 
	#O_DSYNC
 
__O_DSYNC


	)

159 #ià
defšed
 
__O_RSYNC


160 
	#O_RSYNC
 
__O_RSYNC


	)

162 
	#O_RSYNC
 
O_SYNC


	)

167 
	#F_DUPFD
 0

	)

168 
	#F_GETFD
 1

	)

169 
	#F_SETFD
 2

	)

170 
	#F_GETFL
 3

	)

171 
	#F_SETFL
 4

	)

173 #iâdeà
__F_SETOWN


174 
	#__F_SETOWN
 8

	)

175 
	#__F_GETOWN
 9

	)

178 #ià
defšed
 
__USE_UNIX98
 || defšed 
__USE_XOPEN2K8


179 
	#F_SETOWN
 
__F_SETOWN


	)

180 
	#F_GETOWN
 
__F_GETOWN


	)

183 #iâdeà
__F_SETSIG


184 
	#__F_SETSIG
 10

	)

185 
	#__F_GETSIG
 11

	)

187 #iâdeà
__F_SETOWN_EX


188 
	#__F_SETOWN_EX
 15

	)

189 
	#__F_GETOWN_EX
 16

	)

192 #ifdeà
__USE_GNU


193 
	#F_SETSIG
 
__F_SETSIG


	)

194 
	#F_GETSIG
 
__F_GETSIG


	)

195 
	#F_SETOWN_EX
 
__F_SETOWN_EX


	)

196 
	#F_GETOWN_EX
 
__F_GETOWN_EX


	)

199 #ifdeà
__USE_GNU


200 
	#F_SETLEASE
 1024

	)

201 
	#F_GETLEASE
 1025

	)

202 
	#F_NOTIFY
 1026

	)

203 
	#F_SETPIPE_SZ
 1031

	)

204 
	#F_GETPIPE_SZ
 1032

	)

206 #ifdeà
__USE_XOPEN2K8


207 
	#F_DUPFD_CLOEXEC
 1030

	)

212 
	#FD_CLOEXEC
 1

	)

214 #iâdeà
F_RDLCK


216 
	#F_RDLCK
 0

	)

217 
	#F_WRLCK
 1

	)

218 
	#F_UNLCK
 2

	)

223 #iâdeà
F_EXLCK


224 
	#F_EXLCK
 4

	)

225 
	#F_SHLCK
 8

	)

228 #ifdeà
__USE_MISC


230 
	#LOCK_SH
 1

	)

231 
	#LOCK_EX
 2

	)

232 
	#LOCK_NB
 4

	)

234 
	#LOCK_UN
 8

	)

237 #ifdeà
__USE_GNU


238 
	#LOCK_MAND
 32

	)

239 
	#LOCK_READ
 64

	)

240 
	#LOCK_WRITE
 128

	)

241 
	#LOCK_RW
 192

	)

244 #ifdeà
__USE_GNU


246 
	#DN_ACCESS
 0x00000001

	)

247 
	#DN_MODIFY
 0x00000002

	)

248 
	#DN_CREATE
 0x00000004

	)

249 
	#DN_DELETE
 0x00000008

	)

250 
	#DN_RENAME
 0x00000010

	)

251 
	#DN_ATTRIB
 0x00000020

	)

252 
	#DN_MULTISHOT
 0x80000000

	)

256 #ifdeà
__USE_GNU


258 
	e__pid_ty³


260 
	mF_OWNER_TID
 = 0,

261 
	mF_OWNER_PID
,

262 
	mF_OWNER_PGRP
,

263 
	mF_OWNER_GID
 = 
F_OWNER_PGRP


267 
	sf_owÃr_ex


269 
__pid_ty³
 
	mty³
;

270 
__pid_t
 
	mpid
;

276 #ifdef 
__USE_MISC


277 
	#FAPPEND
 
O_APPEND


	)

278 
	#FFSYNC
 
O_FSYNC


	)

279 
	#FASYNC
 
O_ASYNC


	)

280 
	#FNONBLOCK
 
O_NONBLOCK


	)

281 
	#FNDELAY
 
O_NDELAY


	)

284 #iâdeà
__POSIX_FADV_DONTNEED


285 
	#__POSIX_FADV_DONTNEED
 4

	)

286 
	#__POSIX_FADV_NOREUSE
 5

	)

289 #ifdeà
__USE_XOPEN2K


290 
	#POSIX_FADV_NORMAL
 0

	)

291 
	#POSIX_FADV_RANDOM
 1

	)

292 
	#POSIX_FADV_SEQUENTIAL
 2

	)

293 
	#POSIX_FADV_WILLNEED
 3

	)

294 
	#POSIX_FADV_DONTNEED
 
__POSIX_FADV_DONTNEED


	)

295 
	#POSIX_FADV_NOREUSE
 
__POSIX_FADV_NOREUSE


	)

299 #ifdeà
__USE_GNU


301 
	#SYNC_FILE_RANGE_WAIT_BEFORE
 1

	)

304 
	#SYNC_FILE_RANGE_WRITE
 2

	)

307 
	#SYNC_FILE_RANGE_WAIT_AFTER
 4

	)

312 
	#SPLICE_F_MOVE
 1

	)

313 
	#SPLICE_F_NONBLOCK
 2

	)

316 
	#SPLICE_F_MORE
 4

	)

317 
	#SPLICE_F_GIFT
 8

	)

321 
	#FALLOC_FL_KEEP_SIZE
 1

	)

324 
	#FALLOC_FL_PUNCH_HOLE
 2

	)

325 
	#FALLOC_FL_COLLAPSE_RANGE
 8

	)

328 
	#FALLOC_FL_ZERO_RANGE
 16

	)

333 
	sfže_hªdË


335 
	mhªdË_by‹s
;

336 
	mhªdË_ty³
;

338 
	mf_hªdË
[0];

342 
	#MAX_HANDLE_SZ
 128

	)

346 #ifdeà
__USE_ATFILE


347 
	#AT_FDCWD
 -100

	)

350 
	#AT_SYMLINK_NOFOLLOW
 0x100

	)

351 
	#AT_REMOVEDIR
 0x200

	)

353 
	#AT_SYMLINK_FOLLOW
 0x400

	)

354 #ifdeà
__USE_GNU


355 
	#AT_NO_AUTOMOUNT
 0x800

	)

357 
	#AT_EMPTY_PATH
 0x1000

	)

359 
	#AT_EACCESS
 0x200

	)

363 
	g__BEGIN_DECLS


365 #ifdeà
__USE_GNU


368 
ssize_t
 
	$»adah—d
 (
__fd
, 
__off64_t
 
__off£t
, 
size_t
 
__couÁ
)

369 
__THROW
;

376 
	`sync_fže_¿nge
 (
__fd
, 
__off64_t
 
__off£t
, __off64_ˆ
__couÁ
,

377 
__æags
);

384 
ssize_t
 
	`vm¥liû
 (
__fdout
, cÚ¡ 
iovec
 *
__iov
,

385 
size_t
 
__couÁ
, 
__æags
);

391 
ssize_t
 
	`¥liû
 (
__fdš
, 
__off64_t
 *
__offš
, 
__fdout
,

392 
__off64_t
 *
__offout
, 
size_t
 
__Ën
,

393 
__æags
);

399 
ssize_t
 
	`‹e
 (
__fdš
, 
__fdout
, 
size_t
 
__Ën
,

400 
__æags
);

406 #iâdeà
__USE_FILE_OFFSET64


407 
	`çÎoÿ‹
 (
__fd
, 
__mode
, 
__off_t
 
__off£t
, __off_ˆ
__Ën
);

409 #ifdeà
__REDIRECT


410 
	`__REDIRECT
 (
çÎoÿ‹
, (
__fd
, 
__mode
, 
__off64_t
 
__off£t
,

411 
__off64_t
 
__Ën
),

412 
çÎoÿ‹64
);

414 
	#çÎoÿ‹
 
çÎoÿ‹64


	)

417 #ifdeà
__USE_LARGEFILE64


418 
	`çÎoÿ‹64
 (
__fd
, 
__mode
, 
__off64_t
 
__off£t
,

419 
__off64_t
 
__Ën
);

424 
	$Çme_to_hªdË_©
 (
__dfd
, cÚ¡ *
__Çme
,

425 
fže_hªdË
 *
__hªdË
, *
__mÁ_id
,

426 
__æags
è
__THROW
;

432 
	`Ý’_by_hªdË_©
 (
__mouÁdœfd
, 
fže_hªdË
 *
__hªdË
,

433 
__æags
);

437 
__END_DECLS


	@/usr/include/bits/libio-ldbl.h

19 #iâdeà
_IO_STDIO_H


23 
	$__LDBL_REDIR_DECL
 (
_IO_vfsÿnf
)

24 
	`__LDBL_REDIR_DECL
 (
_IO_vårštf
)

	@/usr/include/bits/select.h

18 #iâdeà
_SYS_SELECT_H


22 
	~<b™s/wÜdsize.h
>

25 #ià
defšed
 
__GNUC__
 && __GNUC__ >= 2

27 #ià
__WORDSIZE
 == 64

28 
	#__FD_ZERO_STOS
 "¡osq"

	)

30 
	#__FD_ZERO_STOS
 "¡o¦"

	)

33 
	#__FD_ZERO
(
fd¥
) \

35 
__d0
, 
__d1
; \

36 
__asm__
 
	`__vÞ©že__
 ("þd;„•; " 
__FD_ZERO_STOS
 \

37 : "=c" (
__d0
), "=D" (
__d1
) \

38 : "a" (0), "0" ( (
fd_£t
) \

39 /  (
__fd_mask
)), \

40 "1" (&
	`__FDS_BITS
 (
fd¥
)[0]) \

42 } 0)

	)

48 
	#__FD_ZERO
(
£t
) \

50 
__i
; \

51 
fd_£t
 *
__¬r
 = (
£t
); \

52 
__i
 = 0; __˜<  (
fd_£t
è/  (
__fd_mask
); ++__i) \

53 
	`__FDS_BITS
 (
__¬r
)[
__i
] = 0; \

54 } 0)

	)

58 
	#__FD_SET
(
d
, 
£t
) \

59 ((è(
	`__FDS_BITS
 (
£t
)[
	`__FD_ELT
 (
d
)] |ð
	`__FD_MASK
 (d)))

	)

60 
	#__FD_CLR
(
d
, 
£t
) \

61 ((è(
	`__FDS_BITS
 (
£t
)[
	`__FD_ELT
 (
d
)] &ð~
	`__FD_MASK
 (d)))

	)

62 
	#__FD_ISSET
(
d
, 
£t
) \

63 ((
	`__FDS_BITS
 (
£t
)[
	`__FD_ELT
 (
d
)] & 
	`__FD_MASK
 (d)è!ð0)

	)

	@/usr/include/bits/select2.h

19 #iâdeà
_SYS_SELECT_H


24 
__fd–t_chk
 (
__d
);

25 
	$__fd–t_w¬n
 (
__d
)

26 
	`__w¬Ç‰r
 ("bit outside of fd_set selected");

27 #undeà
__FD_ELT


28 
	#__FD_ELT
(
d
) \

29 
__ex‹nsiÚ__
 \

30 ({ 
__d
 = (
d
); \

31 (
	`__bužtš_cÚ¡ªt_p
 (
__d
) \

32 ? (0 <ð
__d
 && __d < 
__FD_SETSIZE
 \

33 ? (
__d
 / 
__NFDBITS
) \

34 : 
	`__fd–t_w¬n
 (
__d
)) \

35 : 
	`__fd–t_chk
 (
__d
)); 
	}
})

	)

	@/usr/include/bits/timex.h

18 #iâdef 
_BITS_TIMEX_H


19 
	#_BITS_TIMEX_H
 1

	)

21 
	~<b™s/ty³s.h
>

25 
	stimex


27 
	mmodes
;

28 
__sysÿÎ_¦Úg_t
 
	moff£t
;

29 
__sysÿÎ_¦Úg_t
 
	mäeq
;

30 
__sysÿÎ_¦Úg_t
 
	mmax”rÜ
;

31 
__sysÿÎ_¦Úg_t
 
	me¡”rÜ
;

32 
	m¡©us
;

33 
__sysÿÎ_¦Úg_t
 
	mcÚ¡ªt
;

34 
__sysÿÎ_¦Úg_t
 
	m´ecisiÚ
;

35 
__sysÿÎ_¦Úg_t
 
	mtÞ”ªû
;

36 
timev®
 
	mtime
;

37 
__sysÿÎ_¦Úg_t
 
	mtick
;

38 
__sysÿÎ_¦Úg_t
 
	mµsäeq
;

39 
__sysÿÎ_¦Úg_t
 
	mj™‹r
;

40 
	mshiá
;

41 
__sysÿÎ_¦Úg_t
 
	m¡abž
;

42 
__sysÿÎ_¦Úg_t
 
	mj™út
;

43 
__sysÿÎ_¦Úg_t
 
	mÿlút
;

44 
__sysÿÎ_¦Úg_t
 
	m”rút
;

45 
__sysÿÎ_¦Úg_t
 
	m¡bút
;

47 
	mi
;

56 
	#ADJ_OFFSET
 0x0001

	)

57 
	#ADJ_FREQUENCY
 0x0002

	)

58 
	#ADJ_MAXERROR
 0x0004

	)

59 
	#ADJ_ESTERROR
 0x0008

	)

60 
	#ADJ_STATUS
 0x0010

	)

61 
	#ADJ_TIMECONST
 0x0020

	)

62 
	#ADJ_TAI
 0x0080

	)

63 
	#ADJ_SETOFFSET
 0x0100

	)

64 
	#ADJ_MICRO
 0x1000

	)

65 
	#ADJ_NANO
 0x2000

	)

66 
	#ADJ_TICK
 0x4000

	)

67 
	#ADJ_OFFSET_SINGLESHOT
 0x8001

	)

68 
	#ADJ_OFFSET_SS_READ
 0xa001

	)

71 
	#MOD_OFFSET
 
ADJ_OFFSET


	)

72 
	#MOD_FREQUENCY
 
ADJ_FREQUENCY


	)

73 
	#MOD_MAXERROR
 
ADJ_MAXERROR


	)

74 
	#MOD_ESTERROR
 
ADJ_ESTERROR


	)

75 
	#MOD_STATUS
 
ADJ_STATUS


	)

76 
	#MOD_TIMECONST
 
ADJ_TIMECONST


	)

77 
	#MOD_CLKB
 
ADJ_TICK


	)

78 
	#MOD_CLKA
 
ADJ_OFFSET_SINGLESHOT


	)

79 
	#MOD_TAI
 
ADJ_TAI


	)

80 
	#MOD_MICRO
 
ADJ_MICRO


	)

81 
	#MOD_NANO
 
ADJ_NANO


	)

85 
	#STA_PLL
 0x0001

	)

86 
	#STA_PPSFREQ
 0x0002

	)

87 
	#STA_PPSTIME
 0x0004

	)

88 
	#STA_FLL
 0x0008

	)

90 
	#STA_INS
 0x0010

	)

91 
	#STA_DEL
 0x0020

	)

92 
	#STA_UNSYNC
 0x0040

	)

93 
	#STA_FREQHOLD
 0x0080

	)

95 
	#STA_PPSSIGNAL
 0x0100

	)

96 
	#STA_PPSJITTER
 0x0200

	)

97 
	#STA_PPSWANDER
 0x0400

	)

98 
	#STA_PPSERROR
 0x0800

	)

100 
	#STA_CLOCKERR
 0x1000

	)

101 
	#STA_NANO
 0x2000

	)

102 
	#STA_MODE
 0x4000

	)

103 
	#STA_CLK
 0x8000

	)

106 
	#STA_RONLY
 (
STA_PPSSIGNAL
 | 
STA_PPSJITTER
 | 
STA_PPSWANDER
 | \

107 
STA_PPSERROR
 | 
STA_CLOCKERR
 | 
STA_NANO
 | 
STA_MODE
 | 
STA_CLK
)

	)

	@/usr/include/bits/typesizes.h

19 #iâdeà
_BITS_TYPES_H


23 #iâdef 
_BITS_TYPESIZES_H


24 
	#_BITS_TYPESIZES_H
 1

	)

30 #ià
defšed
 
__x86_64__
 && defšed 
__ILP32__


31 
	#__SYSCALL_SLONG_TYPE
 
__SQUAD_TYPE


	)

32 
	#__SYSCALL_ULONG_TYPE
 
__UQUAD_TYPE


	)

34 
	#__SYSCALL_SLONG_TYPE
 
__SLONGWORD_TYPE


	)

35 
	#__SYSCALL_ULONG_TYPE
 
__ULONGWORD_TYPE


	)

38 
	#__DEV_T_TYPE
 
__UQUAD_TYPE


	)

39 
	#__UID_T_TYPE
 
__U32_TYPE


	)

40 
	#__GID_T_TYPE
 
__U32_TYPE


	)

41 
	#__INO_T_TYPE
 
__SYSCALL_ULONG_TYPE


	)

42 
	#__INO64_T_TYPE
 
__UQUAD_TYPE


	)

43 
	#__MODE_T_TYPE
 
__U32_TYPE


	)

44 #ifdeà
__x86_64__


45 
	#__NLINK_T_TYPE
 
__SYSCALL_ULONG_TYPE


	)

46 
	#__FSWORD_T_TYPE
 
__SYSCALL_SLONG_TYPE


	)

48 
	#__NLINK_T_TYPE
 
__UWORD_TYPE


	)

49 
	#__FSWORD_T_TYPE
 
__SWORD_TYPE


	)

51 
	#__OFF_T_TYPE
 
__SYSCALL_SLONG_TYPE


	)

52 
	#__OFF64_T_TYPE
 
__SQUAD_TYPE


	)

53 
	#__PID_T_TYPE
 
__S32_TYPE


	)

54 
	#__RLIM_T_TYPE
 
__SYSCALL_ULONG_TYPE


	)

55 
	#__RLIM64_T_TYPE
 
__UQUAD_TYPE


	)

56 
	#__BLKCNT_T_TYPE
 
__SYSCALL_SLONG_TYPE


	)

57 
	#__BLKCNT64_T_TYPE
 
__SQUAD_TYPE


	)

58 
	#__FSBLKCNT_T_TYPE
 
__SYSCALL_ULONG_TYPE


	)

59 
	#__FSBLKCNT64_T_TYPE
 
__UQUAD_TYPE


	)

60 
	#__FSFILCNT_T_TYPE
 
__SYSCALL_ULONG_TYPE


	)

61 
	#__FSFILCNT64_T_TYPE
 
__UQUAD_TYPE


	)

62 
	#__ID_T_TYPE
 
__U32_TYPE


	)

63 
	#__CLOCK_T_TYPE
 
__SYSCALL_SLONG_TYPE


	)

64 
	#__TIME_T_TYPE
 
__SYSCALL_SLONG_TYPE


	)

65 
	#__USECONDS_T_TYPE
 
__U32_TYPE


	)

66 
	#__SUSECONDS_T_TYPE
 
__SYSCALL_SLONG_TYPE


	)

67 
	#__DADDR_T_TYPE
 
__S32_TYPE


	)

68 
	#__KEY_T_TYPE
 
__S32_TYPE


	)

69 
	#__CLOCKID_T_TYPE
 
__S32_TYPE


	)

70 
	#__TIMER_T_TYPE
 *

	)

71 
	#__BLKSIZE_T_TYPE
 
__SYSCALL_SLONG_TYPE


	)

72 
	#__FSID_T_TYPE
 sŒuù { 
__v®
[2]; }

	)

73 
	#__SSIZE_T_TYPE
 
__SWORD_TYPE


	)

74 
	#__CPU_MASK_TYPE
 
__SYSCALL_ULONG_TYPE


	)

76 #ifdeà
__x86_64__


80 
	#__OFF_T_MATCHES_OFF64_T
 1

	)

83 
	#__INO_T_MATCHES_INO64_T
 1

	)

87 
	#__FD_SETSIZE
 1024

	)

	@/usr/include/bits/wordsize.h

3 #ià
defšed
 
__x86_64__
 && !defšed 
__ILP32__


4 
	#__WORDSIZE
 64

	)

6 
	#__WORDSIZE
 32

	)

9 #ifdeà
__x86_64__


10 
	#__WORDSIZE_TIME64_COMPAT32
 1

	)

12 
	#__SYSCALL_WORDSIZE
 64

	)

	@/usr/include/gnu/stubs.h

6 #ià!
defšed
 
__x86_64__


7 
	~<gnu/¡ubs-32.h
>

9 #ià
defšed
 
__x86_64__
 && defšed 
__LP64__


10 
	~<gnu/¡ubs-64.h
>

12 #ià
defšed
 
__x86_64__
 && defšed 
__ILP32__


13 
	~<gnu/¡ubs-x32.h
>

	@/usr/include/linux/errno.h

1 
	~<asm/”ºo.h
>

	@/usr/include/linux/posix_types.h

1 #iâdeà
_LINUX_POSIX_TYPES_H


2 
	#_LINUX_POSIX_TYPES_H


	)

4 
	~<lšux/¡ddef.h
>

21 #undeà
__FD_SETSIZE


22 
	#__FD_SETSIZE
 1024

	)

25 
	mfds_b™s
[
__FD_SETSIZE
 / (8 * ())];

26 } 
	t__k”Ãl_fd_£t
;

29 (*
	t__k”Ãl_sighªdËr_t
)();

32 
	t__k”Ãl_key_t
;

33 
	t__k”Ãl_mqd_t
;

35 
	~<asm/posix_ty³s.h
>

	@/usr/include/stdc-predef.h

18 #iâdef 
_STDC_PREDEF_H


19 
	#_STDC_PREDEF_H
 1

	)

36 #ifdeà
__GCC_IEC_559


37 #ià
__GCC_IEC_559
 > 0

38 
	#__STDC_IEC_559__
 1

	)

41 
	#__STDC_IEC_559__
 1

	)

44 #ifdeà
__GCC_IEC_559_COMPLEX


45 #ià
__GCC_IEC_559_COMPLEX
 > 0

46 
	#__STDC_IEC_559_COMPLEX__
 1

	)

49 
	#__STDC_IEC_559_COMPLEX__
 1

	)

55 
	#__STDC_ISO_10646__
 201505L

	)

58 
	#__STDC_NO_THREADS__
 1

	)

	@/usr/include/sys/cdefs.h

18 #iâdef 
_SYS_CDEFS_H


19 
	#_SYS_CDEFS_H
 1

	)

22 #iâdeà
_FEATURES_H


23 
	~<ã©u»s.h
>

29 #ià
defšed
 
__GNUC__
 && !defšed 
__STDC__


34 #undeà
__P


35 #undeà
__PMT


37 #ifdeà
__GNUC__


41 #ià
__GNUC_PREREQ
 (4, 6è&& !
defšed
 
_LIBC


42 
	#__LEAF
 , 
__Ëaf__


	)

43 
	#__LEAF_ATTR
 
	`__©Œibu‹__
 ((
__Ëaf__
))

	)

45 
	#__LEAF


	)

46 
	#__LEAF_ATTR


	)

54 #ià!
defšed
 
__ýlu¥lus
 && 
__GNUC_PREREQ
 (3, 3)

55 
	#__THROW
 
	`__©Œibu‹__
 ((
__nÙhrow__
 
__LEAF
))

	)

56 
	#__THROWNL
 
	`__©Œibu‹__
 ((
__nÙhrow__
))

	)

57 
	#__NTH
(
fù
è
	`__©Œibu‹__
 ((
__nÙhrow__
 
__LEAF
)è
	)
fct

59 #ià
defšed
 
__ýlu¥lus
 && 
__GNUC_PREREQ
 (2,8)

60 
	#__THROW
 
	`throw
 ()

	)

61 
	#__THROWNL
 
	`throw
 ()

	)

62 
	#__NTH
(
fù
è
__LEAF_ATTR
 fù 
	`throw
 ()

	)

64 
	#__THROW


	)

65 
	#__THROWNL


	)

66 
	#__NTH
(
fù
è
	)
fct

72 
	#__šlše


	)

74 
	#__THROW


	)

75 
	#__THROWNL


	)

76 
	#__NTH
(
fù
è
	)
fct

82 
	#__P
(
¬gs
è
	)
args

83 
	#__PMT
(
¬gs
è
	)
args

88 
	#__CONCAT
(
x
,
y
èx ## 
	)
y

89 
	#__STRING
(
x
è#x

	)

92 
	#__±r_t
 *

	)

93 
	#__lÚg_doubË_t
 

	)

97 #ifdef 
__ýlu¥lus


98 
	#__BEGIN_DECLS
 "C" {

	)

99 
	#__END_DECLS
 }

	)

101 
	#__BEGIN_DECLS


	)

102 
	#__END_DECLS


	)

111 #ià
defšed
 
__ýlu¥lus
 && defšed 
_GLIBCPP_USE_NAMESPACES


112 
	#__BEGIN_NAMESPACE_STD
 
Çme¥aû
 
¡d
 {

	)

113 
	#__END_NAMESPACE_STD
 }

	)

114 
	#__USING_NAMESPACE_STD
(
Çme
è
usšg
 
¡d
::Çme;

	)

115 
	#__BEGIN_NAMESPACE_C99
 
Çme¥aû
 
__c99
 {

	)

116 
	#__END_NAMESPACE_C99
 }

	)

117 
	#__USING_NAMESPACE_C99
(
Çme
è
usšg
 
__c99
::Çme;

	)

122 
	#__BEGIN_NAMESPACE_STD


	)

123 
	#__END_NAMESPACE_STD


	)

124 
	#__USING_NAMESPACE_STD
(
Çme
)

	)

125 
	#__BEGIN_NAMESPACE_C99


	)

126 
	#__END_NAMESPACE_C99


	)

127 
	#__USING_NAMESPACE_C99
(
Çme
)

	)

132 
	#__bos
(
±r
è
	`__bužtš_objeù_size
 (±r, 
__USE_FORTIFY_LEVEL
 > 1)

	)

133 
	#__bos0
(
±r
è
	`__bužtš_objeù_size
 (±r, 0)

	)

135 #ià
__GNUC_PREREQ
 (4,3)

136 
	#__w¬ndeþ
(
Çme
, 
msg
) \

137 
	`Çme
 (è
	`__©Œibu‹__
((
	`__w¬nšg__
 (
msg
)))

	)

138 
	#__w¬Ç‰r
(
msg
è
	`__©Œibu‹__
((
	`__w¬nšg__
 (msg)))

	)

139 
	#__”rÜdeþ
(
Çme
, 
msg
) \

140 
	`Çme
 (è
	`__©Œibu‹__
((
	`__”rÜ__
 (
msg
)))

	)

142 
	#__w¬ndeþ
(
Çme
, 
msg
è
	`Çme
 ()

	)

143 
	#__w¬Ç‰r
(
msg
)

	)

144 
	#__”rÜdeþ
(
Çme
, 
msg
è
	`Çme
 ()

	)

148 #ià
__GNUC_PREREQ
 (2,97)

150 
	#__æex¬r
 []

	)

152 #ifdeà
__GNUC__


153 
	#__æex¬r
 [0]

	)

155 #ià
defšed
 
__STDC_VERSION__
 && __STDC_VERSION__ >= 199901L

156 
	#__æex¬r
 []

	)

159 
	#__æex¬r
 [1]

	)

175 #ià
defšed
 
__GNUC__
 && __GNUC__ >= 2

177 
	#__REDIRECT
(
Çme
, 
´Ùo
, 
®Ÿs
èÇm´ÙØ
	`__asm__
 (
	`__ASMNAME
 (#®Ÿs))

	)

178 #ifdeà
__ýlu¥lus


179 
	#__REDIRECT_NTH
(
Çme
, 
´Ùo
, 
®Ÿs
) \

180 
Çme
 
´Ùo
 
__THROW
 
	`__asm__
 (
	`__ASMNAME
 (#®Ÿs))

	)

181 
	#__REDIRECT_NTHNL
(
Çme
, 
´Ùo
, 
®Ÿs
) \

182 
Çme
 
´Ùo
 
__THROWNL
 
	`__asm__
 (
	`__ASMNAME
 (#®Ÿs))

	)

184 
	#__REDIRECT_NTH
(
Çme
, 
´Ùo
, 
®Ÿs
) \

185 
Çme
 
´Ùo
 
	`__asm__
 (
	`__ASMNAME
 (#®Ÿs)è
__THROW


	)

186 
	#__REDIRECT_NTHNL
(
Çme
, 
´Ùo
, 
®Ÿs
) \

187 
Çme
 
´Ùo
 
	`__asm__
 (
	`__ASMNAME
 (#®Ÿs)è
__THROWNL


	)

189 
	#__ASMNAME
(
úame
è
	`__ASMNAME2
 (
__USER_LABEL_PREFIX__
, cÇme)

	)

190 
	#__ASMNAME2
(
´efix
, 
úame
è
	`__STRING
 (´efixè
	)
cname

203 #ià!
defšed
 
__GNUC__
 || __GNUC__ < 2

204 
	#__©Œibu‹__
(
xyz
è

	)

210 #ià
__GNUC_PREREQ
 (2,96)

211 
	#__©Œibu‹_m®loc__
 
	`__©Œibu‹__
 ((
__m®loc__
))

	)

213 
	#__©Œibu‹_m®loc__


	)

218 #ià
__GNUC_PREREQ
 (4, 3)

219 
	#__©Œibu‹_®loc_size__
(
·¿ms
) \

220 
	`__©Œibu‹__
 ((
__®loc_size__
 
·¿ms
))

	)

222 
	#__©Œibu‹_®loc_size__
(
·¿ms
è

	)

228 #ià
__GNUC_PREREQ
 (2,96)

229 
	#__©Œibu‹_pu»__
 
	`__©Œibu‹__
 ((
__pu»__
))

	)

231 
	#__©Œibu‹_pu»__


	)

235 #ià
__GNUC_PREREQ
 (2,5)

236 
	#__©Œibu‹_cÚ¡__
 
	`__©Œibu‹__
 ((
__cÚ¡__
))

	)

238 
	#__©Œibu‹_cÚ¡__


	)

244 #ià
__GNUC_PREREQ
 (3,1)

245 
	#__©Œibu‹_u£d__
 
	`__©Œibu‹__
 ((
__u£d__
))

	)

246 
	#__©Œibu‹_nošlše__
 
	`__©Œibu‹__
 ((
__nošlše__
))

	)

248 
	#__©Œibu‹_u£d__
 
	`__©Œibu‹__
 ((
__unu£d__
))

	)

249 
	#__©Œibu‹_nošlše__


	)

253 #ià
__GNUC_PREREQ
 (3,2)

254 
	#__©Œibu‹_d•»ÿ‹d__
 
	`__©Œibu‹__
 ((
__d•»ÿ‹d__
))

	)

256 
	#__©Œibu‹_d•»ÿ‹d__


	)

265 #ià
__GNUC_PREREQ
 (2,8)

266 
	#__©Œibu‹_fÜm©_¬g__
(
x
è
	`__©Œibu‹__
 ((
	`__fÜm©_¬g__
 (x)))

	)

268 
	#__©Œibu‹_fÜm©_¬g__
(
x
è

	)

275 #ià
__GNUC_PREREQ
 (2,97)

276 
	#__©Œibu‹_fÜm©_¡rfmÚ__
(
a
,
b
) \

277 
	`__©Œibu‹__
 ((
	`__fÜm©__
 (
__¡rfmÚ__
, 
a
, 
b
)))

	)

279 
	#__©Œibu‹_fÜm©_¡rfmÚ__
(
a
,
b
è

	)

284 #ià
__GNUC_PREREQ
 (3,3)

285 
	#__nÚnuÎ
(
·¿ms
è
	`__©Œibu‹__
 ((
__nÚnuÎ__
…¬ams))

	)

287 
	#__nÚnuÎ
(
·¿ms
)

	)

292 #ià
__GNUC_PREREQ
 (3,4)

293 
	#__©Œibu‹_w¬n_unu£d_»suÉ__
 \

294 
	`__©Œibu‹__
 ((
__w¬n_unu£d_»suÉ__
))

	)

295 #ià
__USE_FORTIFY_LEVEL
 > 0

296 
	#__wur
 
__©Œibu‹_w¬n_unu£d_»suÉ__


	)

299 
	#__©Œibu‹_w¬n_unu£d_»suÉ__


	)

301 #iâdeà
__wur


302 
	#__wur


	)

306 #ià
__GNUC_PREREQ
 (3,2)

307 
	#__®ways_šlše
 
__šlše
 
	`__©Œibu‹__
 ((
__®ways_šlše__
))

	)

309 
	#__®ways_šlše
 
__šlše


	)

314 #ià
__GNUC_PREREQ
 (4,3)

315 
	#__©Œibu‹_¬tificŸl__
 
	`__©Œibu‹__
 ((
__¬tificŸl__
))

	)

317 
	#__©Œibu‹_¬tificŸl__


	)

329 #ià(!
defšed
 
__ýlu¥lus
 || 
__GNUC_PREREQ
 (4,3) \

330 || (
defšed
 
__þªg__
 && (defšed 
__GNUC_STDC_INLINE__
 \

331 || 
defšed
 
__GNUC_GNU_INLINE__
)))

332 #ià
defšed
 
__GNUC_STDC_INLINE__
 || defšed 
__ýlu¥lus


333 
	#__ex‹º_šlše
 
__šlše
 
	`__©Œibu‹__
 ((
__gnu_šlše__
))

	)

334 
	#__ex‹º_®ways_šlše
 \

335 
__®ways_šlše
 
	`__©Œibu‹__
 ((
__gnu_šlše__
))

	)

337 
	#__ex‹º_šlše
 
__šlše


	)

338 
	#__ex‹º_®ways_šlše
 
__®ways_šlše


	)

342 #ifdeà
__ex‹º_®ways_šlše


343 
	#__fÜtify_funùiÚ
 
__ex‹º_®ways_šlše
 
__©Œibu‹_¬tificŸl__


	)

348 #ià
__GNUC_PREREQ
 (4,3)

349 
	#__va_¬g_·ck
(è
	`__bužtš_va_¬g_·ck
 ()

	)

350 
	#__va_¬g_·ck_Ën
(è
	`__bužtš_va_¬g_·ck_Ën
 ()

	)

357 #ià!
__GNUC_PREREQ
 (2,8)

358 
	#__ex‹nsiÚ__


	)

362 #ià!
__GNUC_PREREQ
 (2,92)

363 
	#__»¡riù


	)

369 #ià
__GNUC_PREREQ
 (3,1è&& !
defšed
 
__GNUG__


370 
	#__»¡riù_¬r
 
__»¡riù


	)

372 #ifdeà
__GNUC__


373 
	#__»¡riù_¬r


	)

375 #ià
defšed
 
__STDC_VERSION__
 && __STDC_VERSION__ >= 199901L

376 
	#__»¡riù_¬r
 
»¡riù


	)

379 
	#__»¡riù_¬r


	)

384 #ià
__GNUC__
 >= 3

385 
	#__glibc_uÆik–y
(
cÚd
è
	`__bužtš_ex³ù
 ((cÚd), 0)

	)

386 
	#__glibc_lik–y
(
cÚd
è
	`__bužtš_ex³ù
 ((cÚd), 1)

	)

388 
	#__glibc_uÆik–y
(
cÚd
è(cÚd)

	)

389 
	#__glibc_lik–y
(
cÚd
è(cÚd)

	)

392 #ià(!
defšed
 
_NÜ‘uº
 \

393 && (
defšed
 
__STDC_VERSION__
 ? __STDC_VERSION__ : 0) < 201112 \

394 && !
	$__GNUC_PREREQ
 (4,7))

395 #ià
	`__GNUC_PREREQ
 (2,8)

396 
	#_NÜ‘uº
 
	`__©Œibu‹__
 ((
__nÜ‘uº__
))

	)

398 
	#_NÜ‘uº


	)

402 #ià(!
defšed
 
_Stic_as£¹
 && !defšed 
__ýlu¥lus
 \

403 && (
defšed
 
__STDC_VERSION__
 ? __STDC_VERSION__ : 0) < 201112 \

404 && (!
	`__GNUC_PREREQ
 (4, 6è|| 
defšed
 
__STRICT_ANSI__
))

405 
	#_Stic_as£¹
(
ex´
, 
dŸgno¡ic
) \

406 (*
	`__Stic_as£¹_funùiÚ
 ()) \

407 [!! (¡ruù { 
__”rÜ_if_Ãg©ive
: (
ex´
è? 2 : -1; })]

	)

410 
	~<b™s/wÜdsize.h
>

412 #ià
defšed
 
__LONG_DOUBLE_MATH_OPTIONAL
 && defšed 
__NO_LONG_DOUBLE_MATH


413 
	#__LDBL_COMPAT
 1

	)

414 #ifdeà
__REDIRECT


415 
	#__LDBL_REDIR1
(
Çme
, 
´Ùo
, 
®Ÿs
è
	`__REDIRECT
 (Çme,…rÙo,‡lŸs)

	)

416 
	#__LDBL_REDIR
(
Çme
, 
´Ùo
) \

417 
	`__LDBL_REDIR1
 (
Çme
, 
´Ùo
, 
__Ædbl_
##Çme)

	)

418 
	#__LDBL_REDIR1_NTH
(
Çme
, 
´Ùo
, 
®Ÿs
è
	`__REDIRECT_NTH
 (Çme,…rÙo,‡lŸs)

	)

419 
	#__LDBL_REDIR_NTH
(
Çme
, 
´Ùo
) \

420 
	`__LDBL_REDIR1_NTH
 (
Çme
, 
´Ùo
, 
__Ædbl_
##Çme)

	)

421 
	#__LDBL_REDIR1_DECL
(
Çme
, 
®Ÿs
) \

422 
	`__ty³of
 (
Çme
èÇm
	`__asm
 (
	`__ASMNAME
 (#®Ÿs));

	)

423 
	#__LDBL_REDIR_DECL
(
Çme
) \

424 
	`__ty³of
 (
Çme
èÇm
	`__asm
 (
	`__ASMNAME
 ("__Ædbl_" #Çme));

	)

425 
	#__REDIRECT_LDBL
(
Çme
, 
´Ùo
, 
®Ÿs
) \

426 
	`__LDBL_REDIR1
 (
Çme
, 
´Ùo
, 
__Ædbl_
##
®Ÿs
)

	)

427 
	#__REDIRECT_NTH_LDBL
(
Çme
, 
´Ùo
, 
®Ÿs
) \

428 
	`__LDBL_REDIR1_NTH
 (
Çme
, 
´Ùo
, 
__Ædbl_
##
®Ÿs
)

	)

431 #ià!
defšed
 
__LDBL_COMPAT
 || !defšed 
__REDIRECT


432 
	#__LDBL_REDIR1
(
Çme
, 
´Ùo
, 
®Ÿs
èÇm
	)
proto

433 
	#__LDBL_REDIR
(
Çme
, 
´Ùo
èÇm
	)
proto

434 
	#__LDBL_REDIR1_NTH
(
Çme
, 
´Ùo
, 
®Ÿs
èÇm´ÙØ
__THROW


	)

435 
	#__LDBL_REDIR_NTH
(
Çme
, 
´Ùo
èÇm´ÙØ
__THROW


	)

436 
	#__LDBL_REDIR_DECL
(
Çme
)

	)

437 #ifdeà
__REDIRECT


438 
	#__REDIRECT_LDBL
(
Çme
, 
´Ùo
, 
®Ÿs
è
	`__REDIRECT
 (Çme,…rÙo,‡lŸs)

	)

439 
	#__REDIRECT_NTH_LDBL
(
Çme
, 
´Ùo
, 
®Ÿs
) \

440 
	`__REDIRECT_NTH
 (
Çme
, 
´Ùo
, 
®Ÿs
)

	)

	@/usr/include/asm-generic/ioctl.h

1 #iâdeà
_ASM_GENERIC_IOCTL_H


2 
	#_ASM_GENERIC_IOCTL_H


	)

22 
	#_IOC_NRBITS
 8

	)

23 
	#_IOC_TYPEBITS
 8

	)

30 #iâdeà
_IOC_SIZEBITS


31 
	#_IOC_SIZEBITS
 14

	)

34 #iâdeà
_IOC_DIRBITS


35 
	#_IOC_DIRBITS
 2

	)

38 
	#_IOC_NRMASK
 ((1 << 
_IOC_NRBITS
)-1)

	)

39 
	#_IOC_TYPEMASK
 ((1 << 
_IOC_TYPEBITS
)-1)

	)

40 
	#_IOC_SIZEMASK
 ((1 << 
_IOC_SIZEBITS
)-1)

	)

41 
	#_IOC_DIRMASK
 ((1 << 
_IOC_DIRBITS
)-1)

	)

43 
	#_IOC_NRSHIFT
 0

	)

44 
	#_IOC_TYPESHIFT
 (
_IOC_NRSHIFT
+
_IOC_NRBITS
)

	)

45 
	#_IOC_SIZESHIFT
 (
_IOC_TYPESHIFT
+
_IOC_TYPEBITS
)

	)

46 
	#_IOC_DIRSHIFT
 (
_IOC_SIZESHIFT
+
_IOC_SIZEBITS
)

	)

53 #iâdeà
_IOC_NONE


54 
	#_IOC_NONE
 0U

	)

57 #iâdeà
_IOC_WRITE


58 
	#_IOC_WRITE
 1U

	)

61 #iâdeà
_IOC_READ


62 
	#_IOC_READ
 2U

	)

65 
	#_IOC
(
dœ
,
ty³
,
Ä
,
size
) \

66 (((
dœ
è<< 
_IOC_DIRSHIFT
) | \

67 ((
ty³
è<< 
_IOC_TYPESHIFT
) | \

68 ((
Ä
è<< 
_IOC_NRSHIFT
) | \

69 ((
size
è<< 
_IOC_SIZESHIFT
))

	)

71 
	#_IOC_TYPECHECK
(
t
è(Ñ))

	)

74 
	#_IO
(
ty³
,
Ä
è
	`_IOC
(
_IOC_NONE
,Ñy³),Òr),0)

	)

75 
	#_IOR
(
ty³
,
Ä
,
size
è
	`_IOC
(
_IOC_READ
,Ñy³),Òr),(
	`_IOC_TYPECHECK
(size)))

	)

76 
	#_IOW
(
ty³
,
Ä
,
size
è
	`_IOC
(
_IOC_WRITE
,Ñy³),Òr),(
	`_IOC_TYPECHECK
(size)))

	)

77 
	#_IOWR
(
ty³
,
Ä
,
size
è
	`_IOC
(
_IOC_READ
|
_IOC_WRITE
,Ñy³),Òr),(
	`_IOC_TYPECHECK
(size)))

	)

78 
	#_IOR_BAD
(
ty³
,
Ä
,
size
è
	`_IOC
(
_IOC_READ
,Ñy³),Òr),(size))

	)

79 
	#_IOW_BAD
(
ty³
,
Ä
,
size
è
	`_IOC
(
_IOC_WRITE
,Ñy³),Òr),(size))

	)

80 
	#_IOWR_BAD
(
ty³
,
Ä
,
size
è
	`_IOC
(
_IOC_READ
|
_IOC_WRITE
,Ñy³),Òr),(size))

	)

83 
	#_IOC_DIR
(
Ä
è((Òrè>> 
_IOC_DIRSHIFT
è& 
_IOC_DIRMASK
)

	)

84 
	#_IOC_TYPE
(
Ä
è((Òrè>> 
_IOC_TYPESHIFT
è& 
_IOC_TYPEMASK
)

	)

85 
	#_IOC_NR
(
Ä
è((Òrè>> 
_IOC_NRSHIFT
è& 
_IOC_NRMASK
)

	)

86 
	#_IOC_SIZE
(
Ä
è((Òrè>> 
_IOC_SIZESHIFT
è& 
_IOC_SIZEMASK
)

	)

90 
	#IOC_IN
 (
_IOC_WRITE
 << 
_IOC_DIRSHIFT
)

	)

91 
	#IOC_OUT
 (
_IOC_READ
 << 
_IOC_DIRSHIFT
)

	)

92 
	#IOC_INOUT
 ((
_IOC_WRITE
|
_IOC_READ
è<< 
_IOC_DIRSHIFT
)

	)

93 
	#IOCSIZE_MASK
 (
_IOC_SIZEMASK
 << 
_IOC_SIZESHIFT
)

	)

94 
	#IOCSIZE_SHIFT
 (
_IOC_SIZESHIFT
)

	)

	@/usr/include/asm-generic/types.h

1 #iâdeà
_ASM_GENERIC_TYPES_H


2 
	#_ASM_GENERIC_TYPES_H


	)

6 
	~<asm-g’”ic/št-Î64.h
>

	@/usr/include/asm/errno.h

1 
	~<asm-g’”ic/”ºo.h
>

	@/usr/include/asm/posix_types.h

1 #ifdeà
__i386__


2 
	~<asm/posix_ty³s_32.h
>

3 #–ià
defšed
(
__ILP32__
)

4 
	~<asm/posix_ty³s_x32.h
>

6 
	~<asm/posix_ty³s_64.h
>

	@/usr/include/bits/byteswap-16.h

19 #iâdeà
_BITS_BYTESWAP_H


23 #ifdeà
__GNUC__


24 #ià
__GNUC__
 >= 2

25 
	#__bsw­_16
(
x
) \

26 (
__ex‹nsiÚ__
 \

27 ({ 
__v
, 
__x
 = (è(
x
); \

28 ià(
	`__bužtš_cÚ¡ªt_p
 (
__x
)) \

29 
__v
 = 
	`__bsw­_cÚ¡ªt_16
 (
__x
); \

31 
	`__asm__
 ("rorw $8, %w0" \

32 : "ô" (
__v
) \

33 : "0" (
__x
) \

35 
__v
; }))

	)

38 
	#__bsw­_16
(
x
) \

39 (
__ex‹nsiÚ__
 \

40 ({ 
__x
 = (è(
x
); \

41 
	`__bsw­_cÚ¡ªt_16
 (
__x
); }))

	)

44 
__šlše
 

45 
	$__bsw­_16
 (
__bsx
)

47  
	`__bsw­_cÚ¡ªt_16
 (
__bsx
);

48 
	}
}

	@/usr/include/bits/uio.h

18 #ià!
defšed
 
_SYS_UIO_H
 && !defšed 
_FCNTL_H


22 #iâdeà
_BITS_UIO_H


23 
	#_BITS_UIO_H
 1

	)

25 
	~<sys/ty³s.h
>

39 
	#UIO_MAXIOV
 1024

	)

43 
	siovec


45 *
	miov_ba£
;

46 
size_t
 
	miov_Ën
;

52 #ifdeà
__USE_GNU


53 #ià
defšed
 
_SYS_UIO_H
 && !defšed 
_BITS_UIO_H_FOR_SYS_UIO_H


54 
	#_BITS_UIO_H_FOR_SYS_UIO_H
 1

	)

56 
__BEGIN_DECLS


59 
ssize_t
 
	$´oûss_vm_»adv
 (
pid_t
 
__pid
, cÚ¡ 
iovec
 *
__lvec
,

60 
__liovút
,

61 cÚ¡ 
iovec
 *
__rvec
,

62 
__riovút
,

63 
__æags
)

64 
__THROW
;

67 
ssize_t
 
	$´oûss_vm_wr™ev
 (
pid_t
 
__pid
, cÚ¡ 
iovec
 *
__lvec
,

68 
__liovút
,

69 cÚ¡ 
iovec
 *
__rvec
,

70 
__riovút
,

71 
__æags
)

72 
__THROW
;

74 
__END_DECLS


	@/usr/include/gconv.h

22 #iâdeà
_GCONV_H


23 
	#_GCONV_H
 1

	)

25 
	~<ã©u»s.h
>

26 
	#__Ãed_mb¡©e_t


	)

27 
	#__Ãed_wšt_t


	)

28 
	~<wch¬.h
>

29 
	#__Ãed_size_t


	)

30 
	#__Ãed_wch¬_t


	)

31 
	~<¡ddef.h
>

34 
	#__UNKNOWN_10646_CHAR
 ((
wch¬_t
è0xfffd)

	)

39 
	m__GCONV_OK
 = 0,

40 
	m__GCONV_NOCONV
,

41 
	m__GCONV_NODB
,

42 
	m__GCONV_NOMEM
,

44 
	m__GCONV_EMPTY_INPUT
,

45 
	m__GCONV_FULL_OUTPUT
,

46 
	m__GCONV_ILLEGAL_INPUT
,

47 
	m__GCONV_INCOMPLETE_INPUT
,

49 
	m__GCONV_ILLEGAL_DESCRIPTOR
,

50 
	m__GCONV_INTERNAL_ERROR


57 
	m__GCONV_IS_LAST
 = 0x0001,

58 
	m__GCONV_IGNORE_ERRORS
 = 0x0002,

59 
	m__GCONV_SWAP
 = 0x0004,

60 
	m__GCONV_TRANSLIT
 = 0x0008

65 
	g__gcÚv_¡•
;

66 
	g__gcÚv_¡•_d©a
;

67 
	g__gcÚv_lßded_objeù
;

71 (*
	t__gcÚv_fù
è(
	t__gcÚv_¡•
 *, 
	t__gcÚv_¡•_d©a
 *,

73 **, 
	tsize_t
 *, , );

76 
	$wšt_t
 (*
	t__gcÚv_btowc_fù
è(
	t__gcÚv_¡•
 *, );

79 (*
	t__gcÚv_š™_fù
è(
	t__gcÚv_¡•
 *);

80 (*
	t__gcÚv_’d_fù
è(
	t__gcÚv_¡•
 *);

84 
	s__gcÚv_¡•


86 
__gcÚv_lßded_objeù
 *
__shlib_hªdË
;

87 cÚ¡ *
__modÇme
;

89 
__couÁ”
;

91 *
__äom_Çme
;

92 *
__to_Çme
;

94 
__gcÚv_fù
 
__fù
;

95 
__gcÚv_btowc_fù
 
__btowc_fù
;

96 
__gcÚv_š™_fù
 
__š™_fù
;

97 
__gcÚv_’d_fù
 
__’d_fù
;

101 
__mš_Ãeded_äom
;

102 
__max_Ãeded_äom
;

103 
__mš_Ãeded_to
;

104 
__max_Ãeded_to
;

107 
__¡©eful
;

109 *
__d©a
;

114 
	s__gcÚv_¡•_d©a


116 *
__outbuf
;

117 *
__outbuãnd
;

121 
__æags
;

125 
__švoÿtiÚ_couÁ”
;

129 
__š‹º®_u£
;

131 
__mb¡©e_t
 *
__¡©•
;

132 
__mb¡©e_t
 
__¡©e
;

138 
	s__gcÚv_šfo


140 
size_t
 
__n¡•s
;

141 
__gcÚv_¡•
 *
__¡•s
;

142 
__ex‹nsiÚ__
 
__gcÚv_¡•_d©a
 
__d©a
 
__æex¬r
;

143 } *
	t__gcÚv_t
;

146 
	`__gcÚv_Œª¦™”©e
 (
__gcÚv_¡•
 *
¡•
,

147 
__gcÚv_¡•_d©a
 *
¡•_d©a
,

148 cÚ¡ *
šbuf¡¬t
,

149 cÚ¡ **
šbuå
,

150 cÚ¡ *
šbuãnd
,

151 **
outbuf¡¬t
,

152 
size_t
 *
œ»v”sibË
);

	@/usr/include/gnu/stubs-32.h

6 #ifdeà
_LIBC


7 #”rÜ 
AµliÿtiÚs
 
may
 
nÙ
 
defše
 
the
 
maüo
 
_LIBC


10 
	#__¡ub_chæags


	)

11 
	#__¡ub_ç‰ach


	)

12 
	#__¡ub_fchæags


	)

13 
	#__¡ub_fd‘ach


	)

14 
	#__¡ub_g‰y


	)

15 
	#__¡ub_lchmod


	)

16 
	#__¡ub_»voke


	)

17 
	#__¡ub_£Žogš


	)

18 
	#__¡ub_sig»tuº


	)

19 
	#__¡ub_s¡k


	)

20 
	#__¡ub_¡ty


	)

	@/usr/include/gnu/stubs-64.h

6 #ifdeà
_LIBC


7 #”rÜ 
AµliÿtiÚs
 
may
 
nÙ
 
defše
 
the
 
maüo
 
_LIBC


10 
	#__¡ub___com·t_bdæush


	)

11 
	#__¡ub_chæags


	)

12 
	#__¡ub_ç‰ach


	)

13 
	#__¡ub_fchæags


	)

14 
	#__¡ub_fd‘ach


	)

15 
	#__¡ub_g‘msg


	)

16 
	#__¡ub_g‰y


	)

17 
	#__¡ub_lchmod


	)

18 
	#__¡ub_putmsg


	)

19 
	#__¡ub_»voke


	)

20 
	#__¡ub_£Žogš


	)

21 
	#__¡ub_sig»tuº


	)

22 
	#__¡ub_s¡k


	)

23 
	#__¡ub_¡ty


	)

	@/usr/include/gnu/stubs-x32.h

6 #ifdeà
_LIBC


7 #”rÜ 
AµliÿtiÚs
 
may
 
nÙ
 
defše
 
the
 
maüo
 
_LIBC


10 
	#__¡ub___com·t_bdæush


	)

11 
	#__¡ub___com·t_ü—‹_moduË


	)

12 
	#__¡ub___com·t_g‘_k”Ãl_syms


	)

13 
	#__¡ub___com·t_qu”y_moduË


	)

14 
	#__¡ub___com·t_u£lib


	)

15 
	#__¡ub_chæags


	)

16 
	#__¡ub_ç‰ach


	)

17 
	#__¡ub_fchæags


	)

18 
	#__¡ub_fd‘ach


	)

19 
	#__¡ub_g‘msg


	)

20 
	#__¡ub_g‰y


	)

21 
	#__¡ub_lchmod


	)

22 
	#__¡ub_nfs£rvùl


	)

23 
	#__¡ub_putmsg


	)

24 
	#__¡ub_»voke


	)

25 
	#__¡ub_£Žogš


	)

26 
	#__¡ub_sig»tuº


	)

27 
	#__¡ub_s¡k


	)

28 
	#__¡ub_¡ty


	)

	@/usr/include/linux/stddef.h

	@/usr/include/wchar.h

23 #iâdeà
_WCHAR_H


25 #ià!
defšed
 
__Ãed_mb¡©e_t
 && !defšed 
__Ãed_wšt_t


26 
	#_WCHAR_H
 1

	)

27 
	~<ã©u»s.h
>

30 #ifdeà
_WCHAR_H


32 
	#__Ãed___FILE


	)

33 #ià
defšed
 
__USE_UNIX98
 || defšed 
__USE_XOPEN2K


34 
	#__Ãed_FILE


	)

36 
	~<¡dio.h
>

38 
	#__Ãed___va_li¡


	)

39 
	~<¡d¬g.h
>

41 
	~<b™s/wch¬.h
>

44 
	#__Ãed_size_t


	)

45 
	#__Ãed_wch¬_t


	)

46 
	#__Ãed_NULL


	)

48 #ià
defšed
 
_WCHAR_H
 || defšed 
__Ãed_wšt_t
 || !defšed 
__WINT_TYPE__


49 #undeà
__Ãed_wšt_t


50 
	#__Ãed_wšt_t


	)

51 
	~<¡ddef.h
>

55 #iâdeà
_WINT_T


60 
	#_WINT_T


	)

61 
	twšt_t
;

65 #ià
defšed
 
__ýlu¥lus
 && defšed 
_GLIBCPP_USE_NAMESPACES
 \

66 && 
defšed
 
__WINT_TYPE__


67 
__BEGIN_NAMESPACE_STD


68 
__WINT_TYPE__
 
	twšt_t
;

69 
	g__END_NAMESPACE_STD


74 #ià
defšed
 
__ýlu¥lus
 && 
__GNUC_PREREQ
 (4, 4)

75 
	#__CORRECT_ISO_CPP_WCHAR_H_PROTO


	)

79 #ià(
defšed
 
_WCHAR_H
 || defšed 
__Ãed_mb¡©e_t
è&& !defšed 
____mb¡©e_t_defšed


80 
	#____mb¡©e_t_defšed
 1

	)

84 
	m__couÁ
;

87 #ifdeà
__WINT_TYPE__


88 
__WINT_TYPE__
 
	m__wch
;

90 
wšt_t
 
	m__wch
;

92 
	m__wchb
[4];

93 } 
	m__v®ue
;

94 } 
	t__mb¡©e_t
;

96 #undeà
__Ãed_mb¡©e_t


101 #ifdeà
_WCHAR_H


103 #iâdeà
__mb¡©e_t_defšed


104 
__BEGIN_NAMESPACE_C99


106 
__mb¡©e_t
 
	tmb¡©e_t
;

107 
	g__END_NAMESPACE_C99


108 
	#__mb¡©e_t_defšed
 1

	)

111 #ifdeà
__USE_GNU


112 
	$__USING_NAMESPACE_C99
(
mb¡©e_t
)

115 #iâdeà
WCHAR_MIN


117 
	#WCHAR_MIN
 
__WCHAR_MIN


	)

118 
	#WCHAR_MAX
 
__WCHAR_MAX


	)

121 #iâdeà
WEOF


122 
	#WEOF
 (0xffffffffu)

	)

127 #ià
defšed
 
__USE_XOPEN
 && !defšed 
__USE_UNIX98


128 
	~<wùy³.h
>

132 
__BEGIN_DECLS


134 
__BEGIN_NAMESPACE_STD


137 
tm
;

138 
__END_NAMESPACE_STD


142 
	$__USING_NAMESPACE_STD
(
tm
)

145 
__BEGIN_NAMESPACE_STD


147 
wch¬_t
 *
	$wcsýy
 (
wch¬_t
 *
__»¡riù
 
__de¡
,

148 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__¤c
)

149 
__THROW
 
	`__nÚnuÎ
 ((1, 2));

152 
wch¬_t
 *
	$wc¢ýy
 (
wch¬_t
 *
__»¡riù
 
__de¡
,

153 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__¤c
, 
size_t
 
__n
)

154 
__THROW
 
	`__nÚnuÎ
 ((1, 2));

157 
wch¬_t
 *
	$wcsÿt
 (
wch¬_t
 *
__»¡riù
 
__de¡
,

158 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__¤c
)

159 
__THROW
 
	`__nÚnuÎ
 ((1, 2));

161 
wch¬_t
 *
	$wc¢ÿt
 (
wch¬_t
 *
__»¡riù
 
__de¡
,

162 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__¤c
, 
size_t
 
__n
)

163 
__THROW
 
	`__nÚnuÎ
 ((1, 2));

166 
	$wcscmp
 (cÚ¡ 
wch¬_t
 *
__s1
, cÚ¡ wch¬_ˆ*
__s2
)

167 
__THROW
 
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1, 2));

169 
	$wc¢cmp
 (cÚ¡ 
wch¬_t
 *
__s1
, cÚ¡ wch¬_ˆ*
__s2
, 
size_t
 
__n
)

170 
__THROW
 
__©Œibu‹_pu»__
 
	`__nÚnuÎ
 ((1, 2));

171 
__END_NAMESPACE_STD


173 #ifdeà
__USE_XOPEN2K8


175 
	$wcsÿ£cmp
 (cÚ¡ 
wch¬_t
 *
__s1
, cÚ¡ wch¬_ˆ*
__s2
è
__THROW
;

178 
	$wc¢ÿ£cmp
 (cÚ¡ 
wch¬_t
 *
__s1
, cÚ¡ wch¬_ˆ*
__s2
,

179 
size_t
 
__n
è
__THROW
;

183 
	~<xloÿË.h
>

185 
	$wcsÿ£cmp_l
 (cÚ¡ 
wch¬_t
 *
__s1
, cÚ¡ wch¬_ˆ*
__s2
,

186 
__loÿË_t
 
__loc
è
__THROW
;

188 
	$wc¢ÿ£cmp_l
 (cÚ¡ 
wch¬_t
 *
__s1
, cÚ¡ wch¬_ˆ*
__s2
,

189 
size_t
 
__n
, 
__loÿË_t
 
__loc
è
__THROW
;

192 
__BEGIN_NAMESPACE_STD


195 
	$wcscÞl
 (cÚ¡ 
wch¬_t
 *
__s1
, cÚ¡ wch¬_ˆ*
__s2
è
__THROW
;

199 
size_t
 
	$wcsxäm
 (
wch¬_t
 *
__»¡riù
 
__s1
,

200 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__s2
, 
size_t
 
__n
è
__THROW
;

201 
__END_NAMESPACE_STD


203 #ifdeà
__USE_XOPEN2K8


209 
	$wcscÞl_l
 (cÚ¡ 
wch¬_t
 *
__s1
, cÚ¡ wch¬_ˆ*
__s2
,

210 
__loÿË_t
 
__loc
è
__THROW
;

215 
size_t
 
	$wcsxäm_l
 (
wch¬_t
 *
__s1
, cÚ¡ wch¬_ˆ*
__s2
,

216 
size_t
 
__n
, 
__loÿË_t
 
__loc
è
__THROW
;

219 
wch¬_t
 *
	$wcsdup
 (cÚ¡ 
wch¬_t
 *
__s
è
__THROW
 
__©Œibu‹_m®loc__
;

222 
__BEGIN_NAMESPACE_STD


224 #ifdeà
__CORRECT_ISO_CPP_WCHAR_H_PROTO


225 "C++" 
wch¬_t
 *
	$wcschr
 (
wch¬_t
 *
__wcs
, wch¬_ˆ
__wc
)

226 
__THROW
 
	`__asm
 ("wcschr"è
__©Œibu‹_pu»__
;

227 "C++" cÚ¡ 
wch¬_t
 *
	$wcschr
 (cÚ¡ 
wch¬_t
 *
__wcs
, wch¬_ˆ
__wc
)

228 
__THROW
 
	`__asm
 ("wcschr"è
__©Œibu‹_pu»__
;

230 
wch¬_t
 *
	$wcschr
 (cÚ¡ 
wch¬_t
 *
__wcs
, wch¬_ˆ
__wc
)

231 
__THROW
 
__©Œibu‹_pu»__
;

234 #ifdeà
__CORRECT_ISO_CPP_WCHAR_H_PROTO


235 "C++" 
wch¬_t
 *
	$wc¤chr
 (
wch¬_t
 *
__wcs
, wch¬_ˆ
__wc
)

236 
__THROW
 
	`__asm
 ("wc¤chr"è
__©Œibu‹_pu»__
;

237 "C++" cÚ¡ 
wch¬_t
 *
	$wc¤chr
 (cÚ¡ 
wch¬_t
 *
__wcs
, wch¬_ˆ
__wc
)

238 
__THROW
 
	`__asm
 ("wc¤chr"è
__©Œibu‹_pu»__
;

240 
wch¬_t
 *
	$wc¤chr
 (cÚ¡ 
wch¬_t
 *
__wcs
, wch¬_ˆ
__wc
)

241 
__THROW
 
__©Œibu‹_pu»__
;

243 
__END_NAMESPACE_STD


245 #ifdeà
__USE_GNU


248 
wch¬_t
 *
	$wcschºul
 (cÚ¡ 
wch¬_t
 *
__s
, wch¬_ˆ
__wc
)

249 
__THROW
 
__©Œibu‹_pu»__
;

252 
__BEGIN_NAMESPACE_STD


255 
size_t
 
	$wcsc¥n
 (cÚ¡ 
wch¬_t
 *
__wcs
, cÚ¡ wch¬_ˆ*
__»jeù
)

256 
__THROW
 
__©Œibu‹_pu»__
;

259 
size_t
 
	$wcs¥n
 (cÚ¡ 
wch¬_t
 *
__wcs
, cÚ¡ wch¬_ˆ*
__acû±
)

260 
__THROW
 
__©Œibu‹_pu»__
;

262 #ifdeà
__CORRECT_ISO_CPP_WCHAR_H_PROTO


263 "C++" 
wch¬_t
 *
	$wc¥brk
 (
wch¬_t
 *
__wcs
, cÚ¡ wch¬_ˆ*
__acû±
)

264 
__THROW
 
	`__asm
 ("wc¥brk"è
__©Œibu‹_pu»__
;

265 "C++" cÚ¡ 
wch¬_t
 *
	$wc¥brk
 (cÚ¡ 
wch¬_t
 *
__wcs
,

266 cÚ¡ 
wch¬_t
 *
__acû±
)

267 
__THROW
 
	`__asm
 ("wc¥brk"è
__©Œibu‹_pu»__
;

269 
wch¬_t
 *
	$wc¥brk
 (cÚ¡ 
wch¬_t
 *
__wcs
, cÚ¡ wch¬_ˆ*
__acû±
)

270 
__THROW
 
__©Œibu‹_pu»__
;

273 #ifdeà
__CORRECT_ISO_CPP_WCHAR_H_PROTO


274 "C++" 
wch¬_t
 *
	$wcs¡r
 (
wch¬_t
 *
__hay¡ack
, cÚ¡ wch¬_ˆ*
__ÃedË
)

275 
__THROW
 
	`__asm
 ("wcs¡r"è
__©Œibu‹_pu»__
;

276 "C++" cÚ¡ 
wch¬_t
 *
	$wcs¡r
 (cÚ¡ 
wch¬_t
 *
__hay¡ack
,

277 cÚ¡ 
wch¬_t
 *
__ÃedË
)

278 
__THROW
 
	`__asm
 ("wcs¡r"è
__©Œibu‹_pu»__
;

280 
wch¬_t
 *
	$wcs¡r
 (cÚ¡ 
wch¬_t
 *
__hay¡ack
, cÚ¡ wch¬_ˆ*
__ÃedË
)

281 
__THROW
 
__©Œibu‹_pu»__
;

285 
wch¬_t
 *
	$wc¡ok
 (
wch¬_t
 *
__»¡riù
 
__s
,

286 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__d–im
,

287 
wch¬_t
 **
__»¡riù
 
__±r
è
__THROW
;

290 
size_t
 
	$wc¦’
 (cÚ¡ 
wch¬_t
 *
__s
è
__THROW
 
__©Œibu‹_pu»__
;

291 
__END_NAMESPACE_STD


293 #ifdeà
__USE_XOPEN


295 #ifdeà
__CORRECT_ISO_CPP_WCHAR_H_PROTO


296 "C++" 
wch¬_t
 *
	$wcswcs
 (
wch¬_t
 *
__hay¡ack
, cÚ¡ wch¬_ˆ*
__ÃedË
)

297 
__THROW
 
	`__asm
 ("wcswcs"è
__©Œibu‹_pu»__
;

298 "C++" cÚ¡ 
wch¬_t
 *
	$wcswcs
 (cÚ¡ 
wch¬_t
 *
__hay¡ack
,

299 cÚ¡ 
wch¬_t
 *
__ÃedË
)

300 
__THROW
 
	`__asm
 ("wcswcs"è
__©Œibu‹_pu»__
;

302 
wch¬_t
 *
	$wcswcs
 (cÚ¡ 
wch¬_t
 *
__hay¡ack
, cÚ¡ wch¬_ˆ*
__ÃedË
)

303 
__THROW
 
__©Œibu‹_pu»__
;

307 #ifdeà
__USE_XOPEN2K8


309 
size_t
 
	$wc¢Ën
 (cÚ¡ 
wch¬_t
 *
__s
, 
size_t
 
__maxËn
)

310 
__THROW
 
__©Œibu‹_pu»__
;

314 
__BEGIN_NAMESPACE_STD


316 #ifdeà
__CORRECT_ISO_CPP_WCHAR_H_PROTO


317 "C++" 
wch¬_t
 *
	$wmemchr
 (
wch¬_t
 *
__s
, wch¬_ˆ
__c
, 
size_t
 
__n
)

318 
__THROW
 
	`__asm
 ("wmemchr"è
__©Œibu‹_pu»__
;

319 "C++" cÚ¡ 
wch¬_t
 *
	$wmemchr
 (cÚ¡ 
wch¬_t
 *
__s
, wch¬_ˆ
__c
,

320 
size_t
 
__n
)

321 
__THROW
 
	`__asm
 ("wmemchr"è
__©Œibu‹_pu»__
;

323 
wch¬_t
 *
	$wmemchr
 (cÚ¡ 
wch¬_t
 *
__s
, wch¬_ˆ
__c
, 
size_t
 
__n
)

324 
__THROW
 
__©Œibu‹_pu»__
;

328 
	$wmemcmp
 (cÚ¡ 
wch¬_t
 *
__s1
, cÚ¡ wch¬_ˆ*
__s2
, 
size_t
 
__n
)

329 
__THROW
 
__©Œibu‹_pu»__
;

332 
wch¬_t
 *
	$wmemýy
 (
wch¬_t
 *
__»¡riù
 
__s1
,

333 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__s2
, 
size_t
 
__n
è
__THROW
;

337 
wch¬_t
 *
	$wmemmove
 (
wch¬_t
 *
__s1
, cÚ¡ wch¬_ˆ*
__s2
, 
size_t
 
__n
)

338 
__THROW
;

341 
wch¬_t
 *
	$wmem£t
 (
wch¬_t
 *
__s
, wch¬_ˆ
__c
, 
size_t
 
__n
è
__THROW
;

342 
__END_NAMESPACE_STD


344 #ifdeà
__USE_GNU


347 
wch¬_t
 *
	$wmempýy
 (
wch¬_t
 *
__»¡riù
 
__s1
,

348 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__s2
, 
size_t
 
__n
)

349 
__THROW
;

353 
__BEGIN_NAMESPACE_STD


356 
wšt_t
 
	$btowc
 (
__c
è
__THROW
;

360 
	$wùob
 (
wšt_t
 
__c
è
__THROW
;

364 
	$mbsš™
 (cÚ¡ 
mb¡©e_t
 *
__ps
è
__THROW
 
__©Œibu‹_pu»__
;

368 
size_t
 
	$mb¹owc
 (
wch¬_t
 *
__»¡riù
 
__pwc
,

369 cÚ¡ *
__»¡riù
 
__s
, 
size_t
 
__n
,

370 
mb¡©e_t
 *
__»¡riù
 
__p
è
__THROW
;

373 
size_t
 
	$wütomb
 (*
__»¡riù
 
__s
, 
wch¬_t
 
__wc
,

374 
mb¡©e_t
 *
__»¡riù
 
__ps
è
__THROW
;

377 
size_t
 
	$__mb¾’
 (cÚ¡ *
__»¡riù
 
__s
, 
size_t
 
__n
,

378 
mb¡©e_t
 *
__»¡riù
 
__ps
è
__THROW
;

379 
size_t
 
	$mb¾’
 (cÚ¡ *
__»¡riù
 
__s
, 
size_t
 
__n
,

380 
mb¡©e_t
 *
__»¡riù
 
__ps
è
__THROW
;

381 
__END_NAMESPACE_STD


383 #ifdeà
__USE_EXTERN_INLINES


389 
wšt_t
 
	$__btowc_®Ÿs
 (
__c
è
	`__asm
 ("btowc");

390 
__ex‹º_šlše
 
wšt_t


391 
	`__NTH
 (
	$btowc
 (
__c
))

392 {  (
	`__bužtš_cÚ¡ªt_p
 (
__c
) && __c >= '\0' && __c <= '\x7f'

393 ? (
wšt_t
è
__c
 : 
	`__btowc_®Ÿs
 (__c)); 
	}
}

395 
	$__wùob_®Ÿs
 (
wšt_t
 
__c
è
	`__asm
 ("wctob");

396 
__ex‹º_šlše
 

397 
	`__NTH
 (
	$wùob
 (
wšt_t
 
__wc
))

398 {  (
	`__bužtš_cÚ¡ªt_p
 (
__wc
è&& __wø>ð
L
'\0' && __wc <= L'\x7f'

399 ? (è
__wc
 : 
	`__wùob_®Ÿs
 (__wc)); 
	}
}

401 
__ex‹º_šlše
 
size_t


402 
__NTH
 (
	$mb¾’
 (cÚ¡ *
__»¡riù
 
__s
, 
size_t
 
__n
,

403 
mb¡©e_t
 *
__»¡riù
 
__ps
))

404 {  (
__ps
 !ð
NULL


405 ? 
	`mb¹owc
 (
NULL
, 
__s
, 
__n
, 
__ps
è: 
	`__mb¾’
 (__s, __n, NULL)); 
	}
}

408 
__BEGIN_NAMESPACE_STD


411 
size_t
 
	$mb¤towcs
 (
wch¬_t
 *
__»¡riù
 
__d¡
,

412 cÚ¡ **
__»¡riù
 
__¤c
, 
size_t
 
__Ën
,

413 
mb¡©e_t
 *
__»¡riù
 
__ps
è
__THROW
;

417 
size_t
 
	$wc¤tombs
 (*
__»¡riù
 
__d¡
,

418 cÚ¡ 
wch¬_t
 **
__»¡riù
 
__¤c
, 
size_t
 
__Ën
,

419 
mb¡©e_t
 *
__»¡riù
 
__ps
è
__THROW
;

420 
__END_NAMESPACE_STD


423 #ifdef 
__USE_XOPEN2K8


426 
size_t
 
	$mb¢¹owcs
 (
wch¬_t
 *
__»¡riù
 
__d¡
,

427 cÚ¡ **
__»¡riù
 
__¤c
, 
size_t
 
__nmc
,

428 
size_t
 
__Ën
, 
mb¡©e_t
 *
__»¡riù
 
__ps
è
__THROW
;

432 
size_t
 
	$wc¢¹ombs
 (*
__»¡riù
 
__d¡
,

433 cÚ¡ 
wch¬_t
 **
__»¡riù
 
__¤c
,

434 
size_t
 
__nwc
, size_ˆ
__Ën
,

435 
mb¡©e_t
 *
__»¡riù
 
__ps
è
__THROW
;

440 #ifdeà
__USE_XOPEN


442 
	$wcwidth
 (
wch¬_t
 
__c
è
__THROW
;

446 
	$wcswidth
 (cÚ¡ 
wch¬_t
 *
__s
, 
size_t
 
__n
è
__THROW
;

450 
__BEGIN_NAMESPACE_STD


453 
	$wc¡od
 (cÚ¡ 
wch¬_t
 *
__»¡riù
 
__ÅŒ
,

454 
wch¬_t
 **
__»¡riù
 
__’d±r
è
__THROW
;

455 
__END_NAMESPACE_STD


457 #ifdeà
__USE_ISOC99


458 
__BEGIN_NAMESPACE_C99


460 
	$wc¡of
 (cÚ¡ 
wch¬_t
 *
__»¡riù
 
__ÅŒ
,

461 
wch¬_t
 **
__»¡riù
 
__’d±r
è
__THROW
;

462 
	$wc¡Þd
 (cÚ¡ 
wch¬_t
 *
__»¡riù
 
__ÅŒ
,

463 
wch¬_t
 **
__»¡riù
 
__’d±r
è
__THROW
;

464 
__END_NAMESPACE_C99


468 
__BEGIN_NAMESPACE_STD


471 
	$wc¡Þ
 (cÚ¡ 
wch¬_t
 *
__»¡riù
 
__ÅŒ
,

472 
wch¬_t
 **
__»¡riù
 
__’d±r
, 
__ba£
è
__THROW
;

476 
	$wc¡oul
 (cÚ¡ 
wch¬_t
 *
__»¡riù
 
__ÅŒ
,

477 
wch¬_t
 **
__»¡riù
 
__’d±r
, 
__ba£
)

478 
__THROW
;

479 
__END_NAMESPACE_STD


481 #ifdeà
__USE_ISOC99


482 
__BEGIN_NAMESPACE_C99


485 
__ex‹nsiÚ__


486 
	$wc¡Þl
 (cÚ¡ 
wch¬_t
 *
__»¡riù
 
__ÅŒ
,

487 
wch¬_t
 **
__»¡riù
 
__’d±r
, 
__ba£
)

488 
__THROW
;

492 
__ex‹nsiÚ__


493 
	$wc¡ouÎ
 (cÚ¡ 
wch¬_t
 *
__»¡riù
 
__ÅŒ
,

494 
wch¬_t
 **
__»¡riù
 
__’d±r
,

495 
__ba£
è
__THROW
;

496 
__END_NAMESPACE_C99


499 #ifdeà
__USE_GNU


502 
__ex‹nsiÚ__


503 
	$wc¡oq
 (cÚ¡ 
wch¬_t
 *
__»¡riù
 
__ÅŒ
,

504 
wch¬_t
 **
__»¡riù
 
__’d±r
, 
__ba£
)

505 
__THROW
;

509 
__ex‹nsiÚ__


510 
	$wc¡ouq
 (cÚ¡ 
wch¬_t
 *
__»¡riù
 
__ÅŒ
,

511 
wch¬_t
 **
__»¡riù
 
__’d±r
,

512 
__ba£
è
__THROW
;

515 #ifdeà
__USE_GNU


529 
	~<xloÿË.h
>

533 
	$wc¡Þ_l
 (cÚ¡ 
wch¬_t
 *
__»¡riù
 
__ÅŒ
,

534 
wch¬_t
 **
__»¡riù
 
__’d±r
, 
__ba£
,

535 
__loÿË_t
 
__loc
è
__THROW
;

537 
	$wc¡oul_l
 (cÚ¡ 
wch¬_t
 *
__»¡riù
 
__ÅŒ
,

538 
wch¬_t
 **
__»¡riù
 
__’d±r
,

539 
__ba£
, 
__loÿË_t
 
__loc
è
__THROW
;

541 
__ex‹nsiÚ__


542 
	$wc¡Þl_l
 (cÚ¡ 
wch¬_t
 *
__»¡riù
 
__ÅŒ
,

543 
wch¬_t
 **
__»¡riù
 
__’d±r
,

544 
__ba£
, 
__loÿË_t
 
__loc
è
__THROW
;

546 
__ex‹nsiÚ__


547 
	$wc¡ouÎ_l
 (cÚ¡ 
wch¬_t
 *
__»¡riù
 
__ÅŒ
,

548 
wch¬_t
 **
__»¡riù
 
__’d±r
,

549 
__ba£
, 
__loÿË_t
 
__loc
)

550 
__THROW
;

552 
	$wc¡od_l
 (cÚ¡ 
wch¬_t
 *
__»¡riù
 
__ÅŒ
,

553 
wch¬_t
 **
__»¡riù
 
__’d±r
, 
__loÿË_t
 
__loc
)

554 
__THROW
;

556 
	$wc¡of_l
 (cÚ¡ 
wch¬_t
 *
__»¡riù
 
__ÅŒ
,

557 
wch¬_t
 **
__»¡riù
 
__’d±r
, 
__loÿË_t
 
__loc
)

558 
__THROW
;

560 
	$wc¡Þd_l
 (cÚ¡ 
wch¬_t
 *
__»¡riù
 
__ÅŒ
,

561 
wch¬_t
 **
__»¡riù
 
__’d±r
,

562 
__loÿË_t
 
__loc
è
__THROW
;

566 #ifdeà
__USE_XOPEN2K8


569 
wch¬_t
 *
	$wýýy
 (
wch¬_t
 *
__»¡riù
 
__de¡
,

570 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__¤c
è
__THROW
;

574 
wch¬_t
 *
	$wýnýy
 (
wch¬_t
 *
__»¡riù
 
__de¡
,

575 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__¤c
, 
size_t
 
__n
)

576 
__THROW
;

583 
__FILE
 *
	$Ý’_wmem¡»am
 (
wch¬_t
 **
__buæoc
, 
size_t
 *
__siz–oc
è
__THROW
;

586 #ià
defšed
 
__USE_ISOC95
 || defšed 
__USE_UNIX98


587 
__BEGIN_NAMESPACE_STD


590 
	$fwide
 (
__FILE
 *
__å
, 
__mode
è
__THROW
;

597 
	`fw´štf
 (
__FILE
 *
__»¡riù
 
__¡»am
,

598 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fÜm©
, ...)

604 
	`w´štf
 (cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fÜm©
, ...)

607 
	$sw´štf
 (
wch¬_t
 *
__»¡riù
 
__s
, 
size_t
 
__n
,

608 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fÜm©
, ...)

609 
__THROW
 ;

615 
	`vfw´štf
 (
__FILE
 *
__»¡riù
 
__s
,

616 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fÜm©
,

617 
__gnuc_va_li¡
 
__¬g
)

623 
	`vw´štf
 (cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fÜm©
,

624 
__gnuc_va_li¡
 
__¬g
)

628 
	$vsw´štf
 (
wch¬_t
 *
__»¡riù
 
__s
, 
size_t
 
__n
,

629 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fÜm©
,

630 
__gnuc_va_li¡
 
__¬g
)

631 
__THROW
 ;

638 
	`fwsÿnf
 (
__FILE
 *
__»¡riù
 
__¡»am
,

639 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fÜm©
, ...)

645 
	`wsÿnf
 (cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fÜm©
, ...)

648 
	$swsÿnf
 (cÚ¡ 
wch¬_t
 *
__»¡riù
 
__s
,

649 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fÜm©
, ...)

650 
__THROW
 ;

652 #ià
defšed
 
__USE_ISOC99
 && !defšed 
__USE_GNU
 \

653 && (!
defšed
 
__LDBL_COMPAT
 || !defšed 
__REDIRECT
) \

654 && (
defšed
 
__STRICT_ANSI__
 || defšed 
__USE_XOPEN2K
)

655 #ifdeà
__REDIRECT


659 
	`__REDIRECT
 (
fwsÿnf
, (
__FILE
 *
__»¡riù
 
__¡»am
,

660 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fÜm©
, ...),

661 
__isoc99_fwsÿnf
)

663 
	`__REDIRECT
 (
wsÿnf
, (cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fÜm©
, ...),

664 
__isoc99_wsÿnf
)

666 
	`__REDIRECT_NTH
 (
swsÿnf
, (cÚ¡ 
wch¬_t
 *
__»¡riù
 
__s
,

667 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fÜm©
,

668 ...), 
__isoc99_swsÿnf
)

671 
	`__isoc99_fwsÿnf
 (
__FILE
 *
__»¡riù
 
__¡»am
,

672 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fÜm©
, ...);

673 
	`__isoc99_wsÿnf
 (cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fÜm©
, ...);

674 
	$__isoc99_swsÿnf
 (cÚ¡ 
wch¬_t
 *
__»¡riù
 
__s
,

675 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fÜm©
, ...)

676 
__THROW
;

677 
	#fwsÿnf
 
__isoc99_fwsÿnf


	)

678 
	#wsÿnf
 
__isoc99_wsÿnf


	)

679 
	#swsÿnf
 
__isoc99_swsÿnf


	)

683 
__END_NAMESPACE_STD


686 #ifdeà
__USE_ISOC99


687 
__BEGIN_NAMESPACE_C99


692 
	`vfwsÿnf
 (
__FILE
 *
__»¡riù
 
__s
,

693 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fÜm©
,

694 
__gnuc_va_li¡
 
__¬g
)

700 
	`vwsÿnf
 (cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fÜm©
,

701 
__gnuc_va_li¡
 
__¬g
)

704 
	$vswsÿnf
 (cÚ¡ 
wch¬_t
 *
__»¡riù
 
__s
,

705 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fÜm©
,

706 
__gnuc_va_li¡
 
__¬g
)

707 
__THROW
 ;

709 #ià!
defšed
 
__USE_GNU
 \

710 && (!
defšed
 
__LDBL_COMPAT
 || !defšed 
__REDIRECT
) \

711 && (
defšed
 
__STRICT_ANSI__
 || defšed 
__USE_XOPEN2K
)

712 #ifdeà
__REDIRECT


713 
	`__REDIRECT
 (
vfwsÿnf
, (
__FILE
 *
__»¡riù
 
__s
,

714 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fÜm©
,

715 
__gnuc_va_li¡
 
__¬g
), 
__isoc99_vfwsÿnf
)

717 
	`__REDIRECT
 (
vwsÿnf
, (cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fÜm©
,

718 
__gnuc_va_li¡
 
__¬g
), 
__isoc99_vwsÿnf
)

720 
	`__REDIRECT_NTH
 (
vswsÿnf
, (cÚ¡ 
wch¬_t
 *
__»¡riù
 
__s
,

721 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fÜm©
,

722 
__gnuc_va_li¡
 
__¬g
), 
__isoc99_vswsÿnf
)

725 
	`__isoc99_vfwsÿnf
 (
__FILE
 *
__»¡riù
 
__s
,

726 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fÜm©
,

727 
__gnuc_va_li¡
 
__¬g
);

728 
	`__isoc99_vwsÿnf
 (cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fÜm©
,

729 
__gnuc_va_li¡
 
__¬g
);

730 
	$__isoc99_vswsÿnf
 (cÚ¡ 
wch¬_t
 *
__»¡riù
 
__s
,

731 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fÜm©
,

732 
__gnuc_va_li¡
 
__¬g
è
__THROW
;

733 
	#vfwsÿnf
 
__isoc99_vfwsÿnf


	)

734 
	#vwsÿnf
 
__isoc99_vwsÿnf


	)

735 
	#vswsÿnf
 
__isoc99_vswsÿnf


	)

739 
__END_NAMESPACE_C99


743 
__BEGIN_NAMESPACE_STD


748 
wšt_t
 
	`fg‘wc
 (
__FILE
 *
__¡»am
);

749 
wšt_t
 
	`g‘wc
 (
__FILE
 *
__¡»am
);

755 
wšt_t
 
	`g‘wch¬
 ();

762 
wšt_t
 
	`åutwc
 (
wch¬_t
 
__wc
, 
__FILE
 *
__¡»am
);

763 
wšt_t
 
	`putwc
 (
wch¬_t
 
__wc
, 
__FILE
 *
__¡»am
);

769 
wšt_t
 
	`putwch¬
 (
wch¬_t
 
__wc
);

777 
wch¬_t
 *
	`fg‘ws
 (wch¬_ˆ*
__»¡riù
 
__ws
, 
__n
,

778 
__FILE
 *
__»¡riù
 
__¡»am
);

784 
	`åutws
 (cÚ¡ 
wch¬_t
 *
__»¡riù
 
__ws
,

785 
__FILE
 *
__»¡riù
 
__¡»am
);

792 
wšt_t
 
	`ung‘wc
 (wšt_ˆ
__wc
, 
__FILE
 *
__¡»am
);

793 
__END_NAMESPACE_STD


796 #ifdeà
__USE_GNU


804 
wšt_t
 
	`g‘wc_uÆocked
 (
__FILE
 *
__¡»am
);

805 
wšt_t
 
	`g‘wch¬_uÆocked
 ();

813 
wšt_t
 
	`fg‘wc_uÆocked
 (
__FILE
 *
__¡»am
);

821 
wšt_t
 
	`åutwc_uÆocked
 (
wch¬_t
 
__wc
, 
__FILE
 *
__¡»am
);

830 
wšt_t
 
	`putwc_uÆocked
 (
wch¬_t
 
__wc
, 
__FILE
 *
__¡»am
);

831 
wšt_t
 
	`putwch¬_uÆocked
 (
wch¬_t
 
__wc
);

840 
wch¬_t
 *
	`fg‘ws_uÆocked
 (wch¬_ˆ*
__»¡riù
 
__ws
, 
__n
,

841 
__FILE
 *
__»¡riù
 
__¡»am
);

849 
	`åutws_uÆocked
 (cÚ¡ 
wch¬_t
 *
__»¡riù
 
__ws
,

850 
__FILE
 *
__»¡riù
 
__¡»am
);

854 
__BEGIN_NAMESPACE_C99


858 
size_t
 
	$wcsáime
 (
wch¬_t
 *
__»¡riù
 
__s
, 
size_t
 
__maxsize
,

859 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fÜm©
,

860 cÚ¡ 
tm
 *
__»¡riù
 
__
è
__THROW
;

861 
__END_NAMESPACE_C99


863 #ifdeà
__USE_GNU


864 
	~<xloÿË.h
>

868 
size_t
 
	$wcsáime_l
 (
wch¬_t
 *
__»¡riù
 
__s
, 
size_t
 
__maxsize
,

869 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fÜm©
,

870 cÚ¡ 
tm
 *
__»¡riù
 
__
,

871 
__loÿË_t
 
__loc
è
__THROW
;

880 #ià
defšed
 
__USE_UNIX98
 && !defšed 
__USE_GNU


881 
	#__Ãed_iswxxx


	)

882 
	~<wùy³.h
>

886 #ià
__USE_FORTIFY_LEVEL
 > 0 && 
defšed
 
__fÜtify_funùiÚ


887 
	~<b™s/wch¬2.h
>

890 #ifdeà
__LDBL_COMPAT


891 
	~<b™s/wch¬-ldbl.h
>

894 
__END_DECLS


902 #undeà
__Ãed_mb¡©e_t


903 #undeà
__Ãed_wšt_t


	@/usr/include/asm-generic/errno.h

1 #iâdeà
_ASM_GENERIC_ERRNO_H


2 
	#_ASM_GENERIC_ERRNO_H


	)

4 
	~<asm-g’”ic/”ºo-ba£.h
>

6 
	#EDEADLK
 35

	)

7 
	#ENAMETOOLONG
 36

	)

8 
	#ENOLCK
 37

	)

17 
	#ENOSYS
 38

	)

19 
	#ENOTEMPTY
 39

	)

20 
	#ELOOP
 40

	)

21 
	#EWOULDBLOCK
 
EAGAIN


	)

22 
	#ENOMSG
 42

	)

23 
	#EIDRM
 43

	)

24 
	#ECHRNG
 44

	)

25 
	#EL2NSYNC
 45

	)

26 
	#EL3HLT
 46

	)

27 
	#EL3RST
 47

	)

28 
	#ELNRNG
 48

	)

29 
	#EUNATCH
 49

	)

30 
	#ENOCSI
 50

	)

31 
	#EL2HLT
 51

	)

32 
	#EBADE
 52

	)

33 
	#EBADR
 53

	)

34 
	#EXFULL
 54

	)

35 
	#ENOANO
 55

	)

36 
	#EBADRQC
 56

	)

37 
	#EBADSLT
 57

	)

39 
	#EDEADLOCK
 
EDEADLK


	)

41 
	#EBFONT
 59

	)

42 
	#ENOSTR
 60

	)

43 
	#ENODATA
 61

	)

44 
	#ETIME
 62

	)

45 
	#ENOSR
 63

	)

46 
	#ENONET
 64

	)

47 
	#ENOPKG
 65

	)

48 
	#EREMOTE
 66

	)

49 
	#ENOLINK
 67

	)

50 
	#EADV
 68

	)

51 
	#ESRMNT
 69

	)

52 
	#ECOMM
 70

	)

53 
	#EPROTO
 71

	)

54 
	#EMULTIHOP
 72

	)

55 
	#EDOTDOT
 73

	)

56 
	#EBADMSG
 74

	)

57 
	#EOVERFLOW
 75

	)

58 
	#ENOTUNIQ
 76

	)

59 
	#EBADFD
 77

	)

60 
	#EREMCHG
 78

	)

61 
	#ELIBACC
 79

	)

62 
	#ELIBBAD
 80

	)

63 
	#ELIBSCN
 81

	)

64 
	#ELIBMAX
 82

	)

65 
	#ELIBEXEC
 83

	)

66 
	#EILSEQ
 84

	)

67 
	#ERESTART
 85

	)

68 
	#ESTRPIPE
 86

	)

69 
	#EUSERS
 87

	)

70 
	#ENOTSOCK
 88

	)

71 
	#EDESTADDRREQ
 89

	)

72 
	#EMSGSIZE
 90

	)

73 
	#EPROTOTYPE
 91

	)

74 
	#ENOPROTOOPT
 92

	)

75 
	#EPROTONOSUPPORT
 93

	)

76 
	#ESOCKTNOSUPPORT
 94

	)

77 
	#EOPNOTSUPP
 95

	)

78 
	#EPFNOSUPPORT
 96

	)

79 
	#EAFNOSUPPORT
 97

	)

80 
	#EADDRINUSE
 98

	)

81 
	#EADDRNOTAVAIL
 99

	)

82 
	#ENETDOWN
 100

	)

83 
	#ENETUNREACH
 101

	)

84 
	#ENETRESET
 102

	)

85 
	#ECONNABORTED
 103

	)

86 
	#ECONNRESET
 104

	)

87 
	#ENOBUFS
 105

	)

88 
	#EISCONN
 106

	)

89 
	#ENOTCONN
 107

	)

90 
	#ESHUTDOWN
 108

	)

91 
	#ETOOMANYREFS
 109

	)

92 
	#ETIMEDOUT
 110

	)

93 
	#ECONNREFUSED
 111

	)

94 
	#EHOSTDOWN
 112

	)

95 
	#EHOSTUNREACH
 113

	)

96 
	#EALREADY
 114

	)

97 
	#EINPROGRESS
 115

	)

98 
	#ESTALE
 116

	)

99 
	#EUCLEAN
 117

	)

100 
	#ENOTNAM
 118

	)

101 
	#ENAVAIL
 119

	)

102 
	#EISNAM
 120

	)

103 
	#EREMOTEIO
 121

	)

104 
	#EDQUOT
 122

	)

106 
	#ENOMEDIUM
 123

	)

107 
	#EMEDIUMTYPE
 124

	)

108 
	#ECANCELED
 125

	)

109 
	#ENOKEY
 126

	)

110 
	#EKEYEXPIRED
 127

	)

111 
	#EKEYREVOKED
 128

	)

112 
	#EKEYREJECTED
 129

	)

115 
	#EOWNERDEAD
 130

	)

116 
	#ENOTRECOVERABLE
 131

	)

118 
	#ERFKILL
 132

	)

120 
	#EHWPOISON
 133

	)

	@/usr/include/asm-generic/int-ll64.h

8 #iâdeà
_ASM_GENERIC_INT_LL64_H


9 
	#_ASM_GENERIC_INT_LL64_H


	)

11 
	~<asm/b™¥”lÚg.h
>

13 #iâdeà
__ASSEMBLY__


19 
__sigÃd__
 
	t__s8
;

20 
	t__u8
;

22 
__sigÃd__
 
	t__s16
;

23 
	t__u16
;

25 
__sigÃd__
 
	t__s32
;

26 
	t__u32
;

28 #ifdeà
__GNUC__


29 
__ex‹nsiÚ__
 
__sigÃd__
 
	t__s64
;

30 
__ex‹nsiÚ__
 
	t__u64
;

32 
__sigÃd__
 
	t__s64
;

33 
	t__u64
;

	@/usr/include/asm/posix_types_32.h

1 #iâdeà
_ASM_X86_POSIX_TYPES_32_H


2 
	#_ASM_X86_POSIX_TYPES_32_H


	)

10 
	t__k”Ãl_mode_t
;

11 
	#__k”Ãl_mode_t
 
__k”Ãl_mode_t


	)

13 
	t__k”Ãl_c_pid_t
;

14 
	#__k”Ãl_c_pid_t
 
__k”Ãl_c_pid_t


	)

16 
	t__k”Ãl_uid_t
;

17 
	t__k”Ãl_gid_t
;

18 
	#__k”Ãl_uid_t
 
__k”Ãl_uid_t


	)

20 
	t__k”Ãl_Þd_dev_t
;

21 
	#__k”Ãl_Þd_dev_t
 
__k”Ãl_Þd_dev_t


	)

23 
	~<asm-g’”ic/posix_ty³s.h
>

	@/usr/include/asm/posix_types_64.h

1 #iâdeà
_ASM_X86_POSIX_TYPES_64_H


2 
	#_ASM_X86_POSIX_TYPES_64_H


	)

10 
	t__k”Ãl_Þd_uid_t
;

11 
	t__k”Ãl_Þd_gid_t
;

12 
	#__k”Ãl_Þd_uid_t
 
__k”Ãl_Þd_uid_t


	)

14 
	t__k”Ãl_Þd_dev_t
;

15 
	#__k”Ãl_Þd_dev_t
 
__k”Ãl_Þd_dev_t


	)

17 
	~<asm-g’”ic/posix_ty³s.h
>

	@/usr/include/asm/posix_types_x32.h

1 #iâdeà
_ASM_X86_POSIX_TYPES_X32_H


2 
	#_ASM_X86_POSIX_TYPES_X32_H


	)

13 
	t__k”Ãl_lÚg_t
;

14 
	t__k”Ãl_ulÚg_t
;

15 
	#__k”Ãl_lÚg_t
 
__k”Ãl_lÚg_t


	)

17 
	~<asm/posix_ty³s_64.h
>

	@/usr/include/bits/wchar-ldbl.h

19 #iâdeà
_WCHAR_H


23 #ià
defšed
 
__USE_ISOC95
 || defšed 
__USE_UNIX98


24 
__BEGIN_NAMESPACE_C99


25 
__LDBL_REDIR_DECL
 (
fw´štf
);

26 
__LDBL_REDIR_DECL
 (
w´štf
);

27 
__LDBL_REDIR_DECL
 (
sw´štf
);

28 
__LDBL_REDIR_DECL
 (
vfw´štf
);

29 
__LDBL_REDIR_DECL
 (
vw´štf
);

30 
__LDBL_REDIR_DECL
 (
vsw´štf
);

31 #ià
defšed
 
__USE_ISOC99
 && !defšed 
__USE_GNU
 \

32 && !
defšed
 
	g__REDIRECT
 \

33 && (
defšed
 
	g__STRICT_ANSI__
 || defšed 
	g__USE_XOPEN2K
)

34 
	$__LDBL_REDIR1_DECL
 (
fwsÿnf
, 
__Ædbl___isoc99_fwsÿnf
)

35 
	$__LDBL_REDIR1_DECL
 (
wsÿnf
, 
__Ædbl___isoc99_wsÿnf
)

36 
	$__LDBL_REDIR1_DECL
 (
swsÿnf
, 
__Ædbl___isoc99_swsÿnf
)

38 
	`__LDBL_REDIR_DECL
 (
fwsÿnf
);

39 
	`__LDBL_REDIR_DECL
 (
wsÿnf
);

40 
	`__LDBL_REDIR_DECL
 (
swsÿnf
);

42 
__END_NAMESPACE_C99


45 #ifdeà
__USE_ISOC99


46 
__BEGIN_NAMESPACE_C99


47 
	`__LDBL_REDIR1_DECL
 (
wc¡Þd
, 
wc¡od
);

48 #ià!
defšed
 
__USE_GNU
 && !defšed 
__REDIRECT
 \

49 && (
defšed
 
__STRICT_ANSI__
 || defšed 
__USE_XOPEN2K
)

50 
	$__LDBL_REDIR1_DECL
 (
vfwsÿnf
, 
__Ædbl___isoc99_vfwsÿnf
)

51 
	$__LDBL_REDIR1_DECL
 (
vwsÿnf
, 
__Ædbl___isoc99_vwsÿnf
)

52 
	$__LDBL_REDIR1_DECL
 (
vswsÿnf
, 
__Ædbl___isoc99_vswsÿnf
)

54 
	`__LDBL_REDIR_DECL
 (
vfwsÿnf
);

55 
	`__LDBL_REDIR_DECL
 (
vwsÿnf
);

56 
	`__LDBL_REDIR_DECL
 (
vswsÿnf
);

58 
__END_NAMESPACE_C99


61 #ifdeà
__USE_GNU


62 
	`__LDBL_REDIR1_DECL
 (
wc¡Þd_l
, 
wc¡od_l
);

65 #ià
__USE_FORTIFY_LEVEL
 > 0 && 
defšed
 
__fÜtify_funùiÚ


66 
	$__LDBL_REDIR_DECL
 (
__sw´štf_chk
)

67 
	$__LDBL_REDIR_DECL
 (
__vsw´štf_chk
)

68 #ià
__USE_FORTIFY_LEVEL
 > 1

69 
	$__LDBL_REDIR_DECL
 (
__fw´štf_chk
)

70 
	$__LDBL_REDIR_DECL
 (
__w´štf_chk
)

71 
	$__LDBL_REDIR_DECL
 (
__vfw´štf_chk
)

72 
	$__LDBL_REDIR_DECL
 (
__vw´štf_chk
)

	@/usr/include/bits/wchar.h

19 #iâdeà
_BITS_WCHAR_H


20 
	#_BITS_WCHAR_H
 1

	)

33 #ifdeà
__WCHAR_MAX__


34 
	#__WCHAR_MAX
 
__WCHAR_MAX__


	)

35 #–ià
L
'\0' - 1 > 0

36 
	#__WCHAR_MAX
 (0xffffffffu + 
L
'\0')

	)

38 
	#__WCHAR_MAX
 (0x7ffffffà+ 
L
'\0')

	)

41 #ifdeà
__WCHAR_MIN__


42 
	#__WCHAR_MIN
 
__WCHAR_MIN__


	)

43 #–ià
L
'\0' - 1 > 0

44 
	#__WCHAR_MIN
 (
L
'\0' + 0)

	)

46 
	#__WCHAR_MIN
 (-
__WCHAR_MAX
 - 1)

	)

	@/usr/include/bits/wchar2.h

19 #iâdeà
_WCHAR_H


24 
wch¬_t
 *
	$__wmemýy_chk
 (
wch¬_t
 *
__»¡riù
 
__s1
,

25 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__s2
, 
size_t
 
__n
,

26 
size_t
 
__ns1
è
__THROW
;

27 
wch¬_t
 *
	`__REDIRECT_NTH
 (
__wmemýy_®Ÿs
,

28 (
wch¬_t
 *
__»¡riù
 
__s1
,

29 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__s2
, 
size_t
 
__n
),

30 
wmemýy
);

31 
wch¬_t
 *
	`__REDIRECT_NTH
 (
__wmemýy_chk_w¬n
,

32 (
wch¬_t
 *
__»¡riù
 
__s1
,

33 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__s2
, 
size_t
 
__n
,

34 
size_t
 
__ns1
), 
__wmemýy_chk
)

35 
	`__w¬Ç‰r
 ("wmemcpy called with†ength biggerhan size of destination "

38 
__fÜtify_funùiÚ
 
wch¬_t
 *

39 
	`__NTH
 (
	$wmemýy
 (
wch¬_t
 *
__»¡riù
 
__s1
, cÚ¡ wch¬_ˆ*__»¡riù 
__s2
,

40 
size_t
 
__n
))

42 ià(
	`__bos0
 (
__s1
è!ð(
size_t
) -1)

44 ià(!
	`__bužtš_cÚ¡ªt_p
 (
__n
))

45  
	`__wmemýy_chk
 (
__s1
, 
__s2
, 
__n
,

46 
	`__bos0
 (
__s1
è/  (
wch¬_t
));

48 ià(
__n
 > 
	`__bos0
 (
__s1
è/  (
wch¬_t
))

49  
	`__wmemýy_chk_w¬n
 (
__s1
, 
__s2
, 
__n
,

50 
	`__bos0
 (
__s1
è/  (
wch¬_t
));

52  
	`__wmemýy_®Ÿs
 (
__s1
, 
__s2
, 
__n
);

53 
	}
}

56 
wch¬_t
 *
	$__wmemmove_chk
 (
wch¬_t
 *
__s1
, cÚ¡ wch¬_ˆ*
__s2
,

57 
size_t
 
__n
, size_ˆ
__ns1
è
__THROW
;

58 
wch¬_t
 *
	`__REDIRECT_NTH
 (
__wmemmove_®Ÿs
, (wch¬_ˆ*
__s1
,

59 cÚ¡ 
wch¬_t
 *
__s2
,

60 
size_t
 
__n
), 
wmemmove
);

61 
wch¬_t
 *
	`__REDIRECT_NTH
 (
__wmemmove_chk_w¬n
,

62 (
wch¬_t
 *
__s1
, cÚ¡ wch¬_ˆ*
__s2
,

63 
size_t
 
__n
, size_ˆ
__ns1
), 
__wmemmove_chk
)

64 
	`__w¬Ç‰r
 ("wmemmove called with†ength biggerhan size of destination "

67 
__fÜtify_funùiÚ
 
wch¬_t
 *

68 
	`__NTH
 (
	$wmemmove
 (
wch¬_t
 *
__s1
, cÚ¡ wch¬_ˆ*
__s2
, 
size_t
 
__n
))

70 ià(
	`__bos0
 (
__s1
è!ð(
size_t
) -1)

72 ià(!
	`__bužtš_cÚ¡ªt_p
 (
__n
))

73  
	`__wmemmove_chk
 (
__s1
, 
__s2
, 
__n
,

74 
	`__bos0
 (
__s1
è/  (
wch¬_t
));

76 ià(
__n
 > 
	`__bos0
 (
__s1
è/  (
wch¬_t
))

77  
	`__wmemmove_chk_w¬n
 (
__s1
, 
__s2
, 
__n
,

78 
	`__bos0
 (
__s1
è/  (
wch¬_t
));

80  
	`__wmemmove_®Ÿs
 (
__s1
, 
__s2
, 
__n
);

81 
	}
}

84 #ifdeà
__USE_GNU


85 
wch¬_t
 *
	$__wmempýy_chk
 (
wch¬_t
 *
__»¡riù
 
__s1
,

86 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__s2
, 
size_t
 
__n
,

87 
size_t
 
__ns1
è
__THROW
;

88 
wch¬_t
 *
	`__REDIRECT_NTH
 (
__wmempýy_®Ÿs
,

89 (
wch¬_t
 *
__»¡riù
 
__s1
,

90 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__s2
,

91 
size_t
 
__n
), 
wmempýy
);

92 
wch¬_t
 *
	`__REDIRECT_NTH
 (
__wmempýy_chk_w¬n
,

93 (
wch¬_t
 *
__»¡riù
 
__s1
,

94 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__s2
, 
size_t
 
__n
,

95 
size_t
 
__ns1
), 
__wmempýy_chk
)

96 
	`__w¬Ç‰r
 ("wmempcpy called with†ength biggerhan size of destination "

99 
__fÜtify_funùiÚ
 
wch¬_t
 *

100 
	`__NTH
 (
	$wmempýy
 (
wch¬_t
 *
__»¡riù
 
__s1
, cÚ¡ wch¬_ˆ*__»¡riù 
__s2
,

101 
size_t
 
__n
))

103 ià(
	`__bos0
 (
__s1
è!ð(
size_t
) -1)

105 ià(!
	`__bužtš_cÚ¡ªt_p
 (
__n
))

106  
	`__wmempýy_chk
 (
__s1
, 
__s2
, 
__n
,

107 
	`__bos0
 (
__s1
è/  (
wch¬_t
));

109 ià(
__n
 > 
	`__bos0
 (
__s1
è/  (
wch¬_t
))

110  
	`__wmempýy_chk_w¬n
 (
__s1
, 
__s2
, 
__n
,

111 
	`__bos0
 (
__s1
è/  (
wch¬_t
));

113  
	`__wmempýy_®Ÿs
 (
__s1
, 
__s2
, 
__n
);

114 
	}
}

118 
wch¬_t
 *
	$__wmem£t_chk
 (
wch¬_t
 *
__s
, wch¬_ˆ
__c
, 
size_t
 
__n
,

119 
size_t
 
__ns
è
__THROW
;

120 
wch¬_t
 *
	`__REDIRECT_NTH
 (
__wmem£t_®Ÿs
, (wch¬_ˆ*
__s
, wch¬_ˆ
__c
,

121 
size_t
 
__n
), 
wmem£t
);

122 
wch¬_t
 *
	`__REDIRECT_NTH
 (
__wmem£t_chk_w¬n
,

123 (
wch¬_t
 *
__s
, wch¬_ˆ
__c
, 
size_t
 
__n
,

124 
size_t
 
__ns
), 
__wmem£t_chk
)

125 
	`__w¬Ç‰r
 ("wmemset called with†ength biggerhan size of destination "

128 
__fÜtify_funùiÚ
 
wch¬_t
 *

129 
	`__NTH
 (
	$wmem£t
 (
wch¬_t
 *
__s
, wch¬_ˆ
__c
, 
size_t
 
__n
))

131 ià(
	`__bos0
 (
__s
è!ð(
size_t
) -1)

133 ià(!
	`__bužtš_cÚ¡ªt_p
 (
__n
))

134  
	`__wmem£t_chk
 (
__s
, 
__c
, 
__n
, 
	`__bos0
 (__sè/  (
wch¬_t
));

136 ià(
__n
 > 
	`__bos0
 (
__s
è/  (
wch¬_t
))

137  
	`__wmem£t_chk_w¬n
 (
__s
, 
__c
, 
__n
,

138 
	`__bos0
 (
__s
è/  (
wch¬_t
));

140  
	`__wmem£t_®Ÿs
 (
__s
, 
__c
, 
__n
);

141 
	}
}

144 
wch¬_t
 *
	$__wcsýy_chk
 (
wch¬_t
 *
__»¡riù
 
__de¡
,

145 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__¤c
,

146 
size_t
 
__n
è
__THROW
;

147 
wch¬_t
 *
	`__REDIRECT_NTH
 (
__wcsýy_®Ÿs
,

148 (
wch¬_t
 *
__»¡riù
 
__de¡
,

149 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__¤c
), 
wcsýy
);

151 
__fÜtify_funùiÚ
 
wch¬_t
 *

152 
	`__NTH
 (
	$wcsýy
 (
wch¬_t
 *
__»¡riù
 
__de¡
, cÚ¡ wch¬_ˆ*__»¡riù 
__¤c
))

154 ià(
	`__bos
 (
__de¡
è!ð(
size_t
) -1)

155  
	`__wcsýy_chk
 (
__de¡
, 
__¤c
, 
	`__bos
 (__de¡è/  (
wch¬_t
));

156  
	`__wcsýy_®Ÿs
 (
__de¡
, 
__¤c
);

157 
	}
}

160 
wch¬_t
 *
	$__wýýy_chk
 (
wch¬_t
 *
__»¡riù
 
__de¡
,

161 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__¤c
,

162 
size_t
 
__de¡Ën
è
__THROW
;

163 
wch¬_t
 *
	`__REDIRECT_NTH
 (
__wýýy_®Ÿs
,

164 (
wch¬_t
 *
__»¡riù
 
__de¡
,

165 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__¤c
), 
wýýy
);

167 
__fÜtify_funùiÚ
 
wch¬_t
 *

168 
	`__NTH
 (
	$wýýy
 (
wch¬_t
 *
__»¡riù
 
__de¡
, cÚ¡ wch¬_ˆ*__»¡riù 
__¤c
))

170 ià(
	`__bos
 (
__de¡
è!ð(
size_t
) -1)

171  
	`__wýýy_chk
 (
__de¡
, 
__¤c
, 
	`__bos
 (__de¡è/  (
wch¬_t
));

172  
	`__wýýy_®Ÿs
 (
__de¡
, 
__¤c
);

173 
	}
}

176 
wch¬_t
 *
	$__wc¢ýy_chk
 (
wch¬_t
 *
__»¡riù
 
__de¡
,

177 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__¤c
, 
size_t
 
__n
,

178 
size_t
 
__de¡Ën
è
__THROW
;

179 
wch¬_t
 *
	`__REDIRECT_NTH
 (
__wc¢ýy_®Ÿs
,

180 (
wch¬_t
 *
__»¡riù
 
__de¡
,

181 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__¤c
,

182 
size_t
 
__n
), 
wc¢ýy
);

183 
wch¬_t
 *
	`__REDIRECT_NTH
 (
__wc¢ýy_chk_w¬n
,

184 (
wch¬_t
 *
__»¡riù
 
__de¡
,

185 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__¤c
,

186 
size_t
 
__n
, size_ˆ
__de¡Ën
), 
__wc¢ýy_chk
)

187 
	`__w¬Ç‰r
 ("wcsncpy called with†ength biggerhan size of destination "

190 
__fÜtify_funùiÚ
 
wch¬_t
 *

191 
	`__NTH
 (
	$wc¢ýy
 (
wch¬_t
 *
__»¡riù
 
__de¡
, cÚ¡ wch¬_ˆ*__»¡riù 
__¤c
,

192 
size_t
 
__n
))

194 ià(
	`__bos
 (
__de¡
è!ð(
size_t
) -1)

196 ià(!
	`__bužtš_cÚ¡ªt_p
 (
__n
))

197  
	`__wc¢ýy_chk
 (
__de¡
, 
__¤c
, 
__n
,

198 
	`__bos
 (
__de¡
è/  (
wch¬_t
));

199 ià(
__n
 > 
	`__bos
 (
__de¡
è/  (
wch¬_t
))

200  
	`__wc¢ýy_chk_w¬n
 (
__de¡
, 
__¤c
, 
__n
,

201 
	`__bos
 (
__de¡
è/  (
wch¬_t
));

203  
	`__wc¢ýy_®Ÿs
 (
__de¡
, 
__¤c
, 
__n
);

204 
	}
}

207 
wch¬_t
 *
	$__wýnýy_chk
 (
wch¬_t
 *
__»¡riù
 
__de¡
,

208 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__¤c
, 
size_t
 
__n
,

209 
size_t
 
__de¡Ën
è
__THROW
;

210 
wch¬_t
 *
	`__REDIRECT_NTH
 (
__wýnýy_®Ÿs
,

211 (
wch¬_t
 *
__»¡riù
 
__de¡
,

212 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__¤c
,

213 
size_t
 
__n
), 
wýnýy
);

214 
wch¬_t
 *
	`__REDIRECT_NTH
 (
__wýnýy_chk_w¬n
,

215 (
wch¬_t
 *
__»¡riù
 
__de¡
,

216 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__¤c
,

217 
size_t
 
__n
, size_ˆ
__de¡Ën
), 
__wýnýy_chk
)

218 
	`__w¬Ç‰r
 ("wcpncpy called with†ength biggerhan size of destination "

221 
__fÜtify_funùiÚ
 
wch¬_t
 *

222 
	`__NTH
 (
	$wýnýy
 (
wch¬_t
 *
__»¡riù
 
__de¡
, cÚ¡ wch¬_ˆ*__»¡riù 
__¤c
,

223 
size_t
 
__n
))

225 ià(
	`__bos
 (
__de¡
è!ð(
size_t
) -1)

227 ià(!
	`__bužtš_cÚ¡ªt_p
 (
__n
))

228  
	`__wýnýy_chk
 (
__de¡
, 
__¤c
, 
__n
,

229 
	`__bos
 (
__de¡
è/  (
wch¬_t
));

230 ià(
__n
 > 
	`__bos
 (
__de¡
è/  (
wch¬_t
))

231  
	`__wýnýy_chk_w¬n
 (
__de¡
, 
__¤c
, 
__n
,

232 
	`__bos
 (
__de¡
è/  (
wch¬_t
));

234  
	`__wýnýy_®Ÿs
 (
__de¡
, 
__¤c
, 
__n
);

235 
	}
}

238 
wch¬_t
 *
	$__wcsÿt_chk
 (
wch¬_t
 *
__»¡riù
 
__de¡
,

239 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__¤c
,

240 
size_t
 
__de¡Ën
è
__THROW
;

241 
wch¬_t
 *
	`__REDIRECT_NTH
 (
__wcsÿt_®Ÿs
,

242 (
wch¬_t
 *
__»¡riù
 
__de¡
,

243 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__¤c
), 
wcsÿt
);

245 
__fÜtify_funùiÚ
 
wch¬_t
 *

246 
	`__NTH
 (
	$wcsÿt
 (
wch¬_t
 *
__»¡riù
 
__de¡
, cÚ¡ wch¬_ˆ*__»¡riù 
__¤c
))

248 ià(
	`__bos
 (
__de¡
è!ð(
size_t
) -1)

249  
	`__wcsÿt_chk
 (
__de¡
, 
__¤c
, 
	`__bos
 (__de¡è/  (
wch¬_t
));

250  
	`__wcsÿt_®Ÿs
 (
__de¡
, 
__¤c
);

251 
	}
}

254 
wch¬_t
 *
	$__wc¢ÿt_chk
 (
wch¬_t
 *
__»¡riù
 
__de¡
,

255 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__¤c
,

256 
size_t
 
__n
, size_ˆ
__de¡Ën
è
__THROW
;

257 
wch¬_t
 *
	`__REDIRECT_NTH
 (
__wc¢ÿt_®Ÿs
,

258 (
wch¬_t
 *
__»¡riù
 
__de¡
,

259 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__¤c
,

260 
size_t
 
__n
), 
wc¢ÿt
);

262 
__fÜtify_funùiÚ
 
wch¬_t
 *

263 
	`__NTH
 (
	$wc¢ÿt
 (
wch¬_t
 *
__»¡riù
 
__de¡
, cÚ¡ wch¬_ˆ*__»¡riù 
__¤c
,

264 
size_t
 
__n
))

266 ià(
	`__bos
 (
__de¡
è!ð(
size_t
) -1)

267  
	`__wc¢ÿt_chk
 (
__de¡
, 
__¤c
, 
__n
,

268 
	`__bos
 (
__de¡
è/  (
wch¬_t
));

269  
	`__wc¢ÿt_®Ÿs
 (
__de¡
, 
__¤c
, 
__n
);

270 
	}
}

273 
	$__sw´štf_chk
 (
wch¬_t
 *
__»¡riù
 
__s
, 
size_t
 
__n
,

274 
__æag
, 
size_t
 
__s_Ën
,

275 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fÜm©
, ...)

276 
__THROW
 ;

278 
	`__REDIRECT_NTH_LDBL
 (
__sw´štf_®Ÿs
,

279 (
wch¬_t
 *
__»¡riù
 
__s
, 
size_t
 
__n
,

280 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fmt
, ...),

281 
sw´štf
);

283 #ifdeà
__va_¬g_·ck


284 
__fÜtify_funùiÚ
 

285 
	`__NTH
 (
	$sw´štf
 (
wch¬_t
 *
__»¡riù
 
__s
, 
size_t
 
__n
,

286 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fmt
, ...))

288 ià(
	`__bos
 (
__s
è!ð(
size_t
è-1 || 
__USE_FORTIFY_LEVEL
 > 1)

289  
	`__sw´štf_chk
 (
__s
, 
__n
, 
__USE_FORTIFY_LEVEL
 - 1,

290 
	`__bos
 (
__s
è/  (
wch¬_t
),

291 
__fmt
, 
	`__va_¬g_·ck
 ());

292  
	`__sw´štf_®Ÿs
 (
__s
, 
__n
, 
__fmt
, 
	`__va_¬g_·ck
 ());

293 
	}
}

294 #–ià!
defšed
 
__ýlu¥lus


296 
	#sw´štf
(
s
, 
n
, ...) \

297 (
	`__bos
 (
s
è!ð(
size_t
è-1 || 
__USE_FORTIFY_LEVEL
 > 1 \

298 ? 
	`__sw´štf_chk
 (
s
, 
n
, 
__USE_FORTIFY_LEVEL
 - 1, \

299 
	`__bos
 (
s
è/  (
wch¬_t
), 
__VA_ARGS__
) \

300 : 
	`sw´štf
 (
s
, 
n
, 
__VA_ARGS__
))

	)

303 
	$__vsw´štf_chk
 (
wch¬_t
 *
__»¡riù
 
__s
, 
size_t
 
__n
,

304 
__æag
, 
size_t
 
__s_Ën
,

305 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fÜm©
,

306 
__gnuc_va_li¡
 
__¬g
)

307 
__THROW
 ;

309 
	`__REDIRECT_NTH_LDBL
 (
__vsw´štf_®Ÿs
,

310 (
wch¬_t
 *
__»¡riù
 
__s
, 
size_t
 
__n
,

311 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fmt
,

312 
__gnuc_va_li¡
 
__­
), 
vsw´štf
);

314 
__fÜtify_funùiÚ
 

315 
	`__NTH
 (
	$vsw´štf
 (
wch¬_t
 *
__»¡riù
 
__s
, 
size_t
 
__n
,

316 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fmt
, 
__gnuc_va_li¡
 
__­
))

318 ià(
	`__bos
 (
__s
è!ð(
size_t
è-1 || 
__USE_FORTIFY_LEVEL
 > 1)

319  
	`__vsw´štf_chk
 (
__s
, 
__n
, 
__USE_FORTIFY_LEVEL
 - 1,

320 
	`__bos
 (
__s
è/  (
wch¬_t
), 
__fmt
, 
__­
);

321  
	`__vsw´štf_®Ÿs
 (
__s
, 
__n
, 
__fmt
, 
__­
);

322 
	}
}

325 #ià
__USE_FORTIFY_LEVEL
 > 1

327 
__fw´štf_chk
 (
__FILE
 *
__»¡riù
 
__¡»am
, 
__æag
,

328 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fÜm©
, ...);

329 
__w´štf_chk
 (
__æag
, cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fÜm©
,

331 
__vfw´štf_chk
 (
__FILE
 *
__»¡riù
 
__¡»am
, 
__æag
,

332 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fÜm©
,

333 
__gnuc_va_li¡
 
__­
);

334 
__vw´štf_chk
 (
__æag
, cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fÜm©
,

335 
__gnuc_va_li¡
 
__­
);

337 #ifdeà
__va_¬g_·ck


338 
__fÜtify_funùiÚ
 

339 
	$w´štf
 (cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fmt
, ...)

341  
	`__w´štf_chk
 (
__USE_FORTIFY_LEVEL
 - 1, 
__fmt
, 
	`__va_¬g_·ck
 ());

342 
	}
}

344 
__fÜtify_funùiÚ
 

345 
	$fw´štf
 (
__FILE
 *
__»¡riù
 
__¡»am
, cÚ¡ 
wch¬_t
 *__»¡riù 
__fmt
, ...)

347  
	`__fw´štf_chk
 (
__¡»am
, 
__USE_FORTIFY_LEVEL
 - 1, 
__fmt
,

348 
	`__va_¬g_·ck
 ());

349 
	}
}

350 #–ià!
defšed
 
__ýlu¥lus


351 
	#w´štf
(...) \

352 
	`__w´štf_chk
 (
__USE_FORTIFY_LEVEL
 - 1, 
__VA_ARGS__
)

	)

353 
	#fw´štf
(
¡»am
, ...) \

354 
	`__fw´štf_chk
 (
¡»am
, 
__USE_FORTIFY_LEVEL
 - 1, 
__VA_ARGS__
)

	)

357 
__fÜtify_funùiÚ
 

358 
	$vw´štf
 (cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fmt
, 
__gnuc_va_li¡
 
__­
)

360  
	`__vw´štf_chk
 (
__USE_FORTIFY_LEVEL
 - 1, 
__fmt
, 
__­
);

361 
	}
}

363 
__fÜtify_funùiÚ
 

364 
	$vfw´štf
 (
__FILE
 *
__»¡riù
 
__¡»am
,

365 cÚ¡ 
wch¬_t
 *
__»¡riù
 
__fmt
, 
__gnuc_va_li¡
 
__­
)

367  
	`__vfw´štf_chk
 (
__¡»am
, 
__USE_FORTIFY_LEVEL
 - 1, 
__fmt
, 
__­
);

368 
	}
}

372 
wch¬_t
 *
	$__fg‘ws_chk
 (
wch¬_t
 *
__»¡riù
 
__s
, 
size_t
 
__size
, 
__n
,

373 
__FILE
 *
__»¡riù
 
__¡»am
è
__wur
;

374 
wch¬_t
 *
	`__REDIRECT
 (
__fg‘ws_®Ÿs
,

375 (
wch¬_t
 *
__»¡riù
 
__s
, 
__n
,

376 
__FILE
 *
__»¡riù
 
__¡»am
), 
fg‘ws
è
__wur
;

377 
wch¬_t
 *
	`__REDIRECT
 (
__fg‘ws_chk_w¬n
,

378 (
wch¬_t
 *
__»¡riù
 
__s
, 
size_t
 
__size
, 
__n
,

379 
__FILE
 *
__»¡riù
 
__¡»am
), 
__fg‘ws_chk
)

380 
__wur
 
	`__w¬Ç‰r
 ("fgetws called with bigger sizehan†ength "

383 
__fÜtify_funùiÚ
 
__wur
 
wch¬_t
 *

384 
	$fg‘ws
 (
wch¬_t
 *
__»¡riù
 
__s
, 
__n
, 
__FILE
 *__»¡riù 
__¡»am
)

386 ià(
	`__bos
 (
__s
è!ð(
size_t
) -1)

388 ià(!
	`__bužtš_cÚ¡ªt_p
 (
__n
) || __n <= 0)

389  
	`__fg‘ws_chk
 (
__s
, 
	`__bos
 (__sè/  (
wch¬_t
),

390 
__n
, 
__¡»am
);

392 ià((
size_t
è
__n
 > 
	`__bos
 (
__s
è/  (
wch¬_t
))

393  
	`__fg‘ws_chk_w¬n
 (
__s
, 
	`__bos
 (__sè/  (
wch¬_t
),

394 
__n
, 
__¡»am
);

396  
	`__fg‘ws_®Ÿs
 (
__s
, 
__n
, 
__¡»am
);

397 
	}
}

399 #ifdeà
__USE_GNU


400 
wch¬_t
 *
	$__fg‘ws_uÆocked_chk
 (
wch¬_t
 *
__»¡riù
 
__s
, 
size_t
 
__size
,

401 
__n
, 
__FILE
 *
__»¡riù
 
__¡»am
)

402 
__wur
;

403 
wch¬_t
 *
	`__REDIRECT
 (
__fg‘ws_uÆocked_®Ÿs
,

404 (
wch¬_t
 *
__»¡riù
 
__s
, 
__n
,

405 
__FILE
 *
__»¡riù
 
__¡»am
), 
fg‘ws_uÆocked
)

406 
__wur
;

407 
wch¬_t
 *
	`__REDIRECT
 (
__fg‘ws_uÆocked_chk_w¬n
,

408 (
wch¬_t
 *
__»¡riù
 
__s
, 
size_t
 
__size
, 
__n
,

409 
__FILE
 *
__»¡riù
 
__¡»am
),

410 
__fg‘ws_uÆocked_chk
)

411 
__wur
 
	`__w¬Ç‰r
 ("fgetws_unlocked called with bigger sizehan†ength "

414 
__fÜtify_funùiÚ
 
__wur
 
wch¬_t
 *

415 
	$fg‘ws_uÆocked
 (
wch¬_t
 *
__»¡riù
 
__s
, 
__n
, 
__FILE
 *__»¡riù 
__¡»am
)

417 ià(
	`__bos
 (
__s
è!ð(
size_t
) -1)

419 ià(!
	`__bužtš_cÚ¡ªt_p
 (
__n
) || __n <= 0)

420  
	`__fg‘ws_uÆocked_chk
 (
__s
, 
	`__bos
 (__sè/  (
wch¬_t
),

421 
__n
, 
__¡»am
);

423 ià((
size_t
è
__n
 > 
	`__bos
 (
__s
è/  (
wch¬_t
))

424  
	`__fg‘ws_uÆocked_chk_w¬n
 (
__s
, 
	`__bos
 (__sè/  (
wch¬_t
),

425 
__n
, 
__¡»am
);

427  
	`__fg‘ws_uÆocked_®Ÿs
 (
__s
, 
__n
, 
__¡»am
);

428 
	}
}

432 
size_t
 
	$__wütomb_chk
 (*
__»¡riù
 
__s
, 
wch¬_t
 
__wch¬
,

433 
mb¡©e_t
 *
__»¡riù
 
__p
,

434 
size_t
 
__buæ’
è
__THROW
 
__wur
;

435 
size_t
 
	`__REDIRECT_NTH
 (
__wütomb_®Ÿs
,

436 (*
__»¡riù
 
__s
, 
wch¬_t
 
__wch¬
,

437 
mb¡©e_t
 *
__»¡riù
 
__ps
), 
wütomb
è
__wur
;

439 
__fÜtify_funùiÚ
 
__wur
 
size_t


440 
	`__NTH
 (
	$wütomb
 (*
__»¡riù
 
__s
, 
wch¬_t
 
__wch¬
,

441 
mb¡©e_t
 *
__»¡riù
 
__ps
))

446 
	#__WCHAR_MB_LEN_MAX
 16

	)

447 #ià
defšed
 
MB_LEN_MAX
 && MB_LEN_MAX !ð
__WCHAR_MB_LEN_MAX


450 ià(
	`__bos
 (
__s
è!ð(
size_t
è-1 && 
__WCHAR_MB_LEN_MAX
 > __bos (__s))

451  
	`__wütomb_chk
 (
__s
, 
__wch¬
, 
__ps
, 
	`__bos
 (__s));

452  
	`__wütomb_®Ÿs
 (
__s
, 
__wch¬
, 
__ps
);

453 
	}
}

456 
size_t
 
	$__mb¤towcs_chk
 (
wch¬_t
 *
__»¡riù
 
__d¡
,

457 cÚ¡ **
__»¡riù
 
__¤c
,

458 
size_t
 
__Ën
, 
mb¡©e_t
 *
__»¡riù
 
__ps
,

459 
size_t
 
__d¡Ën
è
__THROW
;

460 
size_t
 
	`__REDIRECT_NTH
 (
__mb¤towcs_®Ÿs
,

461 (
wch¬_t
 *
__»¡riù
 
__d¡
,

462 cÚ¡ **
__»¡riù
 
__¤c
,

463 
size_t
 
__Ën
, 
mb¡©e_t
 *
__»¡riù
 
__ps
),

464 
mb¤towcs
);

465 
size_t
 
	`__REDIRECT_NTH
 (
__mb¤towcs_chk_w¬n
,

466 (
wch¬_t
 *
__»¡riù
 
__d¡
,

467 cÚ¡ **
__»¡riù
 
__¤c
,

468 
size_t
 
__Ën
, 
mb¡©e_t
 *
__»¡riù
 
__ps
,

469 
size_t
 
__d¡Ën
), 
__mb¤towcs_chk
)

470 
	`__w¬Ç‰r
 ("mbsrtowcs called with dst buffer smallerhan†en "

473 
__fÜtify_funùiÚ
 
size_t


474 
	`__NTH
 (
	$mb¤towcs
 (
wch¬_t
 *
__»¡riù
 
__d¡
, cÚ¡ **__»¡riù 
__¤c
,

475 
size_t
 
__Ën
, 
mb¡©e_t
 *
__»¡riù
 
__ps
))

477 ià(
	`__bos
 (
__d¡
è!ð(
size_t
) -1)

479 ià(!
	`__bužtš_cÚ¡ªt_p
 (
__Ën
))

480  
	`__mb¤towcs_chk
 (
__d¡
, 
__¤c
, 
__Ën
, 
__ps
,

481 
	`__bos
 (
__d¡
è/  (
wch¬_t
));

483 ià(
__Ën
 > 
	`__bos
 (
__d¡
è/  (
wch¬_t
))

484  
	`__mb¤towcs_chk_w¬n
 (
__d¡
, 
__¤c
, 
__Ën
, 
__ps
,

485 
	`__bos
 (
__d¡
è/  (
wch¬_t
));

487  
	`__mb¤towcs_®Ÿs
 (
__d¡
, 
__¤c
, 
__Ën
, 
__ps
);

488 
	}
}

491 
size_t
 
	$__wc¤tombs_chk
 (*
__»¡riù
 
__d¡
,

492 cÚ¡ 
wch¬_t
 **
__»¡riù
 
__¤c
,

493 
size_t
 
__Ën
, 
mb¡©e_t
 *
__»¡riù
 
__ps
,

494 
size_t
 
__d¡Ën
è
__THROW
;

495 
size_t
 
	`__REDIRECT_NTH
 (
__wc¤tombs_®Ÿs
,

496 (*
__»¡riù
 
__d¡
,

497 cÚ¡ 
wch¬_t
 **
__»¡riù
 
__¤c
,

498 
size_t
 
__Ën
, 
mb¡©e_t
 *
__»¡riù
 
__ps
),

499 
wc¤tombs
);

500 
size_t
 
	`__REDIRECT_NTH
 (
__wc¤tombs_chk_w¬n
,

501 (*
__»¡riù
 
__d¡
,

502 cÚ¡ 
wch¬_t
 **
__»¡riù
 
__¤c
,

503 
size_t
 
__Ën
, 
mb¡©e_t
 *
__»¡riù
 
__ps
,

504 
size_t
 
__d¡Ën
), 
__wc¤tombs_chk
)

505 
	`__w¬Ç‰r
 ("wcsrtombs called with dst buffer smallerhan†en");

507 
__fÜtify_funùiÚ
 
size_t


508 
	`__NTH
 (
	$wc¤tombs
 (*
__»¡riù
 
__d¡
, cÚ¡ 
wch¬_t
 **__»¡riù 
__¤c
,

509 
size_t
 
__Ën
, 
mb¡©e_t
 *
__»¡riù
 
__ps
))

511 ià(
	`__bos
 (
__d¡
è!ð(
size_t
) -1)

513 ià(!
	`__bužtš_cÚ¡ªt_p
 (
__Ën
))

514  
	`__wc¤tombs_chk
 (
__d¡
, 
__¤c
, 
__Ën
, 
__ps
, 
	`__bos
 (__dst));

516 ià(
__Ën
 > 
	`__bos
 (
__d¡
))

517  
	`__wc¤tombs_chk_w¬n
 (
__d¡
, 
__¤c
, 
__Ën
, 
__ps
, 
	`__bos
 (__dst));

519  
	`__wc¤tombs_®Ÿs
 (
__d¡
, 
__¤c
, 
__Ën
, 
__ps
);

520 
	}
}

523 #ifdeà
__USE_GNU


524 
size_t
 
	$__mb¢¹owcs_chk
 (
wch¬_t
 *
__»¡riù
 
__d¡
,

525 cÚ¡ **
__»¡riù
 
__¤c
, 
size_t
 
__nmc
,

526 
size_t
 
__Ën
, 
mb¡©e_t
 *
__»¡riù
 
__ps
,

527 
size_t
 
__d¡Ën
è
__THROW
;

528 
size_t
 
	`__REDIRECT_NTH
 (
__mb¢¹owcs_®Ÿs
,

529 (
wch¬_t
 *
__»¡riù
 
__d¡
,

530 cÚ¡ **
__»¡riù
 
__¤c
, 
size_t
 
__nmc
,

531 
size_t
 
__Ën
, 
mb¡©e_t
 *
__»¡riù
 
__ps
),

532 
mb¢¹owcs
);

533 
size_t
 
	`__REDIRECT_NTH
 (
__mb¢¹owcs_chk_w¬n
,

534 (
wch¬_t
 *
__»¡riù
 
__d¡
,

535 cÚ¡ **
__»¡riù
 
__¤c
, 
size_t
 
__nmc
,

536 
size_t
 
__Ën
, 
mb¡©e_t
 *
__»¡riù
 
__ps
,

537 
size_t
 
__d¡Ën
), 
__mb¢¹owcs_chk
)

538 
	`__w¬Ç‰r
 ("mbsnrtowcs called with dst buffer smallerhan†en "

541 
__fÜtify_funùiÚ
 
size_t


542 
	`__NTH
 (
	$mb¢¹owcs
 (
wch¬_t
 *
__»¡riù
 
__d¡
, cÚ¡ **__»¡riù 
__¤c
,

543 
size_t
 
__nmc
, size_ˆ
__Ën
, 
mb¡©e_t
 *
__»¡riù
 
__ps
))

545 ià(
	`__bos
 (
__d¡
è!ð(
size_t
) -1)

547 ià(!
	`__bužtš_cÚ¡ªt_p
 (
__Ën
))

548  
	`__mb¢¹owcs_chk
 (
__d¡
, 
__¤c
, 
__nmc
, 
__Ën
, 
__ps
,

549 
	`__bos
 (
__d¡
è/  (
wch¬_t
));

551 ià(
__Ën
 > 
	`__bos
 (
__d¡
è/  (
wch¬_t
))

552  
	`__mb¢¹owcs_chk_w¬n
 (
__d¡
, 
__¤c
, 
__nmc
, 
__Ën
, 
__ps
,

553 
	`__bos
 (
__d¡
è/  (
wch¬_t
));

555  
	`__mb¢¹owcs_®Ÿs
 (
__d¡
, 
__¤c
, 
__nmc
, 
__Ën
, 
__ps
);

556 
	}
}

559 
size_t
 
	$__wc¢¹ombs_chk
 (*
__»¡riù
 
__d¡
,

560 cÚ¡ 
wch¬_t
 **
__»¡riù
 
__¤c
,

561 
size_t
 
__nwc
, size_ˆ
__Ën
,

562 
mb¡©e_t
 *
__»¡riù
 
__ps
, 
size_t
 
__d¡Ën
)

563 
__THROW
;

564 
size_t
 
	`__REDIRECT_NTH
 (
__wc¢¹ombs_®Ÿs
,

565 (*
__»¡riù
 
__d¡
,

566 cÚ¡ 
wch¬_t
 **
__»¡riù
 
__¤c
,

567 
size_t
 
__nwc
, size_ˆ
__Ën
,

568 
mb¡©e_t
 *
__»¡riù
 
__ps
), 
wc¢¹ombs
);

569 
size_t
 
	`__REDIRECT_NTH
 (
__wc¢¹ombs_chk_w¬n
,

570 (*
__»¡riù
 
__d¡
,

571 cÚ¡ 
wch¬_t
 **
__»¡riù
 
__¤c
,

572 
size_t
 
__nwc
, size_ˆ
__Ën
,

573 
mb¡©e_t
 *
__»¡riù
 
__ps
,

574 
size_t
 
__d¡Ën
), 
__wc¢¹ombs_chk
)

575 
	`__w¬Ç‰r
 ("wcsnrtombs called with dst buffer smallerhan†en");

577 
__fÜtify_funùiÚ
 
size_t


578 
	`__NTH
 (
	$wc¢¹ombs
 (*
__»¡riù
 
__d¡
, cÚ¡ 
wch¬_t
 **__»¡riù 
__¤c
,

579 
size_t
 
__nwc
, size_ˆ
__Ën
, 
mb¡©e_t
 *
__»¡riù
 
__ps
))

581 ià(
	`__bos
 (
__d¡
è!ð(
size_t
) -1)

583 ià(!
	`__bužtš_cÚ¡ªt_p
 (
__Ën
))

584  
	`__wc¢¹ombs_chk
 (
__d¡
, 
__¤c
, 
__nwc
, 
__Ën
, 
__ps
,

585 
	`__bos
 (
__d¡
));

587 ià(
__Ën
 > 
	`__bos
 (
__d¡
))

588  
	`__wc¢¹ombs_chk_w¬n
 (
__d¡
, 
__¤c
, 
__nwc
, 
__Ën
, 
__ps
,

589 
	`__bos
 (
__d¡
));

591  
	`__wc¢¹ombs_®Ÿs
 (
__d¡
, 
__¤c
, 
__nwc
, 
__Ën
, 
__ps
);

592 
	}
}

	@/usr/include/wctype.h

23 #iâdeà
_WCTYPE_H


25 
	~<ã©u»s.h
>

26 
	~<b™s/ty³s.h
>

28 #iâdeà
__Ãed_iswxxx


29 
	#_WCTYPE_H
 1

	)

32 
	#__Ãed_wšt_t


	)

33 
	~<wch¬.h
>

37 #iâdeà
WEOF


38 
	#WEOF
 (0xffffffffu)

	)

41 #undeà
__Ãed_iswxxx


46 #iâdeà
__iswxxx_defšed


47 
	#__iswxxx_defšed
 1

	)

49 
__BEGIN_NAMESPACE_C99


52 
	twùy³_t
;

53 
	g__END_NAMESPACE_C99


55 #iâdeà
_ISwb™


60 
	~<’dŸn.h
>

61 #ià
__BYTE_ORDER
 =ð
__BIG_ENDIAN


62 
	#_ISwb™
(
b™
è(1 << (b™))

	)

64 
	#_ISwb™
(
b™
) \

65 ((
b™
) < 8 ? () ((1UL << (bit)) << 24) \

66 : ((
b™
) < 16 ? () ((1UL << (bit)) << 8) \

67 : ((
b™
) < 24 ? () ((1UL << (bit)) >> 8) \

68 : (è((1UL << (
b™
)è>> 24))))

	)

73 
	m__ISwuµ”
 = 0,

74 
	m__ISwlow”
 = 1,

75 
	m__ISw®pha
 = 2,

76 
	m__ISwdig™
 = 3,

77 
	m__ISwxdig™
 = 4,

78 
	m__ISw¥aû
 = 5,

79 
	m__ISw´št
 = 6,

80 
	m__ISwg¿ph
 = 7,

81 
	m__ISwbÏnk
 = 8,

82 
	m__ISwúŒl
 = 9,

83 
	m__ISwpunù
 = 10,

84 
	m__ISw®num
 = 11,

86 
	m_ISwuµ”
 = 
_ISwb™
 (
__ISwuµ”
),

87 
	m_ISwlow”
 = 
_ISwb™
 (
__ISwlow”
),

88 
	m_ISw®pha
 = 
_ISwb™
 (
__ISw®pha
),

89 
	m_ISwdig™
 = 
_ISwb™
 (
__ISwdig™
),

90 
	m_ISwxdig™
 = 
_ISwb™
 (
__ISwxdig™
),

91 
	m_ISw¥aû
 = 
_ISwb™
 (
__ISw¥aû
),

92 
	m_ISw´št
 = 
_ISwb™
 (
__ISw´št
),

93 
	m_ISwg¿ph
 = 
_ISwb™
 (
__ISwg¿ph
),

94 
	m_ISwbÏnk
 = 
_ISwb™
 (
__ISwbÏnk
),

95 
	m_ISwúŒl
 = 
_ISwb™
 (
__ISwúŒl
),

96 
	m_ISwpunù
 = 
_ISwb™
 (
__ISwpunù
),

97 
	m_ISw®num
 = 
_ISwb™
 (
__ISw®num
)

102 
__BEGIN_DECLS


104 
__BEGIN_NAMESPACE_C99


111 
	$isw®num
 (
wšt_t
 
__wc
è
__THROW
;

117 
	$isw®pha
 (
wšt_t
 
__wc
è
__THROW
;

120 
	$iswúŒl
 (
wšt_t
 
__wc
è
__THROW
;

124 
	$iswdig™
 (
wšt_t
 
__wc
è
__THROW
;

128 
	$iswg¿ph
 (
wšt_t
 
__wc
è
__THROW
;

133 
	$iswlow”
 (
wšt_t
 
__wc
è
__THROW
;

136 
	$isw´št
 (
wšt_t
 
__wc
è
__THROW
;

141 
	$iswpunù
 (
wšt_t
 
__wc
è
__THROW
;

146 
	$isw¥aû
 (
wšt_t
 
__wc
è
__THROW
;

151 
	$iswuµ”
 (
wšt_t
 
__wc
è
__THROW
;

156 
	$iswxdig™
 (
wšt_t
 
__wc
è
__THROW
;

161 #ifdeà
__USE_ISOC99


162 
	$iswbÏnk
 (
wšt_t
 
__wc
è
__THROW
;

171 
wùy³_t
 
	$wùy³
 (cÚ¡ *
__´Ý”ty
è
__THROW
;

175 
	$iswùy³
 (
wšt_t
 
__wc
, 
wùy³_t
 
__desc
è
__THROW
;

176 
__END_NAMESPACE_C99


183 
__BEGIN_NAMESPACE_C99


186 cÚ¡ 
	t__št32_t
 *
	twù¿ns_t
;

187 
__END_NAMESPACE_C99


188 #ifdeà
__USE_GNU


189 
	$__USING_NAMESPACE_C99
(
wù¿ns_t
)

192 
__BEGIN_NAMESPACE_C99


194 
wšt_t
 
	$towlow”
 (
wšt_t
 
__wc
è
__THROW
;

197 
wšt_t
 
	$towuµ”
 (
wšt_t
 
__wc
è
__THROW
;

198 
__END_NAMESPACE_C99


200 
__END_DECLS


207 #ifdeà
_WCTYPE_H


213 
__BEGIN_DECLS


215 
__BEGIN_NAMESPACE_C99


218 
wù¿ns_t
 
	$wù¿ns
 (cÚ¡ *
__´Ý”ty
è
__THROW
;

221 
wšt_t
 
	$towù¿ns
 (
wšt_t
 
__wc
, 
wù¿ns_t
 
__desc
è
__THROW
;

222 
__END_NAMESPACE_C99


224 #ifdeà
__USE_XOPEN2K8


226 
	~<xloÿË.h
>

230 
	$isw®num_l
 (
wšt_t
 
__wc
, 
__loÿË_t
 
__loÿË
è
__THROW
;

236 
	$isw®pha_l
 (
wšt_t
 
__wc
, 
__loÿË_t
 
__loÿË
è
__THROW
;

239 
	$iswúŒl_l
 (
wšt_t
 
__wc
, 
__loÿË_t
 
__loÿË
è
__THROW
;

243 
	$iswdig™_l
 (
wšt_t
 
__wc
, 
__loÿË_t
 
__loÿË
è
__THROW
;

247 
	$iswg¿ph_l
 (
wšt_t
 
__wc
, 
__loÿË_t
 
__loÿË
è
__THROW
;

252 
	$iswlow”_l
 (
wšt_t
 
__wc
, 
__loÿË_t
 
__loÿË
è
__THROW
;

255 
	$isw´št_l
 (
wšt_t
 
__wc
, 
__loÿË_t
 
__loÿË
è
__THROW
;

260 
	$iswpunù_l
 (
wšt_t
 
__wc
, 
__loÿË_t
 
__loÿË
è
__THROW
;

265 
	$isw¥aû_l
 (
wšt_t
 
__wc
, 
__loÿË_t
 
__loÿË
è
__THROW
;

270 
	$iswuµ”_l
 (
wšt_t
 
__wc
, 
__loÿË_t
 
__loÿË
è
__THROW
;

275 
	$iswxdig™_l
 (
wšt_t
 
__wc
, 
__loÿË_t
 
__loÿË
è
__THROW
;

280 
	$iswbÏnk_l
 (
wšt_t
 
__wc
, 
__loÿË_t
 
__loÿË
è
__THROW
;

284 
wùy³_t
 
	$wùy³_l
 (cÚ¡ *
__´Ý”ty
, 
__loÿË_t
 
__loÿË
)

285 
__THROW
;

289 
	$iswùy³_l
 (
wšt_t
 
__wc
, 
wùy³_t
 
__desc
, 
__loÿË_t
 
__loÿË
)

290 
__THROW
;

298 
wšt_t
 
	$towlow”_l
 (
wšt_t
 
__wc
, 
__loÿË_t
 
__loÿË
è
__THROW
;

301 
wšt_t
 
	$towuµ”_l
 (
wšt_t
 
__wc
, 
__loÿË_t
 
__loÿË
è
__THROW
;

305 
wù¿ns_t
 
	$wù¿ns_l
 (cÚ¡ *
__´Ý”ty
, 
__loÿË_t
 
__loÿË
)

306 
__THROW
;

309 
wšt_t
 
	$towù¿ns_l
 (
wšt_t
 
__wc
, 
wù¿ns_t
 
__desc
,

310 
__loÿË_t
 
__loÿË
è
__THROW
;

314 
__END_DECLS


	@/usr/include/asm-generic/errno-base.h

1 #iâdeà
_ASM_GENERIC_ERRNO_BASE_H


2 
	#_ASM_GENERIC_ERRNO_BASE_H


	)

4 
	#EPERM
 1

	)

5 
	#ENOENT
 2

	)

6 
	#ESRCH
 3

	)

7 
	#EINTR
 4

	)

8 
	#EIO
 5

	)

9 
	#ENXIO
 6

	)

10 
	#E2BIG
 7

	)

11 
	#ENOEXEC
 8

	)

12 
	#EBADF
 9

	)

13 
	#ECHILD
 10

	)

14 
	#EAGAIN
 11

	)

15 
	#ENOMEM
 12

	)

16 
	#EACCES
 13

	)

17 
	#EFAULT
 14

	)

18 
	#ENOTBLK
 15

	)

19 
	#EBUSY
 16

	)

20 
	#EEXIST
 17

	)

21 
	#EXDEV
 18

	)

22 
	#ENODEV
 19

	)

23 
	#ENOTDIR
 20

	)

24 
	#EISDIR
 21

	)

25 
	#EINVAL
 22

	)

26 
	#ENFILE
 23

	)

27 
	#EMFILE
 24

	)

28 
	#ENOTTY
 25

	)

29 
	#ETXTBSY
 26

	)

30 
	#EFBIG
 27

	)

31 
	#ENOSPC
 28

	)

32 
	#ESPIPE
 29

	)

33 
	#EROFS
 30

	)

34 
	#EMLINK
 31

	)

35 
	#EPIPE
 32

	)

36 
	#EDOM
 33

	)

37 
	#ERANGE
 34

	)

	@/usr/include/asm-generic/posix_types.h

1 #iâdeà
__ASM_GENERIC_POSIX_TYPES_H


2 
	#__ASM_GENERIC_POSIX_TYPES_H


	)

4 
	~<asm/b™¥”lÚg.h
>

13 #iâdeà
__k”Ãl_lÚg_t


14 
	t__k”Ãl_lÚg_t
;

15 
	t__k”Ãl_ulÚg_t
;

18 #iâdeà
__k”Ãl_šo_t


19 
__k”Ãl_ulÚg_t
 
	t__k”Ãl_šo_t
;

22 #iâdeà
__k”Ãl_mode_t


23 
	t__k”Ãl_mode_t
;

26 #iâdeà
__k”Ãl_pid_t


27 
	t__k”Ãl_pid_t
;

30 #iâdeà
__k”Ãl_c_pid_t


31 
	t__k”Ãl_c_pid_t
;

34 #iâdeà
__k”Ãl_uid_t


35 
	t__k”Ãl_uid_t
;

36 
	t__k”Ãl_gid_t
;

39 #iâdeà
__k”Ãl_su£cÚds_t


40 
__k”Ãl_lÚg_t
 
	t__k”Ãl_su£cÚds_t
;

43 #iâdeà
__k”Ãl_daddr_t


44 
	t__k”Ãl_daddr_t
;

47 #iâdeà
__k”Ãl_uid32_t


48 
	t__k”Ãl_uid32_t
;

49 
	t__k”Ãl_gid32_t
;

52 #iâdeà
__k”Ãl_Þd_uid_t


53 
__k”Ãl_uid_t
 
	t__k”Ãl_Þd_uid_t
;

54 
__k”Ãl_gid_t
 
	t__k”Ãl_Þd_gid_t
;

57 #iâdeà
__k”Ãl_Þd_dev_t


58 
	t__k”Ãl_Þd_dev_t
;

65 #iâdeà
__k”Ãl_size_t


66 #ià
__BITS_PER_LONG
 != 64

67 
	t__k”Ãl_size_t
;

68 
	t__k”Ãl_ssize_t
;

69 
	t__k”Ãl_±rdiff_t
;

71 
__k”Ãl_ulÚg_t
 
	t__k”Ãl_size_t
;

72 
__k”Ãl_lÚg_t
 
	t__k”Ãl_ssize_t
;

73 
__k”Ãl_lÚg_t
 
	t__k”Ãl_±rdiff_t
;

77 #iâdeà
__k”Ãl_fsid_t


79 
	mv®
[2];

80 } 
	t__k”Ãl_fsid_t
;

86 
__k”Ãl_lÚg_t
 
	t__k”Ãl_off_t
;

87 
	t__k”Ãl_loff_t
;

88 
__k”Ãl_lÚg_t
 
	t__k”Ãl_time_t
;

89 
__k”Ãl_lÚg_t
 
	t__k”Ãl_þock_t
;

90 
	t__k”Ãl_tim”_t
;

91 
	t__k”Ãl_þockid_t
;

92 * 
	t__k”Ãl_ÿddr_t
;

93 
	t__k”Ãl_uid16_t
;

94 
	t__k”Ãl_gid16_t
;

	@/usr/include/asm/bitsperlong.h

1 #iâdeà
__ASM_X86_BITSPERLONG_H


2 
	#__ASM_X86_BITSPERLONG_H


	)

4 #ià
defšed
(
__x86_64__
è&& !defšed(
__ILP32__
)

5 
	#__BITS_PER_LONG
 64

	)

7 
	#__BITS_PER_LONG
 32

	)

10 
	~<asm-g’”ic/b™¥”lÚg.h
>

	@/usr/include/asm-generic/bitsperlong.h

1 #iâdeà
__ASM_GENERIC_BITS_PER_LONG


2 
	#__ASM_GENERIC_BITS_PER_LONG


	)

11 #iâdeà
__BITS_PER_LONG


12 
	#__BITS_PER_LONG
 32

	)

	@
1
.
1
/usr/include
196
4481
fs/bitmap.c
fs/block_dev.c
fs/buffer.c
fs/char_dev.c
fs/exec.c
fs/fcntl.c
fs/file_dev.c
fs/file_table.c
fs/inode.c
fs/ioctl.c
fs/namei.c
fs/open.c
fs/pipe.c
fs/read_write.c
fs/stat.c
fs/super.c
fs/truncate.c
include/a.out.h
include/asm/io.h
include/asm/memory.h
include/asm/segment.h
include/asm/system.h
include/const.h
include/ctype.h
include/errno.h
include/fcntl.h
include/linux/config.h
include/linux/fdreg.h
include/linux/fs.h
include/linux/hdreg.h
include/linux/head.h
include/linux/kernel.h
include/linux/mm.h
include/linux/sched.h
include/linux/sys.h
include/linux/tty.h
include/signal.h
include/stdarg.h
include/stddef.h
include/string.h
include/sys/stat.h
include/sys/times.h
include/sys/types.h
include/sys/utsname.h
include/sys/wait.h
include/termios.h
include/time.h
include/unistd.h
include/utime.h
init/main.c
kernel/blk_drv/blk.h
kernel/blk_drv/floppy.c
kernel/blk_drv/hd.c
kernel/blk_drv/ll_rw_blk.c
kernel/blk_drv/ramdisk.c
kernel/chr_drv/console.c
kernel/chr_drv/serial.c
kernel/chr_drv/tty_io.c
kernel/chr_drv/tty_ioctl.c
kernel/exit.c
kernel/fork.c
kernel/math/math_emulate.c
kernel/mktime.c
kernel/panic.c
kernel/printk.c
kernel/sched.c
kernel/signal.c
kernel/sys.c
kernel/traps.c
kernel/vsprintf.c
lib/_exit.c
lib/close.c
lib/ctype.c
lib/dup.c
lib/errno.c
lib/execve.c
lib/malloc.c
lib/open.c
lib/setsid.c
lib/string.c
lib/wait.c
lib/write.c
mm/memory.c
tools/build.c
/usr/include/ctype.h
/usr/include/errno.h
/usr/include/fcntl.h
/usr/include/linux/fdreg.h
/usr/include/linux/fs.h
/usr/include/linux/hdreg.h
/usr/include/linux/kernel.h
/usr/include/linux/sched.h
/usr/include/linux/tty.h
/usr/include/signal.h
/usr/include/stdio.h
/usr/include/stdlib.h
/usr/include/string.h
/usr/include/sys/stat.h
/usr/include/sys/times.h
/usr/include/sys/types.h
/usr/include/sys/utsname.h
/usr/include/sys/wait.h
/usr/include/termios.h
/usr/include/time.h
/usr/include/unistd.h
/usr/include/utime.h
/usr/include/alloca.h
/usr/include/bits/confname.h
/usr/include/bits/environments.h
/usr/include/bits/errno.h
/usr/include/bits/fcntl.h
/usr/include/bits/fcntl2.h
/usr/include/bits/posix_opt.h
/usr/include/bits/pthreadtypes.h
/usr/include/bits/sigaction.h
/usr/include/bits/sigcontext.h
/usr/include/bits/siginfo.h
/usr/include/bits/signum.h
/usr/include/bits/sigset.h
/usr/include/bits/sigstack.h
/usr/include/bits/sigthread.h
/usr/include/bits/stat.h
/usr/include/bits/stdio-ldbl.h
/usr/include/bits/stdio.h
/usr/include/bits/stdio2.h
/usr/include/bits/stdio_lim.h
/usr/include/bits/stdlib-bsearch.h
/usr/include/bits/stdlib-float.h
/usr/include/bits/stdlib-ldbl.h
/usr/include/bits/stdlib.h
/usr/include/bits/string.h
/usr/include/bits/string2.h
/usr/include/bits/string3.h
/usr/include/bits/sys_errlist.h
/usr/include/bits/termios.h
/usr/include/bits/time.h
/usr/include/bits/types.h
/usr/include/bits/unistd.h
/usr/include/bits/utsname.h
/usr/include/bits/waitflags.h
/usr/include/bits/waitstatus.h
/usr/include/endian.h
/usr/include/features.h
/usr/include/getopt.h
/usr/include/libio.h
/usr/include/linux/ioctl.h
/usr/include/linux/limits.h
/usr/include/linux/sysinfo.h
/usr/include/linux/types.h
/usr/include/sys/select.h
/usr/include/sys/sysmacros.h
/usr/include/sys/ttydefaults.h
/usr/include/sys/ucontext.h
/usr/include/xlocale.h
/usr/include/_G_config.h
/usr/include/asm/ioctl.h
/usr/include/asm/types.h
/usr/include/bits/byteswap.h
/usr/include/bits/endian.h
/usr/include/bits/fcntl-linux.h
/usr/include/bits/libio-ldbl.h
/usr/include/bits/select.h
/usr/include/bits/select2.h
/usr/include/bits/timex.h
/usr/include/bits/typesizes.h
/usr/include/bits/wordsize.h
/usr/include/gnu/stubs.h
/usr/include/linux/errno.h
/usr/include/linux/posix_types.h
/usr/include/stdc-predef.h
/usr/include/sys/cdefs.h
/usr/include/asm-generic/ioctl.h
/usr/include/asm-generic/types.h
/usr/include/asm/errno.h
/usr/include/asm/posix_types.h
/usr/include/bits/byteswap-16.h
/usr/include/bits/uio.h
/usr/include/gconv.h
/usr/include/gnu/stubs-32.h
/usr/include/gnu/stubs-64.h
/usr/include/gnu/stubs-x32.h
/usr/include/linux/stddef.h
/usr/include/wchar.h
/usr/include/asm-generic/errno.h
/usr/include/asm-generic/int-ll64.h
/usr/include/asm/posix_types_32.h
/usr/include/asm/posix_types_64.h
/usr/include/asm/posix_types_x32.h
/usr/include/bits/wchar-ldbl.h
/usr/include/bits/wchar.h
/usr/include/bits/wchar2.h
/usr/include/wctype.h
/usr/include/asm-generic/errno-base.h
/usr/include/asm-generic/posix_types.h
/usr/include/asm/bitsperlong.h
/usr/include/asm-generic/bitsperlong.h