time.c 64 KB

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