* Windows has mktime. The configurators do not check.
 */

#ifdef _WIN32
#define HAVE_MKTIME 1
#endif

/*
 * Constants
 */

#define JULIAN_DAY_POSIX_EPOCH		2440588
#define GREGORIAN_CHANGE_DATE		2361222
#define SECONDS_PER_DAY			86400
#define JULIAN_SEC_POSIX_EPOCH	      (((Tcl_WideInt) JULIAN_DAY_POSIX_EPOCH) \
					* SECONDS_PER_DAY)
#define FOUR_CENTURIES			146097	/* days */
#define JDAY_1_JAN_1_CE_JULIAN		1721424
#define JDAY_1_JAN_1_CE_GREGORIAN	1721426
#define ONE_CENTURY_GREGORIAN		36524	/* days */
#define FOUR_YEARS			1461	/* days */
#define ONE_YEAR			365	/* days */

/*
 * Table of the days in each month, leap and common years
 */

static const int hath[2][12] = {
    {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
    {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}

    LIT_ERA,		LIT_GMT,		LIT_GREGORIAN,
    LIT_INTEGER_VALUE_TOO_LARGE,
    LIT_ISO8601WEEK,	LIT_ISO8601YEAR,
    LIT_JULIANDAY,	LIT_LOCALSECONDS,
    LIT_MONTH,
    LIT_SECONDS,	LIT_TZNAME,		LIT_TZOFFSET,
    LIT_YEAR,
    LIT_CURRENTYEARCENTURY,
    LIT_YEAROFCENTURYSWITCH,
    LIT_TZDATA,
    LIT_GETSYSTEMTIMEZONE,
    LIT_SETUPTIMEZONE,
#if 0
    LIT_FREESCAN,
#endif
    LIT__END

    "era",		":GMT",			"gregorian",
    "integer value too large to represent",
    "iso8601Week",	"iso8601Year",
    "julianDay",	"localSeconds",
    "month",
    "seconds",		"tzName",		"tzOffset",
    "year",
    "::tcl::clock::CurrentYearCentury",
    "::tcl::clock::YearOfCenturySwitch",
    "::tcl::clock::TZData",
    "::tcl::clock::GetSystemTimeZone",
    "::tcl::clock::SetupTimeZone",
#if 0
    "::tcl::clock::FreeScan"
#endif
};

#define CurrentYearCentury 2000

/*
 * Structure containing the client data for [clock]
 */

typedef struct ClockClientData {
    size_t refCount;		/* Number of live references. */
    Tcl_Obj **literals;		/* Pool of object literals. */
    /* Cache for current clock parameters, imparted via "configure" */
    unsigned long LastTZEpoch;
    int currentYearCentury;
    int yearOfCenturySwitch;
    Tcl_Obj *SystemTimeZone;
    Tcl_Obj *SystemSetupTZData;
    Tcl_Obj *GMTSetupTimeZone;
    Tcl_Obj *GMTSetupTZData;
    Tcl_Obj *AnySetupTimeZone;
    Tcl_Obj *AnySetupTZData;
    Tcl_Obj *LastUnnormSetupTimeZone;
    Tcl_Obj *LastSetupTimeZone;
    Tcl_Obj *LastSetupTZData;
    /* Cache for last base (fast convert if base/tz not changed) */
    Tcl_Obj *lastBaseTimeZone;
    TclDateFields lastBaseDate;
    /*
    /* [SB] TODO: back-port (from tclSE) the same date caching ...
     * Cache for last date (fast convert if date parsed was the same) * /
    struct {
      DateInfo	    yy;
      TclDateFields date;
    } lastDate;
    */
} ClockClientData;

static const char *const eras[] = { "CE", "BCE", NULL };

/*
 * Thread specific data block holding a 'struct tm' for the 'gmtime' and
 * 'localtime' library calls.
 */

static Tcl_ThreadDataKey tmKey;

/*
 * Mutex protecting 'gmtime', 'localtime' and 'mktime' calls and the statics
 * in the date parsing code.
 */

TCL_DECLARE_MUTEX(clockMutex)

/*
 * Function prototypes for local procedures in this file:
 */

static int		ConvertUTCToLocal(Tcl_Interp *,
static int		ConvertUTCToLocal(ClientData clientData, Tcl_Interp *,
			    TclDateFields *, Tcl_Obj *, int);
static int		ConvertUTCToLocalUsingTable(Tcl_Interp *,
			    TclDateFields *, int, Tcl_Obj *const[]);
static int		ConvertUTCToLocalUsingC(Tcl_Interp *,
			    TclDateFields *, int);
static int		ConvertLocalToUTC(Tcl_Interp *,
static int		ConvertLocalToUTC(ClientData clientData, Tcl_Interp *,
			    TclDateFields *, Tcl_Obj *, int);
static int		ConvertLocalToUTCUsingTable(Tcl_Interp *,
			    TclDateFields *, int, Tcl_Obj *const[]);
static int		ConvertLocalToUTCUsingC(Tcl_Interp *,
			    TclDateFields *, int);
static int		ClockConfigureObjCmd(ClientData clientData,
			    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]);

static int		ClockClicksObjCmd(
			    ClientData clientData, Tcl_Interp *interp,
			    int objc, Tcl_Obj *const objv[]);
static int		ClockConvertlocaltoutcObjCmd(
			    ClientData clientData, Tcl_Interp *interp,
			    int objc, Tcl_Obj *const objv[]);

static int		ClockGetDateFields(Tcl_Interp *interp, 
			    TclDateFields *fields, Tcl_Obj *tzdata,
			    int changeover);
static int		ClockGetDateFields(ClientData clientData, 
			    Tcl_Interp *interp, TclDateFields *fields, 
			    Tcl_Obj *tzdata, int changeover);
static int		ClockGetdatefieldsObjCmd(
			    ClientData clientData, Tcl_Interp *interp,
			    int objc, Tcl_Obj *const objv[]);
static int		ClockGetjuliandayfromerayearmonthdayObjCmd(
			    ClientData clientData, Tcl_Interp *interp,
			    int objc, Tcl_Obj *const objv[]);
static int		ClockGetjuliandayfromerayearweekdayObjCmd(

    data->refCount = 0;
    data->literals = ckalloc(LIT__END * sizeof(Tcl_Obj*));
    for (i = 0; i < LIT__END; ++i) {
	data->literals[i] = Tcl_NewStringObj(Literals[i], -1);
	Tcl_IncrRefCount(data->literals[i]);
    }
    data->LastTZEpoch = 0;
    data->currentYearCentury = -1;
    data->yearOfCenturySwitch = -1;
    data->currentYearCentury = ClockDefaultYearCentury;
    data->yearOfCenturySwitch = ClockDefaultCenturySwitch;
    data->SystemTimeZone = NULL;
    data->SystemSetupTZData = NULL;
    data->GMTSetupTimeZone = NULL;
    data->GMTSetupTZData = NULL;
    data->AnySetupTimeZone = NULL;
    data->AnySetupTZData = NULL;
    data->LastUnnormSetupTimeZone = NULL;
    data->LastSetupTimeZone = NULL;
    data->LastSetupTZData = NULL;

    data->lastBaseTimeZone = NULL;
    data->lastBase.TimeZone = NULL;
    data->UTC2Local.tzData = NULL;
    data->UTC2Local.tzName = NULL;
    data->Local2UTC.tzData = NULL;

    /*
     * Install the commands.
     */

#define TCL_CLOCK_PREFIX_LEN 14 /* == strlen("::tcl::clock::") */
    memcpy(cmdName, "::tcl::clock::", TCL_CLOCK_PREFIX_LEN);

 */

static void
ClockConfigureClear(
    ClockClientData *data)
{
    data->LastTZEpoch = 0;
    data->currentYearCentury = -1;
    data->yearOfCenturySwitch = -1;
    Tcl_UnsetObjRef(data->SystemTimeZone);
    Tcl_UnsetObjRef(data->SystemSetupTZData);
    Tcl_UnsetObjRef(data->GMTSetupTimeZone);
    Tcl_UnsetObjRef(data->GMTSetupTZData);
    Tcl_UnsetObjRef(data->AnySetupTimeZone);
    Tcl_UnsetObjRef(data->AnySetupTZData);
    Tcl_UnsetObjRef(data->LastUnnormSetupTimeZone);
    Tcl_UnsetObjRef(data->LastSetupTimeZone);
    Tcl_UnsetObjRef(data->LastSetupTZData);

    Tcl_UnsetObjRef(data->lastBase.TimeZone);
    Tcl_UnsetObjRef(data->UTC2Local.tzData);
    Tcl_UnsetObjRef(data->UTC2Local.tzName);
    Tcl_UnsetObjRef(data->Local2UTC.tzData);
}

static void
ClockDeleteCmdProc(
    ClientData clientData)	/* Opaque pointer to the client data */
{
    ClockClientData *data = clientData;
    int i;

    data->refCount--;
    if (data->refCount-- <= 1) {
    if (data->refCount == 0) {
	for (i = 0; i < LIT__END; ++i) {
	    Tcl_DecrRefCount(data->literals[i]);
	}

	ClockConfigureClear(data);

	ckfree(data->literals);

    Tcl_Obj *const objv[])  /* Parameter vector */
{
    ClockClientData *dataPtr = clientData;
    Tcl_Obj **litPtr = dataPtr->literals;
    
    static const char *const options[] = {
	"-system-tz",	  "-setup-tz",	   "-clear",
	"-year-century",  "-century-switch",
	NULL
    };
    enum optionInd {
	CLOCK_SYSTEM_TZ,  CLOCK_SETUP_TZ,  CLOCK_CLEAR_CACHE,
	CLOCK_YEAR_CENTURY, CLOCK_CENTURY_SWITCH,
	CLOCK_SETUP_GMT, CLOCK_SETUP_NOP
    };
    int optionIndex;		/* Index of an option. */
    int i;

    for (i = 1; i < objc; i+=2) {
	if (Tcl_GetIndexFromObj(interp, objv[i], options, 

		break;
		}
	    }
	    if (dataPtr->LastSetupTimeZone != NULL) {
		Tcl_SetObjResult(interp, dataPtr->LastSetupTimeZone);
	    }
	break;
	case CLOCK_YEAR_CENTURY:
	    if (i+1 < objc) {
		int year;
		if (TclGetIntFromObj(interp, objv[i+1], &year) != TCL_OK) {
		    return TCL_ERROR;
		}
		dataPtr->currentYearCentury = year;
		Tcl_SetObjResult(interp, objv[i+1]);
		continue;
	    } 
	    Tcl_SetObjResult(interp, 
		Tcl_NewIntObj(dataPtr->currentYearCentury));
	break;
	case CLOCK_CENTURY_SWITCH:
	    if (i+1 < objc) {
		int year;
		if (TclGetIntFromObj(interp, objv[i+1], &year) != TCL_OK) {
		    return TCL_ERROR;
		}
		dataPtr->yearOfCenturySwitch = year;
		Tcl_SetObjResult(interp, objv[i+1]);
		continue;
	    } 
	    Tcl_SetObjResult(interp, 
		Tcl_NewIntObj(dataPtr->yearOfCenturySwitch));
	break;
	case CLOCK_CLEAR_CACHE:
	    ClockConfigureClear(dataPtr);
	break;
	}
    }

    return TCL_OK;

	return dataPtr->LastSetupTZData;
    }

    /* differentiate GMT and system zones, because used often */
    /* simple caching, because almost used the tz-data of last timezone
     */
    if (timezoneObj == dataPtr->SystemTimeZone) {
	if (dataPtr->SystemSetupTZData != NULL)
	if (dataPtr->SystemSetupTZData != NULL) {
	    return dataPtr->SystemSetupTZData;
	}
	out = &dataPtr->SystemSetupTZData;
    }
    else 
    if (timezoneObj == dataPtr->GMTSetupTimeZone) {
	if (dataPtr->GMTSetupTZData != NULL)
	if (dataPtr->GMTSetupTZData != NULL) {
	    return dataPtr->GMTSetupTZData;
	}
	out = &dataPtr->GMTSetupTZData;
    }
    else
    if (timezoneObj == dataPtr->AnySetupTimeZone) {
	if (dataPtr->AnySetupTZData != NULL) {
	    return dataPtr->AnySetupTZData;
	}
	out = &dataPtr->AnySetupTZData;
    }

    ret = Tcl_ObjGetVar2(interp, literals[LIT_TZDATA],
	timezoneObj, TCL_LEAVE_ERR_MSG);

    /* cache using corresponding slot and as last used */
    if (out != NULL) {
	Tcl_SetObjRef(*out, ret);
    }
		Tcl_SetObjRef(dataPtr->LastSetupTZData, ret);
    Tcl_SetObjRef(dataPtr->LastSetupTZData, ret);
    if (dataPtr->LastSetupTimeZone != timezoneObj) {
	Tcl_SetObjRef(dataPtr->LastSetupTimeZone, timezoneObj);
	Tcl_UnsetObjRef(dataPtr->LastUnnormSetupTimeZone);
		}
    }
    return ret;
}
/*
 *----------------------------------------------------------------------
 */
static Tcl_Obj *
ClockGetSystemTimeZone(

    z %= 60;
    if (z != 0) {
	return Tcl_ObjPrintf("%c%02d%02d%02d", sign, h, m, z);
    }
    return Tcl_ObjPrintf("%c%02d%02d", sign, h, m);
}

/*
 *----------------------------------------------------------------------
 * [SB] TODO: make constans cacheable (once per second, etc.) ...
 */
inline int
ClockCurrentYearCentury(
    ClientData clientData,	/* Opaque pointer to literal pool, etc. */
    Tcl_Interp *interp)		/* Tcl interpreter */
{
    ClockClientData *dataPtr = clientData;
    Tcl_Obj **literals = dataPtr->literals;
    int year = dataPtr->currentYearCentury;

    if (year == -1) {
	Tcl_Obj * yearObj;
	year = 2000;
	yearObj = Tcl_ObjGetVar2(interp, 
	    literals[LIT_CURRENTYEARCENTURY], NULL, TCL_LEAVE_ERR_MSG);
	Tcl_GetIntFromObj(NULL, yearObj, &year);
	dataPtr->currentYearCentury = year;
    }
    return year;
}
inline int
ClockGetYearOfCenturySwitch(
    ClientData clientData,	/* Opaque pointer to literal pool, etc. */
    Tcl_Interp *interp)		/* Tcl interpreter */
{
    ClockClientData *dataPtr = clientData;
    Tcl_Obj **literals = dataPtr->literals;
    int year = dataPtr->yearOfCenturySwitch;
    
    if (year == -1) {
	Tcl_Obj * yearObj;
	year = 37;
	yearObj = Tcl_ObjGetVar2(interp, 
	    literals[LIT_YEAROFCENTURYSWITCH], NULL, TCL_LEAVE_ERR_MSG);
	Tcl_GetIntFromObj(NULL, yearObj, &year);
	dataPtr->yearOfCenturySwitch = year;
    }
    return year;
}

/*
 *----------------------------------------------------------------------
 *
 * ClockConvertlocaltoutcObjCmd --
 *
 *	Tcl command that converts a UTC time to a local time by whatever means
 *	is available.

	Tcl_SetObjResult(interp, Tcl_NewStringObj("key \"localseconds\" not "
		"found in dictionary", -1));
	return TCL_ERROR;
    }
    if ((Tcl_GetWideIntFromObj(interp, secondsObj,
	    &fields.localSeconds) != TCL_OK)
	|| (TclGetIntFromObj(interp, objv[3], &changeover) != TCL_OK)
	|| ConvertLocalToUTC(interp, &fields, objv[2], changeover)) {
	|| ConvertLocalToUTC(clientData, interp, &fields, objv[2], changeover)) {
	return TCL_ERROR;
    }

    /*
     * Copy-on-write; set the 'seconds' field in the dictionary and place the
     * modified dictionary in the interpreter result.
     */

    if (objv[1]->typePtr == &tclBignumType) {
	Tcl_SetObjResult(interp, literals[LIT_INTEGER_VALUE_TOO_LARGE]);
	return TCL_ERROR;
    }

    /* Extract fields */

    if (ClockGetDateFields(interp, &fields, objv[2], changeover)
	  != TCL_OK) {
    if (ClockGetDateFields(clientData, interp, &fields, objv[2], 
	  changeover) != TCL_OK) {
	return TCL_ERROR;
    }

    /* Make dict of fields */

    dict = Tcl_NewDictObj();
    Tcl_DictObjPut(NULL, dict, literals[LIT_LOCALSECONDS],

}

/*
 *----------------------------------------------------------------------
 */
int
ClockGetDateFields(
    ClientData clientData,	/* Client data of the interpreter */
    Tcl_Interp *interp,		/* Tcl interpreter */
    TclDateFields *fields,	/* Pointer to result fields, where
				 * fields->seconds contains date to extract */
    Tcl_Obj *tzdata,		/* Time zone data object or NULL for gmt */
    int changeover)		/* Julian Day Number */
{
    /*
     * Convert UTC time to local.
     */

    if (ConvertUTCToLocal(clientData, interp, fields, tzdata, 
    if (ConvertUTCToLocal(interp, fields, tzdata, changeover) != TCL_OK) {
	    changeover) != TCL_OK) {
	return TCL_ERROR;
    }

    /*
     * Extract Julian day.
     */

 *	in the interpreter result on failure.
 *
 *----------------------------------------------------------------------
 */

static int
ConvertLocalToUTC(
    ClientData clientData,	/* Client data of the interpreter */
    Tcl_Interp *interp,		/* Tcl interpreter */
    TclDateFields *fields,	/* Fields of the time */
    Tcl_Obj *tzdata,		/* Time zone data */
    int changeover)		/* Julian Day of the Gregorian transition */
{
    ClockClientData *dataPtr = clientData;
    int rowc;			/* Number of rows in tzdata */
    Tcl_Obj **rowv;		/* Pointers to the rows */

    /*
     * Check cacheable conversion could be used
     * (last-minute Local2UTC cache with the same TZ)
     */
    if ( tzdata == dataPtr->Local2UTC.tzData
      && ( fields->localSeconds == dataPtr->Local2UTC.localSeconds
	|| fields->localSeconds / 60 == dataPtr->Local2UTC.localSeconds / 60
      )
      && changeover == dataPtr->Local2UTC.changeover
    ) {
	/* the same time zone and offset (UTC time inside the last minute) */
	fields->tzOffset = dataPtr->Local2UTC.tzOffset;
	fields->seconds = fields->localSeconds - fields->tzOffset;
	return TCL_OK;
    }

    /*
     * Unpack the tz data.
     */

    if (TclListObjGetElements(interp, tzdata, &rowc, &rowv) != TCL_OK) {
	return TCL_ERROR;
    }

    /*
     * Special case: If the time zone is :localtime, the tzdata will be empty.
     * Use 'mktime' to convert the time to local
     */

    if (rowc == 0) {
	return ConvertLocalToUTCUsingC(interp, fields, changeover);
	if (ConvertLocalToUTCUsingC(interp, fields, changeover) != TCL_OK) {
	    return TCL_ERROR;
	};
    } else {
	return ConvertLocalToUTCUsingTable(interp, fields, rowc, rowv);
	if (ConvertLocalToUTCUsingTable(interp, fields, rowc, rowv) != TCL_OK) {
	    return TCL_ERROR;
	};
    }

    /* Cache the last conversion */
    Tcl_SetObjRef(dataPtr->Local2UTC.tzData, tzdata);
    dataPtr->Local2UTC.localSeconds = fields->localSeconds;
    dataPtr->Local2UTC.changeover = changeover;
    dataPtr->Local2UTC.tzOffset = fields->tzOffset;

    return TCL_OK;
}

/*
 *----------------------------------------------------------------------
 *
 * ConvertLocalToUTCUsingTable --
 *

	    }
	    have[nHave++] = fields->tzOffset;
	}
	fields->seconds = fields->localSeconds - fields->tzOffset;
    }
    fields->tzOffset = have[i];
    fields->seconds = fields->localSeconds - fields->tzOffset;

#if 0
    /*
     * Convert back from UTC, if local times are different - wrong local time
     * (local time seems to be in between DST-hole).
     */
    if (fields->tzOffset) {

	int corrOffset;
	Tcl_WideInt backCompVal;
	/* check DST-hole interval contains UTC time */
	Tcl_GetWideIntFromObj(NULL, cellv[0], &backCompVal);
	if ( fields->seconds >= backCompVal - fields->tzOffset 
	  && fields->seconds <= backCompVal + fields->tzOffset
	) {
	    row = LookupLastTransition(interp, fields->seconds, rowc, rowv);
	    if (row == NULL ||
		    TclListObjGetElements(interp, row, &cellc, &cellv) != TCL_OK ||
		    TclGetIntFromObj(interp, cellv[1], &corrOffset) != TCL_OK) {
		return TCL_ERROR;
	    }
	    if (fields->localSeconds != fields->seconds + corrOffset) {
		Tcl_Panic("wrong local time %ld by LocalToUTC conversion,"
		    " local time seems to be in between DST-hole", 
		    fields->localSeconds);
		/* correcting offset * /
		fields->tzOffset -= corrOffset;
		fields->seconds += fields->tzOffset;
		*/
	    }
	}
    }
#endif

    return TCL_OK;
}

/*
 *----------------------------------------------------------------------
 *
 * ConvertLocalToUTCUsingC --

 *	Populates the 'tzName' and 'tzOffset' fields.
 *
 *----------------------------------------------------------------------
 */

static int
ConvertUTCToLocal(
    ClientData clientData,	/* Client data of the interpreter */
    Tcl_Interp *interp,		/* Tcl interpreter */
    TclDateFields *fields,	/* Fields of the time */
    Tcl_Obj *tzdata,		/* Time zone data */
    int changeover)		/* Julian Day of the Gregorian transition */
{
    ClockClientData *dataPtr = clientData;
    int rowc;			/* Number of rows in tzdata */
    Tcl_Obj **rowv;		/* Pointers to the rows */

    /*
     * Check cacheable conversion could be used
     * (last-minute UTC2Local cache with the same TZ)
     */
    if ( tzdata == dataPtr->UTC2Local.tzData
      && ( fields->seconds == dataPtr->UTC2Local.seconds
	|| fields->seconds / 60 == dataPtr->UTC2Local.seconds / 60
      )
      && changeover == dataPtr->UTC2Local.changeover
    ) {
	/* the same time zone and offset (UTC time inside the last minute) */
	Tcl_SetObjRef(fields->tzName, dataPtr->UTC2Local.tzName);
	fields->tzOffset = dataPtr->UTC2Local.tzOffset;
	fields->localSeconds = fields->seconds + fields->tzOffset;
	return TCL_OK;
    }

    /*
     * Unpack the tz data.
     */

    if (TclListObjGetElements(interp, tzdata, &rowc, &rowv) != TCL_OK) {
	return TCL_ERROR;
    }

    /*
     * Special case: If the time zone is :localtime, the tzdata will be empty.
     * Use 'localtime' to convert the time to local
     */

    if (rowc == 0) {
	return ConvertUTCToLocalUsingC(interp, fields, changeover);
	if (ConvertUTCToLocalUsingC(interp, fields, changeover) != TCL_OK) {
	    return TCL_ERROR;
	}
    } else {
	return ConvertUTCToLocalUsingTable(interp, fields, rowc, rowv);
    }
	if (ConvertUTCToLocalUsingTable(interp, fields, rowc, rowv) != TCL_OK) {
	    return TCL_ERROR;
	}
    }

    /* Cache the last conversion */
    Tcl_SetObjRef(dataPtr->UTC2Local.tzData, tzdata);
    dataPtr->UTC2Local.seconds = fields->seconds;
    dataPtr->UTC2Local.changeover = changeover;
    dataPtr->UTC2Local.tzOffset = fields->tzOffset;
    Tcl_SetObjRef(dataPtr->UTC2Local.tzName, fields->tzName);
    return TCL_OK;
}

/*
 *----------------------------------------------------------------------
 *
 * ConvertUTCToLocalUsingTable --
 *

     * Extract values for the keywords.
     */

    resOpts->formatObj = NULL;
    resOpts->localeObj = NULL;
    resOpts->timezoneObj = NULL;
    resOpts->baseObj = NULL;
    resOpts->flags = 0;
    for (i = 2; i < objc; i+=2) {
	if (Tcl_GetIndexFromObj(interp, objv[i], options[forScan], 
	    "option", 0, &optionIndex) != TCL_OK) {
	    Tcl_SetErrorCode(interp, "CLOCK", "badOption",
		    Tcl_GetString(objv[i]), NULL);
	    return TCL_ERROR;
	}

    ret = _ClockParseFmtScnArgs(clientData, interp, objc, objv,
	&opts, 1);
    if (ret != TCL_OK) {
	return ret;
    }

    ret = TCL_ERROR;

    info->flags = 0;

    if (opts.baseObj != NULL) {
	if (Tcl_GetWideIntFromObj(interp, opts.baseObj, &baseVal) != TCL_OK) {
	    return TCL_ERROR;
	}
    } else {
	Tcl_Time now;

    yydate.tzData = ClockGetTZData(clientData, interp, opts.timezoneObj);
    if (yydate.tzData == NULL) {
	goto done;
    }
    Tcl_SetObjRef(yydate.tzName, opts.timezoneObj);

    /* check cached */
    if ( dataPtr->lastBaseTimeZone == opts.timezoneObj
      && dataPtr->lastBaseDate.seconds == baseVal) {
	memcpy(&yydate, &dataPtr->lastBaseDate, ClockCacheableDateFieldsSize);
    /* check base fields already cached (by TZ, last-second cache) */
    if ( dataPtr->lastBase.TimeZone == opts.timezoneObj
      && dataPtr->lastBase.Date.seconds == baseVal) {
	memcpy(&yydate, &dataPtr->lastBase.Date, ClockCacheableDateFieldsSize);
    } else {
	/* extact fields from base */
	yydate.seconds = baseVal;
	if (ClockGetDateFields(interp, &yydate, yydate.tzData, GREGORIAN_CHANGE_DATE)
	      != TCL_OK) {
	if (ClockGetDateFields(clientData, interp, &yydate, yydate.tzData,
	      GREGORIAN_CHANGE_DATE) != TCL_OK) {
	    goto done;
	}
	/* cache last base */
	memcpy(&dataPtr->lastBaseDate, &yydate, ClockCacheableDateFieldsSize);
	dataPtr->lastBaseTimeZone = opts.timezoneObj;
	memcpy(&dataPtr->lastBase.Date, &yydate, ClockCacheableDateFieldsSize);
	Tcl_SetObjRef(dataPtr->lastBase.TimeZone, opts.timezoneObj);
    }

    /* seconds are in localSeconds (relative base date), so reset time here */
    yyHour = 0; yyMinutes = 0; yySeconds = 0; yyMeridian = MER24;

    /* If free scan */
    if (opts.formatObj == NULL) {
	/* Use compiled version of FreeScan - */

	/* [SB] TODO: Perhaps someday we'll localize the legacy code. Right now, it's not localized. */
	if (opts.localeObj != NULL) {
	    Tcl_SetResult(interp,
		"legacy [clock scan] does not support -locale", TCL_STATIC);
	    Tcl_SetErrorCode(interp, "CLOCK", "flagWithLegacyFormat", NULL);
	    return TCL_ERROR;
	}
	ret = ClockFreeScan(clientData, interp, info, objv[1], &opts);
    } 
#if 0
#if 1
    else
    if (1) {
	/* TODO: Tcled Scan proc - */
		int ret;
	Tcl_Obj *callargs[10];
	memcpy(callargs, objv, objc * sizeof(*objv));
				callargs[0] = Tcl_NewStringObj("::tcl::clock::__org_scan", -1);

	ret = ClockScan(clientData, interp, info, objv[1], &opts);
    }

    if (ret != TCL_OK) {
	goto done;
    }


    /* If needed assemble julianDay using new year, month, etc. */
    if (yydate.julianDay == CL_INVALIDATE) {
    if (info->flags & CLF_INVALIDATE_JULIANDAY) {
	GetJulianDayFromEraYearMonthDay(&yydate, GREGORIAN_CHANGE_DATE);
    }
    

    /* some overflow checks, if not extended */
    if (!(opts.flags & CLF_EXTENDED)) {
	if (yydate.julianDay > 5373484) {
	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
		"requested date too large to represent", -1));
	    Tcl_SetErrorCode(interp, "CLOCK", "dateTooLarge", NULL);
	    ret = TCL_ERROR;
	    goto done;
	}
    }

    /* Local seconds to UTC (stored in yydate.seconds) */

    if (info->flags & (CLF_INVALIDATE_SECONDS|CLF_INVALIDATE_JULIANDAY)) {
    yydate.localSeconds =
	-210866803200L
	+ ( 86400 * (Tcl_WideInt)yydate.julianDay )
	+ ( yySeconds % 86400 );

    if (ConvertLocalToUTC(interp, &yydate, yydate.tzData, GREGORIAN_CHANGE_DATE)
	yydate.localSeconds =
	    -210866803200L
	    + ( SECONDS_PER_DAY * (Tcl_WideInt)yydate.julianDay )
	    + ( yySeconds % SECONDS_PER_DAY );
    }

    if (ConvertLocalToUTC(clientData, interp, &yydate, yydate.tzData, GREGORIAN_CHANGE_DATE)
	  != TCL_OK) {
	goto done;
    }

    /* Increment UTC seconds with relative time */
    
    yydate.seconds += yyRelSeconds;

    ret = TCL_OK;

done:

    Tcl_UnsetObjRef(yydate.tzName);

    register
    DateInfo	       *info,	/* Date fields used for parsing & converting
				 * simultaneously a yy-parse structure of the 
				 * TclClockFreeScan */	  
    Tcl_Obj *strObj,		/* String containing the time to scan */
    ClockFmtScnCmdArgs *opts)	/* Command options */
{
    // ClockClientData *dataPtr = clientData;
    ClockClientData *dataPtr = clientData;
    // Tcl_Obj **literals = dataPtr->literals;

    int ret = TCL_ERROR;

    /*
     * Parse the date. The parser will fill a structure "info" with date,
     * time, time zone, relative month/day/seconds, relative weekday, ordinal

     * If the caller supplied a date in the string, update the date with
     * the value. If the caller didn't specify a time with the date, default to
     * midnight.
     */

    if (yyHaveDate) {
	if (yyYear < 100) {
	    if (yyYear >= ClockGetYearOfCenturySwitch(clientData, interp)) {
	    if (yyYear >= dataPtr->yearOfCenturySwitch) {
		yyYear -= 100;
	    }
	    yyYear += ClockCurrentYearCentury(clientData, interp);
	    yyYear += dataPtr->currentYearCentury;
	}
	yydate.era = CE;
	if (yyHaveTime == 0) {
	    yyHaveTime = -1;
	}
	info->flags |= CLF_INVALIDATE_JULIANDAY|CLF_INVALIDATE_SECONDS;
    }

    /*
     * If the caller supplied a time zone in the string, make it into a time 
     * zone indicator of +-hhmm and setup this time zone.
     */

	yydate.tzData = ClockGetTZData(clientData, interp, opts->timezoneObj);
	if (yydate.tzData == NULL) {
	    goto done;
	}

	Tcl_SetObjRef(yydate.tzName, opts->timezoneObj);

	info->flags |= CLF_INVALIDATE_SECONDS;
    }
    
    /* on demand (lazy) assemble julianDay using new year, month, etc. */
    yydate.julianDay = CL_INVALIDATE;

    /* 
     * Assemble date, time, zone into seconds-from-epoch
     */

    if (yyHaveTime == -1) {
	yySeconds = 0;
	info->flags |= CLF_INVALIDATE_SECONDS;
    }
    else
    if (yyHaveTime) {
	yySeconds = ToSeconds(yyHour, yyMinutes,
			    yySeconds, yyMeridian);
	info->flags |= CLF_INVALIDATE_SECONDS;
    } 
    else 
    if ( (yyHaveDay && !yyHaveDate)
	    || yyHaveOrdinalMonth
	    || ( yyHaveRel
		&& ( yyRelMonth != 0
		     || yyRelDay != 0 ) )
    ) {
	yySeconds = 0;
	info->flags |= CLF_INVALIDATE_SECONDS;
    } 
    else {
	yySeconds = yydate.localSeconds % 86400;
	yySeconds = yydate.localSeconds % SECONDS_PER_DAY;
    }

    /*
     * Do relative times
     */

repeat_rel:

    if (yyHaveRel) {

	/* 
	 * Relative conversion normally possible in UTC time only, because
	 * of possible wrong local time increment if ignores in-between DST-hole.
	 * (see test-cases clock-34.53, clock-34.54).
	 * So increment date in julianDay, but time inside day in UTC (seconds).
	 */

	/* add months (or years in months) */

	if (yyRelMonth != 0) {
	    int m, h;

	    /* if needed extract year, month, etc. again */
	    if (yyMonth == CL_INVALIDATE) {
	    if (info->flags & CLF_INVALIDATE_DATE) {
		GetGregorianEraYearDay(&yydate, GREGORIAN_CHANGE_DATE);
		GetMonthDay(&yydate);
		GetYearWeekDay(&yydate, GREGORIAN_CHANGE_DATE);
		info->flags &= ~CLF_INVALIDATE_DATE;
	    }

	    /* add the requisite number of months */
	    yyMonth += yyRelMonth - 1;
	    yyYear += yyMonth / 12;
	    m = yyMonth % 12;
	    yyMonth = m + 1;

	    /* if the day doesn't exist in the current month, repair it */
	    h = hath[IsGregorianLeapYear(&yydate)][m];
	    if (yyDay > h) {
		yyDay = h;
	    }

	    /* on demand (lazy) assemble julianDay using new year, month, etc. */
	    yydate.julianDay = CL_INVALIDATE;
	    info->flags |= CLF_INVALIDATE_JULIANDAY|CLF_INVALIDATE_SECONDS;

	    yyRelMonth = 0;
	}

	/* add days (or other parts aligned to days) */
	if (yyRelDay) {

	    /* assemble julianDay using new year, month, etc. */
	    if (yydate.julianDay == CL_INVALIDATE) {
	    if (info->flags & CLF_INVALIDATE_JULIANDAY) {
		GetJulianDayFromEraYearMonthDay(&yydate, GREGORIAN_CHANGE_DATE);
		info->flags &= ~CLF_INVALIDATE_JULIANDAY;
	    }
	    yydate.julianDay += yyRelDay;	    
	    yydate.julianDay += yyRelDay;
	    
	    /* julianDay was changed, on demand (lazy) extract year, month, etc. again */
	    yyMonth = CL_INVALIDATE;
	    info->flags |= CLF_INVALIDATE_DATE|CLF_INVALIDATE_SECONDS;

	    yyRelDay = 0;
	}

	/* relative time (seconds) */
	yySeconds += yyRelSeconds;
	yyRelSeconds = 0;
	/* relative time (seconds), if exceeds current date, do the day conversion and
	 * leave rest of the increment in yyRelSeconds to add it hereafter in UTC seconds */
	if (yyRelSeconds) {
	    time_t newSecs = yySeconds + yyRelSeconds;
	       
	    /* if seconds increment outside of current date, increment day */
	    if (newSecs / SECONDS_PER_DAY != yySeconds / SECONDS_PER_DAY) {
		
		yyRelDay += newSecs / SECONDS_PER_DAY;
		yySeconds = 0;		    
		yyRelSeconds = newSecs % SECONDS_PER_DAY;

		goto repeat_rel;
	    }
	}
    }

    /*
     * Do relative (ordinal) month
     */

    if (yyHaveOrdinalMonth) {
	int monthDiff;

	/* if needed extract year, month, etc. again */
	if (yyMonth == CL_INVALIDATE) {
	if (info->flags & CLF_INVALIDATE_DATE) {
	    GetGregorianEraYearDay(&yydate, GREGORIAN_CHANGE_DATE);
	    GetMonthDay(&yydate);
	    GetYearWeekDay(&yydate, GREGORIAN_CHANGE_DATE);
	    info->flags &= ~CLF_INVALIDATE_DATE;
	}

	if (yyMonthOrdinalIncr > 0) {
	    monthDiff = yyMonthOrdinal - yyMonth;
	    if (monthDiff <= 0) {
		monthDiff += 12;
	    }

	/* process it further via relative times */
	yyHaveRel++;
	yyYear += yyMonthOrdinalIncr;
	yyRelMonth += monthDiff;
	yyHaveOrdinalMonth = 0;

	info->flags |= CLF_INVALIDATE_JULIANDAY|CLF_INVALIDATE_SECONDS;

	goto repeat_rel;
    }

    /*
     * Do relative weekday
     */

    if (yyHaveDay && !yyHaveDate) {

	/* if needed assemble julianDay now */
	if (yydate.julianDay == CL_INVALIDATE) {
	if (info->flags & CLF_INVALIDATE_JULIANDAY) {
	    GetJulianDayFromEraYearMonthDay(&yydate, GREGORIAN_CHANGE_DATE);
	    info->flags &= ~CLF_INVALIDATE_JULIANDAY;
	}

	yydate.era = CE;
	yydate.julianDay = WeekdayOnOrBefore(yyDayNumber, yydate.julianDay + 6)
		    + 7 * yyDayOrdinal;
	if (yyDayOrdinal > 0) {
	    yydate.julianDay -= 7;
	}
	info->flags |= CLF_INVALIDATE_DATE|CLF_INVALIDATE_SECONDS;
    }

    /* Free scanning completed - date ready */

    ret = TCL_OK;

done: