haiku.git

/*
 * Copyright 2010, Oliver Tappe, zooey@hirschkaefer.de.
 * Distributed under the terms of the MIT License.
 */


#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#include <syscalls.h>

#include <StorageDefs.h>

#include <errno_private.h>
#include "LocaleBackend.h"


using BPrivate::Libroot::GetCurrentLocaleBackend;
using BPrivate::Libroot::LocaleBackend;


static char sStandardTZName[64] 		= { "GMT" };
static char sDaylightSavingTZName[64]	= { "GMT" };


char* tzname[2] = {
	sStandardTZName,
	sDaylightSavingTZName
};
long timezone = 0;
int daylight = 0;


// These three functions are used as a fallback when the locale backend could not
// be loaded, or for the POSIX locale. They are implemented in localtime_fallback.c.
extern "C" struct tm* __gmtime_r_fallback(const time_t* timep, struct tm* tmp);
extern "C" time_t __mktime_fallback(struct tm* tmp);
extern "C" time_t __timegm_fallback(struct tm* tmp);


extern "C" void
tzset(void)
{
	if (GetCurrentLocaleBackend() == NULL && LocaleBackend::LoadBackend() != B_OK)
		return;

	char timeZoneID[B_FILE_NAME_LENGTH] = { "GMT" };
	_kern_get_timezone(NULL, timeZoneID, sizeof(timeZoneID));

	GetCurrentLocaleBackend()->TZSet(timeZoneID, getenv("TZ"));
}


extern "C" struct tm*
localtime(const time_t* inTime)
{
	static tm tm;

	return localtime_r(inTime, &tm);
}


extern "C" struct tm*
localtime_r(const time_t* inTime, struct tm* tmOut)
{
	if (inTime == NULL) {
		__set_errno(EINVAL);
		return NULL;
	}

	tzset();

	LocaleBackend* backend = GetCurrentLocaleBackend();

	if (backend != NULL) {
		status_t status = backend->Localtime(inTime, tmOut);

		if (status != B_OK)
			__set_errno(EOVERFLOW);

		return tmOut;
	}

	// without a locale backend, there are no timezones, so we fall back to
	// using a basic gmtime_r implementation.
	return __gmtime_r_fallback(inTime, tmOut);
}


extern "C" struct tm*
gmtime(const time_t* inTime)
{
	static tm tm;

	return gmtime_r(inTime, &tm);
}


extern "C" struct tm*
gmtime_r(const time_t* inTime, struct tm* tmOut)
{
	if (inTime == NULL) {
		__set_errno(EINVAL);
		return NULL;
	}

	tzset();

	LocaleBackend* backend = GetCurrentLocaleBackend();

	if (backend != NULL) {
		status_t status = backend->Gmtime(inTime, tmOut);

		if (status != B_OK)
			__set_errno(EOVERFLOW);

		return tmOut;
	}

	// without a locale backend, we fall back to using a basic gmtime_r
	// implementation.
	return __gmtime_r_fallback(inTime, tmOut);
}


extern "C" time_t
mktime(struct tm* inTm)
{
	if (inTm == NULL) {
		__set_errno(EINVAL);
		return -1;
	}

	tzset();

	LocaleBackend* backend = GetCurrentLocaleBackend();

	if (backend != NULL) {
		time_t timeOut;
		status_t status = backend->Mktime(inTm, timeOut);

		if (status != B_OK) {
			__set_errno(EOVERFLOW);
			return -1;
		}

		return timeOut;
	}

	// without a locale backend, we fall back to using a basic gmtime_r
	// implementation.
	return __mktime_fallback(inTm);
}


extern "C" time_t
timegm(struct tm* inTm)
{
	if (inTm == NULL) {
		__set_errno(EINVAL);
		return -1;
	}
	tzset();

	LocaleBackend* backend = GetCurrentLocaleBackend();

	if (backend != NULL) {
		time_t timeOut;
		status_t status = backend->Timegm(inTm, timeOut);

		if (status != B_OK) {
			__set_errno(EOVERFLOW);
			return -1;
		}

		return timeOut;
	}

	// without a locale backend, we fall back to using a basic timegm
	// implementation.
	return __timegm_fallback(inTm);
}