time.c 59 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319
  1. /* Copyright (C) 2002-2004 Manuel Novoa III <mjn3@codepoet.org>
  2. *
  3. * GNU Library General Public License (LGPL) version 2 or later.
  4. *
  5. * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details.
  6. */
  7. /* June 15, 2002 Initial Notes:
  8. *
  9. * Note: It is assumed throught that time_t is either long or unsigned long.
  10. * Similarly, clock_t is assumed to be long int.
  11. *
  12. * Warning: Assumptions are made about the layout of struct tm! It is
  13. * assumed that the initial fields of struct tm are (in order):
  14. * tm_sec, tm_min, tm_hour, tm_mday, tm_mon, tm_year, tm_wday, tm_yday
  15. *
  16. * Reached the inital goal of supporting the ANSI/ISO C99 time functions
  17. * as well as SUSv3's strptime. All timezone info is obtained from the
  18. * TZ env variable.
  19. *
  20. * Differences from glibc worth noting:
  21. *
  22. * Leap seconds are not considered here.
  23. *
  24. * glibc stores additional timezone info the struct tm, whereas we don't.
  25. *
  26. * Alternate digits and era handling are not currently implemented.
  27. * The modifiers are accepted, and tested for validity with the following
  28. * specifier, but are ignored otherwise.
  29. *
  30. * strftime does not implement glibc extension modifiers or widths for
  31. * conversion specifiers. However it does implement the glibc
  32. * extension specifiers %l, %k, and %s. It also recognizes %P, but
  33. * treats it as a synonym for %p; i.e. doesn't convert to lower case.
  34. *
  35. * strptime implements the glibc extension specifiers. However, it follows
  36. * SUSv3 in requiring at least one non-alphanumeric char between
  37. * conversion specifiers. Also, strptime only sets struct tm fields
  38. * for which format specifiers appear and does not try to infer other
  39. * fields (such as wday) as glibc's version does.
  40. *
  41. * TODO - Since glibc's %l and %k can space-pad their output in strftime,
  42. * it might be reasonable to eat whitespace first for those specifiers.
  43. * This could be done by pushing " %I" and " %H" respectively so that
  44. * leading whitespace is consumed. This is really only an issue if %l
  45. * or %k occurs at the start of the format string.
  46. *
  47. * TODO - Implement getdate? tzfile? struct tm extensions?
  48. *
  49. * TODO - Rework _time_mktime to remove the dependency on long long.
  50. */
  51. /* Oct 28, 2002
  52. *
  53. * Fixed allowed char check for std and dst TZ fields.
  54. *
  55. * Added several options concerned with timezone support. The names will
  56. * probably change once Erik gets the new config system in place.
  57. *
  58. * Defining __TIME_TZ_FILE causes tzset() to attempt to read the TZ value
  59. * from the file /etc/TZ if the TZ env variable isn't set. The file contents
  60. * must be the intended value of TZ, followed by a newline. No other chars,
  61. * spacing, etc is allowed. As an example, an easy way for me to init
  62. * /etc/TZ appropriately would be: echo CST6CDT > /etc/TZ
  63. *
  64. * Defining __TIME_TZ_FILE_ONCE will cause all further accesses of /etc/TZ
  65. * to be skipped once a legal value has been read.
  66. *
  67. * Defining __TIME_TZ_OPT_SPEED will cause a tzset() to keep a copy of the
  68. * last TZ setting string and do a "fast out" if the current string is the
  69. * same.
  70. *
  71. * Nov 21, 2002 Fix an error return case in _time_mktime.
  72. *
  73. * Nov 26, 2002 Fix bug in setting daylight and timezone when no (valid) TZ.
  74. * Bug reported by Arne Bernin <arne@alamut.de> in regards to freeswan.
  75. *
  76. * July 27, 2003 Adjust the struct tm extension field support.
  77. * Change __tm_zone back to a ptr and add the __tm_tzname[] buffer for
  78. * __tm_zone to point to. This gets around complaints from g++.
  79. * Who knows... it might even fix the PPC timezone init problem.
  80. *
  81. * July 29, 2003 Fix a bug in mktime behavior when tm_isdst was -1.
  82. * Bug reported by "Sid Wade" <sid@vivato.net> in regards to busybox.
  83. *
  84. * NOTE: uClibc mktime behavior is different than glibc's when
  85. * the struct tm has tm_isdst == -1 and also had fields outside of
  86. * the normal ranges.
  87. *
  88. * Apparently, glibc examines (at least) tm_sec and guesses the app's
  89. * intention of assuming increasing or decreasing time when entering an
  90. * ambiguous time period at the dst<->st boundaries.
  91. *
  92. * The uClibc behavior is to always normalize the struct tm and then
  93. * try to determing the dst setting.
  94. *
  95. * As long as tm_isdst != -1 or the time specifiec by struct tm is
  96. * unambiguous (not falling in the dst<->st transition region) both
  97. * uClibc and glibc should produce the same result for mktime.
  98. *
  99. * Oct 31, 2003 Kill the seperate __tm_zone and __tm_tzname[] and which
  100. * doesn't work if you want the memcpy the struct. Sigh... I didn't
  101. * think about that. So now, when the extensions are enabled, we
  102. * malloc space when necessary and keep the timezone names in a linked
  103. * list.
  104. *
  105. * Fix a dst-related bug which resulted in use of uninitialized data.
  106. *
  107. * Nov 15, 2003 I forgot to update the thread locking in the last dst fix.
  108. *
  109. * Dec 14, 2003 Fix some dst issues in _time_mktime().
  110. * Normalize the tm_isdst value to -1, 0, or 1.
  111. * If no dst for this timezone, then reset tm_isdst to 0.
  112. *
  113. * May 7, 2004
  114. * Change clock() to allow wrapping.
  115. * Add timegm() function.
  116. * Make lookup_tzname() static (as it should have been).
  117. * Have strftime() get timezone information from the passed struct
  118. * for the %z and %Z conversions when using struct tm extensions.
  119. */
  120. #define _GNU_SOURCE
  121. #include <stdio.h>
  122. #include <stdlib.h>
  123. #include <stddef.h>
  124. #include <string.h>
  125. #include <time.h>
  126. #include <limits.h>
  127. #include <assert.h>
  128. #include <errno.h>
  129. #include <ctype.h>
  130. #include <langinfo.h>
  131. #include <locale.h>
  132. #include <bits/uClibc_uintmaxtostr.h>
  133. #ifdef __UCLIBC_HAS_XLOCALE__
  134. #include <xlocale.h>
  135. #endif
  136. #ifndef __isleap
  137. #define __isleap(y) ( !((y) % 4) && ( ((y) % 100) || !((y) % 400) ) )
  138. #endif
  139. #ifndef TZNAME_MAX
  140. #define TZNAME_MAX _POSIX_TZNAME_MAX
  141. #endif
  142. /**********************************************************************/
  143. /* The era code is currently unfinished. */
  144. /* #define ENABLE_ERA_CODE */
  145. #define TZ_BUFLEN (2*TZNAME_MAX + 56)
  146. #ifdef __UCLIBC_HAS_TZ_FILE__
  147. #include <sys/stat.h>
  148. #include <fcntl.h>
  149. #include <unistd.h>
  150. #include "paths.h"
  151. /* ":<tzname>+hh:mm:ss<tzname>+hh:mm:ss,Mmm.w.d/hh:mm:ss,Mmm.w.d/hh:mm:ss" + nul */
  152. /* 1 + 2*(1+TZNAME_MAX+1 + 9 + 7 + 9) + 1 = 2*TZNAME_MAX + 56 */
  153. #else /* __UCLIBC_HAS_TZ_FILE__ */
  154. /* Probably no longer needed. */
  155. #undef __UCLIBC_HAS_TZ_FILE_READ_MANY__
  156. #endif /* __UCLIBC_HAS_TZ_FILE__ */
  157. /**********************************************************************/
  158. extern struct tm __time_tm;
  159. typedef struct {
  160. long gmt_offset;
  161. long dst_offset;
  162. short day; /* for J or normal */
  163. short week;
  164. short month;
  165. short rule_type; /* J, M, \0 */
  166. char tzname[TZNAME_MAX+1];
  167. } rule_struct;
  168. #ifdef __UCLIBC_HAS_THREADS__
  169. #include <pthread.h>
  170. extern pthread_mutex_t _time_tzlock;
  171. #define TZLOCK __pthread_mutex_lock(&_time_tzlock)
  172. #define TZUNLOCK __pthread_mutex_unlock(&_time_tzlock)
  173. #else
  174. #define TZLOCK ((void) 0)
  175. #define TZUNLOCK ((void) 0)
  176. #endif
  177. extern rule_struct _time_tzinfo[2];
  178. extern struct tm *_time_t2tm(const time_t *__restrict timer,
  179. int offset, struct tm *__restrict result);
  180. extern time_t _time_mktime(struct tm *timeptr, int store_on_success);
  181. extern struct tm *__time_localtime_tzi(const time_t *__restrict timer,
  182. struct tm *__restrict result,
  183. rule_struct *tzi);
  184. extern time_t _time_mktime_tzi(struct tm *timeptr, int store_on_success,
  185. rule_struct *tzi);
  186. /**********************************************************************/
  187. #ifdef L_asctime
  188. static char __time_str[26];
  189. char *asctime(const struct tm *__restrict ptm)
  190. {
  191. return asctime_r(ptm, __time_str);
  192. }
  193. #endif
  194. /**********************************************************************/
  195. #ifdef L_asctime_r
  196. /* Strictly speaking, this implementation isn't correct. ANSI/ISO specifies
  197. * that the implementation of asctime() be equivalent to
  198. *
  199. * char *asctime(const struct tm *timeptr)
  200. * {
  201. * static char wday_name[7][3] = {
  202. * "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
  203. * };
  204. * static char mon_name[12][3] = {
  205. * "Jan", "Feb", "Mar", "Apr", "May", "Jun",
  206. * "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
  207. * };
  208. * static char result[26];
  209. *
  210. * sprintf(result, "%.3s %.3s%3d %.2d:%.2d:%.2d %d\n",
  211. * wday_name[timeptr->tm_wday],
  212. * mon_name[timeptr->tm_mon],
  213. * timeptr->tm_mday, timeptr->tm_hour,
  214. * timeptr->tm_min, timeptr->tm_sec,
  215. * 1900 + timeptr->tm_year);
  216. * return result;
  217. * }
  218. *
  219. * but the above is either inherently unsafe, or carries with it the implicit
  220. * assumption that all fields of timeptr fall within their usual ranges, and
  221. * that the tm_year value falls in the range [-2899,8099] to avoid overflowing
  222. * the static buffer.
  223. *
  224. * If we take the implicit assumption as given, then the implementation below
  225. * is still incorrect for tm_year values < -900, as there will be either
  226. * 0-padding and/or a missing negative sign for the year conversion . But given
  227. * the ususal use of asctime(), I think it isn't unreasonable to restrict correct
  228. * operation to the domain of years between 1000 and 9999.
  229. */
  230. /* This is generally a good thing, but if you're _sure_ any data passed will be
  231. * in range, you can #undef this. */
  232. #define SAFE_ASCTIME_R 1
  233. static const unsigned char at_data[] = {
  234. 'S', 'u', 'n', 'M', 'o', 'n', 'T', 'u', 'e', 'W', 'e', 'd',
  235. 'T', 'h', 'u', 'F', 'r', 'i', 'S', 'a', 't',
  236. 'J', 'a', 'n', 'F', 'e', 'b', 'M', 'a', 'r', 'A', 'p', 'r',
  237. 'M', 'a', 'y', 'J', 'u', 'n', 'J', 'u', 'l', 'A', 'u', 'g',
  238. 'S', 'e', 'p', 'O', 'c', 't', 'N', 'o', 'v', 'D', 'e', 'c',
  239. #ifdef SAFE_ASCTIME_R
  240. '?', '?', '?',
  241. #endif
  242. ' ', '?', '?', '?',
  243. ' ', '0',
  244. offsetof(struct tm, tm_mday),
  245. ' ', '0',
  246. offsetof(struct tm, tm_hour),
  247. ':', '0',
  248. offsetof(struct tm, tm_min),
  249. ':', '0',
  250. offsetof(struct tm, tm_sec),
  251. ' ', '?', '?', '?', '?', '\n', 0
  252. };
  253. char *asctime_r(register const struct tm *__restrict ptm,
  254. register char *__restrict buffer)
  255. {
  256. int tmp;
  257. assert(ptm);
  258. assert(buffer);
  259. #ifdef SAFE_ASCTIME_R
  260. memcpy(buffer, at_data + 3*(7 + 12), sizeof(at_data) - 3*(7 + 12));
  261. if (((unsigned int)(ptm->tm_wday)) <= 6) {
  262. memcpy(buffer, at_data + 3 * ptm->tm_wday, 3);
  263. }
  264. if (((unsigned int)(ptm->tm_mon)) <= 11) {
  265. memcpy(buffer + 4, at_data + 3*7 + 3 * ptm->tm_mon, 3);
  266. }
  267. #else
  268. assert(((unsigned int)(ptm->tm_wday)) <= 6);
  269. assert(((unsigned int)(ptm->tm_mon)) <= 11);
  270. memcpy(buffer, at_data + 3*(7 + 12) - 3, sizeof(at_data) + 3 - 3*(7 + 12));
  271. memcpy(buffer, at_data + 3 * ptm->tm_wday, 3);
  272. memcpy(buffer + 4, at_data + 3*7 + 3 * ptm->tm_mon, 3);
  273. #endif
  274. #ifdef SAFE_ASCTIME_R
  275. buffer += 19;
  276. tmp = ptm->tm_year + 1900;
  277. if (((unsigned int) tmp) < 10000) {
  278. buffer += 4;
  279. do {
  280. *buffer = '0' + (tmp % 10);
  281. tmp /= 10;
  282. } while (*--buffer == '?');
  283. }
  284. #else /* SAFE_ASCTIME_R */
  285. buffer += 23;
  286. tmp = ptm->tm_year + 1900;
  287. assert( ((unsigned int) tmp) < 10000 );
  288. do {
  289. *buffer = '0' + (tmp % 10);
  290. tmp /= 10;
  291. } while (*--buffer == '?');
  292. #endif /* SAFE_ASCTIME_R */
  293. do {
  294. --buffer;
  295. tmp = *((int *)(((const char *) ptm) + (int) *buffer));
  296. #ifdef SAFE_ASCTIME_R
  297. if (((unsigned int) tmp) >= 100) { /* Just check 2 digit non-neg. */
  298. buffer[-1] = *buffer = '?';
  299. } else
  300. #else /* SAFE_ASCTIME_R */
  301. assert(((unsigned int) tmp) < 100); /* Just check 2 digit non-neg. */
  302. #endif /* SAFE_ASCTIME_R */
  303. {
  304. *buffer = '0' + (tmp % 10);
  305. #ifdef __BCC__
  306. buffer[-1] = '0' + (tmp/10);
  307. #else /* __BCC__ */
  308. buffer[-1] += (tmp/10);
  309. #endif /* __BCC__ */
  310. }
  311. } while ((buffer -= 2)[-2] == '0');
  312. if (*++buffer == '0') { /* Space-pad day of month. */
  313. *buffer = ' ';
  314. }
  315. return buffer - 8;
  316. }
  317. #endif
  318. /**********************************************************************/
  319. #ifdef L_clock
  320. #include <sys/times.h>
  321. #ifndef __BCC__
  322. #if CLOCKS_PER_SEC != 1000000L
  323. #error unexpected value for CLOCKS_PER_SEC!
  324. #endif
  325. #endif
  326. #ifdef __UCLIBC_CLK_TCK_CONST
  327. # if __UCLIBC_CLK_TCK_CONST > CLOCKS_PER_SEC
  328. # error __UCLIBC_CLK_TCK_CONST > CLOCKS_PER_SEC!
  329. # elif __UCLIBC_CLK_TCK_CONST < 1
  330. # error __UCLIBC_CLK_TCK_CONST < 1!
  331. # endif
  332. #endif
  333. /* Note: SUSv3 notes
  334. *
  335. * On XSI-conformant systems, CLOCKS_PER_SEC is defined to be one million.
  336. *
  337. * The value returned by clock() may wrap around on some implementations.
  338. * For example, on a machine with 32-bit values for clock_t, it wraps
  339. * after 2147 seconds.
  340. *
  341. * This implies that we should bitwise and with LONG_MAX.
  342. */
  343. clock_t clock(void)
  344. {
  345. struct tms xtms;
  346. unsigned long t;
  347. times(&xtms);
  348. t = ((unsigned long) xtms.tms_utime) + xtms.tms_stime;
  349. #ifndef __UCLIBC_CLK_TCK_CONST
  350. # error __UCLIBC_CLK_TCK_CONST not defined!
  351. #elif ((CLOCKS_PER_SEC % __UCLIBC_CLK_TCK_CONST) == 0)
  352. /* CLOCKS_PER_SEC == k * __UCLIBC_CLK_TCK_CONST for some integer k >= 1. */
  353. return ((t * (CLOCKS_PER_SEC/__UCLIBC_CLK_TCK_CONST)) & LONG_MAX);
  354. #else
  355. /* Unlike the previous case, the scaling factor is not an integer.
  356. * So when tms_utime, tms_stime, or their sum wraps, some of the
  357. * "visible" bits in the return value are affected. Nothing we
  358. * can really do about this though other than handle tms_utime and
  359. * tms_stime seperately and then sum. But since that doesn't really
  360. * buy us much, we don't bother. */
  361. return ((((t / __UCLIBC_CLK_TCK_CONST) * CLOCKS_PER_SEC)
  362. + ((((t % __UCLIBC_CLK_TCK_CONST) * CLOCKS_PER_SEC)
  363. / __UCLIBC_CLK_TCK_CONST))
  364. ) & LONG_MAX);
  365. #endif
  366. }
  367. #endif
  368. /**********************************************************************/
  369. #ifdef L_ctime
  370. char *ctime(const time_t *clock)
  371. {
  372. /* ANSI/ISO/SUSv3 say that ctime is equivalent to the following. */
  373. return asctime(localtime(clock));
  374. }
  375. #endif
  376. /**********************************************************************/
  377. #ifdef L_ctime_r
  378. char *ctime_r(const time_t *clock, char *buf)
  379. {
  380. struct tm xtm;
  381. return asctime_r(localtime_r(clock, &xtm), buf);
  382. }
  383. #endif
  384. /**********************************************************************/
  385. #ifdef L_difftime
  386. #include <float.h>
  387. #if FLT_RADIX != 2
  388. #error difftime implementation assumptions violated for you arch!
  389. #endif
  390. double difftime(time_t time1, time_t time0)
  391. {
  392. #if (LONG_MAX >> DBL_MANT_DIG) == 0
  393. /* time_t fits in the mantissa of a double. */
  394. return ((double) time1) - time0;
  395. #elif ((LONG_MAX >> DBL_MANT_DIG) >> DBL_MANT_DIG) == 0
  396. /* time_t can overflow the mantissa of a double. */
  397. time_t t1, t0, d;
  398. d = ((time_t) 1) << DBL_MANT_DIG;
  399. t1 = time1 / d;
  400. time1 -= (t1 * d);
  401. t0 = time0 / d;
  402. time0 -= (t0*d);
  403. /* Since FLT_RADIX==2 and d is a power of 2, the only possible
  404. * rounding error in the expression below would occur from the
  405. * addition. */
  406. return (((double) t1) - t0) * d + (((double) time1) - time0);
  407. #else
  408. #error difftime needs special implementation on your arch.
  409. #endif
  410. }
  411. #endif
  412. /**********************************************************************/
  413. #ifdef L_gmtime
  414. struct tm *gmtime(const time_t *timer)
  415. {
  416. register struct tm *ptm = &__time_tm;
  417. _time_t2tm(timer, 0, ptm); /* Can return NULL... */
  418. return ptm;
  419. }
  420. #endif
  421. /**********************************************************************/
  422. #ifdef L_gmtime_r
  423. struct tm *gmtime_r(const time_t *__restrict timer,
  424. struct tm *__restrict result)
  425. {
  426. return _time_t2tm(timer, 0, result);
  427. }
  428. #endif
  429. /**********************************************************************/
  430. #ifdef L_localtime
  431. struct tm *localtime(const time_t *timer)
  432. {
  433. register struct tm *ptm = &__time_tm;
  434. /* In this implementation, tzset() is called by localtime_r(). */
  435. localtime_r(timer, ptm); /* Can return NULL... */
  436. return ptm;
  437. }
  438. #endif
  439. /**********************************************************************/
  440. #ifdef L_localtime_r
  441. struct tm *localtime_r(register const time_t *__restrict timer,
  442. register struct tm *__restrict result)
  443. {
  444. TZLOCK;
  445. tzset();
  446. __time_localtime_tzi(timer, result, _time_tzinfo);
  447. TZUNLOCK;
  448. return result;
  449. }
  450. #endif
  451. /**********************************************************************/
  452. #ifdef L__time_localtime_tzi
  453. #ifdef __UCLIBC_HAS_TM_EXTENSIONS__
  454. struct ll_tzname_item;
  455. typedef struct ll_tzname_item {
  456. struct ll_tzname_item *next;
  457. char tzname[TZNAME_MAX+1];
  458. } ll_tzname_item_t;
  459. static ll_tzname_item_t ll_tzname[] = {
  460. { ll_tzname + 1, "UTC" }, /* Always 1st. */
  461. { NULL, "???" } /* Always 2nd. (invalid or out-of-memory) */
  462. };
  463. static const char *lookup_tzname(const char *key)
  464. {
  465. ll_tzname_item_t *p;
  466. for (p=ll_tzname ; p ; p=p->next) {
  467. if (!strcmp(p->tzname, key)) {
  468. return p->tzname;
  469. }
  470. }
  471. /* Hmm... a new name. */
  472. if (strnlen(key, TZNAME_MAX+1) < TZNAME_MAX+1) { /* Verify legal length */
  473. if ((p = malloc(sizeof(ll_tzname_item_t))) != NULL) {
  474. /* Insert as 3rd item in the list. */
  475. p->next = ll_tzname[1].next;
  476. ll_tzname[1].next = p;
  477. strcpy(p->tzname, key);
  478. return p->tzname;
  479. }
  480. }
  481. /* Either invalid or couldn't alloc. */
  482. return ll_tzname[1].tzname;
  483. }
  484. #endif /* __UCLIBC_HAS_TM_EXTENSIONS__ */
  485. static const unsigned char day_cor[] = { /* non-leap */
  486. 31, 31, 34, 34, 35, 35, 36, 36, 36, 37, 37, 38, 38
  487. /* 0, 0, 3, 3, 4, 4, 5, 5, 5, 6, 6, 7, 7 */
  488. /* 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 */
  489. };
  490. /* Note: timezone locking is done by localtime_r. */
  491. static int tm_isdst(register const struct tm *__restrict ptm,
  492. register rule_struct *r)
  493. {
  494. long sec;
  495. int i, isdst, isleap, day, day0, monlen, mday;
  496. int oday; /* Note: oday can be uninitialized. */
  497. isdst = 0;
  498. if (r[1].tzname[0] != 0) {
  499. /* First, get the current seconds offset from the start of the year.
  500. * Fields of ptm are assumed to be in their normal ranges. */
  501. sec = ptm->tm_sec
  502. + 60 * (ptm->tm_min
  503. + 60 * (long)(ptm->tm_hour
  504. + 24 * ptm->tm_yday));
  505. /* Do some prep work. */
  506. i = (ptm->tm_year % 400) + 1900; /* Make sure we don't overflow. */
  507. isleap = __isleap(i);
  508. --i;
  509. day0 = (1
  510. + i /* Normal years increment 1 wday. */
  511. + (i/4)
  512. - (i/100)
  513. + (i/400) ) % 7;
  514. i = 0;
  515. do {
  516. day = r->day; /* Common for 'J' and # case. */
  517. if (r->rule_type == 'J') {
  518. if (!isleap || (day < (31+29))) {
  519. --day;
  520. }
  521. } else if (r->rule_type == 'M') {
  522. /* Find 0-based day number for 1st of the month. */
  523. day = 31*r->month - day_cor[r->month -1];
  524. if (isleap && (day >= 59)) {
  525. ++day;
  526. }
  527. monlen = 31 + day_cor[r->month -1] - day_cor[r->month];
  528. if (isleap && (r->month > 1)) {
  529. ++monlen;
  530. }
  531. /* Wweekday (0 is Sunday) of 1st of the month
  532. * is (day0 + day) % 7. */
  533. if ((mday = r->day - ((day0 + day) % 7)) >= 0) {
  534. mday -= 7; /* Back up into prev month since r->week>0. */
  535. }
  536. if ((mday += 7 * r->week) >= monlen) {
  537. mday -= 7;
  538. }
  539. /* So, 0-based day number is... */
  540. day += mday;
  541. }
  542. if (i != 0) {
  543. /* Adjust sec since dst->std change time is in dst. */
  544. sec += (r[-1].gmt_offset - r->gmt_offset);
  545. if (oday > day) {
  546. ++isdst; /* Year starts in dst. */
  547. }
  548. }
  549. oday = day;
  550. /* Now convert day to seconds and add offset and compare. */
  551. if (sec >= (day * 86400L) + r->dst_offset) {
  552. ++isdst;
  553. }
  554. ++r;
  555. } while (++i < 2);
  556. }
  557. return (isdst & 1);
  558. }
  559. struct tm *__time_localtime_tzi(register const time_t *__restrict timer,
  560. register struct tm *__restrict result,
  561. rule_struct *tzi)
  562. {
  563. time_t x[1];
  564. long offset;
  565. int days, dst;
  566. dst = 0;
  567. do {
  568. days = -7;
  569. offset = 604800L - tzi[dst].gmt_offset;
  570. if (*timer > (LONG_MAX - 604800L)) {
  571. days = -days;
  572. offset = -offset;
  573. }
  574. *x = *timer + offset;
  575. _time_t2tm(x, days, result);
  576. result->tm_isdst = dst;
  577. #ifdef __UCLIBC_HAS_TM_EXTENSIONS__
  578. result->tm_gmtoff = - tzi[dst].gmt_offset;
  579. result->tm_zone = lookup_tzname(tzi[dst].tzname);
  580. #endif /* __UCLIBC_HAS_TM_EXTENSIONS__ */
  581. } while ((++dst < 2)
  582. && ((result->tm_isdst = tm_isdst(result, tzi)) != 0));
  583. return result;
  584. }
  585. #endif
  586. /**********************************************************************/
  587. #ifdef L_mktime
  588. /* Another name for `mktime'. */
  589. /* time_t timelocal(struct tm *tp) */
  590. weak_alias(mktime,timelocal);
  591. time_t mktime(struct tm *timeptr)
  592. {
  593. return _time_mktime(timeptr, 1);
  594. }
  595. #endif
  596. /**********************************************************************/
  597. #ifdef L_timegm
  598. /* Like `mktime' but timeptr represents Universal Time, not local time. */
  599. time_t timegm(struct tm *timeptr)
  600. {
  601. rule_struct gmt_tzinfo[2];
  602. memset(gmt_tzinfo, 0, sizeof(gmt_tzinfo));
  603. strcpy(gmt_tzinfo[0].tzname, "GMT"); /* Match glibc behavior here. */
  604. return _time_mktime_tzi(timeptr, 1, gmt_tzinfo);
  605. }
  606. #endif
  607. /**********************************************************************/
  608. #if defined(L_strftime) || defined(L_strftime_l)
  609. #if defined(__UCLIBC_HAS_XLOCALE__) && !defined(__UCLIBC_DO_XLOCALE)
  610. size_t strftime(char *__restrict s, size_t maxsize,
  611. const char *__restrict format,
  612. const struct tm *__restrict timeptr)
  613. {
  614. return __strftime_l(s, maxsize, format, timeptr, __UCLIBC_CURLOCALE);
  615. }
  616. #else /* defined(__UCLIBC_HAS_XLOCALE__) && !defined(__UCLIBC_DO_XLOCALE) */
  617. #define NO_E_MOD 0x80
  618. #define NO_O_MOD 0x40
  619. #define ILLEGAL_SPEC 0x3f
  620. #define INT_SPEC 0x00 /* must be 0x00!! */
  621. #define STRING_SPEC 0x10 /* must be 0x10!! */
  622. #define CALC_SPEC 0x20
  623. #define STACKED_SPEC 0x30
  624. #define MASK_SPEC 0x30
  625. /* Compatibility:
  626. *
  627. * No alternate digit (%O?) handling. Always uses 0-9.
  628. * Alternate locale format (%E?) handling is broken for nontrivial ERAs.
  629. * glibc's %P is currently faked by %p. This means it doesn't do lower case.
  630. * glibc's %k, %l, and %s are handled.
  631. * glibc apparently allows (and ignores) extraneous 'E' and 'O' modifiers,
  632. * while they are flagged as illegal conversions here.
  633. */
  634. /* Warning: Assumes ASCII values! (as do lots of other things in the lib...) */
  635. static const unsigned char spec[] = {
  636. /* A */ 0x03 | STRING_SPEC | NO_E_MOD | NO_O_MOD,
  637. /* B */ 0x04 | STRING_SPEC | NO_E_MOD | NO_O_MOD,
  638. /* C */ 0x0a | INT_SPEC | NO_O_MOD,
  639. /* D */ 0x02 | STACKED_SPEC | NO_E_MOD | NO_O_MOD,
  640. /* E */ ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
  641. /* F */ 0x03 | STACKED_SPEC | NO_E_MOD | NO_O_MOD,
  642. /* G */ 0x03 | CALC_SPEC | NO_E_MOD | NO_O_MOD,
  643. /* H */ 0x0b | INT_SPEC | NO_E_MOD,
  644. /* I */ 0x0c | INT_SPEC | NO_E_MOD,
  645. /* J */ ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
  646. /* K */ ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
  647. /* L */ ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
  648. /* M */ 0x0d | INT_SPEC | NO_E_MOD,
  649. /* N */ ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
  650. /* O */ ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
  651. /* P */ 0x05 | STRING_SPEC | NO_E_MOD | NO_O_MOD, /* glibc ; use %p */
  652. /* Q */ ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
  653. /* R */ 0x04 | STACKED_SPEC | NO_E_MOD | NO_O_MOD,
  654. /* S */ 0x0e | INT_SPEC | NO_E_MOD,
  655. /* T */ 0x05 | STACKED_SPEC | NO_E_MOD | NO_O_MOD,
  656. /* U */ 0x04 | CALC_SPEC | NO_E_MOD,
  657. /* V */ 0x05 | CALC_SPEC | NO_E_MOD,
  658. /* W */ 0x06 | CALC_SPEC | NO_E_MOD,
  659. /* X */ 0x0a | STACKED_SPEC | NO_O_MOD,
  660. /* Y */ 0x0f | INT_SPEC | NO_O_MOD,
  661. /* Z */ 0x01 | CALC_SPEC | NO_E_MOD | NO_O_MOD,
  662. '?', /* 26 */
  663. '?', /* 27 */
  664. '?', /* 28 */
  665. '?', /* 29 */
  666. 0, /* 30 */
  667. 0, /* 31 */
  668. /* a */ 0x00 | STRING_SPEC | NO_E_MOD | NO_O_MOD,
  669. /* b */ 0x01 | STRING_SPEC | NO_E_MOD | NO_O_MOD,
  670. /* c */ 0x08 | STACKED_SPEC | NO_O_MOD,
  671. /* d */ 0x00 | INT_SPEC | NO_E_MOD,
  672. /* e */ 0x01 | INT_SPEC | NO_E_MOD,
  673. /* f */ ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
  674. /* g */ 0x02 | CALC_SPEC | NO_E_MOD | NO_O_MOD,
  675. /* h */ 0x01 | STRING_SPEC | NO_E_MOD | NO_O_MOD, /* same as b */
  676. /* i */ ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
  677. /* j */ 0x08 | INT_SPEC | NO_E_MOD | NO_O_MOD,
  678. /* k */ 0x03 | INT_SPEC | NO_E_MOD | NO_O_MOD, /* glibc */
  679. /* l */ 0x04 | INT_SPEC | NO_E_MOD | NO_O_MOD, /* glibc */
  680. /* m */ 0x05 | INT_SPEC | NO_E_MOD,
  681. /* n */ 0x00 | STACKED_SPEC | NO_E_MOD | NO_O_MOD,
  682. /* o */ ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
  683. /* p */ 0x02 | STRING_SPEC | NO_E_MOD | NO_O_MOD,
  684. /* q */ ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
  685. /* r */ 0x0b | STACKED_SPEC | NO_E_MOD | NO_O_MOD,
  686. /* s */ 0x07 | CALC_SPEC | NO_E_MOD | NO_O_MOD, /* glibc */
  687. /* t */ 0x01 | STACKED_SPEC | NO_E_MOD | NO_O_MOD,
  688. /* u */ 0x07 | INT_SPEC | NO_E_MOD,
  689. /* v */ ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
  690. /* w */ 0x02 | INT_SPEC | NO_E_MOD,
  691. /* x */ 0x09 | STACKED_SPEC | NO_O_MOD,
  692. /* y */ 0x09 | INT_SPEC,
  693. /* z */ 0x00 | CALC_SPEC | NO_E_MOD | NO_O_MOD,
  694. /* WARNING!!! These are dependent on the layout of struct tm!!! */
  695. #define FIELD_MAX (26+6+26)
  696. 60 /* 61? */, 59, 23, 31, 11, 0 /* 9999 */, 6, 0 /* 365 */,
  697. #define TP_OFFSETS (FIELD_MAX+8)
  698. 3, /* d */
  699. 3, /* e */
  700. 6, /* w */
  701. 2, /* k */
  702. 2, /* l */
  703. 4, /* m */
  704. 0, /* CURRENTLY UNUSED */
  705. /* NOTE: u,j,y order must be preserved as 6,7,5 seq is used in the code! */
  706. #define CALC_OFFSETS (TP_OFFSETS + 7)
  707. 6, /* u */
  708. 7, /* j */
  709. 5, /* y */
  710. 5, /* C */
  711. 2, /* H */
  712. 2, /* I */
  713. 1, /* M */
  714. 0, /* S */
  715. 5, /* Y */
  716. 6, /* a */
  717. 4, /* b, h */
  718. 2, /* p */
  719. 6, /* A */
  720. 4, /* B */
  721. 2, /* P */
  722. #define TP_CODES (TP_OFFSETS + 16 + 6)
  723. 2 | 16, /* d */
  724. 2, /* e */
  725. 0 | 16, /* w */
  726. 2, /* k */
  727. 2 | 32 | 0, /* l */
  728. 2 | 16 | 1, /* m */
  729. 0, /* CURRENTLY UNUSED */
  730. 0 | 16 | 8 , /* u */
  731. 4 | 16 | 1, /* j */
  732. 2 | 128 | 32 | 16 , /* y */
  733. 2 | 128 | 64 | 32 | 16 , /* C */
  734. 2 | 16, /* H */
  735. 2 | 32 | 16 | 0, /* I */
  736. 2 | 16, /* M */
  737. 2 | 16, /* S */
  738. 6 | 16, /* Y */
  739. 2, /* a */
  740. 2, /* b, h */
  741. 2 | 64, /* p */
  742. 2, /* A */
  743. 2, /* B */
  744. 2 | 64, /* P */
  745. #define STRINGS_NL_ITEM_START (TP_CODES + 16 + 6)
  746. _NL_ITEM_INDEX(ABDAY_1), /* a */
  747. _NL_ITEM_INDEX(ABMON_1), /* b, h */
  748. _NL_ITEM_INDEX(AM_STR), /* p */
  749. _NL_ITEM_INDEX(DAY_1), /* A */
  750. _NL_ITEM_INDEX(MON_1), /* B */
  751. _NL_ITEM_INDEX(AM_STR), /* P -- wrong! need lower case */
  752. #define STACKED_STRINGS_START (STRINGS_NL_ITEM_START+6)
  753. 6, 7, 8, 16, 24, 29, /* 6 - offsets from offset-count to strings */
  754. '\n', 0, /* 2 */
  755. '\t', 0, /* 2 */
  756. '%', 'm', '/', '%', 'd', '/', '%', 'y', 0, /* 9 - %D */
  757. '%', 'Y', '-', '%', 'm', '-', '%', 'd', 0, /* 9 - %F (glibc extension) */
  758. '%', 'H', ':', '%', 'M', 0, /* 6 - %R*/
  759. '%', 'H', ':', '%', 'M', ':', '%', 'S', 0, /* 9 - %T */
  760. #define STACKED_STRINGS_NL_ITEM_START (STACKED_STRINGS_START + 43)
  761. _NL_ITEM_INDEX(D_T_FMT), /* c */
  762. _NL_ITEM_INDEX(D_FMT), /* x */
  763. _NL_ITEM_INDEX(T_FMT), /* X */
  764. _NL_ITEM_INDEX(T_FMT_AMPM), /* r */
  765. #ifdef ENABLE_ERA_CODE
  766. _NL_ITEM_INDEX(ERA_D_T_FMT), /* Ec */
  767. _NL_ITEM_INDEX(ERA_D_FMT), /* Ex */
  768. _NL_ITEM_INDEX(ERA_T_FMT), /* EX */
  769. #endif
  770. };
  771. static int load_field(int k, const struct tm *__restrict timeptr)
  772. {
  773. int r;
  774. int r_max;
  775. r = ((int *) timeptr)[k];
  776. r_max = spec[FIELD_MAX + k];
  777. if (k == 7) {
  778. r_max = 365;
  779. } else if (k == 5) {
  780. r += 1900;
  781. r_max = 9999;
  782. }
  783. if ((((unsigned int) r) > r_max) || ((k == 3) && !r)) {
  784. r = -1;
  785. }
  786. return r;
  787. }
  788. #define MAX_PUSH 4
  789. #ifdef __UCLIBC_MJN3_ONLY__
  790. #warning TODO: Check multibyte format string validity.
  791. #endif
  792. size_t __XL(strftime)(char *__restrict s, size_t maxsize,
  793. const char *__restrict format,
  794. const struct tm *__restrict timeptr __LOCALE_PARAM )
  795. {
  796. long tzo;
  797. register const char *p;
  798. register const char *o;
  799. #ifndef __UCLIBC_HAS_TM_EXTENSIONS__
  800. const rule_struct *rsp;
  801. #endif
  802. const char *stack[MAX_PUSH];
  803. size_t count;
  804. size_t o_count;
  805. int field_val, i, j, lvl;
  806. int x[3]; /* wday, yday, year */
  807. int isofm, days;
  808. char buf[__UIM_BUFLEN_LONG];
  809. unsigned char mod;
  810. unsigned char code;
  811. tzset(); /* We'll, let's get this out of the way. */
  812. lvl = 0;
  813. p = format;
  814. count = maxsize;
  815. LOOP:
  816. if (!count) {
  817. return 0;
  818. }
  819. if (!*p) {
  820. if (lvl == 0) {
  821. *s = 0; /* nul-terminate */
  822. return maxsize - count;
  823. }
  824. p = stack[--lvl];
  825. goto LOOP;
  826. }
  827. o_count = 1;
  828. if ((*(o = p) == '%') && (*++p != '%')) {
  829. o_count = 2;
  830. mod = ILLEGAL_SPEC;
  831. if ((*p == 'O') || (*p == 'E')) { /* modifier */
  832. mod |= ((*p == 'O') ? NO_O_MOD : NO_E_MOD);
  833. ++o_count;
  834. ++p;
  835. }
  836. if ((((unsigned char)(((*p) | 0x20) - 'a')) >= 26)
  837. || (((code = spec[(int)(*p - 'A')]) & mod) >= ILLEGAL_SPEC)
  838. ) {
  839. if (!*p) {
  840. --p;
  841. --o_count;
  842. }
  843. goto OUTPUT;
  844. }
  845. code &= ILLEGAL_SPEC; /* modifiers are preserved in mod var. */
  846. if ((code & MASK_SPEC) == STACKED_SPEC) {
  847. if (lvl == MAX_PUSH) {
  848. goto OUTPUT; /* Stack full so treat as illegal spec. */
  849. }
  850. stack[lvl++] = ++p;
  851. if ((code &= 0xf) < 8) {
  852. p = ((const char *) spec) + STACKED_STRINGS_START + code;
  853. p += *((unsigned char *)p);
  854. goto LOOP;
  855. }
  856. p = ((const char *) spec) + STACKED_STRINGS_NL_ITEM_START
  857. + (code & 7);
  858. #ifdef ENABLE_ERA_CODE
  859. if ((mod & NO_E_MOD) /* Actually, this means E modifier present. */
  860. && (*(o = __XL(nl_langinfo)(_NL_ITEM(LC_TIME,
  861. (int)(((unsigned char *)p)[4]))
  862. __LOCALE_ARG
  863. )))
  864. ) {
  865. p = o;
  866. goto LOOP;
  867. }
  868. #endif
  869. p = __XL(nl_langinfo)(_NL_ITEM(LC_TIME,
  870. (int)(*((unsigned char *)p)))
  871. __LOCALE_ARG
  872. );
  873. goto LOOP;
  874. }
  875. o = spec + 26; /* set to "????" */
  876. if ((code & MASK_SPEC) == CALC_SPEC) {
  877. if (*p == 's') {
  878. time_t t;
  879. /* Use a cast to silence the warning since *timeptr won't
  880. * be changed. */
  881. if ((t = _time_mktime((struct tm *) timeptr, 0))
  882. == ((time_t) -1)
  883. ) {
  884. o_count = 1;
  885. goto OUTPUT;
  886. }
  887. #ifdef TIME_T_IS_UNSIGNED
  888. o = _uintmaxtostr(buf + sizeof(buf) - 1,
  889. (uintmax_t) t,
  890. 10, __UIM_DECIMAL);
  891. #else
  892. o = _uintmaxtostr(buf + sizeof(buf) - 1,
  893. (uintmax_t) t,
  894. -10, __UIM_DECIMAL);
  895. #endif
  896. o_count = sizeof(buf);
  897. goto OUTPUT;
  898. } else if (((*p) | 0x20) == 'z') { /* 'z' or 'Z' */
  899. if (timeptr->tm_isdst < 0) {
  900. /* SUSv3 specifies this behavior for 'z', but we'll also
  901. * treat it as "no timezone info" for 'Z' too. */
  902. o_count = 0;
  903. goto OUTPUT;
  904. }
  905. #ifdef __UCLIBC_HAS_TM_EXTENSIONS__
  906. #define RSP_TZUNLOCK ((void) 0)
  907. #define RSP_TZNAME timeptr->tm_zone
  908. #define RSP_GMT_OFFSET timeptr->tm_gmtoff
  909. #else
  910. #define RSP_TZUNLOCK TZUNLOCK
  911. #define RSP_TZNAME rsp->tzname
  912. #define RSP_GMT_OFFSET rsp->gmt_offset
  913. TZLOCK;
  914. rsp = _time_tzinfo;
  915. if (timeptr->tm_isdst > 0) {
  916. ++rsp;
  917. }
  918. #endif
  919. if (*p == 'Z') {
  920. o = RSP_TZNAME;
  921. assert(o != NULL);
  922. #if 0
  923. if (!o) { /* PARANOIA */
  924. o = spec+30; /* empty string */
  925. }
  926. #endif
  927. o_count = SIZE_MAX;
  928. RSP_TZUNLOCK;
  929. goto OUTPUT;
  930. } else { /* z */
  931. *s = '+';
  932. if ((tzo = -RSP_GMT_OFFSET) < 0) {
  933. tzo = -tzo;
  934. *s = '-';
  935. }
  936. RSP_TZUNLOCK;
  937. ++s;
  938. --count;
  939. i = tzo / 60;
  940. field_val = ((i / 60) * 100) + (i % 60);
  941. i = 16 + 6; /* 0-fill, width = 4 */
  942. }
  943. } else {
  944. /* TODO: don't need year for U, W */
  945. for (i=0 ; i < 3 ; i++) {
  946. if ((x[i] = load_field(spec[CALC_OFFSETS+i],timeptr)) < 0) {
  947. goto OUTPUT;
  948. }
  949. }
  950. i = 16 + 2; /* 0-fill, width = 2 */
  951. if ((*p == 'U') || (*p == 'W')) {
  952. field_val = ((x[1] - x[0]) + 7);
  953. if (*p == 'W') {
  954. ++field_val;
  955. }
  956. field_val /= 7;
  957. if ((*p == 'W') && !x[0]) {
  958. --field_val;
  959. }
  960. } else { /* ((*p == 'g') || (*p == 'G') || (*p == 'V')) */
  961. ISO_LOOP:
  962. isofm = (((x[1] - x[0]) + 11) % 7) - 3; /* [-3,3] */
  963. if (x[1] < isofm) { /* belongs to previous year */
  964. --x[2];
  965. x[1] += 365 + __isleap(x[2]);
  966. goto ISO_LOOP;
  967. }
  968. field_val = ((x[1] - isofm) / 7) + 1; /* week # */
  969. days = 365 + __isleap(x[2]);
  970. isofm = ((isofm + 7*53 + 3 - days)) %7 + days - 3; /* next year */
  971. if (x[1] >= isofm) { /* next year */
  972. x[1] -= days;
  973. ++x[2];
  974. goto ISO_LOOP;
  975. }
  976. if (*p != 'V') { /* need year */
  977. field_val = x[2]; /* TODO: what if x[2] now 10000 ?? */
  978. if (*p == 'g') {
  979. field_val %= 100;
  980. } else {
  981. i = 16 + 6; /* 0-fill, width = 4 */
  982. }
  983. }
  984. }
  985. }
  986. } else {
  987. i = TP_OFFSETS + (code & 0x1f);
  988. if ((field_val = load_field(spec[i],timeptr)) < 0) {
  989. goto OUTPUT;
  990. }
  991. i = spec[i+(TP_CODES - TP_OFFSETS)];
  992. j = (i & 128) ? 100: 12;
  993. if (i & 64) {
  994. field_val /= j;;
  995. }
  996. if (i & 32) {
  997. field_val %= j;
  998. if (((i&128) + field_val) == 0) { /* mod 12? == 0 */
  999. field_val = j; /* set to 12 */
  1000. }
  1001. }
  1002. field_val += (i & 1);
  1003. if ((i & 8) && !field_val) {
  1004. field_val += 7;
  1005. }
  1006. }
  1007. if ((code & MASK_SPEC) == STRING_SPEC) {
  1008. o_count = SIZE_MAX;
  1009. field_val += spec[STRINGS_NL_ITEM_START + (code & 0xf)];
  1010. o = __XL(nl_langinfo)(_NL_ITEM(LC_TIME, field_val) __LOCALE_ARG );
  1011. } else {
  1012. o_count = ((i >> 1) & 3) + 1;
  1013. o = buf + o_count;
  1014. do {
  1015. *(char *)(--o) = '0' + (field_val % 10);
  1016. field_val /= 10;
  1017. } while (o > buf);
  1018. if (*buf == '0') {
  1019. *buf = ' ' + (i & 16);
  1020. }
  1021. }
  1022. }
  1023. OUTPUT:
  1024. ++p;
  1025. while (o_count && count && *o) {
  1026. *s++ = *o++;
  1027. --o_count;
  1028. --count;
  1029. }
  1030. goto LOOP;
  1031. }
  1032. __XL_ALIAS(strftime)
  1033. #endif /* defined(__UCLIBC_HAS_XLOCALE__) && !defined(__UCLIBC_DO_XLOCALE) */
  1034. #endif
  1035. /**********************************************************************/
  1036. #if defined(L_strptime) || defined(L_strptime_l)
  1037. #if defined(L_strptime) || defined(L_strptime_l)
  1038. #define ISDIGIT(C) __isdigit_char((C))
  1039. #endif
  1040. #ifdef __UCLIBC_DO_XLOCALE
  1041. #define ISSPACE(C) isspace_l((C), locale_arg)
  1042. #else
  1043. #define ISSPACE(C) isspace((C))
  1044. #endif
  1045. #if defined(__UCLIBC_HAS_XLOCALE__) && !defined(__UCLIBC_DO_XLOCALE)
  1046. char *strptime(const char *__restrict buf, const char *__restrict format,
  1047. struct tm *__restrict tm)
  1048. {
  1049. return __strptime_l(buf, format, tm, __UCLIBC_CURLOCALE);
  1050. }
  1051. #else /* defined(__UCLIBC_HAS_XLOCALE__) && !defined(__UCLIBC_DO_XLOCALE) */
  1052. /* TODO:
  1053. * 1) %l and %k are space-padded, so "%l" by itself fails while " %l" succeeds.
  1054. * Both work for glibc. So, should we always strip spaces?
  1055. * 2) %Z
  1056. */
  1057. /* Notes:
  1058. * There are several differences between this strptime and glibc's strptime.
  1059. * 1) glibc strips leading space before numeric conversions.
  1060. * 2) glibc will read fields without whitespace in between. SUSv3 states
  1061. * that you must have whitespace between conversion operators. Besides,
  1062. * how do you know how long a number should be if there are leading 0s?
  1063. * 3) glibc attempts to compute some the struct tm fields based on the
  1064. * data retrieved; tm_wday in particular. I don't as I consider it
  1065. * another glibc attempt at mind-reading...
  1066. */
  1067. #define NO_E_MOD 0x80
  1068. #define NO_O_MOD 0x40
  1069. #define ILLEGAL_SPEC 0x3f
  1070. #define INT_SPEC 0x00 /* must be 0x00!! */
  1071. #define STRING_SPEC 0x10 /* must be 0x10!! */
  1072. #define CALC_SPEC 0x20
  1073. #define STACKED_SPEC 0x30
  1074. #define MASK_SPEC 0x30
  1075. /* Warning: Assumes ASCII values! (as do lots of other things in the lib...) */
  1076. static const unsigned char spec[] = {
  1077. /* A */ 0x02 | STRING_SPEC | NO_E_MOD | NO_O_MOD,
  1078. /* B */ 0x01 | STRING_SPEC | NO_E_MOD | NO_O_MOD,
  1079. /* C */ 0x08 | INT_SPEC | NO_O_MOD,
  1080. /* D */ 0x01 | STACKED_SPEC | NO_E_MOD | NO_O_MOD,
  1081. /* E */ ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
  1082. /* F */ 0x02 | STACKED_SPEC | NO_E_MOD | NO_O_MOD, /* glibc */
  1083. /* G */ 0x0f | INT_SPEC | NO_E_MOD | NO_O_MOD, /* glibc */
  1084. /* H */ 0x06 | INT_SPEC | NO_E_MOD,
  1085. /* I */ 0x07 | INT_SPEC | NO_E_MOD,
  1086. /* J */ ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
  1087. /* K */ ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
  1088. /* L */ ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
  1089. /* M */ 0x04 | INT_SPEC | NO_E_MOD,
  1090. /* N */ ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
  1091. /* O */ ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
  1092. /* P */ 0x00 | STRING_SPEC | NO_E_MOD | NO_O_MOD, /* glibc */
  1093. /* Q */ ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
  1094. /* R */ 0x03 | STACKED_SPEC | NO_E_MOD | NO_O_MOD,
  1095. /* S */ 0x05 | INT_SPEC | NO_E_MOD,
  1096. /* T */ 0x04 | STACKED_SPEC | NO_E_MOD | NO_O_MOD,
  1097. /* U */ 0x0c | INT_SPEC | NO_E_MOD,
  1098. /* V */ 0x0d | INT_SPEC | NO_E_MOD | NO_O_MOD, /* glibc */
  1099. /* W */ 0x0c | INT_SPEC | NO_E_MOD,
  1100. /* X */ 0x0a | STACKED_SPEC | NO_O_MOD,
  1101. /* Y */ 0x0a | INT_SPEC | NO_O_MOD,
  1102. /* Z */ 0x02 | CALC_SPEC | NO_E_MOD | NO_O_MOD, /* glibc */
  1103. /* WARNING! This assumes orderings:
  1104. * AM,PM
  1105. * ABDAY_1-ABDAY-7,DAY_1-DAY_7
  1106. * ABMON_1-ABMON_12,MON_1-MON12
  1107. * Also, there are exactly 6 bytes between 'Z' and 'a'.
  1108. */
  1109. #define STRINGS_NL_ITEM_START (26)
  1110. _NL_ITEM_INDEX(AM_STR), /* p (P) */
  1111. _NL_ITEM_INDEX(ABMON_1), /* B, b */
  1112. _NL_ITEM_INDEX(ABDAY_1), /* A, a */
  1113. 2,
  1114. 24,
  1115. 14,
  1116. /* a */ 0x02 | STRING_SPEC | NO_E_MOD | NO_O_MOD,
  1117. /* b */ 0x01 | STRING_SPEC | NO_E_MOD | NO_O_MOD,
  1118. /* c */ 0x08 | STACKED_SPEC | NO_O_MOD,
  1119. /* d */ 0x00 | INT_SPEC | NO_E_MOD,
  1120. /* e */ 0x00 | INT_SPEC | NO_E_MOD,
  1121. /* f */ ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
  1122. /* g */ 0x0e | INT_SPEC | NO_E_MOD | NO_O_MOD, /* glibc */
  1123. /* h */ 0x01 | STRING_SPEC | NO_E_MOD | NO_O_MOD,
  1124. /* i */ ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
  1125. /* j */ 0x01 | INT_SPEC | NO_E_MOD | NO_O_MOD,
  1126. /* k */ 0x06 | INT_SPEC | NO_E_MOD, /* glibc */
  1127. /* l */ 0x07 | INT_SPEC | NO_E_MOD, /* glibc */
  1128. /* m */ 0x02 | INT_SPEC | NO_E_MOD,
  1129. /* n */ 0x00 | STACKED_SPEC | NO_E_MOD | NO_O_MOD,
  1130. /* o */ ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
  1131. /* p */ 0x00 | STRING_SPEC | NO_E_MOD | NO_O_MOD,
  1132. /* q */ ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
  1133. /* r */ 0x0b | STACKED_SPEC | NO_E_MOD | NO_O_MOD,
  1134. /* s */ 0x00 | CALC_SPEC | NO_E_MOD | NO_O_MOD, /* glibc */
  1135. /* t */ 0x00 | STACKED_SPEC | NO_E_MOD | NO_O_MOD,
  1136. /* u */ 0x0b | INT_SPEC | NO_E_MOD | NO_O_MOD, /* glibc */
  1137. /* v */ ILLEGAL_SPEC | NO_E_MOD | NO_O_MOD,
  1138. /* w */ 0x03 | INT_SPEC | NO_E_MOD,
  1139. /* x */ 0x09 | STACKED_SPEC | NO_O_MOD,
  1140. /* y */ 0x09 | INT_SPEC,
  1141. /* z */ 0x01 | CALC_SPEC | NO_E_MOD | NO_O_MOD, /* glibc */
  1142. #define INT_FIELD_START (26+6+26)
  1143. /* (field #) << 3 + lower bound (0|1) + correction 0:none, 2:-1, 4:-1900
  1144. * followed by upper bound prior to correction with 1=>366 and 2=>9999. */
  1145. /* d, e */ (3 << 3) + 1 + 0, 31,
  1146. /* j */ (7 << 3) + 1 + 2, /* 366 */ 1,
  1147. /* m */ (4 << 3) + 1 + 2, 12,
  1148. /* w */ (6 << 3) + 0 + 0, 6,
  1149. /* M */ (1 << 3) + 0 + 0, 59,
  1150. /* S */ 0 + 0 + 0, 60,
  1151. /* H (k) */ (2 << 3) + 0 + 0, 23,
  1152. /* I (l) */ (9 << 3) + 1 + 0, 12, /* goes with 8 -- am/pm */
  1153. /* C */ (10<< 3) + 0 + 0, 99,
  1154. /* y */ (11<< 3) + 0 + 0, 99,
  1155. /* Y */ (5 << 3) + 0 + 4, /* 9999 */ 2,
  1156. /* u */ (6 << 3) + 1 + 0, 7,
  1157. /* The following are processed and range-checked, but ignored otherwise. */
  1158. /* U, W */ (12<< 3) + 0 + 0, 53,
  1159. /* V */ (12<< 3) + 1 + 0, 53,
  1160. /* g */ (12<< 3) + 0 + 0, 99,
  1161. /* G */ (12<< 3) + 0 /*+ 4*/, /* 9999 */ 2, /* Note: -1 or 10000? */
  1162. #define STACKED_STRINGS_START (INT_FIELD_START+32)
  1163. 5, 6, 14, 22, 27, /* 5 - offsets from offset-count to strings */
  1164. ' ', 0, /* 2 - %n or %t */
  1165. '%', 'm', '/', '%', 'd', '/', '%', 'y', 0, /* 9 - %D */
  1166. '%', 'Y', '-', '%', 'm', '-', '%', 'd', 0, /* 9 - %F (glibc extension) */
  1167. '%', 'H', ':', '%', 'M', 0, /* 6 - %R*/
  1168. '%', 'H', ':', '%', 'M', ':', '%', 'S', 0, /* 9 - %T */
  1169. #define STACKED_STRINGS_NL_ITEM_START (STACKED_STRINGS_START + 40)
  1170. _NL_ITEM_INDEX(D_T_FMT), /* c */
  1171. _NL_ITEM_INDEX(D_FMT), /* x */
  1172. _NL_ITEM_INDEX(T_FMT), /* X */
  1173. _NL_ITEM_INDEX(T_FMT_AMPM), /* r */
  1174. #ifdef ENABLE_ERA_CODE
  1175. _NL_ITEM_INDEX(ERA_D_T_FMT), /* Ec */
  1176. _NL_ITEM_INDEX(ERA_D_FMT), /* Ex */
  1177. _NL_ITEM_INDEX(ERA_T_FMT), /* EX */
  1178. #endif
  1179. };
  1180. #define MAX_PUSH 4
  1181. char *__XL(strptime)(const char *__restrict buf, const char *__restrict format,
  1182. struct tm *__restrict tm __LOCALE_PARAM)
  1183. {
  1184. register const char *p;
  1185. char *o;
  1186. const char *stack[MAX_PUSH];
  1187. int i, j, lvl;
  1188. int fields[13];
  1189. unsigned char mod;
  1190. unsigned char code;
  1191. i = 0;
  1192. do {
  1193. fields[i] = INT_MIN;
  1194. } while (++i < 13);
  1195. lvl = 0;
  1196. p = format;
  1197. LOOP:
  1198. if (!*p) {
  1199. if (lvl == 0) { /* Done. */
  1200. if (fields[6] == 7) { /* Cleanup for %u here since just once. */
  1201. fields[6] = 0; /* Don't use mod in case unset. */
  1202. }
  1203. i = 0;
  1204. do { /* Store the values into tm. */
  1205. ((int *) tm)[i] = fields[i];
  1206. } while (++i < 8);
  1207. return (char *) buf; /* Success. */
  1208. }
  1209. p = stack[--lvl];
  1210. goto LOOP;
  1211. }
  1212. if ((*p == '%') && (*++p != '%')) {
  1213. mod = ILLEGAL_SPEC;
  1214. if ((*p == 'O') || (*p == 'E')) { /* Modifier? */
  1215. mod |= ((*p == 'O') ? NO_O_MOD : NO_E_MOD);
  1216. ++p;
  1217. }
  1218. if (!*p
  1219. || (((unsigned char)(((*p) | 0x20) - 'a')) >= 26)
  1220. || (((code = spec[(int)(*p - 'A')]) & mod) >= ILLEGAL_SPEC)
  1221. ) {
  1222. return NULL; /* Illegal spec. */
  1223. }
  1224. if ((code & MASK_SPEC) == STACKED_SPEC) {
  1225. if (lvl == MAX_PUSH) {
  1226. return NULL; /* Stack full so treat as illegal spec. */
  1227. }
  1228. stack[lvl++] = ++p;
  1229. if ((code &= 0xf) < 8) {
  1230. p = ((const char *) spec) + STACKED_STRINGS_START + code;
  1231. p += *((unsigned char *)p);
  1232. goto LOOP;
  1233. }
  1234. p = ((const char *) spec) + STACKED_STRINGS_NL_ITEM_START
  1235. + (code & 7);
  1236. #ifdef ENABLE_ERA_CODE
  1237. if ((mod & NO_E_MOD) /* Actually, this means E modifier present. */
  1238. && (*(o = __XL(nl_langinfo)(_NL_ITEM(LC_TIME,
  1239. (int)(((unsigned char *)p)[4]))
  1240. __LOCALE_ARG
  1241. )))
  1242. ) {
  1243. p = o;
  1244. goto LOOP;
  1245. }
  1246. #endif
  1247. p = __XL(nl_langinfo)(_NL_ITEM(LC_TIME,
  1248. (int)(*((unsigned char *)p)))
  1249. __LOCALE_ARG );
  1250. goto LOOP;
  1251. }
  1252. ++p;
  1253. if ((code & MASK_SPEC) == STRING_SPEC) {
  1254. code &= 0xf;
  1255. j = spec[STRINGS_NL_ITEM_START + 3 + code];
  1256. i = _NL_ITEM(LC_TIME, spec[STRINGS_NL_ITEM_START + code]);
  1257. /* Go backwards to check full names before abreviations. */
  1258. do {
  1259. --j;
  1260. o = __XL(nl_langinfo)(i+j __LOCALE_ARG);
  1261. if (!__XL(strncasecmp)(buf,o,strlen(o) __LOCALE_ARG) && *o) {
  1262. do { /* Found a match. */
  1263. ++buf;
  1264. } while (*++o);
  1265. if (!code) { /* am/pm */
  1266. fields[8] = j * 12;
  1267. if (fields[9] >= 0) { /* We have a previous %I or %l. */
  1268. fields[2] = fields[9] + fields[8];
  1269. }
  1270. } else { /* day (4) or month (6) */
  1271. fields[2 + (code << 1)]
  1272. = j % (spec[STRINGS_NL_ITEM_START + 3 + code] >> 1);
  1273. }
  1274. goto LOOP;
  1275. }
  1276. } while (j);
  1277. return NULL; /* Failed to match. */
  1278. }
  1279. if ((code & MASK_SPEC) == CALC_SPEC) {
  1280. if ((code &= 0xf) < 1) { /* s or z*/
  1281. time_t t;
  1282. o = (char *) buf;
  1283. i = errno;
  1284. __set_errno(0);
  1285. if (!ISSPACE(*buf)) { /* Signal an error if whitespace. */
  1286. #ifdef TIME_T_IS_UNSIGNED
  1287. t = __XL(strtoul)(buf, &o, 10 __LOCALE_ARG);
  1288. #else
  1289. t = __XL(strtol)(buf, &o, 10 __LOCALE_ARG);
  1290. #endif
  1291. }
  1292. if ((o == buf) || errno) { /* Not a number or overflow. */
  1293. return NULL;
  1294. }
  1295. __set_errno(i); /* Restore errno. */
  1296. buf = o;
  1297. if (!code) { /* s */
  1298. localtime_r(&t, tm); /* TODO: check for failure? */
  1299. i = 0;
  1300. do { /* Now copy values from tm to fields. */
  1301. fields[i] = ((int *) tm)[i];
  1302. } while (++i < 8);
  1303. }
  1304. }
  1305. /* TODO: glibc treats %Z as a nop. For now, do the same. */
  1306. goto LOOP;
  1307. }
  1308. assert((code & MASK_SPEC) == INT_SPEC);
  1309. {
  1310. register const unsigned char *x;
  1311. code &= 0xf;
  1312. x = spec + INT_FIELD_START + (code << 1);
  1313. if ((j = x[1]) < 3) { /* upper bound (inclusive) */
  1314. j = ((j==1) ? 366 : 9999);
  1315. }
  1316. i = -1;
  1317. while (ISDIGIT(*buf)) {
  1318. if (i < 0) {
  1319. i = 0;
  1320. }
  1321. if ((i = 10*i + (*buf - '0')) > j) { /* Overflow. */
  1322. return NULL;
  1323. }
  1324. ++buf;
  1325. }
  1326. if (i < (*x & 1)) { /* This catches no-digit case too. */
  1327. return NULL;
  1328. }
  1329. if (*x & 2) {
  1330. --i;
  1331. }
  1332. if (*x & 4) {
  1333. i -= 1900;
  1334. }
  1335. if (*x == (9 << 3) + 1 + 0) { /* %I or %l */
  1336. if (i == 12) {
  1337. i = 0;
  1338. }
  1339. if (fields[8] >= 0) { /* We have a previous %p or %P. */
  1340. fields[2] = i + fields[8];
  1341. }
  1342. }
  1343. fields[(*x) >> 3] = i;
  1344. if (((unsigned char)(*x - (10<< 3) + 0 + 0)) <= 8) { /* %C or %y */
  1345. if ((j = fields[10]) < 0) { /* No %C, so i must be %y data. */
  1346. if (i <= 68) { /* Map [0-68] to 2000+i */
  1347. i += 100;
  1348. }
  1349. } else { /* Have %C data, but what about %y? */
  1350. if ((i = fields[11]) < 0) { /* No %y data. */
  1351. i = 0; /* Treat %y val as 0 following glibc's example. */
  1352. }
  1353. i += 100*(j - 19);
  1354. }
  1355. fields[5] = i;
  1356. }
  1357. }
  1358. goto LOOP;
  1359. } else if (ISSPACE(*p)) {
  1360. ++p;
  1361. while (ISSPACE(*buf)) {
  1362. ++buf;
  1363. }
  1364. goto LOOP;
  1365. } else if (*buf++ == *p++) {
  1366. goto LOOP;
  1367. }
  1368. return NULL;
  1369. }
  1370. __XL_ALIAS(strptime)
  1371. #endif /* defined(__UCLIBC_HAS_XLOCALE__) && !defined(__UCLIBC_DO_XLOCALE) */
  1372. #endif
  1373. /**********************************************************************/
  1374. #ifdef L_time
  1375. #ifndef __BCC__
  1376. #error The uClibc version of time is in sysdeps/linux/common.
  1377. #endif
  1378. time_t time(register time_t *tloc)
  1379. {
  1380. struct timeval tv;
  1381. register struct timeval *p = &tv;
  1382. gettimeofday(p, NULL); /* This should never fail... */
  1383. if (tloc) {
  1384. *tloc = p->tv_sec;
  1385. }
  1386. return p->tv_sec;
  1387. }
  1388. #endif
  1389. /**********************************************************************/
  1390. #ifdef L_tzset
  1391. static const char vals[] = {
  1392. 'T', 'Z', 0, /* 3 */
  1393. 'U', 'T', 'C', 0, /* 4 */
  1394. 25, 60, 60, 1, /* 4 */
  1395. '.', 1, /* M */
  1396. 5, '.', 1,
  1397. 6, 0, 0, /* Note: overloaded for non-M non-J case... */
  1398. 0, 1, 0, /* J */
  1399. ',', 'M', '4', '.', '1', '.', '0',
  1400. ',', 'M', '1', '0', '.', '5', '.', '0', 0
  1401. };
  1402. #define TZ vals
  1403. #define UTC (vals + 3)
  1404. #define RANGE (vals + 7)
  1405. #define RULE (vals + 11 - 1)
  1406. #define DEFAULT_RULES (vals + 22)
  1407. /* Initialize to UTC. */
  1408. int daylight = 0;
  1409. long timezone = 0;
  1410. char *tzname[2] = { (char *) UTC, (char *) (UTC-1) };
  1411. #ifdef __UCLIBC_HAS_THREADS__
  1412. pthread_mutex_t _time_tzlock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
  1413. #endif
  1414. rule_struct _time_tzinfo[2];
  1415. static const char *getoffset(register const char *e, long *pn)
  1416. {
  1417. register const char *s = RANGE-1;
  1418. long n;
  1419. int f;
  1420. n = 0;
  1421. f = -1;
  1422. do {
  1423. ++s;
  1424. if (__isdigit_char(*e)) {
  1425. f = *e++ - '0';
  1426. }
  1427. if (__isdigit_char(*e)) {
  1428. f = 10 * f + (*e++ - '0');
  1429. }
  1430. if (((unsigned int)f) >= *s) {
  1431. return NULL;
  1432. }
  1433. n = (*s) * n + f;
  1434. f = 0;
  1435. if (*e == ':') {
  1436. ++e;
  1437. --f;
  1438. }
  1439. } while (*s > 1);
  1440. *pn = n;
  1441. return e;
  1442. }
  1443. static const char *getnumber(register const char *e, int *pn)
  1444. {
  1445. #ifdef __BCC__
  1446. /* bcc can optimize the counter if it thinks it is a pointer... */
  1447. register const char *n = (const char *) 3;
  1448. int f;
  1449. f = 0;
  1450. while (n && __isdigit_char(*e)) {
  1451. f = 10 * f + (*e++ - '0');
  1452. --n;
  1453. }
  1454. *pn = f;
  1455. return (n == (const char *) 3) ? NULL : e;
  1456. #else /* __BCC__ */
  1457. int n, f;
  1458. n = 3;
  1459. f = 0;
  1460. while (n && __isdigit_char(*e)) {
  1461. f = 10 * f + (*e++ - '0');
  1462. --n;
  1463. }
  1464. *pn = f;
  1465. return (n == 3) ? NULL : e;
  1466. #endif /* __BCC__ */
  1467. }
  1468. #ifdef __UCLIBC_MJN3_ONLY__
  1469. #warning CONSIDER: Should we preserve errno from open/read/close errors re TZ file?
  1470. #endif
  1471. #ifdef __UCLIBC_HAS_TZ_FILE__
  1472. #ifndef __UCLIBC_HAS_TZ_FILE_READ_MANY__
  1473. static int TZ_file_read; /* Let BSS initialization set this to 0. */
  1474. #endif /* __UCLIBC_HAS_TZ_FILE_READ_MANY__ */
  1475. static char *read_TZ_file(char *buf)
  1476. {
  1477. int fd;
  1478. ssize_t r;
  1479. size_t todo;
  1480. char *p = NULL;
  1481. if ((fd = open(__UCLIBC_TZ_FILE_PATH__, O_RDONLY)) >= 0) {
  1482. todo = TZ_BUFLEN;
  1483. p = buf;
  1484. do {
  1485. if ((r = read(fd, p, todo)) < 0) {
  1486. goto ERROR;
  1487. }
  1488. if (r == 0) {
  1489. break;
  1490. }
  1491. p += r;
  1492. todo -= r;
  1493. } while (todo);
  1494. if ((p > buf) && (p[-1] == '\n')) { /* Must end with newline. */
  1495. p[-1] = 0;
  1496. p = buf;
  1497. #ifndef __UCLIBC_HAS_TZ_FILE_READ_MANY__
  1498. ++TZ_file_read;
  1499. #endif /* __UCLIBC_HAS_TZ_FILE_READ_MANY__ */
  1500. } else {
  1501. ERROR:
  1502. p = NULL;
  1503. }
  1504. close(fd);
  1505. }
  1506. return p;
  1507. }
  1508. #endif /* __UCLIBC_HAS_TZ_FILE__ */
  1509. void tzset(void)
  1510. {
  1511. register const char *e;
  1512. register char *s;
  1513. long off;
  1514. short *p;
  1515. rule_struct new_rules[2];
  1516. int n, count, f;
  1517. char c;
  1518. #ifdef __UCLIBC_HAS_TZ_FILE__
  1519. char buf[TZ_BUFLEN];
  1520. #endif /* __UCLIBC_HAS_TZ_FILE__ */
  1521. #ifdef __UCLIBC_HAS_TZ_CACHING__
  1522. static char oldval[TZ_BUFLEN]; /* BSS-zero'd. */
  1523. #endif /* __UCLIBC_HAS_TZ_CACHING__ */
  1524. TZLOCK;
  1525. e = getenv(TZ); /* TZ env var always takes precedence. */
  1526. #if defined(__UCLIBC_HAS_TZ_FILE__) && !defined(__UCLIBC_HAS_TZ_FILE_READ_MANY__)
  1527. /* Put this inside the lock to prevent the possiblity of two different
  1528. * timezones being used in a threaded app. */
  1529. if (e != NULL) {
  1530. TZ_file_read = 0; /* Reset if the TZ env var is set. */
  1531. } else if (TZ_file_read > 0) {
  1532. goto FAST_DONE;
  1533. }
  1534. #endif /* defined(__UCLIBC_HAS_TZ_FILE__) && !defined(__UCLIBC_HAS_TZ_FILE_READ_MANY__) */
  1535. /* Warning!!! Since uClibc doesn't do lib locking, the following is
  1536. * potentially unsafe in a multi-threaded program since it is remotely
  1537. * possible that another thread could call setenv() for TZ and overwrite
  1538. * the string being parsed. So, don't do that... */
  1539. if ((!e /* TZ env var not set... */
  1540. #ifdef __UCLIBC_HAS_TZ_FILE__
  1541. && !(e = read_TZ_file(buf)) /* and no file or invalid file */
  1542. #endif /* __UCLIBC_HAS_TZ_FILE__ */
  1543. ) || !*e) { /* or set to empty string. */
  1544. ILLEGAL: /* TODO: Clean up the following... */
  1545. #ifdef __UCLIBC_HAS_TZ_CACHING__
  1546. *oldval = 0; /* Set oldval to an empty string. */
  1547. #endif /* __UCLIBC_HAS_TZ_CACHING__ */
  1548. memset(_time_tzinfo, 0, 2*sizeof(rule_struct));
  1549. strcpy(_time_tzinfo[0].tzname, UTC);
  1550. goto DONE;
  1551. }
  1552. if (*e == ':') { /* Ignore leading ':'. */
  1553. ++e;
  1554. }
  1555. #ifdef __UCLIBC_HAS_TZ_CACHING__
  1556. if (strcmp(e, oldval) == 0) { /* Same string as last time... */
  1557. goto FAST_DONE; /* So nothing to do. */
  1558. }
  1559. /* Make a copy of the TZ env string. It won't be nul-terminated if
  1560. * it is too long, but it that case it will be illegal and will be reset
  1561. * to the empty string anyway. */
  1562. strncpy(oldval, e, TZ_BUFLEN);
  1563. #endif /* __UCLIBC_HAS_TZ_CACHING__ */
  1564. count = 0;
  1565. new_rules[1].tzname[0] = 0;
  1566. LOOP:
  1567. /* Get std or dst name. */
  1568. c = 0;
  1569. if (*e == '<') {
  1570. ++e;
  1571. c = '>';
  1572. }
  1573. s = new_rules[count].tzname;
  1574. n = 0;
  1575. while (*e
  1576. && isascii(*e) /* SUSv3 requires char in portable char set. */
  1577. && (isalpha(*e)
  1578. || (c && (isalnum(*e) || (*e == '+') || (*e == '-'))))
  1579. ) {
  1580. *s++ = *e++;
  1581. if (++n > TZNAME_MAX) {
  1582. goto ILLEGAL;
  1583. }
  1584. }
  1585. *s = 0;
  1586. if ((n < 3) /* Check for minimum length. */
  1587. || (c && (*e++ != c)) /* Match any quoting '<'. */
  1588. ) {
  1589. goto ILLEGAL;
  1590. }
  1591. /* Get offset */
  1592. s = (char *) e;
  1593. if ((*e != '-') && (*e != '+')) {
  1594. if (count && !__isdigit_char(*e)) {
  1595. off -= 3600; /* Default to 1 hour ahead of std. */
  1596. goto SKIP_OFFSET;
  1597. }
  1598. --e;
  1599. }
  1600. ++e;
  1601. if (!(e = getoffset(e, &off))) {
  1602. goto ILLEGAL;
  1603. }
  1604. if (*s == '-') {
  1605. off = -off; /* Save off in case needed for dst default. */
  1606. }
  1607. SKIP_OFFSET:
  1608. new_rules[count].gmt_offset = off;
  1609. if (!count) {
  1610. new_rules[1].gmt_offset = off; /* Shouldn't be needed... */
  1611. if (*e) {
  1612. ++count;
  1613. goto LOOP;
  1614. }
  1615. } else { /* OK, we have dst, so get some rules. */
  1616. count = 0;
  1617. if (!*e) { /* No rules so default to US rules. */
  1618. e = DEFAULT_RULES;
  1619. }
  1620. do {
  1621. if (*e++ != ',') {
  1622. goto ILLEGAL;
  1623. }
  1624. n = 365;
  1625. s = (char *) RULE;
  1626. if ((c = *e++) == 'M') {
  1627. n = 12;
  1628. } else if (c == 'J') {
  1629. s += 8;
  1630. } else {
  1631. --e;
  1632. c = 0;
  1633. s += 6;
  1634. }
  1635. *(p = &new_rules[count].rule_type) = c;
  1636. if (c != 'M') {
  1637. p -= 2;
  1638. }
  1639. do {
  1640. ++s;
  1641. if (!(e = getnumber(e, &f))
  1642. || (((unsigned int)(f - s[1])) > n)
  1643. || (*s && (*e++ != *s))
  1644. ) {
  1645. goto ILLEGAL;
  1646. }
  1647. *--p = f;
  1648. } while ((n = *(s += 2)) > 0);
  1649. off = 2 * 60 * 60; /* Default to 2:00:00 */
  1650. if (*e == '/') {
  1651. ++e;
  1652. if (!(e = getoffset(e, &off))) {
  1653. goto ILLEGAL;
  1654. }
  1655. }
  1656. new_rules[count].dst_offset = off;
  1657. } while (++count < 2);
  1658. if (*e) {
  1659. goto ILLEGAL;
  1660. }
  1661. }
  1662. memcpy(_time_tzinfo, new_rules, sizeof(new_rules));
  1663. DONE:
  1664. tzname[0] = _time_tzinfo[0].tzname;
  1665. tzname[1] = _time_tzinfo[1].tzname;
  1666. daylight = !!_time_tzinfo[1].tzname[0];
  1667. timezone = _time_tzinfo[0].gmt_offset;
  1668. FAST_DONE:
  1669. TZUNLOCK;
  1670. }
  1671. #endif
  1672. /**********************************************************************/
  1673. /* #ifdef L_utime */
  1674. /* utime is a syscall in both linux and elks. */
  1675. /* int utime(const char *path, const struct utimbuf *times) */
  1676. /* #endif */
  1677. /**********************************************************************/
  1678. /* Non-SUSv3 */
  1679. /**********************************************************************/
  1680. #ifdef L_utimes
  1681. #ifndef __BCC__
  1682. #error The uClibc version of utimes is in sysdeps/linux/common.
  1683. #endif
  1684. #include <utime.h>
  1685. #include <sys/time.h>
  1686. int utimes(const char *filename, register const struct timeval *tvp)
  1687. {
  1688. register struct utimbuf *p = NULL;
  1689. struct utimbuf utb;
  1690. if (tvp) {
  1691. p = &utb;
  1692. p->actime = tvp[0].tv_sec;
  1693. p->modtime = tvp[1].tv_sec;
  1694. }
  1695. return utime(filename, p);
  1696. }
  1697. #endif
  1698. /**********************************************************************/
  1699. #ifdef L__time_t2tm
  1700. static const uint16_t vals[] = {
  1701. 60, 60, 24, 7 /* special */, 36524, 1461, 365, 0
  1702. };
  1703. static const unsigned char days[] = {
  1704. 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, /* non-leap */
  1705. 29,
  1706. };
  1707. #ifdef __UCLIBC_HAS_TM_EXTENSIONS__
  1708. static const char utc_string[] = "UTC";
  1709. #endif
  1710. /* Notes:
  1711. * If time_t is 32 bits, then no overflow is possible.
  1712. * It time_t is > 32 bits, this needs to be adjusted to deal with overflow.
  1713. */
  1714. /* Note: offset is the correction in _days_ to *timer! */
  1715. struct tm *_time_t2tm(const time_t *__restrict timer,
  1716. int offset, struct tm *__restrict result)
  1717. {
  1718. register int *p;
  1719. time_t t1, t, v;
  1720. int wday; /* Note: wday can be uninitialized. */
  1721. {
  1722. register const uint16_t *vp;
  1723. t = *timer;
  1724. p = (int *) result;
  1725. p[7] = 0;
  1726. vp = vals;
  1727. do {
  1728. if ((v = *vp) == 7) {
  1729. /* Overflow checking, assuming time_t is long int... */
  1730. #if (LONG_MAX > INT_MAX) && (LONG_MAX > 2147483647L)
  1731. #if (INT_MAX == 2147483647L) && (LONG_MAX == 9223372036854775807L)
  1732. /* Valid range for t is [-784223472856L, 784223421720L].
  1733. * Outside of this range, the tm_year field will overflow. */
  1734. if (((unsigned long)(t + offset- -784223472856L))
  1735. > (784223421720L - -784223472856L)
  1736. ) {
  1737. return NULL;
  1738. }
  1739. #else
  1740. #error overflow conditions unknown
  1741. #endif
  1742. #endif
  1743. /* We have days since the epoch, so caluclate the weekday. */
  1744. #if defined(__BCC__) && TIME_T_IS_UNSIGNED
  1745. wday = (t + 4) % (*vp); /* t is unsigned */
  1746. #else
  1747. wday = ((int)((t % (*vp)) + 11)) % ((int)(*vp)); /* help bcc */
  1748. #endif
  1749. /* Set divisor to days in 400 years. Be kind to bcc... */
  1750. v = ((time_t)(vp[1])) << 2;
  1751. ++v;
  1752. /* Change to days since 1/1/1601 so that for 32 bit time_t
  1753. * values, we'll have t >= 0. This should be changed for
  1754. * archs with larger time_t types.
  1755. * Also, correct for offset since a multiple of 7. */
  1756. /* TODO: Does this still work on archs with time_t > 32 bits? */
  1757. t += (135140L - 366) + offset; /* 146097 - (365*30 + 7) -366 */
  1758. }
  1759. #if defined(__BCC__) && TIME_T_IS_UNSIGNED
  1760. t -= ((t1 = t / v) * v);
  1761. #else
  1762. if ((t -= ((t1 = t / v) * v)) < 0) {
  1763. t += v;
  1764. --t1;
  1765. }
  1766. #endif
  1767. if ((*vp == 7) && (t == v-1)) {
  1768. --t; /* Correct for 400th year leap case */
  1769. ++p[4]; /* Stash the extra day... */
  1770. }
  1771. #if defined(__BCC__) && 0
  1772. *p = t1;
  1773. if (v <= 60) {
  1774. *p = t;
  1775. t = t1;
  1776. }
  1777. ++p;
  1778. #else
  1779. if (v <= 60) {
  1780. *p++ = t;
  1781. t = t1;
  1782. } else {
  1783. *p++ = t1;
  1784. }
  1785. #endif
  1786. } while (*++vp);
  1787. }
  1788. if (p[-1] == 4) {
  1789. --p[-1];
  1790. t = 365;
  1791. }
  1792. *p += ((int) t); /* result[7] .. tm_yday */
  1793. p -= 2; /* at result[5] */
  1794. #if (LONG_MAX > INT_MAX) && (LONG_MAX > 2147483647L)
  1795. /* Protect against overflow. TODO: Unecessary if int arith wraps? */
  1796. *p = ((((p[-2]<<2) + p[-1])*25 + p[0])<< 2) + (p[1] - 299); /* tm_year */
  1797. #else
  1798. *p = ((((p[-2]<<2) + p[-1])*25 + p[0])<< 2) + p[1] - 299; /* tm_year */
  1799. #endif
  1800. p[1] = wday; /* result[6] .. tm_wday */
  1801. {
  1802. register const unsigned char *d = days;
  1803. wday = 1900 + *p;
  1804. if (__isleap(wday)) {
  1805. d += 11;
  1806. }
  1807. wday = p[2] + 1; /* result[7] .. tm_yday */
  1808. *--p = 0; /* at result[4] .. tm_mon */
  1809. while (wday > *d) {
  1810. wday -= *d;
  1811. if (*d == 29) {
  1812. d -= 11; /* Backup to non-leap Feb. */
  1813. }
  1814. ++d;
  1815. ++*p; /* Increment tm_mon. */
  1816. }
  1817. p[-1] = wday; /* result[3] .. tm_mday */
  1818. }
  1819. /* TODO -- should this be 0? */
  1820. p[4] = 0; /* result[8] .. tm_isdst */
  1821. #ifdef __UCLIBC_HAS_TM_EXTENSIONS__
  1822. result->tm_gmtoff = 0;
  1823. result->tm_zone = utc_string;
  1824. #endif /* __UCLIBC_HAS_TM_EXTENSIONS__ */
  1825. return result;
  1826. }
  1827. #endif
  1828. /**********************************************************************/
  1829. #ifdef L___time_tm
  1830. struct tm __time_tm; /* Global shared by gmtime() and localtime(). */
  1831. #endif
  1832. /**********************************************************************/
  1833. #ifdef L__time_mktime
  1834. time_t _time_mktime(struct tm *timeptr, int store_on_success)
  1835. {
  1836. time_t t;
  1837. TZLOCK;
  1838. tzset();
  1839. t = _time_mktime_tzi(timeptr, store_on_success, _time_tzinfo);
  1840. TZUNLOCK;
  1841. return t;
  1842. }
  1843. #endif
  1844. /**********************************************************************/
  1845. #ifdef L__time_mktime_tzi
  1846. static const unsigned char vals[] = {
  1847. 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, /* non-leap */
  1848. 29,
  1849. };
  1850. time_t _time_mktime_tzi(struct tm *timeptr, int store_on_success,
  1851. rule_struct *tzi)
  1852. {
  1853. #ifdef __BCC__
  1854. long days, secs;
  1855. #else
  1856. long long secs;
  1857. #endif
  1858. time_t t;
  1859. struct tm x;
  1860. /* 0:sec 1:min 2:hour 3:mday 4:mon 5:year 6:wday 7:yday 8:isdst */
  1861. register int *p = (int *) &x;
  1862. register const unsigned char *s;
  1863. int d, default_dst;
  1864. memcpy(p, timeptr, sizeof(struct tm));
  1865. if (!tzi[1].tzname[0]) { /* No dst in this timezone, */
  1866. p[8] = 0; /* so set tm_isdst to 0. */
  1867. }
  1868. default_dst = 0;
  1869. if (p[8]) { /* Either dst or unknown? */
  1870. default_dst = 1; /* Assume advancing (even if unknown). */
  1871. p[8] = ((p[8] > 0) ? 1 : -1); /* Normalize so abs() <= 1. */
  1872. }
  1873. d = 400;
  1874. p[5] = (p[5] - ((p[6] = p[5]/d) * d)) + (p[7] = p[4]/12);
  1875. if ((p[4] -= 12 * p[7]) < 0) {
  1876. p[4] += 12;
  1877. --p[5];
  1878. }
  1879. s = vals;
  1880. d = (p[5] += 1900); /* Correct year. Now between 1900 and 2300. */
  1881. if (__isleap(d)) {
  1882. s += 11;
  1883. }
  1884. p[7] = 0;
  1885. d = p[4];
  1886. while (d) {
  1887. p[7] += *s;
  1888. if (*s == 29) {
  1889. s -= 11; /* Backup to non-leap Feb. */
  1890. }
  1891. ++s;
  1892. --d;
  1893. }
  1894. #ifdef __BCC__
  1895. d = p[5] - 1;
  1896. days = -719163L + ((long)d)*365 + ((d/4) - (d/100) + (d/400) + p[3] + p[7]);
  1897. secs = p[0] + 60*( p[1] + 60*((long)(p[2])) )
  1898. + tzi[default_dst].gmt_offset;
  1899. DST_CORRECT:
  1900. if (secs < 0) {
  1901. secs += 120009600L;
  1902. days -= 1389;
  1903. }
  1904. if ( ((unsigned long)(days + secs/86400L)) > 49710L) {
  1905. t = ((time_t)(-1));
  1906. goto DONE;
  1907. }
  1908. secs += (days * 86400L);
  1909. #else
  1910. d = p[5] - 1;
  1911. d = -719163L + d*365 + (d/4) - (d/100) + (d/400);
  1912. secs = p[0]
  1913. + tzi[default_dst].gmt_offset
  1914. + 60*( p[1]
  1915. + 60*(p[2]
  1916. + 24*(((146073L * ((long long)(p[6])) + d)
  1917. + p[3]) + p[7])));
  1918. DST_CORRECT:
  1919. if (((unsigned long long)(secs - LONG_MIN))
  1920. > (((unsigned long long)LONG_MAX) - LONG_MIN)
  1921. ) {
  1922. t = ((time_t)(-1));
  1923. goto DONE;
  1924. }
  1925. #endif
  1926. d = ((struct tm *)p)->tm_isdst;
  1927. t = secs;
  1928. __time_localtime_tzi(&t, (struct tm *)p, tzi);
  1929. if (t == ((time_t)(-1))) { /* Remember, time_t can be unsigned. */
  1930. goto DONE;
  1931. }
  1932. if ((d < 0) && (((struct tm *)p)->tm_isdst != default_dst)) {
  1933. #ifdef __BCC__
  1934. secs -= (days * 86400L);
  1935. #endif
  1936. secs += (tzi[1-default_dst].gmt_offset
  1937. - tzi[default_dst].gmt_offset);
  1938. goto DST_CORRECT;
  1939. }
  1940. if (store_on_success) {
  1941. memcpy(timeptr, p, sizeof(struct tm));
  1942. }
  1943. DONE:
  1944. return t;
  1945. }
  1946. #endif
  1947. /**********************************************************************/
  1948. #if defined(L_wcsftime) || defined(L_wcsftime_l)
  1949. #if defined(__UCLIBC_HAS_XLOCALE__) && !defined(__UCLIBC_DO_XLOCALE)
  1950. extern size_t __wcsftime_l (wchar_t *__restrict __s, size_t __maxsize,
  1951. __const wchar_t *__restrict __format,
  1952. __const struct tm *__restrict __timeptr,
  1953. __locale_t __loc) __THROW;
  1954. size_t wcsftime(wchar_t *__restrict s, size_t maxsize,
  1955. const wchar_t *__restrict format,
  1956. const struct tm *__restrict timeptr)
  1957. {
  1958. return __wcsftime_l(s, maxsize, format, timeptr, __UCLIBC_CURLOCALE);
  1959. }
  1960. #else /* defined(__UCLIBC_HAS_XLOCALE__) && !defined(__UCLIBC_DO_XLOCALE) */
  1961. size_t __XL(wcsftime)(wchar_t *__restrict s, size_t maxsize,
  1962. const wchar_t *__restrict format,
  1963. const struct tm *__restrict timeptr __LOCALE_PARAM )
  1964. {
  1965. #warning wcsftime always fails
  1966. return 0; /* always fail */
  1967. }
  1968. __XL_ALIAS(wcsftime)
  1969. #endif /* defined(__UCLIBC_HAS_XLOCALE__) && !defined(__UCLIBC_DO_XLOCALE) */
  1970. #endif
  1971. /**********************************************************************/
  1972. #ifdef L_dysize
  1973. /* Return the number of days in YEAR. */
  1974. int dysize(int year)
  1975. {
  1976. return __isleap(year) ? 366 : 365;
  1977. }
  1978. #endif
  1979. /**********************************************************************/