stdio.c 95 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576
  1. /* Copyright (C) 2002 Manuel Novoa III
  2. * My stdio library for linux and (soon) elks.
  3. *
  4. * This library is free software; you can redistribute it and/or
  5. * modify it under the terms of the GNU Library General Public
  6. * License as published by the Free Software Foundation; either
  7. * version 2 of the License, or (at your option) any later version.
  8. *
  9. * This library is distributed in the hope that it will be useful,
  10. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  12. * Library General Public License for more details.
  13. *
  14. * You should have received a copy of the GNU Library General Public
  15. * License along with this library; if not, write to the Free
  16. * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17. */
  18. /* ATTENTION! ATTENTION! ATTENTION! ATTENTION! ATTENTION!
  19. *
  20. * This code is currently under development. Also, I plan to port
  21. * it to elks which is a 16-bit environment with a fairly limited
  22. * compiler. Therefore, please refrain from modifying this code
  23. * and, instead, pass any bug-fixes, etc. to me. Thanks. Manuel
  24. *
  25. * ATTENTION! ATTENTION! ATTENTION! ATTENTION! ATTENTION! */
  26. /* 8-05-2002
  27. * Changed fflush() behavior to no-op for r/w streams in read-mode.
  28. * This falls under undefined behavior wrt ANSI/ISO C99, but
  29. * SUSv3 seems to treat it as a no-op and it occurs in some apps.
  30. * Fixed a problem with _stdio_fwrite() not checking for underlying
  31. * write() failures.
  32. * Fixed both _stdio_fwrite() and _stdio_fread() to make sure that
  33. * the putc and getc macros were disabled if the stream was in
  34. * and error state.
  35. * The above changes should take care of a problem initially reported
  36. * by "Steven J. Hill" <sjhill@realitydiluted.com>.
  37. *
  38. * 8-25-2002
  39. * Changed fclose behavior when custom streams were enabled. Previously,
  40. * the cookie pointer was set to NULL as a debugging aid. However,
  41. * some of the perl 5.8 test rely on being able to close stderr and
  42. * still try writing to it. So now, the cookie pointer and handler
  43. * function pointers are set to that it is a "normal" file with a
  44. * file descriptor of -1. Note: The cookie pointer is reset to NULL
  45. * if the FILE struct is free'd by fclose.
  46. *
  47. * Nov 21, 2002
  48. * Added internal function _wstdio_fwrite.
  49. * Jan 3, 2003
  50. * Fixed a bug in _wstdio_fwrite.
  51. *
  52. * Jan 22, 2003
  53. * Fixed a bug related file position in append mode. _stdio_fwrite now
  54. * seeks to the end of the stream when append mode is set and we are
  55. * transitioning to write mode, so that subsequent ftell() return
  56. * values are correct.
  57. * Also fix _stdio_fopen to support fdopen() with append specified when
  58. * the underlying file didn't have O_APPEND set. It now sets the
  59. * O_APPEND flag as recommended by SUSv3 and is done by glibc.
  60. *
  61. * May 15, 2003
  62. * Modify __stdio_fread to deal with fake streams used by *sscanf.
  63. * Set EOF to end of buffer when fmemopen used on a readonly stream.
  64. * Note: I really need to run some tests on this to see what the
  65. * glibc code does in each case.
  66. */
  67. /* Before we include anything, convert L_ctermid to L_ctermid_function
  68. * and undef L_ctermid if defined. This is necessary as L_ctermid is
  69. * a SUSv3 standard macro defined in stdio.h. */
  70. #ifdef L_ctermid
  71. #define L_ctermid_function
  72. #undef L_ctermid
  73. #endif
  74. #define _ISOC99_SOURCE /* for ULLONG primarily... */
  75. #define _GNU_SOURCE
  76. #define _STDIO_UTILITY /* for _stdio_fdout and _uintmaxtostr. */
  77. #include <stdio.h>
  78. #include <stddef.h>
  79. #include <stdlib.h>
  80. #include <string.h>
  81. #include <limits.h>
  82. #include <stdint.h>
  83. #include <stdarg.h>
  84. #include <errno.h>
  85. #include <assert.h>
  86. #include <stdio_ext.h>
  87. #include <unistd.h>
  88. #include <fcntl.h>
  89. #ifndef O_LARGEFILE /* uClibc undefines this if no large file support. */
  90. #ifdef __STDIO_LARGE_FILES
  91. #error missing define for O_LARGEFILE!
  92. #endif
  93. #define O_LARGEFILE 0
  94. #endif
  95. /**********************************************************************/
  96. /* First deal with some build issues... */
  97. #ifndef __STDIO_THREADSAFE
  98. /* Just build empty object files if any of these were defined. */
  99. /* Note though that we do keep the various *_unlocked names as aliases. */
  100. #undef L___fsetlocking
  101. #undef L___flockfile
  102. #undef L___ftrylockfile
  103. #undef L___funlockfile
  104. #endif
  105. #ifndef __STDIO_LARGE_FILES
  106. /* Just build empty object files if any of these were defined. */
  107. #undef L_fopen64
  108. #undef L_freopen64
  109. #undef L_ftello64
  110. #undef L_fseeko64
  111. #undef L_fsetpos64
  112. #undef L_fgetpos64
  113. #endif
  114. /**********************************************************************/
  115. #ifndef __STDIO_THREADSAFE
  116. #if defined(__BCC__) && 0
  117. #define UNLOCKED_STREAM(RETURNTYPE,NAME,PARAMS,ARGS,STREAM) \
  118. asm(".text\nexport _" "NAME" "_unlocked\n_" "NAME" "_unlocked = _" "NAME"); \
  119. RETURNTYPE NAME PARAMS
  120. #else
  121. #define UNLOCKED_STREAM(RETURNTYPE,NAME,PARAMS,ARGS,STREAM) \
  122. strong_alias(NAME,NAME##_unlocked) \
  123. RETURNTYPE NAME PARAMS
  124. #endif
  125. #define UNLOCKED(RETURNTYPE,NAME,PARAMS,ARGS) \
  126. UNLOCKED_STREAM(RETURNTYPE,NAME,PARAMS,ARGS,stream)
  127. #if defined(__BCC__) && 0
  128. #define UNLOCKED_VOID_RETURN(NAME,PARAMS,ARGS) \
  129. asm(".text\nexport _" "NAME" "_unlocked\n_" "NAME" "_unlocked = _" "NAME"); \
  130. void NAME PARAMS
  131. #else
  132. #define UNLOCKED_VOID_RETURN(NAME,PARAMS,ARGS) \
  133. strong_alias(NAME,NAME##_unlocked) \
  134. void NAME PARAMS
  135. #endif
  136. #define __STDIO_THREADLOCK_OPENLIST
  137. #define __STDIO_THREADUNLOCK_OPENLIST
  138. #else /* __STDIO_THREADSAFE */
  139. #include <pthread.h>
  140. #define UNLOCKED_STREAM(RETURNTYPE,NAME,PARAMS,ARGS,STREAM) \
  141. RETURNTYPE NAME PARAMS \
  142. { \
  143. RETURNTYPE retval; \
  144. __STDIO_THREADLOCK(STREAM); \
  145. retval = NAME##_unlocked ARGS ; \
  146. __STDIO_THREADUNLOCK(STREAM); \
  147. return retval; \
  148. } \
  149. RETURNTYPE NAME##_unlocked PARAMS
  150. #define UNLOCKED(RETURNTYPE,NAME,PARAMS,ARGS) \
  151. UNLOCKED_STREAM(RETURNTYPE,NAME,PARAMS,ARGS,stream)
  152. #define UNLOCKED_VOID_RETURN(NAME,PARAMS,ARGS) \
  153. void NAME PARAMS \
  154. { \
  155. __STDIO_THREADLOCK(stream); \
  156. NAME##_unlocked ARGS ; \
  157. __STDIO_THREADUNLOCK(stream); \
  158. } \
  159. void NAME##_unlocked PARAMS
  160. #define __STDIO_THREADLOCK_OPENLIST \
  161. pthread_mutex_lock(&_stdio_openlist_lock)
  162. #define __STDIO_THREADUNLOCK_OPENLIST \
  163. pthread_mutex_unlock(&_stdio_openlist_lock)
  164. #define __STDIO_THREADTRYLOCK_OPENLIST \
  165. pthread_mutex_trylock(&_stdio_openlist_lock)
  166. #endif /* __STDIO_THREADSAFE */
  167. /**********************************************************************/
  168. #ifdef __STDIO_WIDE
  169. #define __STDIO_FILE_INIT_UNGOT { 0, 0 }, { 0, 0 },
  170. #else
  171. #define __STDIO_FILE_INIT_UNGOT { 0, 0 },
  172. #endif
  173. #ifdef __STDIO_GETC_MACRO
  174. #define __STDIO_FILE_INIT_BUFGETC(x) x,
  175. #else
  176. #define __STDIO_FILE_INIT_BUFGETC(x)
  177. #endif
  178. #ifdef __STDIO_PUTC_MACRO
  179. #define __STDIO_FILE_INIT_BUFPUTC(x) x,
  180. #else
  181. #define __STDIO_FILE_INIT_BUFPUTC(x)
  182. #endif
  183. #if defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS)
  184. #define __STDIO_FILE_INIT_NEXT(next) (next),
  185. #else /* defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) */
  186. #define __STDIO_FILE_INIT_NEXT(next)
  187. #endif /* defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) */
  188. #ifdef __STDIO_BUFFERS
  189. #define __STDIO_FILE_INIT_BUFFERS(buf,bufsize) \
  190. (buf), (buf)+(bufsize), (buf), (buf),
  191. #else
  192. #define __STDIO_FILE_INIT_BUFFERS(buf,bufsize)
  193. #endif
  194. #ifdef __STDIO_GLIBC_CUSTOM_STREAMS
  195. #define __STDIO_FILE_INIT_CUSTOM_STREAM(stream) \
  196. &((stream).filedes), { _cs_read, _cs_write, NULL, _cs_close },
  197. #else
  198. #define __STDIO_FILE_INIT_CUSTOM_STREAM(stream)
  199. #endif
  200. #ifdef __STDIO_MBSTATE
  201. #define __STDIO_FILE_INIT_MBSTATE \
  202. { 0, 0 },
  203. #else
  204. #define __STDIO_FILE_INIT_MBSTATE
  205. #endif
  206. #ifdef __STDIO_THREADSAFE
  207. #define __STDIO_FILE_INIT_THREADSAFE \
  208. 0, PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP,
  209. #else
  210. #define __STDIO_FILE_INIT_THREADSAFE
  211. #endif
  212. #define __STDIO_INIT_FILE_STRUCT(stream, flags, filedes, next, buf, bufsize) \
  213. { (flags), \
  214. __STDIO_FILE_INIT_UNGOT \
  215. (filedes), \
  216. __STDIO_FILE_INIT_NEXT(next) \
  217. __STDIO_FILE_INIT_BUFFERS(buf,bufsize) \
  218. __STDIO_FILE_INIT_BUFGETC((buf)) \
  219. __STDIO_FILE_INIT_BUFPUTC((buf)) \
  220. __STDIO_FILE_INIT_CUSTOM_STREAM(stream) \
  221. __STDIO_FILE_INIT_MBSTATE \
  222. __STDIO_FILE_INIT_THREADSAFE \
  223. } /* TODO: mbstate and builtin buf */
  224. #ifdef __STDIO_GLIBC_CUSTOM_STREAMS
  225. /* TODO -- what does glibc do for undefined funcs? errno set? */
  226. #define __READ(STREAMPTR,BUF,SIZE) \
  227. ((((STREAMPTR)->gcs.read) == NULL) ? -1 : \
  228. (((STREAMPTR)->gcs.read)((STREAMPTR)->cookie,(BUF),(SIZE))))
  229. #define __WRITE(STREAMPTR,BUF,SIZE) \
  230. ((((STREAMPTR)->gcs.write) == NULL) ? -1 : \
  231. (((STREAMPTR)->gcs.write)((STREAMPTR)->cookie,(BUF),(SIZE))))
  232. #define __CLOSE(STREAMPTR) \
  233. ((((STREAMPTR)->gcs.close) == NULL) ? 0 : \
  234. (((STREAMPTR)->gcs.close)((STREAMPTR)->cookie)))
  235. #else /* __STDIO_GLIBC_CUSTOM_STREAMS */
  236. #define __READ(STREAMPTR,BUF,SIZE) \
  237. (read((STREAMPTR)->filedes,(BUF),(SIZE)))
  238. #define __WRITE(STREAMPTR,BUF,SIZE) \
  239. (write((STREAMPTR)->filedes,(BUF),(SIZE)))
  240. #define __CLOSE(STREAMPTR) \
  241. (close((STREAMPTR)->filedes))
  242. #endif /* __STDIO_GLIBC_CUSTOM_STREAMS */
  243. /**********************************************************************/
  244. /* POSIX functions */
  245. /**********************************************************************/
  246. #ifdef L_getw
  247. /* SUSv2 Legacy function -- need not be reentrant. */
  248. int getw(FILE *stream)
  249. {
  250. int aw[1];
  251. #ifdef __STDIO_WIDE
  252. return (fread((void *)aw, sizeof(int), 1, stream) > 0) ? (*aw) : EOF;
  253. #else /* __STDIO_WIDE */
  254. return (_stdio_fread((unsigned char *)(aw), sizeof(int), stream)
  255. == sizeof(int)) ? (*aw) : EOF;
  256. #endif /* __STDIO_WIDE */
  257. }
  258. #endif
  259. /**********************************************************************/
  260. #ifdef L_putw
  261. /* SUSv2 Legacy function -- need not be reentrant. */
  262. int putw(int w, FILE *stream)
  263. {
  264. int aw[1];
  265. *aw = w; /* In case 'w' is in a register... */
  266. #ifdef __STDIO_WIDE
  267. return (fwrite((void *)aw, sizeof(int), 1, stream) == 1) ? 0 : EOF;
  268. #else /* __STDIO_WIDE */
  269. return (_stdio_fwrite((unsigned char *)aw, sizeof(int), stream)
  270. == sizeof(int)) ? 0 : EOF;
  271. #endif /* __STDIO_WIDE */
  272. }
  273. #endif
  274. /**********************************************************************/
  275. #ifdef L_fileno
  276. /* Reentrancy handled by UNLOCKED() macro. */
  277. UNLOCKED(int,fileno,(register FILE *stream),(stream))
  278. {
  279. #ifdef __STDIO_GLIBC_CUSTOM_STREAMS
  280. return ( (stream && (stream->cookie == &(stream->filedes)) && (stream->filedes >= 0))
  281. ? stream->filedes
  282. : (__set_errno(EBADF), -1) );
  283. #else /* __STDIO_GLIBC_CUSTOM_STREAMS */
  284. return ((stream && stream->filedes >= 0)) ? stream->filedes : (__set_errno(EBADF), -1);
  285. #endif /* __STDIO_GLIBC_CUSTOM_STREAMS */
  286. }
  287. #endif
  288. /**********************************************************************/
  289. #ifdef L_fdopen
  290. /* No reentrancy issues. */
  291. FILE *fdopen(int filedes, const char *mode)
  292. {
  293. register char *cur_mode; /* TODO -- replace by intptr_t?? */
  294. return (((int)(cur_mode = (char *) fcntl(filedes, F_GETFL))) != -1)
  295. ? _stdio_fopen(cur_mode, mode, NULL, filedes)
  296. : NULL;
  297. }
  298. #endif
  299. /**********************************************************************/
  300. #ifdef L_fopen64
  301. /* No reentrancy issues. */
  302. FILE *fopen64(const char * __restrict filename, const char * __restrict mode)
  303. {
  304. return _stdio_fopen(filename, mode, NULL, -2);
  305. }
  306. #endif
  307. /**********************************************************************/
  308. #ifdef L_ctermid_function
  309. /* Not required to be reentrant. */
  310. char *ctermid(register char *s)
  311. {
  312. static char sbuf[L_ctermid];
  313. #ifdef __BCC__
  314. /* Currently elks doesn't support /dev/tty. */
  315. if (!s) {
  316. s = sbuf;
  317. }
  318. *s = 0;
  319. return s;
  320. #else
  321. /* glibc always returns /dev/tty for linux. */
  322. return strcpy((s ? s : sbuf), "/dev/tty");
  323. #endif
  324. }
  325. #endif
  326. /**********************************************************************/
  327. /* BSD functions */
  328. /**********************************************************************/
  329. #ifdef L_setbuffer
  330. /* No reentrancy issues. */
  331. void setbuffer(FILE * __restrict stream, register char * __restrict buf,
  332. size_t size)
  333. {
  334. #ifdef __STDIO_BUFFERS
  335. setvbuf(stream, buf, (buf ? _IOFBF : _IONBF), size);
  336. #else /* __STDIO_BUFFERS */
  337. /* Nothing to do. */
  338. #endif /* __STDIO_BUFFERS */
  339. }
  340. #endif
  341. /**********************************************************************/
  342. #ifdef L_setlinebuf
  343. /* No reentrancy issues. */
  344. void setlinebuf(FILE * __restrict stream)
  345. {
  346. #ifdef __STDIO_BUFFERS
  347. setvbuf(stream, NULL, _IOLBF, (size_t) 0);
  348. #else /* __STDIO_BUFFERS */
  349. /* Nothing to do. */
  350. #endif /* __STDIO_BUFFERS */
  351. }
  352. #endif
  353. /**********************************************************************/
  354. /* GLIBC functions */
  355. /**********************************************************************/
  356. #ifdef L_fcloseall
  357. /* NOTE: GLIBC difference!!! -- fcloseall
  358. * According to the info pages, glibc actually fclose()s all open files.
  359. * Apparently, glibc's new version only fflush()s and unbuffers all
  360. * writing streams to cope with unordered destruction of c++ static
  361. * objects. Here we implement the old behavior as default.
  362. */
  363. /* Not reentrant. */
  364. int fcloseall (void)
  365. {
  366. #if defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS)
  367. register FILE *stream;
  368. int rv;
  369. _stdio_term(); /* Let _stdio_term() do all the work. */
  370. rv = 0;
  371. for (stream = _stdio_openlist ; stream ; stream = stream->nextopen) {
  372. if (stream->modeflags & (__FLAG_WRITING|__FLAG_ERROR)) {
  373. /* TODO -- is this correct? Maybe ferror set before flush...
  374. * could check if pending writable but what if term unbuffers?
  375. * in that case, could clear error flag... */
  376. rv = EOF; /* Only care about failed writes. */
  377. }
  378. }
  379. /* Make sure _stdio_term() does nothing on exit. */
  380. _stdio_openlist = NULL;
  381. return rv;
  382. #else /* defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) */
  383. return 0;
  384. #endif /* defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) */
  385. }
  386. #endif
  387. /**********************************************************************/
  388. #ifdef L_fmemopen
  389. #ifdef __STDIO_GLIBC_CUSTOM_STREAMS
  390. typedef struct {
  391. size_t pos;
  392. size_t len;
  393. size_t eof;
  394. int dynbuf;
  395. unsigned char *buf;
  396. FILE *fp;
  397. } __fmo_cookie;
  398. #define COOKIE ((__fmo_cookie *) cookie)
  399. static ssize_t fmo_read(register void *cookie, char *buf, size_t bufsize)
  400. {
  401. size_t count = COOKIE->len - COOKIE->pos;
  402. /* Note: bufsize < SSIZE_MAX because of _stdio_READ. */
  403. if (bufsize > count) {
  404. bufsize = count;
  405. }
  406. #if 1 /* TODO - choose code option */
  407. memcpy(buf, COOKIE->buf + COOKIE->pos, bufsize);
  408. COOKIE->pos += bufsize;
  409. #else
  410. {
  411. register char *p = COOKIE->buf + COOKIE->pos;
  412. count = bufsize;
  413. while (count) {
  414. *buf++ = *p++;
  415. --count;
  416. }
  417. COOKIE->pos += bufsize;
  418. }
  419. #endif
  420. return bufsize;
  421. }
  422. static ssize_t fmo_write(register void *cookie, const char *buf, size_t bufsize)
  423. {
  424. size_t count;
  425. /* Note: bufsize < SSIZE_MAX because of _stdio_WRITE. */
  426. /* If appending, need to seek to end of file!!!! */
  427. if (COOKIE->fp->modeflags & __FLAG_APPEND) {
  428. COOKIE->pos = COOKIE->eof;
  429. }
  430. count = COOKIE->len - COOKIE->pos;
  431. if (bufsize > count) {
  432. bufsize = count;
  433. if (count == 0) { /* We're at the end of the buffer... */
  434. __set_errno(EFBIG);
  435. return -1;
  436. }
  437. }
  438. #if 1 /* TODO - choose code option */
  439. memcpy(COOKIE->buf + COOKIE->pos, buf, bufsize);
  440. COOKIE->pos += bufsize;
  441. if (COOKIE->pos > COOKIE->eof) {
  442. COOKIE->eof = COOKIE->pos;
  443. if (bufsize < count) { /* New eof and still room in buffer? */
  444. *(COOKIE->buf + COOKIE->pos) = 0;
  445. }
  446. }
  447. #else
  448. {
  449. register char *p = COOKIE->buf + COOKIE->pos;
  450. size_t i = bufsize;
  451. while (i > 0) {
  452. *p++ = *buf++;
  453. --i;
  454. }
  455. COOKIE->pos += bufsize;
  456. if (COOKIE->pos > COOKIE->eof) {
  457. COOKIE->eof = COOKIE->pos;
  458. if (bufsize < count) { /* New eof and still room in buffer? */
  459. *p = 0;
  460. }
  461. }
  462. }
  463. #endif
  464. return bufsize;
  465. }
  466. /* glibc doesn't allow seeking, but it has in-buffer seeks... we don't. */
  467. static int fmo_seek(register void *cookie, __offmax_t *pos, int whence)
  468. {
  469. __offmax_t p = *pos;
  470. /* Note: fseek already checks that whence is legal, so don't check here
  471. * unless debugging. */
  472. assert(((unsigned int) whence) <= 2);
  473. if (whence != SEEK_SET) {
  474. p += (whence == SEEK_CUR) ? COOKIE->pos : /* SEEK_END */ COOKIE->eof;
  475. }
  476. /* Note: glibc only allows seeking in the buffer. We'll actually restrict
  477. * to the data. */
  478. /* Check for offset < 0, offset > eof, or offset overflow... */
  479. if (((uintmax_t) p) > COOKIE->eof) {
  480. return -1;
  481. }
  482. COOKIE->pos = *pos = p;
  483. return 0;
  484. }
  485. static int fmo_close(register void *cookie)
  486. {
  487. if (COOKIE->dynbuf) {
  488. free(COOKIE->buf);
  489. }
  490. free(cookie);
  491. return 0;
  492. }
  493. #undef COOKIE
  494. static const cookie_io_functions_t _fmo_io_funcs = {
  495. fmo_read, fmo_write, fmo_seek, fmo_close
  496. };
  497. /* TODO: If we have buffers enabled, it might be worthwile to add a pointer
  498. * to the FILE in the cookie and have read, write, and seek operate directly
  499. * on the buffer itself (ie replace the FILE buffer with the cookie buffer
  500. * and update FILE bufstart, etc. whenever we seek). */
  501. FILE *fmemopen(void *s, size_t len, const char *modes)
  502. {
  503. FILE *fp;
  504. register __fmo_cookie *cookie;
  505. size_t i;
  506. if ((cookie = malloc(sizeof(__fmo_cookie))) != NULL) {
  507. cookie->len = len;
  508. cookie->eof = cookie->pos = 0; /* pos and eof adjusted below. */
  509. cookie->dynbuf = 0;
  510. if (((cookie->buf = s) == NULL) && (len > 0)) {
  511. if ((cookie->buf = malloc(len)) == NULL) {
  512. goto EXIT_cookie;
  513. }
  514. cookie->dynbuf = 1;
  515. *cookie->buf = 0; /* If we're appending, treat as empty file. */
  516. }
  517. #ifndef __BCC__
  518. fp = fopencookie(cookie, modes, _fmo_io_funcs);
  519. #else
  520. fp = fopencookie(cookie, modes, &_fmo_io_funcs);
  521. #endif
  522. /* Note: We don't need to worry about locking fp in the thread case
  523. * as the only possible access would be a close or flush with
  524. * nothing currently in the FILE's write buffer. */
  525. if (fp != NULL) {
  526. cookie->fp = fp;
  527. if (fp->modeflags & __FLAG_READONLY) {
  528. cookie->eof = len;
  529. }
  530. if ((fp->modeflags & __FLAG_APPEND) && (len > 0)) {
  531. for (i = 0 ; i < len ; i++) {
  532. if (cookie->buf[i] == 0) {
  533. break;
  534. }
  535. }
  536. cookie->eof = cookie->pos = i; /* Adjust eof and pos. */
  537. }
  538. return fp;
  539. }
  540. }
  541. if (!s) {
  542. free(cookie->buf);
  543. }
  544. EXIT_cookie:
  545. free(cookie);
  546. return NULL;
  547. }
  548. #endif /* __STDIO_GLIBC_CUSTOM_STREAMS */
  549. #endif
  550. /**********************************************************************/
  551. #ifdef L_open_memstream
  552. #ifdef __STDIO_GLIBC_CUSTOM_STREAMS
  553. #define COOKIE ((__oms_cookie *) cookie)
  554. typedef struct {
  555. char *buf;
  556. size_t len;
  557. size_t pos;
  558. size_t eof;
  559. char **bufloc;
  560. size_t *sizeloc;
  561. } __oms_cookie;
  562. /* Nothing to do here, as memstreams are write-only. */
  563. /* static ssize_t oms_read(void *cookie, char *buf, size_t bufsize) */
  564. /* { */
  565. /* } */
  566. static ssize_t oms_write(register void *cookie, const char *buf, size_t bufsize)
  567. {
  568. register char *newbuf;
  569. size_t count;
  570. /* Note: we already know bufsize < SSIZE_MAX... */
  571. count = COOKIE->len - COOKIE->pos - 1;
  572. assert(COOKIE->pos < COOKIE->len); /* Always nul-terminate! */
  573. if (bufsize > count) {
  574. newbuf = realloc(COOKIE->buf, COOKIE->len + bufsize - count);
  575. if (newbuf) {
  576. *COOKIE->bufloc = COOKIE->buf = newbuf;
  577. COOKIE->len += (bufsize - count);
  578. } else {
  579. bufsize = count;
  580. if (count == 0) {
  581. __set_errno(EFBIG); /* TODO: check glibc errno setting... */
  582. return -1;
  583. }
  584. }
  585. }
  586. memcpy(COOKIE->buf + COOKIE->pos, buf, bufsize);
  587. COOKIE->pos += bufsize;
  588. if (COOKIE->pos > COOKIE->eof) {
  589. *COOKIE->sizeloc = COOKIE->eof = COOKIE->pos;
  590. COOKIE->buf[COOKIE->eof] = 0; /* Need to nul-terminate. */
  591. }
  592. return bufsize;
  593. }
  594. static int oms_seek(register void *cookie, __offmax_t *pos, int whence)
  595. {
  596. __offmax_t p = *pos;
  597. register char *buf;
  598. size_t leastlen;
  599. /* Note: fseek already checks that whence is legal, so don't check here
  600. * unless debugging. */
  601. assert(((unsigned int) whence) <= 2);
  602. if (whence != SEEK_SET) {
  603. p += (whence == SEEK_CUR) ? COOKIE->pos : /* SEEK_END */ COOKIE->eof;
  604. }
  605. /* Note: glibc only allows seeking in the buffer. We'll actually restrict
  606. * to the data. */
  607. /* Check for offset < 0, offset >= too big (need nul), or overflow... */
  608. if (((uintmax_t) p) >= SIZE_MAX - 1) {
  609. return -1;
  610. }
  611. leastlen = ((size_t) p) + 1; /* New pos + 1 for nul if necessary. */
  612. if (leastlen >= COOKIE->len) { /* Need to grow buffer... */
  613. buf = realloc(COOKIE->buf, leastlen);
  614. if (buf) {
  615. *COOKIE->bufloc = COOKIE->buf = buf;
  616. COOKIE->len = leastlen;
  617. memset(buf + COOKIE->eof, leastlen - COOKIE->eof, 0); /* 0-fill */
  618. } else {
  619. /* TODO: check glibc errno setting... */
  620. return -1;
  621. }
  622. }
  623. *pos = COOKIE->pos = --leastlen;
  624. if (leastlen > COOKIE->eof) {
  625. memset(COOKIE->buf + COOKIE->eof, leastlen - COOKIE->eof, 0);
  626. *COOKIE->sizeloc = COOKIE->eof;
  627. }
  628. return 0;
  629. }
  630. static int oms_close(void *cookie)
  631. {
  632. free(cookie);
  633. return 0;
  634. }
  635. #undef COOKIE
  636. static const cookie_io_functions_t _oms_io_funcs = {
  637. NULL, oms_write, oms_seek, oms_close
  638. };
  639. /* TODO: If we have buffers enabled, it might be worthwile to add a pointer
  640. * to the FILE in the cookie and operate directly on the buffer itself
  641. * (ie replace the FILE buffer with the cookie buffer and update FILE bufstart,
  642. * etc. whenever we seek). */
  643. FILE *open_memstream(char **__restrict bufloc, size_t *__restrict sizeloc)
  644. {
  645. register __oms_cookie *cookie;
  646. register FILE *fp;
  647. if ((cookie = malloc(sizeof(__oms_cookie))) != NULL) {
  648. if ((cookie->buf = malloc(cookie->len = BUFSIZ)) == NULL) {
  649. goto EXIT_cookie;
  650. }
  651. *cookie->buf = 0; /* Set nul terminator for buffer. */
  652. *(cookie->bufloc = bufloc) = cookie->buf;
  653. *(cookie->sizeloc = sizeloc) = cookie->eof = cookie->pos = 0;
  654. #ifndef __BCC__
  655. fp = fopencookie(cookie, "w", _oms_io_funcs);
  656. #else
  657. fp = fopencookie(cookie, "w", &_oms_io_funcs);
  658. #endif
  659. /* Note: We don't need to worry about locking fp in the thread case
  660. * as the only possible access would be a close or flush with
  661. * nothing currently in the FILE's write buffer. */
  662. if (fp != NULL) {
  663. return fp;
  664. }
  665. }
  666. if (cookie->buf != NULL) {
  667. free(cookie->buf);
  668. }
  669. EXIT_cookie:
  670. free(cookie);
  671. return NULL;
  672. }
  673. #endif /* __STDIO_GLIBC_CUSTOM_STREAMS */
  674. #endif
  675. /**********************************************************************/
  676. #ifdef L_fopencookie
  677. #ifdef __STDIO_GLIBC_CUSTOM_STREAMS
  678. /* NOTE: GLIBC difference!!! -- fopencookie
  679. * According to the info pages, glibc allows seeking within buffers even if
  680. * no seek function is supplied. We don't. */
  681. /* NOTE: GLIBC difference!!! -- fopencookie
  682. * When compiled without large file support, the offset pointer for the
  683. * cookie_seek function is off_t * and not off64_t * as for glibc. */
  684. /* TODO: rewrite _stdio_fopen() to avoid the fopencookie() kludge. */
  685. /* Currently no real reentrancy issues other than a possible double close(). */
  686. #ifndef __BCC__
  687. FILE *fopencookie(void * __restrict cookie, const char * __restrict mode,
  688. cookie_io_functions_t io_functions)
  689. {
  690. FILE *stream;
  691. int fd;
  692. if ((stream = _stdio_fopen("/dev/null", mode, NULL, -1)) != NULL) {
  693. fd = stream->filedes;
  694. stream->filedes = -1;
  695. close(fd);
  696. stream->gcs = io_functions;
  697. stream->cookie = cookie;
  698. }
  699. #if !defined(__STDIO_BUFFERS) && !defined(__STDIO_THREADSAFE)
  700. /* I we don't have buffers or threads, we only need to worry about
  701. * custom streams on the open list, as no flushing is necessary and
  702. * no locking of possible underlying normal streams need be done.
  703. * We do need to explicitly close custom streams on termination of stdio,
  704. * and we need to lock the list as it can be modified by fclose(). */
  705. __STDIO_THREADLOCK_OPENLIST;
  706. stream->nextopen = _stdio_openlist; /* New files are inserted at */
  707. _stdio_openlist = stream; /* the head of the list. */
  708. __STDIO_THREADUNLOCK_OPENLIST;
  709. #endif /* !defined(__STDIO_BUFFERS) && !defined(__STDIO_THREADSAFE) */
  710. return stream;
  711. }
  712. #else /* __BCC__ */
  713. /* NOTE: GLIBC difference!!! -- fopencookie (bcc only)
  714. * Since bcc doesn't support passing of structs, we define fopencookie as a
  715. * macro in terms of _fopencookie which takes a struct * for the io functions
  716. * instead.
  717. */
  718. FILE *_fopencookie(void * __restrict cookie, const char * __restrict mode,
  719. register cookie_io_functions_t *io_functions)
  720. {
  721. register FILE *stream;
  722. if ((stream = _stdio_fopen("/dev/null", mode, NULL, -1)) != NULL) {
  723. int fd = stream->filedes;
  724. stream->filedes = -1;
  725. close(fd);
  726. stream->gcs.read = io_functions->read;
  727. stream->gcs.write = io_functions->write;
  728. stream->gcs.seek = io_functions->seek;
  729. stream->gcs.close = io_functions->close;
  730. stream->cookie = cookie;
  731. }
  732. #if !defined(__STDIO_BUFFERS) && !defined(__STDIO_THREADSAFE)
  733. /* I we don't have buffers or threads, we only need to worry about
  734. * custom streams on the open list, as no flushing is necessary and
  735. * no locking of possible underlying normal streams need be done.
  736. * We do need to explicitly close custom streams on termination of stdio,
  737. * and we need to lock the list as it can be modified by fclose(). */
  738. __STDIO_THREADLOCK_OPENLIST;
  739. stream->nextopen = _stdio_openlist; /* New files are inserted at */
  740. _stdio_openlist = stream; /* the head of the list. */
  741. __STDIO_THREADUNLOCK_OPENLIST;
  742. #endif /* !defined(__STDIO_BUFFERS) && !defined(__STDIO_THREADSAFE) */
  743. return stream;
  744. }
  745. #endif /* __BCC__ */
  746. #endif /* __STDIO_GLIBC_CUSTOM_STREAMS */
  747. #endif
  748. /**********************************************************************/
  749. #ifdef L___fbufsize
  750. /* Not reentrant. */
  751. size_t __fbufsize(register FILE * __restrict stream)
  752. {
  753. #ifdef __STDIO_BUFFERS
  754. return (stream->modeflags & __FLAG_NBF)
  755. ? 0 : (stream->bufend - stream->bufstart);
  756. #else /* __STDIO_BUFFERS */
  757. return 0;
  758. #endif /* __STDIO_BUFFERS */
  759. }
  760. #endif
  761. /**********************************************************************/
  762. #ifdef L___freading
  763. /* No reentrancy issues. */
  764. int __freading(FILE * __restrict stream)
  765. {
  766. return stream->modeflags & (__FLAG_READING|__FLAG_READONLY);
  767. }
  768. #endif
  769. /**********************************************************************/
  770. #ifdef L___fwriting
  771. /* No reentrancy issues. */
  772. int __fwriting(FILE * __restrict stream)
  773. {
  774. return stream->modeflags & (__FLAG_WRITING|__FLAG_WRITEONLY);
  775. }
  776. #endif
  777. /**********************************************************************/
  778. #ifdef L___freadable
  779. /* No reentrancy issues. */
  780. int __freadable(FILE * __restrict stream)
  781. {
  782. return ~(stream->modeflags & __FLAG_WRITEONLY);
  783. }
  784. #endif
  785. /**********************************************************************/
  786. #ifdef L___fwritable
  787. /* No reentrancy issues. */
  788. int __fwritable(FILE * __restrict stream)
  789. {
  790. return ~(stream->modeflags & __FLAG_READONLY);
  791. }
  792. #endif
  793. /**********************************************************************/
  794. #ifdef L___flbf
  795. /* No reentrancy issues. */
  796. int __flbf(FILE * __restrict stream)
  797. {
  798. #ifdef __STDIO_BUFFERS
  799. return (stream->modeflags & __FLAG_LBF);
  800. #else /* __STDIO_BUFFERS */
  801. /* TODO -- Even though there is no buffer, return flag setting? */
  802. return __FLAG_NBF;
  803. #endif /* __STDIO_BUFFERS */
  804. }
  805. #endif
  806. /**********************************************************************/
  807. #ifdef L___fpurge
  808. /* Not reentrant. */
  809. void __fpurge(register FILE * __restrict stream)
  810. {
  811. #ifdef __STDIO_BUFFERS
  812. #ifdef __STDIO_PUTC_MACRO
  813. stream->bufputc = /* Must disable putc. */
  814. #endif /* __STDIO_PUTC_MACRO */
  815. #ifdef __STDIO_GETC_MACRO
  816. stream->bufgetc = /* Must disable getc. */
  817. #endif
  818. stream->bufpos = stream->bufread = stream->bufstart; /* Reset pointers. */
  819. #endif /* __STDIO_BUFFERS */
  820. /* Reset r/w flags and clear ungots. */
  821. stream->modeflags &= ~(__FLAG_READING|__FLAG_WRITING|__MASK_UNGOT);
  822. }
  823. #endif
  824. /**********************************************************************/
  825. #ifdef L___fpending
  826. /* Not reentrant. */
  827. #ifdef __STDIO_WIDE
  828. #warning unlike the glibc version, this __fpending returns bytes in buffer for wide streams too!
  829. link_warning(__fpending, "This version of __fpending returns bytes remaining in buffer for both narrow and wide streams. glibc's version returns wide chars in buffer for the wide stream case.")
  830. #endif /* __STDIO_WIDE */
  831. size_t __fpending(register FILE * __restrict stream)
  832. {
  833. #ifdef __STDIO_BUFFERS
  834. /* TODO -- should we check this? should we set errno? just assert? */
  835. return (stream->modeflags & (__FLAG_READING|__FLAG_READONLY))
  836. ? 0 : (stream->bufpos - stream->bufstart);
  837. #else /* __STDIO_BUFFERS */
  838. return 0;
  839. #endif /* __STDIO_BUFFERS */
  840. }
  841. #endif
  842. /**********************************************************************/
  843. #ifdef L__flushlbf
  844. /* No reentrancy issues. */
  845. void _flushlbf(void)
  846. {
  847. #ifdef __STDIO_BUFFERS
  848. fflush((FILE *) &_stdio_openlist); /* Uses an implementation hack!!! */
  849. #else /* __STDIO_BUFFERS */
  850. /* Nothing to do. */
  851. #endif /* __STDIO_BUFFERS */
  852. }
  853. #endif
  854. /**********************************************************************/
  855. #ifdef L___fsetlocking
  856. /* NOT threadsafe!!! (I don't think glibc's is either)
  857. *
  858. * This interacts badly with internal locking/unlocking. If you use this routine,
  859. * make sure the file isn't being accessed by any other threads. Typical use would
  860. * be to change to user locking immediately after opening the stream.
  861. */
  862. #ifdef __UCLIBC_MJN3_ONLY__
  863. link_warning(__fsetlocking, "Oddly enough, __fsetlocking() is NOT threadsafe.")
  864. #endif
  865. int __fsetlocking(FILE *stream, int locking_mode)
  866. {
  867. #ifdef __STDIO_THREADSAFE
  868. int old_mode;
  869. #endif
  870. assert((FSETLOCKING_QUERY == 0) && (FSETLOCKING_INTERNAL == 1)
  871. && (FSETLOCKING_BYCALLER == 2));
  872. assert(((unsigned int) locking_mode) <= 2);
  873. #ifdef __STDIO_THREADSAFE
  874. old_mode = stream->user_locking;
  875. assert(((unsigned int) old_mode) <= 1); /* Must be 0 (internal) or 1 (user). */
  876. if (locking_mode != FSETLOCKING_QUERY) {
  877. /* In case we're not debugging, treat any unknown as a request to
  878. * set internal locking, in order to match glibc behavior. */
  879. stream->user_locking = (locking_mode == FSETLOCKING_BYCALLER);
  880. }
  881. return 2 - old_mode;
  882. #else
  883. return FSETLOCKING_BYCALLER; /* Well, without thread support... */
  884. #endif
  885. }
  886. #endif
  887. /**********************************************************************/
  888. #ifdef L_flockfile
  889. void flockfile(FILE *stream)
  890. {
  891. #ifdef __STDIO_THREADSAFE
  892. pthread_mutex_lock(&stream->lock);
  893. #endif
  894. }
  895. #endif
  896. /**********************************************************************/
  897. #ifdef L_ftrylockfile
  898. int ftrylockfile(FILE *stream)
  899. {
  900. #ifdef __STDIO_THREADSAFE
  901. return pthread_mutex_trylock(&stream->lock);
  902. #else
  903. return 1;
  904. #endif
  905. }
  906. #endif
  907. /**********************************************************************/
  908. #ifdef L_funlockfile
  909. void funlockfile(FILE *stream)
  910. {
  911. #ifdef __STDIO_THREADSAFE
  912. pthread_mutex_unlock(&stream->lock);
  913. #endif
  914. }
  915. #endif
  916. /**********************************************************************/
  917. #ifdef L_getline
  918. ssize_t getline(char **__restrict lineptr, size_t *__restrict n,
  919. FILE *__restrict stream)
  920. {
  921. return __getdelim(lineptr, n, '\n', stream);
  922. }
  923. #endif
  924. /**********************************************************************/
  925. #ifdef L_getdelim
  926. weak_alias(__getdelim,getdelim);
  927. #define GETDELIM_GROWBY 64
  928. ssize_t __getdelim(char **__restrict lineptr, size_t *__restrict n,
  929. int delimiter, register FILE *__restrict stream)
  930. {
  931. register char *buf;
  932. size_t pos;
  933. int c;
  934. if (!lineptr || !n || !stream) { /* Be compatable with glibc... even */
  935. __set_errno(EINVAL); /* though I think we should assert here */
  936. return -1; /* if anything. */
  937. }
  938. if (!(buf = *lineptr)) { /* If passed NULL for buffer, */
  939. *n = 0; /* ignore value passed and treat size as 0. */
  940. }
  941. pos = 1; /* Make sure we have space for terminating nul. */
  942. __STDIO_THREADLOCK(stream);
  943. do {
  944. if (pos >= *n) {
  945. if (!(buf = realloc(buf, *n + GETDELIM_GROWBY))) {
  946. __set_errno(ENOMEM); /* Emulate old uClibc implementation. */
  947. break;
  948. }
  949. *n += GETDELIM_GROWBY;
  950. *lineptr = buf;
  951. }
  952. } while (((c = getc(stream)) != EOF) && ((buf[pos++ - 1] = c) != delimiter));
  953. __STDIO_THREADUNLOCK(stream);
  954. if (--pos) {
  955. buf[pos] = 0;
  956. return pos;
  957. }
  958. return -1; /* Either initial realloc failed or first read was EOF. */
  959. }
  960. #endif
  961. /**********************************************************************/
  962. /* my extension functions */
  963. /**********************************************************************/
  964. #ifdef L__stdio_fsfopen
  965. /*
  966. * Stack|Static File open -- open a file where the FILE is either
  967. * stack or staticly allocated.
  968. */
  969. /* No reentrancy issues. */
  970. FILE *_stdio_fsfopen(const char * __restrict filename,
  971. const char * __restrict mode,
  972. register FILE * __restrict stream)
  973. {
  974. #ifdef __STDIO_BUFFERS
  975. stream->modeflags = __FLAG_FBF;
  976. #if __STDIO_BUILTIN_BUF_SIZE > 0
  977. stream->bufstart = stream->builtinbuf;
  978. stream->bufend = stream->builtinbuf + sizeof(stream->builtinbuf);
  979. #else /* __STDIO_BUILTIN_BUF_SIZE > 0 */
  980. stream->bufend = stream->bufstart = NULL;
  981. #endif /* __STDIO_BUILTIN_BUF_SIZE > 0 */
  982. #endif /* __STDIO_BUFFERS */
  983. return _stdio_fopen(filename, mode, stream, -1);
  984. }
  985. #endif
  986. /**********************************************************************/
  987. /* stdio internal functions */
  988. /**********************************************************************/
  989. #ifdef L__stdio_adjpos
  990. /*
  991. * ANSI/ISO p. 370: The file positioning indicator is unspecified after
  992. * a successful call to ungetwc.
  993. * Note however, that this applies only to _user_ calls to ungetwc. We
  994. * need to allow for internal calls by scanf. So we store the byte count
  995. * of the first ungot wide char in ungot0_bytes. If it is 0 (user case)
  996. * then the file position is treated as unknown.
  997. */
  998. /* Internal function -- not reentrant. */
  999. int _stdio_adjpos(register FILE * __restrict stream, register __offmax_t *pos)
  1000. {
  1001. __offmax_t r;
  1002. int cor = stream->modeflags & __MASK_UNGOT; /* handle ungots */
  1003. #ifdef __STDIO_WIDE
  1004. /* Assumed narrow stream so correct if wide. */
  1005. if (cor && (stream->modeflags & __FLAG_WIDE)) {
  1006. cor = cor - 1 + stream->ungot_width[0];
  1007. if (((stream->modeflags & __MASK_UNGOT) > 1) || stream->ungot[1]) {
  1008. return -1; /* App did ungetwc, so position is indeterminate. */
  1009. }
  1010. assert(stream->ungot_width[0] > 0);
  1011. }
  1012. #endif /* __STDIO_WIDE */
  1013. #ifdef __STDIO_BUFFERS
  1014. if (stream->modeflags & __FLAG_WRITING) {
  1015. cor -= (stream->bufpos - stream->bufstart); /* pending writes */
  1016. }
  1017. if (stream->modeflags & __FLAG_READING) {
  1018. cor += (stream->bufread - stream->bufpos); /* extra's read */
  1019. }
  1020. #endif /* __STDIO_BUFFERS */
  1021. r = *pos;
  1022. return ((*pos -= cor) > r) ? -cor : cor;
  1023. }
  1024. #endif
  1025. /**********************************************************************/
  1026. #ifdef L__stdio_lseek
  1027. /*
  1028. * This function is only called by fseek and ftell.
  1029. * fseek -- doesn't care about pos val, just success or failure.
  1030. * ftell -- needs pos val but offset == 0 and whence == SET_CUR.
  1031. */
  1032. /* Internal function -- not reentrant. */
  1033. int _stdio_lseek(register FILE *stream, register __offmax_t *pos, int whence)
  1034. {
  1035. __offmax_t res;
  1036. #ifdef __STDIO_GLIBC_CUSTOM_STREAMS
  1037. if (stream->cookie != &stream->filedes) {
  1038. return (((stream->gcs.seek == NULL)
  1039. || ((stream->gcs.seek)(stream->cookie, pos, whence) < 0))
  1040. ? -1 : 0);
  1041. }
  1042. #endif /* __STDIO_GLIBC_CUSTOM_STREAMS */
  1043. #ifdef __STDIO_LARGE_FILES
  1044. res = lseek64(stream->filedes, *pos, whence);
  1045. #else
  1046. res = lseek(stream->filedes, *pos, whence);
  1047. #endif /* __STDIO_LARGE_FILES */
  1048. return (res >= 0) ? ((*pos = res), 0) : -1;
  1049. }
  1050. #endif
  1051. /**********************************************************************/
  1052. #ifdef L__stdio_fread
  1053. /*
  1054. * NOTE!!! This routine is meant to be callable by both narrow and wide
  1055. * functions. However, if called by a wide function, there must be
  1056. * NO pending ungetwc()s!!!
  1057. */
  1058. /* Unlike write, it's ok for read to return fewer than bufsize, since
  1059. * we may not need all of them. */
  1060. static ssize_t _stdio_READ(register FILE *stream, unsigned char *buf, size_t bufsize)
  1061. {
  1062. ssize_t rv;
  1063. if (bufsize == 0) {
  1064. return 0;
  1065. }
  1066. if (bufsize > SSIZE_MAX) {
  1067. bufsize = SSIZE_MAX;
  1068. }
  1069. #ifdef __BCC__
  1070. TRY_READ:
  1071. #endif
  1072. rv = __READ(stream, buf, bufsize);
  1073. if (rv > 0) {
  1074. #ifdef __STDIO_GLIBC_CUSTOM_STREAMS
  1075. assert(rv <= bufsize); /* buggy user handler... TODO: check? */
  1076. if (rv > bufsize) { /* Num reported written > number requested */
  1077. rv = bufsize; /* Treat as a full read??? */
  1078. }
  1079. #endif
  1080. } else if (rv == 0) {
  1081. stream->modeflags |= __FLAG_EOF;
  1082. } else {
  1083. #ifdef __BCC__
  1084. if (errno == EINTR) {
  1085. goto TRY_READ;
  1086. }
  1087. #endif
  1088. stream->modeflags |= __FLAG_ERROR;
  1089. rv = 0;
  1090. }
  1091. return rv;
  1092. }
  1093. /* Internal function -- not reentrant. */
  1094. size_t _stdio_fread(unsigned char *buffer, size_t bytes, register FILE *stream)
  1095. {
  1096. __stdio_validate_FILE(stream); /* debugging only */
  1097. #ifdef __STDIO_BUFFERS
  1098. if (stream->modeflags
  1099. #ifdef __STDIO_AUTO_RW_TRANSITION
  1100. & (__FLAG_WRITEONLY)
  1101. #else /* __STDIO_AUTO_RW_TRANSITION */
  1102. /* ANSI/ISO and SUSv3 require not currently writing. */
  1103. & (__FLAG_WRITEONLY|__FLAG_WRITING)
  1104. #endif /* __STDIO_AUTO_RW_TRANSITION */
  1105. ) {
  1106. #ifdef __STDIO_PUTC_MACRO
  1107. stream->bufputc = stream->bufstart; /* Must disable putc. */
  1108. #endif /* __STDIO_PUTC_MACRO */
  1109. stream->modeflags |= __FLAG_ERROR;
  1110. /* TODO: This is for posix behavior if writeonly. To save space, we
  1111. * use this errno for read attempt while writing, as no errno is
  1112. * specified by posix for this case, even though the restriction is
  1113. * mentioned in fopen(). */
  1114. __set_errno(EBADF);
  1115. return 0;
  1116. }
  1117. /* We need to disable putc and getc macros in case of error */
  1118. #if defined(__STDIO_PUTC_MACRO) || defined(__STDIO_GETC_MACRO)
  1119. #ifdef __STDIO_PUTC_MACRO
  1120. stream->bufputc =
  1121. #endif /* __STDIO_GETC_MACRO */
  1122. #ifdef __STDIO_GETC_MACRO
  1123. stream->bufgetc =
  1124. #endif /* __STDIO_GETC_MACRO */
  1125. stream->bufstart;
  1126. #endif /* defined(__STDIO_PUTC_MACRO) || defined(__STDIO_GETC_MACRO) */
  1127. if (stream->modeflags & __MASK_BUFMODE) {
  1128. /* If the stream is readable and not fully buffered, we must first
  1129. * flush all line buffered output streams. Do this before the
  1130. * error check as this may be a read/write line-buffered stream.
  1131. * Note: Uses an implementation-specific hack!!! */
  1132. fflush_unlocked((FILE *) &_stdio_openlist);
  1133. }
  1134. #ifdef __STDIO_AUTO_RW_TRANSITION
  1135. if ((stream->modeflags & __FLAG_WRITING)
  1136. && (fflush_unlocked(stream) == EOF)
  1137. ) {
  1138. return 0; /* Fail if we need to fflush but can't. */
  1139. }
  1140. #endif /* __STDIO_AUTO_RW_TRANSITION */
  1141. stream->modeflags |= __FLAG_READING; /* Make sure Reading flag is set. */
  1142. {
  1143. register unsigned char *p = (unsigned char *) buffer;
  1144. /* First, grab appropriate ungetc() chars. NOT FOR WIDE ORIENTATED! */
  1145. while (bytes && (stream->modeflags & __MASK_UNGOT)) {
  1146. #ifdef __STDIO_WIDE
  1147. assert(stream->modeflags & __FLAG_NARROW);
  1148. #endif /* __STDIO_WIDE */
  1149. *p++ = stream->ungot[(--stream->modeflags) & __MASK_UNGOT];
  1150. stream->ungot[1] = 0;
  1151. --bytes;
  1152. }
  1153. /* Now get any other needed chars from the buffer or the file. */
  1154. FROM_BUF:
  1155. while (bytes && (stream->bufpos < stream->bufread)) {
  1156. --bytes;
  1157. *p++ = *stream->bufpos++;
  1158. }
  1159. if ((bytes > 0) && (stream->filedes != -2)) {
  1160. ssize_t len;
  1161. /* The buffer is exhausted, but we still need chars. */
  1162. stream->bufpos = stream->bufread = stream->bufstart;
  1163. if (bytes <= stream->bufend - stream->bufread) {
  1164. /* We have sufficient space in the buffer. */
  1165. len = _stdio_READ(stream, stream->bufread,
  1166. stream->bufend - stream->bufread);
  1167. if (len > 0) {
  1168. stream->bufread += len;
  1169. goto FROM_BUF;
  1170. }
  1171. } else {
  1172. /* More bytes needed than fit in the buffer, so read */
  1173. /* directly into caller's buffer. */
  1174. len = _stdio_READ(stream, p, bytes);
  1175. if (len > 0) {
  1176. p += len;
  1177. bytes -= len;
  1178. goto FROM_BUF; /* Redundant work, but stops extra read. */
  1179. }
  1180. }
  1181. }
  1182. #ifdef __STDIO_GETC_MACRO
  1183. if (!(stream->modeflags
  1184. & (__FLAG_WIDE|__MASK_UNGOT|__MASK_BUFMODE|__FLAG_ERROR))
  1185. ) {
  1186. stream->bufgetc = stream->bufread; /* Enable getc macro. */
  1187. }
  1188. #endif
  1189. __stdio_validate_FILE(stream); /* debugging only */
  1190. return (p - (unsigned char *)buffer);
  1191. }
  1192. #else /* __STDIO_BUFFERS --------------------------------------- */
  1193. if (stream->modeflags
  1194. #ifdef __STDIO_AUTO_RW_TRANSITION
  1195. & (__FLAG_WRITEONLY)
  1196. #else /* __STDIO_AUTO_RW_TRANSITION */
  1197. /* ANSI/ISO and SUSv3 require not currently writing. */
  1198. & (__FLAG_WRITEONLY|__FLAG_WRITING)
  1199. #endif /* __STDIO_AUTO_RW_TRANSITION */
  1200. ) {
  1201. stream->modeflags |= __FLAG_ERROR;
  1202. /* TODO: This is for posix behavior if writeonly. To save space, we
  1203. * use this errno for read attempt while writing, as no errno is
  1204. * specified by posix for this case, even though the restriction is
  1205. * mentioned in fopen(). */
  1206. __set_errno(EBADF);
  1207. return 0;
  1208. }
  1209. #ifdef __STDIO_AUTO_RW_TRANSITION
  1210. stream->modeflags &= ~(__FLAG_WRITING); /* Make sure Writing flag clear. */
  1211. #endif /* __STDIO_AUTO_RW_TRANSITION */
  1212. stream->modeflags |= __FLAG_READING; /* Make sure Reading flag is set. */
  1213. {
  1214. register unsigned char *p = (unsigned char *) buffer;
  1215. /* First, grab appropriate ungetc() chars. NOT FOR WIDE ORIENTATED! */
  1216. while (bytes && (stream->modeflags & __MASK_UNGOT)) {
  1217. #ifdef __STDIO_WIDE
  1218. assert(stream->modeflags & __FLAG_NARROW);
  1219. #endif /* __STDIO_WIDE */
  1220. *p++ = stream->ungot[(--stream->modeflags) & __MASK_UNGOT];
  1221. stream->ungot[1] = 0;
  1222. --bytes;
  1223. }
  1224. while (bytes > 0) {
  1225. ssize_t len = _stdio_READ(stream, p, (unsigned) bytes);
  1226. if (len == 0) {
  1227. break;
  1228. }
  1229. p += len;
  1230. bytes -= len;
  1231. }
  1232. __stdio_validate_FILE(stream); /* debugging only */
  1233. return (p - (unsigned char *)buffer);
  1234. }
  1235. #endif /* __STDIO_BUFFERS */
  1236. }
  1237. #endif
  1238. /**********************************************************************/
  1239. #ifdef L__stdio_fwrite
  1240. /*
  1241. * If buffer == NULL, attempt to fflush and return number of chars
  1242. * remaining in buffer (0 if successful fflush).
  1243. */
  1244. /* WARNING!!!! Current standards say that termination due to an asyncronous
  1245. * signal may not result in stdio streams being flushed. This libary makes
  1246. * an effort to do so but there is no way, short of blocking signals for
  1247. * each _stdio_fwrite call, that we can maintain the correct state if a
  1248. * signal is recieved mid-call. So any stream in mid-_stdio_fwrite could
  1249. * not some flush data or even duplicate-flush some data. It is possible
  1250. * to avoid the duplicate-flush case by setting/clearing the stream
  1251. * error flag before/after the write process, but it doesn't seem worth
  1252. * the trouble. */
  1253. /* Like standard write, but always does a full write unless error, plus
  1254. * deals correctly with bufsize > SSIZE_MAX... not much on an issue on linux
  1255. * but definitly could be on Elks. Also on Elks, always loops for EINTR..
  1256. * Returns number of bytes written, so a short write indicates an error */
  1257. static size_t _stdio_WRITE(register FILE *stream,
  1258. register const unsigned char *buf, size_t bufsize)
  1259. {
  1260. size_t todo;
  1261. ssize_t rv, stodo;
  1262. todo = bufsize;
  1263. while (todo) {
  1264. stodo = (todo <= SSIZE_MAX) ? todo : SSIZE_MAX;
  1265. rv = __WRITE(stream, buf, stodo);
  1266. if (rv >= 0) {
  1267. #ifdef __STDIO_GLIBC_CUSTOM_STREAMS
  1268. assert(rv <= stodo); /* buggy user handler... TODO: check? */
  1269. if (rv > stodo) { /* Num reported written > number requested */
  1270. rv = stodo; /* Treat as a full write??? */
  1271. }
  1272. #endif
  1273. todo -= rv;
  1274. buf += rv;
  1275. } else
  1276. #ifdef __BCC__
  1277. if (errno != EINTR)
  1278. #endif
  1279. {
  1280. stream->modeflags |= __FLAG_ERROR;
  1281. break;
  1282. }
  1283. }
  1284. return bufsize - todo;
  1285. }
  1286. /* Internal function -- not reentrant. */
  1287. size_t _stdio_fwrite(const unsigned char *buffer, size_t bytes,
  1288. register FILE *stream)
  1289. {
  1290. #ifdef __STDIO_BUFFERS
  1291. register const unsigned char *p;
  1292. __stdio_validate_FILE(stream); /* debugging only */
  1293. if ((stream->modeflags & __FLAG_READONLY)
  1294. #ifndef __STDIO_AUTO_RW_TRANSITION
  1295. /* ANSI/ISO requires either at EOF or currently not reading. */
  1296. || ((stream->modeflags & (__FLAG_READING|__FLAG_EOF))
  1297. == __FLAG_READING)
  1298. #endif /* __STDIO_AUTO_RW_TRANSITION */
  1299. ) {
  1300. stream->modeflags |= __FLAG_ERROR;
  1301. /* TODO: This is for posix behavior if readonly. To save space, we
  1302. * use this errno for write attempt while reading, as no errno is
  1303. * specified by posix for this case, even though the restriction is
  1304. * mentioned in fopen(). */
  1305. __set_errno(EBADF);
  1306. return 0;
  1307. }
  1308. #ifdef __STDIO_AUTO_RW_TRANSITION
  1309. /* If reading, deal with ungots and read-buffered chars. */
  1310. if (stream->modeflags & __FLAG_READING) {
  1311. if (((stream->bufpos < stream->bufread)
  1312. || (stream->modeflags & __MASK_UNGOT))
  1313. /* If appending, we might as well seek to end to save a seek. */
  1314. /* TODO: set EOF in fseek when appropriate? */
  1315. && fseek(stream, 0L,
  1316. ((stream->modeflags & __FLAG_APPEND)
  1317. ? SEEK_END : SEEK_CUR))
  1318. ) {
  1319. /* Note: This differs from glibc's apparent behavior of
  1320. not setting the error flag and discarding the buffered
  1321. read data. */
  1322. stream->modeflags |= __FLAG_ERROR; /* fseek may not set this. */
  1323. return 0; /* Fail if we need to fseek but can't. */
  1324. }
  1325. /* Always reset even if fseek called (saves a test). */
  1326. #ifdef __STDIO_GETC_MACRO
  1327. stream->bufgetc =
  1328. #endif /* __STDIO_GETC_MACRO */
  1329. stream->bufpos = stream->bufread = stream->bufstart;
  1330. } else
  1331. #endif
  1332. if ((stream->modeflags & (__FLAG_WRITING|__FLAG_APPEND)) == __FLAG_APPEND) {
  1333. /* Append mode, but not currently writing. Need to seek to end for proper
  1334. * ftell() return values. Don't worry if the stream isn't seekable. */
  1335. __offmax_t pos[1];
  1336. *pos = 0;
  1337. if (_stdio_lseek(stream, pos, SEEK_END) && (errno != EPIPE)) { /* Too big? */
  1338. stream->modeflags |= __FLAG_ERROR;
  1339. return 0;
  1340. }
  1341. }
  1342. #ifdef __STDIO_PUTC_MACRO
  1343. /* We need to disable putc macro in case of error */
  1344. stream->bufputc = stream->bufstart;
  1345. #endif /* __STDIO_GETC_MACRO */
  1346. /* Clear both reading and writing flags. We need to clear the writing
  1347. * flag in case we're fflush()ing or in case of an error. */
  1348. stream->modeflags &= ~(__FLAG_READING|__FLAG_WRITING);
  1349. {
  1350. const unsigned char *buf0 = buffer;
  1351. size_t write_count = 1; /* 0 means a write failed */
  1352. if (!buffer) { /* fflush the stream */
  1353. FFLUSH:
  1354. {
  1355. size_t count = stream->bufpos - stream->bufstart;
  1356. p = stream->bufstart;
  1357. if (stream->filedes == -2) { /* TODO -- document this hack! */
  1358. stream->modeflags |= __FLAG_WRITING;
  1359. return (!buffer) ? 0 : ((buffer - buf0) + bytes);
  1360. }
  1361. {
  1362. write_count = _stdio_WRITE(stream, p, count);
  1363. p += write_count;
  1364. count -= write_count;
  1365. }
  1366. stream->bufpos = stream->bufstart;
  1367. while (count) {
  1368. *stream->bufpos++ = *p++;
  1369. --count;
  1370. }
  1371. if (!buffer) { /* fflush case... */
  1372. __stdio_validate_FILE(stream); /* debugging only */
  1373. return stream->bufpos - stream->bufstart;
  1374. }
  1375. }
  1376. }
  1377. #if 1
  1378. /* TODO: If the stream is buffered, we may be able to omit. */
  1379. if ((stream->bufpos == stream->bufstart) /* buf empty */
  1380. && (stream->bufend - stream->bufstart <= bytes) /* fills */
  1381. && (stream->filedes != -2)) { /* not strinf fake file */
  1382. /* so want to do a direct write of supplied buffer */
  1383. {
  1384. size_t rv = _stdio_WRITE(stream, buffer, bytes);
  1385. buffer += rv;
  1386. bytes -= rv;
  1387. }
  1388. } else
  1389. #endif
  1390. /* otherwise buffer not empty and/or data fits */
  1391. {
  1392. size_t count = stream->bufend - stream->bufpos;
  1393. p = buffer;
  1394. if (count > bytes) {
  1395. count = bytes;
  1396. }
  1397. bytes -= count;
  1398. while (count) {
  1399. *stream->bufpos++ = *buffer++;
  1400. --count;
  1401. }
  1402. if (write_count) { /* no write errors */
  1403. if (bytes) {
  1404. goto FFLUSH;
  1405. }
  1406. if (stream->modeflags & __FLAG_LBF) {
  1407. while (p < buffer) { /* check for newline. */
  1408. if (*p++ == '\n') {
  1409. goto FFLUSH;
  1410. }
  1411. }
  1412. }
  1413. }
  1414. }
  1415. #ifdef __STDIO_PUTC_MACRO
  1416. if (!(stream->modeflags & (__FLAG_WIDE|__MASK_BUFMODE|__FLAG_ERROR))) {
  1417. /* Not wide, no errors and fully buffered, so enable putc macro. */
  1418. stream->bufputc = stream->bufend;
  1419. }
  1420. #endif /* __STDIO_GETC_MACRO */
  1421. stream->modeflags |= __FLAG_WRITING; /* Ensure Writing flag is set. */
  1422. __stdio_validate_FILE(stream); /* debugging only */
  1423. return buffer - buf0;
  1424. }
  1425. #else /* __STDIO_BUFFERS --------------------------------------- */
  1426. __stdio_validate_FILE(stream); /* debugging only */
  1427. if ((stream->modeflags & __FLAG_READONLY)
  1428. #ifndef __STDIO_AUTO_RW_TRANSITION
  1429. /* ANSI/ISO requires either at EOF or currently not reading. */
  1430. || ((stream->modeflags & (__FLAG_READING|__FLAG_EOF))
  1431. == __FLAG_READING)
  1432. #endif /* __STDIO_AUTO_RW_TRANSITION */
  1433. ) {
  1434. stream->modeflags |= __FLAG_ERROR;
  1435. /* TODO: This is for posix behavior if readonly. To save space, we
  1436. * use this errno for write attempt while reading, as no errno is
  1437. * specified by posix for this case, even though the restriction is
  1438. * mentioned in fopen(). */
  1439. __set_errno(EBADF);
  1440. return 0;
  1441. }
  1442. /* We always clear the reading flag in case at EOF. */
  1443. stream->modeflags &= ~(__FLAG_READING);
  1444. /* Unlike the buffered case, we set the writing flag now since we don't
  1445. * need to do anything here for fflush(). */
  1446. stream->modeflags |= __FLAG_WRITING;
  1447. {
  1448. register unsigned char *p = (unsigned char *) buffer;
  1449. ssize_t rv = _stdio_WRITE(stream, p, bytes);
  1450. p += rv;
  1451. bytes -= rv;
  1452. __stdio_validate_FILE(stream); /* debugging only */
  1453. return (p - (unsigned char *)buffer);
  1454. }
  1455. #endif /* __STDIO_BUFFERS *****************************************/
  1456. }
  1457. #endif
  1458. /**********************************************************************/
  1459. #ifdef L__stdio_init
  1460. /* Internal functions -- _stdio_init() and __stdio_validate_FILE
  1461. * are not reentrant, but _stdio_term() is through fflush().
  1462. * Also, the _cs_{read|write|close} functions are not reentrant. */
  1463. #ifndef NDEBUG
  1464. void __stdio_validate_FILE(FILE *stream)
  1465. {
  1466. if (stream->filedes == -2) { /* fake FILE for sprintf, scanf, etc. */
  1467. return;
  1468. }
  1469. __STDIO_THREADLOCK(stream);
  1470. #ifdef __STDIO_BUFFERS
  1471. assert(stream->bufstart <= stream->bufread);
  1472. if (stream->modeflags & (__FLAG_READING)) {
  1473. assert(stream->bufpos <= stream->bufread);
  1474. }
  1475. assert(stream->bufread <= stream->bufend);
  1476. assert(stream->bufpos <= stream->bufend);
  1477. if ((stream->modeflags & __MASK_BUFMODE) == __FLAG_NBF) {
  1478. assert(stream->bufstart == stream->bufend);
  1479. }
  1480. assert((stream->modeflags & __MASK_BUFMODE) <= __FLAG_NBF);
  1481. #endif
  1482. #ifdef __STDIO_PUTC_MACRO
  1483. assert(stream->bufstart <= stream->bufputc);
  1484. assert(stream->bufputc <= stream->bufend);
  1485. if (stream->bufstart < stream->bufputc) {
  1486. assert(stream->bufputc == stream->bufend);
  1487. assert(stream->modeflags & (__FLAG_WRITING));
  1488. assert(!(stream->modeflags
  1489. & (__FLAG_WIDE|__MASK_BUFMODE|__MASK_UNGOT|__FLAG_READONLY))
  1490. );
  1491. }
  1492. #endif
  1493. #ifdef __STDIO_GETC_MACRO
  1494. assert(stream->bufstart <= stream->bufgetc);
  1495. assert(stream->bufgetc <= stream->bufread);
  1496. if (stream->bufstart < stream->bufgetc) {
  1497. assert(stream->modeflags & (__FLAG_READING));
  1498. assert(!(stream->modeflags
  1499. & (__FLAG_WIDE|__MASK_BUFMODE|__MASK_UNGOT|__FLAG_WRITEONLY))
  1500. );
  1501. }
  1502. #endif
  1503. assert((stream->modeflags & __MASK_UNGOT) != __MASK_UNGOT);
  1504. if (stream->modeflags & __MASK_UNGOT1) {
  1505. assert(stream->ungot[1] <= 1);
  1506. }
  1507. if (stream->modeflags & __MASK_UNGOT) {
  1508. assert(!(stream->modeflags & __FLAG_EOF));
  1509. }
  1510. assert((stream->modeflags & (__FLAG_READONLY|__FLAG_WRITEONLY))
  1511. != (__FLAG_READONLY|__FLAG_WRITEONLY));
  1512. /* TODO -- filepos? ungot_width? filedes? nextopen? */
  1513. __STDIO_THREADUNLOCK(stream);
  1514. }
  1515. #endif
  1516. #ifdef __STDIO_GLIBC_CUSTOM_STREAMS
  1517. ssize_t _cs_read(void *cookie, char *buf, size_t bufsize)
  1518. {
  1519. return read(*((int *) cookie), buf, bufsize);
  1520. }
  1521. ssize_t _cs_write(void *cookie, const char *buf, size_t bufsize)
  1522. {
  1523. return write(*((int *) cookie), (char *) buf, bufsize);
  1524. }
  1525. int _cs_close(void *cookie)
  1526. {
  1527. return close(*((int *) cookie));
  1528. }
  1529. #endif /* __STDIO_GLIBC_CUSTOM_STREAMS */
  1530. #ifdef __STDIO_BUFFERS
  1531. static unsigned char _fixed_buffers[2 * BUFSIZ];
  1532. #define bufin (_fixed_buffers)
  1533. #define bufout (_fixed_buffers + BUFSIZ)
  1534. #endif /* __STDIO_BUFFERS */
  1535. static FILE _stdio_streams[] = {
  1536. __STDIO_INIT_FILE_STRUCT(_stdio_streams[0], __FLAG_LBF|__FLAG_READONLY, \
  1537. 0, _stdio_streams + 1, bufin, BUFSIZ ),
  1538. __STDIO_INIT_FILE_STRUCT(_stdio_streams[1], __FLAG_LBF|__FLAG_WRITEONLY, \
  1539. 1, _stdio_streams + 2, bufout, BUFSIZ ),
  1540. __STDIO_INIT_FILE_STRUCT(_stdio_streams[2], __FLAG_NBF|__FLAG_WRITEONLY, \
  1541. 2, 0, 0, 0 )
  1542. };
  1543. FILE *stdin = _stdio_streams + 0;
  1544. FILE *stdout = _stdio_streams + 1;
  1545. FILE *stderr = _stdio_streams + 2;
  1546. #if defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS)
  1547. #ifdef __STDIO_BUFFERS
  1548. FILE *_stdio_openlist = _stdio_streams;
  1549. #else /* __STDIO_BUFFERS */
  1550. FILE *_stdio_openlist = NULL;
  1551. #endif /* __STDIO_BUFFERS */
  1552. #ifdef __STDIO_THREADSAFE
  1553. pthread_mutex_t _stdio_openlist_lock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
  1554. void __stdio_init_mutex(pthread_mutex_t *m)
  1555. {
  1556. static const pthread_mutex_t __stdio_mutex_initializer
  1557. = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
  1558. memcpy(m, &__stdio_mutex_initializer, sizeof(__stdio_mutex_initializer));
  1559. }
  1560. #endif /* __STDIO_THREADSAFE */
  1561. /* TODO - do we need to lock things, or do we just assume we're the only
  1562. * remaining thread? */
  1563. /* Note: We assume here that we are the only remaining thread. */
  1564. void _stdio_term(void)
  1565. {
  1566. #if defined(__STDIO_GLIBC_CUSTOM_STREAMS) || defined(__STDIO_THREADSAFE)
  1567. register FILE *ptr;
  1568. #endif
  1569. /* TODO: if called via a signal handler for a signal mid _stdio_fwrite,
  1570. * the stream may be in an unstable state... what do we do?
  1571. * perhaps set error flag before and clear when done if successful? */
  1572. #ifdef __STDIO_THREADSAFE
  1573. /* First, forceably unlock the open file list and all files.
  1574. * Note: Set locking mode to "by caller" to save some overhead later. */
  1575. __stdio_init_mutex(&_stdio_openlist_lock);
  1576. for (ptr = _stdio_openlist ; ptr ; ptr = ptr->nextopen ) {
  1577. ptr->user_locking = 1;
  1578. __stdio_init_mutex(&ptr->lock);
  1579. }
  1580. #endif /* __STDIO_THREADSAFE */
  1581. #ifdef __STDIO_BUFFERS
  1582. /* TODO -- set an alarm and flush each file "by hand"? to avoid blocking? */
  1583. /* Now flush all streams. */
  1584. fflush_unlocked(NULL);
  1585. #endif /* __STDIO_BUFFERS */
  1586. /* Next close all custom streams in case of any special cleanup, but
  1587. * don't use fclose() because that pulls in free and malloc. Also,
  1588. * don't worry about removing them from the list. Just set the cookie
  1589. * pointer to NULL so that an error will be generated if someone tries
  1590. * to use the stream. */
  1591. #ifdef __STDIO_GLIBC_CUSTOM_STREAMS
  1592. for (ptr = _stdio_openlist ; ptr ; ptr = ptr->nextopen ) {
  1593. if (ptr->cookie != &ptr->filedes) { /* custom stream */
  1594. __CLOSE(ptr);
  1595. ptr->cookie = NULL; /* Generate an error if used later. */
  1596. #if 0
  1597. /* #ifdef __STDIO_BUFFERS */
  1598. } else {
  1599. /* TODO: "unbuffer" files like glibc does? Inconsistent with
  1600. * custom stream handling above, but that's necessary to deal
  1601. * with special user-defined close behavior. */
  1602. stream->bufpos = stream->bufread = stream->bufend
  1603. #ifdef __STDIO_GETC_MACRO
  1604. = stream->bufgetc
  1605. #endif
  1606. #ifdef __STDIO_PUTC_MACRO
  1607. = stream->bufputc
  1608. #endif
  1609. = stream->bufstart;
  1610. #endif /* __STDIO_BUFFERS */
  1611. }
  1612. }
  1613. #endif /* __STDIO_GLIBC_CUSTOM_STREAMS */
  1614. }
  1615. #if defined(__STDIO_BUFFERS) || !defined(__UCLIBC__)
  1616. void _stdio_init(void)
  1617. {
  1618. #ifdef __STDIO_BUFFERS
  1619. /* stdin and stdout uses line buffering when connected to a tty. */
  1620. _stdio_streams[0].modeflags ^= (1-isatty(0)) * __FLAG_LBF;
  1621. _stdio_streams[1].modeflags ^= (1-isatty(1)) * __FLAG_LBF;
  1622. #endif /* __STDIO_BUFFERS */
  1623. #ifndef __UCLIBC__
  1624. /* __stdio_term is automatically when exiting if stdio is used.
  1625. * See misc/internals/__uClibc_main.c and and stdlib/atexit.c. */
  1626. atexit(_stdio_term);
  1627. #endif /* __UCLIBC__ */
  1628. }
  1629. #endif /* defined(__STDIO_BUFFERS) || !defined(__UCLIBC__) */
  1630. #endif /* defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) */
  1631. #endif
  1632. /**********************************************************************/
  1633. /* ANSI/ISO functions. */
  1634. /**********************************************************************/
  1635. #ifdef L_remove
  1636. #include <unistd.h>
  1637. #include <errno.h>
  1638. /* No reentrancy issues. */
  1639. int remove(register const char *filename)
  1640. {
  1641. int old_errno = errno;
  1642. /* SUSv3 says equivalent to rmdir() if a directory, and unlink()
  1643. * otherwise. Hence, we need to try rmdir() first. */
  1644. return (((rmdir(filename) == 0)
  1645. || ((errno == ENOTDIR)
  1646. && ((__set_errno(old_errno), unlink(filename)) == 0)))
  1647. ? 0 : -1);
  1648. }
  1649. #endif
  1650. /**********************************************************************/
  1651. /* rename is a syscall
  1652. #ifdef L_rename
  1653. int rename(const char *old, const char *new);
  1654. #endif
  1655. */
  1656. /**********************************************************************/
  1657. /* TODO: tmpfile */
  1658. /* #ifdef L_tmpfile */
  1659. /* FILE *tmpfile(void); */
  1660. /* #endif */
  1661. /**********************************************************************/
  1662. /* TODO: tmpname */
  1663. /* #ifdef L_tmpname */
  1664. /* char *tmpname(char *s); */
  1665. /* #endif */
  1666. /**********************************************************************/
  1667. #ifdef L_fclose
  1668. /* We need to be careful here to avoid deadlock when threading, as we
  1669. * need to lock both the file and the open file list. This can clash
  1670. * with fflush. Since fflush is much more common, we do the extra
  1671. * work here. */
  1672. int fclose(register FILE *stream)
  1673. {
  1674. #if defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS)
  1675. register FILE *ptr;
  1676. int rv = 0;
  1677. #ifdef __STDIO_THREADSAFE
  1678. /* Need two non-heirchal mutexs... be careful to avoid deadlock*/
  1679. do {
  1680. __STDIO_THREADLOCK(stream);
  1681. if (__STDIO_THREADTRYLOCK_OPENLIST == 0) {
  1682. break;
  1683. }
  1684. __STDIO_THREADUNLOCK(stream);
  1685. usleep(10000);
  1686. } while (1);
  1687. #endif /* __STDIO_THREADSAFE */
  1688. __stdio_validate_FILE(stream); /* debugging only */
  1689. #ifdef __STDIO_BUFFERS
  1690. if (stream->modeflags & __FLAG_WRITING) {
  1691. rv = fflush_unlocked(stream); /* Write any pending buffered chars. */
  1692. } /* Also disables putc macro if used. */
  1693. #ifdef __STDIO_GETC_MACRO
  1694. /* Not necessary after fflush, but always do this to reduce size. */
  1695. stream->bufgetc = stream->bufstart; /* Disable getc macro for safety. */
  1696. #endif /* __STDIO_GETC_MACRO */
  1697. #endif /* __STDIO_BUFFERS */
  1698. /* Remove file from open list before closing file descriptor. */
  1699. ptr = _stdio_openlist;
  1700. if (ptr == stream) {
  1701. _stdio_openlist = stream->nextopen;
  1702. } else {
  1703. while (ptr) {
  1704. if (ptr->nextopen == stream) {
  1705. ptr->nextopen = stream->nextopen;
  1706. break;
  1707. }
  1708. ptr = ptr->nextopen;
  1709. }
  1710. }
  1711. __STDIO_THREADUNLOCK_OPENLIST; /* We're done with the open file list. */
  1712. if (__CLOSE(stream) < 0) { /* Must close even if fflush failed. */
  1713. rv = EOF;
  1714. }
  1715. #ifdef __STDIO_GLIBC_CUSTOM_STREAMS
  1716. stream->cookie = &(stream->filedes);
  1717. stream->gcs.read = _cs_read;
  1718. stream->gcs.write = _cs_write;
  1719. stream->gcs.seek = 0; /* The internal seek func handles normals. */
  1720. stream->gcs.close = _cs_close;
  1721. #endif
  1722. stream->filedes = -1; /* To aid debugging... */
  1723. #ifdef __STDIO_BUFFERS
  1724. if (stream->modeflags & __FLAG_FREEBUF) {
  1725. free(stream->bufstart);
  1726. }
  1727. #endif /* __STDIO_BUFFERS */
  1728. /* TODO -- leave the stream locked to catch any dangling refs? */
  1729. __STDIO_THREADUNLOCK(stream);
  1730. /* At this point, any dangling refs to the stream are the result of
  1731. * a programming bug... so free the unlocked stream. */
  1732. if (stream->modeflags & __FLAG_FREEFILE) {
  1733. stream->cookie = NULL; /* To aid debugging... */
  1734. free(stream);
  1735. }
  1736. return rv;
  1737. #else /* defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) */
  1738. int rv = 0;
  1739. __STDIO_THREADLOCK(stream);
  1740. __stdio_validate_FILE(stream); /* debugging only */
  1741. if (__CLOSE(stream) < 0) { /* Must close even if fflush failed. */
  1742. rv = EOF;
  1743. }
  1744. #ifdef __STDIO_GLIBC_CUSTOM_STREAMS
  1745. stream->cookie = &(stream->filedes);
  1746. stream->gcs.read = _cs_read;
  1747. stream->gcs.write = _cs_write;
  1748. stream->gcs.seek = 0; /* The internal seek func handles normals. */
  1749. stream->gcs.close = _cs_close;
  1750. #endif
  1751. stream->filedes = -1; /* To aid debugging... */
  1752. __STDIO_THREADUNLOCK(stream);
  1753. /* At this point, any dangling refs to the stream are the result of
  1754. * a programming bug... so free the unlocked stream. */
  1755. if (stream->modeflags & __FLAG_FREEFILE) {
  1756. stream->cookie = NULL; /* To aid debugging... */
  1757. free(stream);
  1758. }
  1759. return rv;
  1760. #endif /* defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS )*/
  1761. }
  1762. #endif
  1763. /**********************************************************************/
  1764. #ifdef L_fflush
  1765. /*
  1766. * Special cases:
  1767. * stream == NULL means fflush all writing streams (ANSI/ISO).
  1768. * stream == (FILE *) &_stdio_openlist -- implementation-specific hack
  1769. * meaning fflush all line buffered writing streams
  1770. */
  1771. /*
  1772. * NOTE: ANSI/ISO difference!!! According to the standard, fflush is only
  1773. * defined for write-only streams, or read/write streams whose last op
  1774. * was a write. However, reading is allowed for a read/write stream if
  1775. * a file positioning operation was done (fseek, fsetpos) even though there
  1776. * is no guarantee of flushing the write data in that case. Hence, for
  1777. * this case we keep a flag to indicate whether or not the buffer needs to
  1778. * be flushed even if the last operation was a read. This falls under the
  1779. * implementation-defined behavior. Otherwise, we would need to flush
  1780. * every time we did fseek, etc. even if we were still in the buffer's range.
  1781. */
  1782. /* Since the stream pointer arg is allowed to be NULL, or the address of the
  1783. * stdio open file list if stdio is buffered in this implementation, we can't
  1784. * use the UNLOCKED() macro here. */
  1785. #ifndef __STDIO_THREADSAFE
  1786. strong_alias(fflush_unlocked,fflush)
  1787. #else /* __STDIO_THREADSAFE */
  1788. int fflush(register FILE *stream)
  1789. {
  1790. int retval;
  1791. if ((stream != NULL)
  1792. #ifdef __STDIO_BUFFERS
  1793. && (stream != (FILE *) &_stdio_openlist)
  1794. #endif /* __STDIO_BUFFERS */
  1795. ) {
  1796. __STDIO_THREADLOCK(stream);
  1797. retval = fflush_unlocked(stream);
  1798. __STDIO_THREADUNLOCK(stream);
  1799. } else {
  1800. retval = fflush_unlocked(stream);
  1801. }
  1802. return retval;
  1803. }
  1804. #endif /* __STDIO_THREADSAFE */
  1805. int fflush_unlocked(register FILE *stream)
  1806. {
  1807. #ifdef __STDIO_BUFFERS
  1808. int rv = 0;
  1809. unsigned short mask = (__FLAG_NBF|__FLAG_LBF);
  1810. #ifndef NDEBUG
  1811. if ((stream != NULL) && (stream != (FILE *) &_stdio_openlist)) {
  1812. __stdio_validate_FILE(stream); /* debugging only */
  1813. }
  1814. #endif
  1815. if (stream == (FILE *) &_stdio_openlist) { /* fflush all line-buffered */
  1816. stream = NULL;
  1817. mask = __FLAG_LBF;
  1818. }
  1819. if (stream == NULL) { /* flush all (line) buffered writing streams */
  1820. /* Note -- We have to lock the list even in the unlocked function. */
  1821. __STDIO_THREADLOCK_OPENLIST;
  1822. /* TODO -- Can we work around locking the list to avoid keeping it
  1823. * locked if the write blocks? */
  1824. for (stream = _stdio_openlist; stream; stream = stream->nextopen) {
  1825. if (((stream->modeflags ^ __FLAG_NBF) & mask)
  1826. && (stream->modeflags & __FLAG_WRITING)
  1827. && fflush(stream)) {
  1828. rv = EOF;
  1829. }
  1830. }
  1831. __STDIO_THREADUNLOCK_OPENLIST;
  1832. } else if (stream->modeflags & __FLAG_WRITING) {
  1833. if (_stdio_fwrite(NULL, 0, stream) > 0) { /* flush buffer contents. */
  1834. rv = -1; /* Not all chars written. */
  1835. }
  1836. } else if (stream->modeflags & __FLAG_READONLY) {
  1837. /* According to info, glibc returns an error when the file is opened
  1838. * in read-only mode.
  1839. * ANSI/ISO says behavior in this case is undefined but also says you
  1840. * shouldn't flush a stream you were reading from. */
  1841. stream->modeflags |= __FLAG_ERROR; /* TODO - check glibc behavior */
  1842. __set_errno(EBADF);
  1843. rv = -1;
  1844. }
  1845. #ifndef NDEBUG
  1846. if ((stream != NULL) && (stream != (FILE *) &_stdio_openlist)) {
  1847. __stdio_validate_FILE(stream); /* debugging only */
  1848. }
  1849. #endif
  1850. return rv;
  1851. #else /* __STDIO_BUFFERS --------------------------------------- */
  1852. #ifndef NDEBUG
  1853. if ((stream != NULL) && (stream != (FILE *) &_stdio_openlist)) {
  1854. __stdio_validate_FILE(stream); /* debugging only */
  1855. }
  1856. #endif
  1857. /* TODO -- check glibc behavior regarding error indicator */
  1858. return ((stream != NULL)
  1859. && (stream->modeflags & __FLAG_READONLY)
  1860. ? ((stream->modeflags |= __FLAG_ERROR), __set_errno(EBADF), EOF)
  1861. : 0 );
  1862. #endif /* __STDIO_BUFFERS */
  1863. }
  1864. #endif
  1865. /**********************************************************************/
  1866. #ifdef L_fopen
  1867. /* No reentrancy issues. */
  1868. FILE *fopen(const char * __restrict filename, const char * __restrict mode)
  1869. {
  1870. return _stdio_fopen(filename, mode, NULL, -1);
  1871. }
  1872. #endif
  1873. /**********************************************************************/
  1874. #ifdef L__stdio_fopen
  1875. /*
  1876. * Cases:
  1877. * fopen : filename != NULL, stream == NULL, filedes == -1
  1878. * freopen : filename != NULL, stream != NULL, filedes == -1
  1879. * fdopen : filename == NULL, stream == NULL, filedes valid
  1880. * fsfopen : filename != NULL, stream != NULL, filedes == -1
  1881. * fopen64 : filename != NULL, stream == NULL, filedes == -2
  1882. */
  1883. #if O_ACCMODE != 3 || O_RDONLY != 0 || O_WRONLY != 1 || O_RDWR != 2
  1884. #error Assumption violated - mode constants
  1885. #endif
  1886. /* Internal function -- reentrant (locks open file list) */
  1887. FILE *_stdio_fopen(const char * __restrict filename,
  1888. register const char * __restrict mode,
  1889. register FILE * __restrict stream, int filedes)
  1890. {
  1891. __mode_t open_mode;
  1892. /* parse mode */
  1893. open_mode = O_RDONLY;
  1894. if (*mode != 'r') { /* not read */
  1895. open_mode = (O_WRONLY | O_CREAT | O_TRUNC);
  1896. if (*mode != 'w') { /* not write (create or truncate)*/
  1897. open_mode = (O_WRONLY | O_CREAT | O_APPEND);
  1898. if (*mode != 'a') { /* not write (create or append) */
  1899. __set_errno(EINVAL); /* then illegal mode */
  1900. if (stream) { /* If this is freopen, free the stream. */
  1901. goto FREE_STREAM;
  1902. }
  1903. return NULL;
  1904. }
  1905. }
  1906. }
  1907. if ((*++mode == 'b')) { /* binary mode (NOP currently) */
  1908. ++mode;
  1909. }
  1910. if (*mode == '+') { /* read-write */
  1911. ++mode;
  1912. open_mode &= ~(O_RDONLY | O_WRONLY);
  1913. open_mode |= O_RDWR;
  1914. }
  1915. #if defined(__STDIO_GNU_FEATURE) || defined(__STDIO_FOPEN_LARGEFILE_MODE)
  1916. while (*mode) { /* ignore everything else except ... */
  1917. #ifdef __STDIO_FOPEN_EXCLUSIVE_MODE
  1918. if (*mode++ == 'x') { /* open exclusive -- glibc extension */
  1919. open_mode |= O_EXCL;
  1920. }
  1921. #endif /* __STDIO_FOPEN_EXCLUSIVE_MODE */
  1922. #ifdef __STDIO_FOPEN_LARGEFILE_MODE
  1923. if (*mode++ == 'F') { /* open large file */
  1924. open_mode |= O_LARGEFILE;
  1925. }
  1926. #endif /* __STDIO_FOPEN_LARGEFILE_MODE */
  1927. }
  1928. #endif /* __STDIO_FOPEN_EXCLUSIVE_MODE or __STDIO_FOPEN_LARGEFILE_MODE def'd */
  1929. #ifdef __BCC__
  1930. mode = filename; /* TODO: help BCC with register allocation. */
  1931. #define filename mode
  1932. #endif /* __BCC__ */
  1933. if (!stream) { /* Need to allocate a FILE. */
  1934. #ifdef __STDIO_BUFFERS
  1935. if ((stream = malloc(sizeof(FILE))) == NULL) {
  1936. return stream;
  1937. }
  1938. stream->modeflags = __FLAG_FREEFILE;
  1939. if ((stream->bufstart = malloc(BUFSIZ)) != 0) {
  1940. stream->bufend = stream->bufstart + BUFSIZ;
  1941. stream->modeflags |= __FLAG_FREEBUF;
  1942. } else {
  1943. #if __STDIO_BUILTIN_BUF_SIZE > 0
  1944. stream->bufstart = stream->unbuf;
  1945. stream->bufend = stream->unbuf + sizeof(stream->unbuf);
  1946. #else /* __STDIO_BUILTIN_BUF_SIZE > 0 */
  1947. stream->bufstart = stream->bufend = NULL;
  1948. #endif /* __STDIO_BUILTIN_BUF_SIZE > 0 */
  1949. }
  1950. #else /* __STDIO_BUFFERS */
  1951. if ((stream = malloc(sizeof(FILE))) == NULL) {
  1952. return stream;
  1953. }
  1954. stream->modeflags = __FLAG_FREEFILE;
  1955. #endif /* __STDIO_BUFFERS */
  1956. }
  1957. if (filedes >= 0) { /* Handle fdopen trickery. */
  1958. /* NOTE: it is insufficient to just check R/W/RW agreement.
  1959. * We must also check largefile compatibility if applicable.
  1960. * Also, if append mode is desired for fdopen but O_APPEND isn't
  1961. * currently set, then set it as recommended by SUSv3. However,
  1962. * if append mode is not specified for fdopen but O_APPEND is set,
  1963. * leave it set (glibc compat). */
  1964. int i = (open_mode & (O_ACCMODE|O_LARGEFILE)) + 1;
  1965. if (((i & (((int) filename) + 1)) != i) /* Check basic agreement. */
  1966. || (((open_mode & O_APPEND)
  1967. && !(((int) filename) & O_APPEND)
  1968. && fcntl(filedes, F_SETFL, O_APPEND))) /* Need O_APPEND. */
  1969. ) {
  1970. __set_errno(EINVAL);
  1971. filedes = -1;
  1972. }
  1973. #ifdef __STDIO_LARGE_FILES
  1974. /* For later... to reflect largefile setting in stream flags. */
  1975. open_mode |= (((int) filename) & O_LARGEFILE);
  1976. #endif /* __STDIO_LARGE_FILES */
  1977. stream->filedes = filedes;
  1978. } else {
  1979. #ifdef __STDIO_LARGE_FILES
  1980. if (filedes < -1) {
  1981. open_mode |= O_LARGEFILE;
  1982. }
  1983. #endif /* __STDIO_LARGE_FILES */
  1984. stream->filedes = open(filename, open_mode, 0666);
  1985. }
  1986. if (stream->filedes < 0) {
  1987. FREE_STREAM:
  1988. #ifdef __STDIO_BUFFERS
  1989. if (stream->modeflags & __FLAG_FREEBUF) {
  1990. free(stream->bufstart);
  1991. }
  1992. #endif /* __STDIO_BUFFERS */
  1993. if (stream->modeflags & __FLAG_FREEFILE) {
  1994. free(stream);
  1995. }
  1996. return NULL;
  1997. }
  1998. stream->modeflags |=
  1999. #ifdef __STDIO_BUFFERS
  2000. (isatty(stream->filedes) * __FLAG_LBF) |
  2001. #endif /* __STDIO_BUFFERS */
  2002. #if (O_APPEND == __FLAG_APPEND) \
  2003. && ((O_LARGEFILE == __FLAG_LARGEFILE) || (O_LARGEFILE == 0))
  2004. (open_mode & (O_APPEND|O_LARGEFILE)) | /* i386 linux and elks */
  2005. #else /* (O_APPEND == __FLAG_APPEND) && (O_LARGEFILE == __FLAG_LARGEFILE) */
  2006. ((open_mode & O_APPEND) ? __FLAG_APPEND : 0) |
  2007. #ifdef __STDIO_LARGE_FILES
  2008. ((open_mode & O_LARGEFILE) ? __FLAG_LARGEFILE : 0) |
  2009. #endif /* __STDIO_LARGE_FILES */
  2010. #endif /* (O_APPEND == __FLAG_APPEND) && (O_LARGEFILE == __FLAG_LARGEFILE) */
  2011. ((((open_mode & O_ACCMODE) + 1) ^ 0x03) * __FLAG_WRITEONLY);
  2012. #ifdef __STDIO_BUFFERS
  2013. #ifdef __STDIO_GETC_MACRO
  2014. stream->bufgetc =
  2015. #endif
  2016. #ifdef __STDIO_PUTC_MACRO
  2017. stream->bufputc =
  2018. #endif
  2019. stream->bufpos = stream->bufread = stream->bufstart;
  2020. #endif /* __STDIO_BUFFERS */
  2021. #ifdef __STDIO_GLIBC_CUSTOM_STREAMS
  2022. stream->cookie = &(stream->filedes);
  2023. stream->gcs.read = _cs_read;
  2024. stream->gcs.write = _cs_write;
  2025. stream->gcs.seek = 0; /* The internal seek func handles normals. */
  2026. stream->gcs.close = _cs_close;
  2027. #endif /* __STDIO_GLIBC_CUSTOM_STREAMS */
  2028. #ifdef __STDIO_MBSTATE
  2029. __INIT_MBSTATE(&(stream->state));
  2030. #endif /* __STDIO_MBSTATE */
  2031. #ifdef __STDIO_THREADSAFE
  2032. stream->user_locking = 0;
  2033. __stdio_init_mutex(&stream->lock);
  2034. #endif /* __STDIO_THREADSAFE */
  2035. #if defined(__STDIO_BUFFERS) \
  2036. || (defined(__STDIO_THREADSAFE) && defined(__STDIO_GLIBC_CUSTOM_STREAMS))
  2037. __STDIO_THREADLOCK_OPENLIST;
  2038. stream->nextopen = _stdio_openlist; /* New files are inserted at */
  2039. _stdio_openlist = stream; /* the head of the list. */
  2040. __STDIO_THREADUNLOCK_OPENLIST;
  2041. #endif
  2042. __stdio_validate_FILE(stream); /* debugging only */
  2043. return stream;
  2044. #ifdef __BCC__
  2045. #undef filename
  2046. #endif /* __BCC__ */
  2047. }
  2048. #endif
  2049. /**********************************************************************/
  2050. #ifdef L_freopen
  2051. /* Reentrant. */
  2052. FILE *freopen(const char * __restrict filename, const char * __restrict mode,
  2053. register FILE * __restrict stream)
  2054. {
  2055. /*
  2056. * ANSI/ISO allow (implementation-defined) change of mode for an
  2057. * existing file if filename is NULL. It doesn't look like Linux
  2058. * supports this, so we don't here.
  2059. *
  2060. * NOTE: Whether or not the stream is free'd on failure is unclear
  2061. * w.r.t. ANSI/ISO. This implementation chooses to free the
  2062. * stream and associated buffer if they were dynamically
  2063. * allocated.
  2064. * TODO: Check the above.
  2065. * TODO: Apparently linux allows setting append mode. Implement?
  2066. */
  2067. unsigned short dynmode;
  2068. register FILE *fp;
  2069. __STDIO_THREADLOCK(stream);
  2070. /* First, flush and close, but don't deallocate, the stream. */
  2071. /* This also removes the stream for the open file list. */
  2072. dynmode =
  2073. #ifdef __STDIO_BUFFERS
  2074. /* __MASK_BUFMODE | */ /* TODO: check */
  2075. #endif /* __STDIO_BUFFERS */
  2076. (stream->modeflags & (__FLAG_FREEBUF|__FLAG_FREEFILE));
  2077. stream->modeflags &= ~(__FLAG_FREEBUF|__FLAG_FREEFILE);
  2078. fclose(stream); /* Failures are ignored. */
  2079. stream->modeflags = dynmode;
  2080. fp = _stdio_fopen(filename, mode, stream, -1);
  2081. __STDIO_THREADUNLOCK(stream);
  2082. return fp;
  2083. }
  2084. #endif
  2085. /**********************************************************************/
  2086. #ifdef L_freopen64
  2087. /* Reentrant. */
  2088. /* TODO -- is it worth collecting the common work (40 bytes) in a function? */
  2089. FILE *freopen64(const char * __restrict filename, const char * __restrict mode,
  2090. register FILE * __restrict stream)
  2091. {
  2092. unsigned short dynmode;
  2093. register FILE *fp;
  2094. __STDIO_THREADLOCK(stream);
  2095. /* First, flush and close, but don't deallocate, the stream. */
  2096. /* This also removes the stream for the open file list. */
  2097. dynmode =
  2098. #ifdef __STDIO_BUFFERS
  2099. /* __MASK_BUFMODE | */ /* TODO: check */
  2100. #endif /* __STDIO_BUFFERS */
  2101. (stream->modeflags & (__FLAG_FREEBUF|__FLAG_FREEFILE));
  2102. stream->modeflags &= ~(__FLAG_FREEBUF|__FLAG_FREEFILE);
  2103. fclose(stream); /* Failures are ignored. */
  2104. stream->modeflags = dynmode;
  2105. fp = _stdio_fopen(filename, mode, stream, -2); /* TODO -- magic const */
  2106. __STDIO_THREADUNLOCK(stream);
  2107. return fp;
  2108. }
  2109. #endif
  2110. /**********************************************************************/
  2111. #ifdef L_setbuf
  2112. /* Reentrant through setvbuf(). */
  2113. void setbuf(FILE * __restrict stream, register char * __restrict buf)
  2114. {
  2115. #ifdef __STDIO_BUFFERS
  2116. int mode;
  2117. mode = (buf != NULL) ? _IOFBF : _IONBF;
  2118. setvbuf(stream, buf, mode, BUFSIZ);
  2119. #else /* __STDIO_BUFFERS */
  2120. /* TODO -- assert on stream? */
  2121. /* Nothing to do. */
  2122. #endif /* __STDIO_BUFFERS */
  2123. }
  2124. #endif
  2125. /**********************************************************************/
  2126. #ifdef L_setvbuf
  2127. /* Reentrant. */
  2128. int setvbuf(register FILE * __restrict stream, register char * __restrict buf,
  2129. int mode, size_t size)
  2130. {
  2131. #ifdef __STDIO_BUFFERS
  2132. int allocated_buf_flag;
  2133. int rv = EOF;
  2134. __STDIO_THREADLOCK(stream);
  2135. __stdio_validate_FILE(stream); /* debugging only */
  2136. if (((unsigned int) mode) > 2) { /* Illegal mode. */
  2137. /* TODO -- set an errno? */
  2138. goto DONE;
  2139. }
  2140. #ifdef __STDIO_FLEXIBLE_SETVBUF
  2141. /* C89 standard requires no ops before setvbuf, but we can be flexible. */
  2142. /* NOTE: This will trash any chars ungetc'd!!! */
  2143. /* TODO: hmm could preserve unget count since ungot slots aren't changed (true?)
  2144. * but this will fail when buffered chars read from a pipe unless the user buf
  2145. * is big enough to copy everything over. */
  2146. if (fseek(stream, 0L, SEEK_CUR)) {
  2147. goto DONE;
  2148. }
  2149. #else /* __STDIO_FLEXIBLE_SETVBUF */
  2150. /*
  2151. * Note: ANSI/ISO requires setvbuf to be called after opening the file
  2152. * but before any other operation other than a failed setvbuf call.
  2153. * We'll cheat here and only test if the wide or narrow mode flag has
  2154. * been set; i.e. no read or write (or unget or fwide) operations have
  2155. * taken place.
  2156. */
  2157. #ifdef __STDIO_WIDE
  2158. if (stream->modeflags & (__FLAG_WIDE|__FLAG_NARROW)) {
  2159. goto DONE;
  2160. }
  2161. #else /* __STDIO_WIDE */
  2162. /* Note: This only checks if not currently reading or writing. */
  2163. if (stream->modeflags & (__FLAG_READING|__FLAG_WRITING)) {
  2164. goto DONE;
  2165. }
  2166. #endif /* __STDIO_WIDE */
  2167. #endif /* __STDIO_FLEXIBLE_SETVBUF */
  2168. if (mode == _IONBF) {
  2169. size = 0;
  2170. buf = NULL;
  2171. } else if (!buf && !size) {
  2172. /* If buf==NULL && size==0 && either _IOFBF or _IOLBF, keep
  2173. * current buffer and only set buffering mode. */
  2174. size = stream->bufend - stream->bufstart;
  2175. }
  2176. stream->modeflags &= ~(__MASK_BUFMODE); /* Clear current mode */
  2177. stream->modeflags |= mode * __FLAG_LBF; /* and set new one. */
  2178. allocated_buf_flag = 0;
  2179. if ((!buf) && (size != (stream->bufend - stream->bufstart))) {
  2180. /* No buffer supplied and requested size different from current. */
  2181. /* If size == 0, create a (hopefully) bogus non-null pointer... */
  2182. if (!(buf = ((size > 0)
  2183. ? ((allocated_buf_flag = __FLAG_FREEBUF), malloc(size))
  2184. : ((char *)NULL) + 1))
  2185. ) {
  2186. /* TODO -- should we really keep current buffer if it was passed
  2187. * to us earlier by the app? */
  2188. goto DONE; /* Keep current buffer. */
  2189. }
  2190. }
  2191. /* TODO: setvbuf "signal" safety */
  2192. if (buf && (buf != (char *) stream->bufstart)) { /* Want new buffer. */
  2193. if (stream->modeflags & __FLAG_FREEBUF) {
  2194. stream->modeflags &= ~(__FLAG_FREEBUF);
  2195. free(stream->bufstart);
  2196. }
  2197. stream->modeflags |= allocated_buf_flag; /* Free-able buffer? */
  2198. #ifdef __STDIO_GETC_MACRO
  2199. stream->bufgetc =
  2200. #endif
  2201. #ifdef __STDIO_PUTC_MACRO
  2202. stream->bufputc =
  2203. #endif
  2204. stream->bufpos = stream->bufread = stream->bufstart = buf;
  2205. stream->bufend = buf + size;
  2206. }
  2207. __stdio_validate_FILE(stream); /* debugging only */
  2208. rv = 0;
  2209. DONE:
  2210. __STDIO_THREADUNLOCK(stream);
  2211. return rv;
  2212. #else /* __STDIO_BUFFERS */
  2213. __stdio_validate_FILE(stream); /* debugging only */
  2214. /* TODO -- set errno for illegal mode? */
  2215. return EOF;
  2216. #endif /* __STDIO_BUFFERS */
  2217. }
  2218. #endif
  2219. /**********************************************************************
  2220. int fprintf(FILE * __restrict stream, const char * __restrict format, ...);
  2221. int fscanf(FILE * __restrict stream, const char * __restrict format, ...);
  2222. int printf(const char * __restrict format, ...);
  2223. int scanf(const char * __restrict format, ...);
  2224. int snprintf(char * __restrict s, size_t n,
  2225. const char * __restrict format, ...);
  2226. int sprintf(char * __restrict s, const char * __restrict format, ...);
  2227. int sscanf(char * __restrict s, const char * __restrict format, ...);
  2228. int vfprintf(FILE * __restrict stream, const char * __restrict format,
  2229. va_list arg);
  2230. int vfscanf(FILE * __restrict stream, const char * __restrict format,
  2231. va_list arg);
  2232. int vprintf(const char * __restrict format, va_list arg);
  2233. int vscanf(const char * __restrict format, va_list arg);
  2234. int vsnprintf(char * __restrict s, size_t n,
  2235. const char * __restrict format, va_list arg);
  2236. int vsprintf(char * __restrict s, const char * __restrict format,
  2237. va_list arg);
  2238. int vsscanf(char * __restrict s, const char * __restrict format,
  2239. va_list arg);
  2240. **********************************************************************/
  2241. #ifdef L_fgetc
  2242. /* Reentrancy handled by UNLOCKED() macro. */
  2243. UNLOCKED(int,fgetc,(FILE *stream),(stream))
  2244. {
  2245. unsigned char buf[1];
  2246. #ifdef __STDIO_WIDE
  2247. return (fread(buf, (size_t) 1, (size_t) 1, stream) > 0) ? *buf : EOF;
  2248. #else /* __STDIO_WIDE */
  2249. return (_stdio_fread(buf, (size_t) 1, stream) > 0) ? *buf : EOF;
  2250. #endif /* __STDIO_WIDE */
  2251. }
  2252. #endif
  2253. /**********************************************************************/
  2254. #ifdef L_fgets
  2255. /* Reentrancy handled by UNLOCKED() macro. */
  2256. UNLOCKED(char *,fgets,
  2257. (char *__restrict s, int n, register FILE * __restrict stream),
  2258. (s, n, stream))
  2259. {
  2260. register char *p;
  2261. int c;
  2262. p = s;
  2263. while ((n > 1) && ((c = getc(stream)) != EOF) && ((*p++ = c) != '\n')) {
  2264. --n;
  2265. }
  2266. if (p == s) {
  2267. /* TODO -- should we set errno? */
  2268. /* if (n <= 0) { */
  2269. /* errno = EINVAL; */
  2270. /* } */
  2271. return NULL;
  2272. }
  2273. *p = 0;
  2274. return s;
  2275. }
  2276. #endif
  2277. /**********************************************************************/
  2278. #ifdef L_fputc
  2279. /* Reentrancy handled by UNLOCKED() macro. */
  2280. UNLOCKED(int,fputc,(int c, FILE *stream),(c,stream))
  2281. {
  2282. unsigned char buf[1];
  2283. *buf = (unsigned char) c;
  2284. #ifdef __STDIO_WIDE
  2285. return (fwrite(buf, (size_t) 1, (size_t) 1, stream) > 0) ? (*buf) : EOF;
  2286. #else /* __STDIO_WIDE */
  2287. return (_stdio_fwrite(buf, (size_t) 1, stream) > 0) ? (*buf) : EOF;
  2288. #endif /* __STDIO_WIDE */
  2289. }
  2290. #endif
  2291. /**********************************************************************/
  2292. #ifdef L_fputs
  2293. /* Reentrancy handled by UNLOCKED() macro. */
  2294. UNLOCKED(int,fputs,
  2295. (register const char * __restrict s, FILE * __restrict stream),
  2296. (s, stream))
  2297. {
  2298. size_t n = strlen(s);
  2299. #ifdef __STDIO_WIDE
  2300. return (fwrite(s, n, (size_t) 1, stream) > 0) ? n : EOF;
  2301. #else /* __STDIO_WIDE */
  2302. return (_stdio_fwrite(s, n, stream) == n) ? n : EOF;
  2303. #endif /* __STDIO_WIDE */
  2304. }
  2305. #endif
  2306. /**********************************************************************/
  2307. #ifdef L_getc
  2308. #undef getc
  2309. /* Reentrancy handled by UNLOCKED() macro. */
  2310. UNLOCKED(int,getc,(register FILE *stream),(stream))
  2311. {
  2312. return __GETC(stream); /* Invoke the macro. */
  2313. }
  2314. #endif
  2315. /**********************************************************************/
  2316. #ifdef L_getchar
  2317. #undef getchar /* Just in case. */
  2318. /* Reentrancy handled by UNLOCKED() macro. */
  2319. UNLOCKED_STREAM(int,getchar,(void),(),stdin)
  2320. {
  2321. register FILE *stream = stdin; /* This helps bcc optimize. */
  2322. return __GETC(stream);
  2323. }
  2324. #endif
  2325. /**********************************************************************/
  2326. #ifdef L_gets
  2327. link_warning(gets, "the 'gets' function is dangerous and should not be used.")
  2328. /* Reentrant. */
  2329. char *gets(char *s) /* WARNING!!! UNSAFE FUNCTION!!! */
  2330. {
  2331. register FILE *stream = stdin; /* This helps bcc optimize. */
  2332. register char *p = s;
  2333. int c;
  2334. __STDIO_THREADLOCK(stream);
  2335. /* Note: don't worry about performance here... this shouldn't be used!
  2336. * Therefore, force actual function call. */
  2337. while (((c = (getc_unlocked)(stream)) != EOF) && ((*p = c) != '\n')) {
  2338. ++p;
  2339. }
  2340. if ((c == EOF) || (s == p)) {
  2341. s = NULL;
  2342. } else {
  2343. *p = 0;
  2344. }
  2345. __STDIO_THREADUNLOCK(stream);
  2346. return s;
  2347. }
  2348. #endif
  2349. /**********************************************************************/
  2350. #ifdef L_putc
  2351. #undef putc
  2352. /* Reentrancy handled by UNLOCKED() macro. */
  2353. UNLOCKED(int,putc,(int c, register FILE *stream),(c,stream))
  2354. {
  2355. return __PUTC(c, stream); /* Invoke the macro. */
  2356. }
  2357. #endif
  2358. /**********************************************************************/
  2359. #ifdef L_putchar
  2360. #undef putchar /* Just in case. */
  2361. /* Reentrancy handled by UNLOCKED() macro. */
  2362. UNLOCKED_STREAM(int,putchar,(int c),(c),stdout)
  2363. {
  2364. register FILE *stream = stdout; /* This helps bcc optimize. */
  2365. return __PUTC(c, stream);
  2366. }
  2367. #endif
  2368. /**********************************************************************/
  2369. #ifdef L_puts
  2370. /* Reentrant. */
  2371. int puts(register const char *s)
  2372. {
  2373. register FILE *stream = stdout; /* This helps bcc optimize. */
  2374. int n;
  2375. __STDIO_THREADLOCK(stream);
  2376. n = fputs_unlocked(s,stream) + 1;
  2377. if (
  2378. #if 1
  2379. fputc_unlocked('\n',stream)
  2380. #else
  2381. fputs_unlocked("\n",stream)
  2382. #endif
  2383. == EOF) {
  2384. n = EOF;
  2385. }
  2386. __STDIO_THREADUNLOCK(stream);
  2387. return n;
  2388. }
  2389. #endif
  2390. /**********************************************************************/
  2391. #ifdef L_ungetc
  2392. /*
  2393. * Note: This is the application-callable ungetc. If scanf calls this, it
  2394. * should also set stream->ungot[1] to 0 if this is the only ungot.
  2395. */
  2396. /* Reentrant. */
  2397. int ungetc(int c, register FILE *stream)
  2398. {
  2399. __STDIO_THREADLOCK(stream);
  2400. __stdio_validate_FILE(stream); /* debugging only */
  2401. #ifdef __STDIO_WIDE
  2402. if (stream->modeflags & __FLAG_WIDE) {
  2403. stream->modeflags |= __FLAG_ERROR;
  2404. c = EOF;
  2405. goto DONE;
  2406. }
  2407. stream->modeflags |= __FLAG_NARROW;
  2408. #endif /* __STDIO_WIDE */
  2409. /* If can't read or there's been an error, or c == EOF, or ungot slots
  2410. * already filled, then return EOF */
  2411. if ((stream->modeflags
  2412. & (__MASK_UNGOT2|__FLAG_WRITEONLY
  2413. #ifndef __STDIO_AUTO_RW_TRANSITION
  2414. |__FLAG_WRITING /* Note: technically no, but yes in spirit */
  2415. #endif /* __STDIO_AUTO_RW_TRANSITION */
  2416. ))
  2417. || ((stream->modeflags & __MASK_UNGOT1) && (stream->ungot[1]))
  2418. || (c == EOF) ) {
  2419. c = EOF;
  2420. goto DONE;;
  2421. }
  2422. #ifdef __STDIO_BUFFERS
  2423. /* TODO: shouldn't allow writing??? */
  2424. if (stream->modeflags & __FLAG_WRITING) {
  2425. fflush_unlocked(stream); /* Commit any write-buffered chars. */
  2426. }
  2427. #endif /* __STDIO_BUFFERS */
  2428. /* Clear EOF and WRITING flags, and set READING FLAG */
  2429. stream->modeflags &= ~(__FLAG_EOF|__FLAG_WRITING);
  2430. stream->modeflags |= __FLAG_READING;
  2431. stream->ungot[1] = 1; /* Flag as app ungetc call; scanf fixes up. */
  2432. stream->ungot[(stream->modeflags++) & __MASK_UNGOT] = c;
  2433. #ifdef __STDIO_GETC_MACRO
  2434. stream->bufgetc = stream->bufstart; /* Must disable getc macro. */
  2435. #endif
  2436. __stdio_validate_FILE(stream); /* debugging only */
  2437. DONE:
  2438. __STDIO_THREADUNLOCK(stream);
  2439. return c;
  2440. }
  2441. #endif
  2442. /**********************************************************************/
  2443. #ifdef L_fread
  2444. /* NOTE: Surely ptr cannot point to a buffer of size > SIZE_MAX.
  2445. * Therefore, we treat the case size * nmemb > SIZE_MAX as an error,
  2446. * and include an assert() for it. */
  2447. /* Reentrancy handled by UNLOCKED() macro. */
  2448. UNLOCKED(size_t,fread,
  2449. (void * __restrict ptr, size_t size, size_t nmemb,
  2450. FILE * __restrict stream),
  2451. (ptr,size,nmemb,stream))
  2452. {
  2453. #ifdef __STDIO_WIDE
  2454. if (stream->modeflags & __FLAG_WIDE) {
  2455. stream->modeflags |= __FLAG_ERROR;
  2456. /* TODO -- errno? it this correct? */
  2457. return 0;
  2458. }
  2459. stream->modeflags |= __FLAG_NARROW;
  2460. #endif /* __STDIO_WIDE */
  2461. return (size == 0)
  2462. ? 0
  2463. : ( assert( ((size_t)(-1)) / size >= nmemb ),
  2464. _stdio_fread(ptr, nmemb * size, stream) / size );
  2465. }
  2466. #endif
  2467. /**********************************************************************/
  2468. #ifdef L_fwrite
  2469. /* NOTE: Surely ptr cannot point to a buffer of size > SIZE_MAX.
  2470. * Therefore, we treat the case size * nmemb > SIZE_MAX as an error,
  2471. * and include an assert() for it. */
  2472. /* Reentrancy handled by UNLOCKED() macro. */
  2473. UNLOCKED(size_t,fwrite,
  2474. (const void * __restrict ptr, size_t size, size_t nmemb,
  2475. FILE * __restrict stream),
  2476. (ptr,size,nmemb,stream))
  2477. {
  2478. #ifdef __STDIO_WIDE
  2479. if (stream->modeflags & __FLAG_WIDE) {
  2480. stream->modeflags |= __FLAG_ERROR;
  2481. /* TODO -- errno? it this correct? */
  2482. return 0;
  2483. }
  2484. stream->modeflags |= __FLAG_NARROW;
  2485. #endif /* __STDIO_WIDE */
  2486. return (size == 0)
  2487. ? 0
  2488. : ( assert( ((size_t)(-1)) / size >= nmemb ),
  2489. _stdio_fwrite(ptr, nmemb * size, stream) / size );
  2490. }
  2491. #endif
  2492. /**********************************************************************/
  2493. #if defined(L_fgetpos) || defined(L_fgetpos64)
  2494. /* Reentrant -- fgetpos() and fgetpos64(). */
  2495. #if defined(L_fgetpos) && defined(L_fgetpos64)
  2496. #error L_fgetpos and L_fgetpos64 are defined simultaneously!
  2497. #endif
  2498. #ifndef L_fgetpos64
  2499. #define fgetpos64 fgetpos
  2500. #define fpos64_t fpos_t
  2501. #define ftello64 ftell
  2502. #endif
  2503. int fgetpos64(FILE * __restrict stream, register fpos64_t * __restrict pos)
  2504. {
  2505. #ifdef __STDIO_MBSTATE
  2506. int retval;
  2507. __STDIO_THREADLOCK(stream);
  2508. retval = ((pos != NULL) && ((pos->__pos = ftello64(stream)) >= 0))
  2509. ? (__COPY_MBSTATE(&(pos->__mbstate), &(stream->state)), 0)
  2510. : (__set_errno(EINVAL), -1);
  2511. __STDIO_THREADUNLOCK(stream);
  2512. return retval;
  2513. #else
  2514. return ((pos != NULL) && ((pos->__pos = ftello64(stream)) >= 0))
  2515. ? 0 : (__set_errno(EINVAL), -1);
  2516. #endif
  2517. }
  2518. #ifndef L_fgetpos64
  2519. #undef fgetpos64
  2520. #undef fpos64_t
  2521. #undef ftello64
  2522. #endif
  2523. #endif
  2524. /**********************************************************************/
  2525. #ifdef L_fseek
  2526. strong_alias(fseek,fseeko);
  2527. #endif
  2528. #if defined(L_fseek) && defined(__STDIO_LARGE_FILES)
  2529. int fseek(register FILE *stream, long int offset, int whence)
  2530. {
  2531. return fseeko64(stream, offset, whence);
  2532. }
  2533. #endif
  2534. #if defined(L_fseeko64) || (defined(L_fseek) && !defined(__STDIO_LARGE_FILES))
  2535. #ifndef L_fseeko64
  2536. #define fseeko64 fseek
  2537. #define __off64_t long int
  2538. #endif
  2539. /* Reentrant -- fseek(), fseeko(), fseeko64() */
  2540. int fseeko64(register FILE *stream, __off64_t offset, int whence)
  2541. {
  2542. #if SEEK_SET != 0 || SEEK_CUR != 1 || SEEK_END != 2
  2543. #error Assumption violated -- values of SEEK_SET, SEEK_CUR, SEEK_END
  2544. #endif
  2545. __offmax_t pos[1];
  2546. int retval;
  2547. if ( ((unsigned int) whence) > 2 ) {
  2548. __set_errno(EINVAL);
  2549. return -1;
  2550. }
  2551. __STDIO_THREADLOCK(stream);
  2552. __stdio_validate_FILE(stream); /* debugging only */
  2553. retval = -1;
  2554. *pos = offset;
  2555. if (
  2556. #ifdef __STDIO_BUFFERS
  2557. /* First commit any pending buffered writes. */
  2558. ((stream->modeflags & __FLAG_WRITING) && fflush_unlocked(stream)) ||
  2559. #endif /* __STDIO_BUFFERS */
  2560. ((whence == SEEK_CUR) && (_stdio_adjpos(stream, pos) < 0))
  2561. || (_stdio_lseek(stream, pos, whence) < 0)
  2562. ) {
  2563. __stdio_validate_FILE(stream); /* debugging only */
  2564. goto DONE;
  2565. }
  2566. #ifdef __STDIO_BUFFERS
  2567. /* only needed if reading but do it anyway to avoid test */
  2568. #ifdef __STDIO_GETC_MACRO
  2569. stream->bufgetc = /* Must disable getc. */
  2570. #endif
  2571. stream->bufpos = stream->bufread = stream->bufstart;
  2572. #endif /* __STDIO_BUFFERS */
  2573. stream->modeflags &=
  2574. ~(__FLAG_READING|__FLAG_WRITING|__FLAG_EOF|__MASK_UNGOT);
  2575. #ifdef __STDIO_MBSTATE
  2576. /* TODO: don't clear state if don't move? */
  2577. __INIT_MBSTATE(&(stream->state));
  2578. #endif /* __STDIO_MBSTATE */
  2579. __stdio_validate_FILE(stream); /* debugging only */
  2580. retval = 0;
  2581. DONE:
  2582. __STDIO_THREADUNLOCK(stream);
  2583. return retval;
  2584. }
  2585. #ifndef L_fseeko64
  2586. #undef fseeko64
  2587. #undef __off64_t
  2588. #endif
  2589. #endif
  2590. /**********************************************************************/
  2591. #if defined(L_fsetpos) || defined(L_fsetpos64)
  2592. #if defined(L_fsetpos) && defined(L_fsetpos64)
  2593. #error L_fsetpos and L_fsetpos64 are defined simultaneously!
  2594. #endif
  2595. #ifndef L_fsetpos64
  2596. #define fsetpos64 fsetpos
  2597. #define fpos64_t fpos_t
  2598. #define fseeko64 fseek
  2599. #endif
  2600. /* Reentrant -- fgetpos{64}() through fseek{64}(). */
  2601. int fsetpos64(FILE *stream, register const fpos64_t *pos)
  2602. {
  2603. if (!pos) {
  2604. __set_errno(EINVAL);
  2605. return EOF;
  2606. }
  2607. #ifdef __STDIO_MBSTATE
  2608. {
  2609. int retval;
  2610. __STDIO_THREADLOCK(stream);
  2611. if ((retval = fseeko64(stream, pos->__pos, SEEK_SET)) == 0) {
  2612. __COPY_MBSTATE(&(stream->state), &(pos->__mbstate));
  2613. }
  2614. __STDIO_THREADUNLOCK(stream);
  2615. return retval;
  2616. }
  2617. #else /* __STDIO_MBSTATE */
  2618. return fseeko64(stream, pos->__pos, SEEK_SET);
  2619. #endif /* __STDIO_MBSTATE */
  2620. }
  2621. #ifndef L_fsetpos64
  2622. #undef fsetpos64
  2623. #undef fpos64_t
  2624. #undef fseeko64
  2625. #endif
  2626. #endif
  2627. /**********************************************************************/
  2628. #ifdef L_ftell
  2629. strong_alias(ftell,ftello);
  2630. #endif
  2631. #if defined(L_ftell) && defined(__STDIO_LARGE_FILES)
  2632. long int ftell(register FILE *stream)
  2633. {
  2634. __offmax_t pos = ftello64(stream);
  2635. return (pos == ((long int) pos)) ? pos : (__set_errno(EOVERFLOW), -1);
  2636. }
  2637. #endif
  2638. #if defined(L_ftello64) || (defined(L_ftell) && !defined(__STDIO_LARGE_FILES))
  2639. #ifndef L_ftello64
  2640. #define ftello64 ftell
  2641. #define __off64_t long int
  2642. #endif
  2643. /* Reentrant -- ftell, ftello, ftello64. */
  2644. __off64_t ftello64(register FILE *stream)
  2645. {
  2646. __offmax_t pos[1];
  2647. __off64_t retval;
  2648. __STDIO_THREADLOCK(stream);
  2649. retval = (((*pos = 0), (_stdio_lseek(stream, pos, SEEK_CUR) < 0))
  2650. || (_stdio_adjpos(stream, pos) < 0)) ? -1 : *pos;
  2651. __STDIO_THREADUNLOCK(stream);
  2652. return retval;
  2653. }
  2654. #ifndef L_ftello64
  2655. #undef ftello64
  2656. #undef __off64_t
  2657. #endif
  2658. #endif
  2659. /**********************************************************************/
  2660. #ifdef L_rewind
  2661. void rewind(register FILE *stream)
  2662. {
  2663. __STDIO_THREADLOCK(stream);
  2664. __CLEARERR(stream); /* Clear errors first and then seek */
  2665. fseek(stream, 0L, SEEK_SET); /* in case there is an error seeking. */
  2666. #ifdef __STDIO_MBSTATE
  2667. /* TODO: Is it correct to re-init the stream's state? I think so... */
  2668. __INIT_MBSTATE(&(stream->state));
  2669. #endif /* __STDIO_MBSTATE */
  2670. __STDIO_THREADUNLOCK(stream);
  2671. }
  2672. #endif
  2673. /**********************************************************************/
  2674. #ifdef L_clearerr
  2675. #undef clearerr
  2676. /* Reentrancy handled by UNLOCKED_VOID_RETURN() macro. */
  2677. UNLOCKED_VOID_RETURN(clearerr,(FILE *stream),(stream))
  2678. {
  2679. __CLEARERR(stream);
  2680. }
  2681. #endif
  2682. /**********************************************************************/
  2683. #ifdef L_feof
  2684. #undef feof
  2685. /* Reentrancy handled by UNLOCKED() macro. */
  2686. UNLOCKED(int,feof,(FILE *stream),(stream))
  2687. {
  2688. return __FEOF(stream);
  2689. }
  2690. #endif
  2691. /**********************************************************************/
  2692. #ifdef L_ferror
  2693. #undef ferror
  2694. /* Reentrancy handled by UNLOCKED() macro. */
  2695. UNLOCKED(int,ferror,(FILE *stream),(stream))
  2696. {
  2697. return __FERROR(stream);
  2698. }
  2699. #endif
  2700. /**********************************************************************/
  2701. #ifdef L_perror
  2702. void perror(register const char *s)
  2703. {
  2704. /* If the program is calling perror, it's a safe bet that printf and
  2705. * friends are used as well. It is also possible that the calling
  2706. * program could buffer stderr, or reassign it. */
  2707. register const char *sep;
  2708. sep = ": ";
  2709. if (!(s && *s)) { /* Caller did not supply a prefix message */
  2710. s = (sep += 2); /* or passed an empty string. */
  2711. }
  2712. #if 1
  2713. #ifdef __STDIO_PRINTF_M_SPEC
  2714. fprintf(stderr, "%s%s%m\n", s, sep); /* Use the gnu %m feature. */
  2715. #else
  2716. {
  2717. char buf[64];
  2718. fprintf(stderr, "%s%s%s\n", s, sep,
  2719. _glibc_strerror_r(errno, buf, sizeof(buf)));
  2720. }
  2721. #endif
  2722. #else
  2723. /* Note: Assumes stderr not closed or buffered. */
  2724. {
  2725. char buf[64];
  2726. __STDIO_THREADLOCK(stderr);
  2727. _stdio_fdout(STDERR_FILENO, s, sep,
  2728. _glibc_strerror_r(errno, buf, sizeof(buf)));
  2729. __STDIO_THREADUNLOCK(stderr);
  2730. }
  2731. #endif
  2732. }
  2733. #endif
  2734. /**********************************************************************/
  2735. /* UTILITY funcs */
  2736. /**********************************************************************/
  2737. #ifdef L__stdio_fdout
  2738. /* Not reentrant -- TODO: lock associated stream if a know file descriptor? */
  2739. void _stdio_fdout(int fd, ...)
  2740. {
  2741. va_list arg;
  2742. register const char *p;
  2743. va_start(arg, fd);
  2744. while ((p = va_arg(arg, const char *)) != NULL) {
  2745. write(fd, p, strlen(p));
  2746. }
  2747. va_end(arg);
  2748. }
  2749. #endif
  2750. /**********************************************************************/
  2751. #ifdef L__uintmaxtostr
  2752. /* Avoid using long long / and % operations to cut down dependencies on
  2753. * libgcc.a. Definitely helps on i386 at least. */
  2754. #if (INTMAX_MAX > INT_MAX) && (((INTMAX_MAX/INT_MAX)/2) - 2 <= INT_MAX)
  2755. #define INTERNAL_DIV_MOD
  2756. #endif
  2757. #ifdef __UCLIBC_MJN3_ONLY__
  2758. #warning REMINDER: move _uintmaxtostr to locale.c???
  2759. #endif
  2760. #include <locale.h>
  2761. #ifndef __LOCALE_C_ONLY
  2762. #define CUR_LOCALE (__global_locale)
  2763. #endif /* __LOCALE_C_ONLY */
  2764. char *_uintmaxtostr(register char * __restrict bufend, uintmax_t uval,
  2765. int base, __UIM_CASE alphacase)
  2766. {
  2767. int negative;
  2768. unsigned int digit;
  2769. #ifdef INTERNAL_DIV_MOD
  2770. unsigned int H, L, high, low, rh;
  2771. #endif
  2772. #ifndef __LOCALE_C_ONLY
  2773. int grouping, outdigit;
  2774. size_t gslen; /* This does not need to be initialized. */
  2775. const char *g; /* This does not need to be initialized. */
  2776. #endif /* __LOCALE_C_ONLY */
  2777. negative = 0;
  2778. if (base < 0) { /* signed value */
  2779. base = -base;
  2780. if (uval > INTMAX_MAX) {
  2781. uval = -uval;
  2782. negative = 1;
  2783. }
  2784. }
  2785. /* this is an internal routine -- we shouldn't need to check this */
  2786. assert(!((base < 2) || (base > 36)));
  2787. #ifndef __LOCALE_C_ONLY
  2788. grouping = -1;
  2789. outdigit = 0x80 & alphacase;
  2790. alphacase ^= outdigit;
  2791. #ifdef __UCLIBC_MJN3_ONLY_
  2792. #warning implement outdigit... need digit lengths! (put it in locale struct)
  2793. #endif
  2794. if (alphacase == __UIM_GROUP) {
  2795. assert(base == 10);
  2796. if (*(g = CUR_LOCALE.grouping)
  2797. && ((gslen = strlen(CUR_LOCALE.thousands_sep)) > 0)
  2798. ) {
  2799. grouping = *g;
  2800. }
  2801. }
  2802. #endif /* __LOCALE_C_ONLY */
  2803. *bufend = '\0';
  2804. #ifndef INTERNAL_DIV_MOD
  2805. do {
  2806. #ifndef __LOCALE_C_ONLY
  2807. if (!grouping) { /* Finished a group. */
  2808. #ifdef __UCLIBC_MJN3_ONLY__
  2809. #warning REMINDER: decide about memcpy in _uintmaxtostr
  2810. #endif
  2811. #if 0
  2812. bufend -= gslen;
  2813. memcpy(bufend, CUR_LOCALE.thousands_sep, gslen);
  2814. #else
  2815. grouping = gslen;
  2816. do {
  2817. *--bufend = CUR_LOCALE.thousands_sep[--grouping];
  2818. } while (grouping);
  2819. #endif
  2820. if (g[1] != 0) { /* g[1] == 0 means repeat last grouping. */
  2821. /* Note: g[1] == -1 means no further grouping. But since
  2822. * we'll never wrap around, we can set grouping to -1 without
  2823. * fear of */
  2824. ++g;
  2825. }
  2826. grouping = *g;
  2827. }
  2828. --grouping;
  2829. #endif /* __LOCALE_C_ONLY */
  2830. digit = uval % base;
  2831. uval /= base;
  2832. #ifndef __LOCALE_C_ONLY
  2833. if (outdigit) {
  2834. outdigit = CUR_LOCALE.outdigit_length[digit];
  2835. do {
  2836. *--bufend = (&CUR_LOCALE.outdigit0_mb)[digit][--outdigit];
  2837. } while (outdigit);
  2838. outdigit = 1;
  2839. } else
  2840. #endif
  2841. {
  2842. *--bufend = ( (digit < 10) ? digit + '0' : digit + alphacase );
  2843. }
  2844. } while (uval);
  2845. #else /* ************************************************** */
  2846. H = (UINT_MAX / base);
  2847. L = UINT_MAX % base + 1;
  2848. if (L == base) {
  2849. ++H;
  2850. L = 0;
  2851. }
  2852. low = (unsigned int) uval;
  2853. high = (unsigned int) (uval >> (sizeof(unsigned int) * CHAR_BIT));
  2854. do {
  2855. #ifndef __LOCALE_C_ONLY
  2856. if (!grouping) { /* Finished a group. */
  2857. #ifdef __UCLIBC_MJN3_ONLY__
  2858. #warning REMINDER: decide about memcpy in _uintmaxtostr
  2859. #endif
  2860. #if 0
  2861. bufend -= gslen;
  2862. memcpy(bufend, CUR_LOCALE.thousands_sep, gslen);
  2863. #else
  2864. grouping = gslen;
  2865. do {
  2866. *--bufend = CUR_LOCALE.thousands_sep[--grouping];
  2867. } while (grouping);
  2868. #endif
  2869. if (g[1] != 0) { /* g[1] == 0 means repeat last grouping. */
  2870. /* Note: g[1] == -1 means no further grouping. But since
  2871. * we'll never wrap around, we can set grouping to -1 without
  2872. * fear of */
  2873. ++g;
  2874. }
  2875. grouping = *g;
  2876. }
  2877. --grouping;
  2878. #endif /* __LOCALE_C_ONLY */
  2879. rh = high % base;
  2880. high /= base;
  2881. digit = (low % base) + (L * rh);
  2882. low = (low / base) + (H * rh) + (digit / base);
  2883. digit %= base;
  2884. #ifndef __LOCALE_C_ONLY
  2885. if (outdigit) {
  2886. outdigit = CUR_LOCALE.outdigit_length[digit];
  2887. do {
  2888. *--bufend = (&CUR_LOCALE.outdigit0_mb)[digit][--outdigit];
  2889. } while (outdigit);
  2890. outdigit = 1;
  2891. } else
  2892. #endif
  2893. {
  2894. *--bufend = ( (digit < 10) ? digit + '0' : digit + alphacase );
  2895. }
  2896. } while (low | high);
  2897. #endif /******************************************************/
  2898. if (negative) {
  2899. *--bufend = '-';
  2900. }
  2901. return bufend;
  2902. }
  2903. #undef INTERNAL_DIV_MOD
  2904. #endif
  2905. /**********************************************************************/
  2906. #ifdef L__wstdio_fwrite
  2907. #include <wchar.h>
  2908. size_t _wstdio_fwrite(const wchar_t *__restrict ws, size_t n,
  2909. register FILE *__restrict stream)
  2910. {
  2911. size_t r, count;
  2912. char buf[64];
  2913. const wchar_t *pw;
  2914. #ifdef __STDIO_BUFFERS
  2915. if (stream->filedes == -3) { /* Special case to support {v}swprintf. */
  2916. count = ((wchar_t *)(stream->bufend)) - ((wchar_t *)(stream->bufpos));
  2917. if (count > n) {
  2918. count = n;
  2919. }
  2920. if (count) {
  2921. wmemcpy((wchar_t *)(stream->bufpos), ws, count);
  2922. stream->bufpos = (char *)(((wchar_t *)(stream->bufpos)) + count);
  2923. }
  2924. return n;
  2925. }
  2926. #endif
  2927. if (stream->modeflags & __FLAG_NARROW) {
  2928. stream->modeflags |= __FLAG_ERROR;
  2929. __set_errno(EBADF);
  2930. return 0;
  2931. }
  2932. stream->modeflags |= __FLAG_WIDE;
  2933. pw = ws;
  2934. count = 0;
  2935. while (n > count) {
  2936. r = wcsnrtombs(buf, &pw, n-count, sizeof(buf), &stream->state);
  2937. if (r != ((size_t) -1)) { /* No encoding errors */
  2938. if (!r) {
  2939. ++r; /* 0 is returned when nul is reached. */
  2940. pw = ws + count + r; /* pw was set to NULL, so correct. */
  2941. }
  2942. if (_stdio_fwrite(buf, r, stream) == r) {
  2943. count = pw - ws;
  2944. continue;
  2945. }
  2946. }
  2947. break;
  2948. }
  2949. /* Note: The count is incorrect if 0 < _stdio_fwrite return < r!!! */
  2950. return count;
  2951. }
  2952. #endif
  2953. /**********************************************************************/