wasCSharpSQLite – Rev 1
?pathlinks?
#define DEBUG
/*
* ClockCmd.java --
*
* Implements the built-in "clock" Tcl command.
*
* Copyright (c) 1998-2000 Christian Krone.
* Copyright (c) 1997 Cornell University.
* Copyright (c) 1995-1997 Sun Microsystems, Inc.
* Copyright (c) 1992-1995 Karl Lehenbauer and Mark Diekhans.
*
* See the file "license.terms" for information on usage and
* redistribution of this file, and for a DISCLAIMER OF ALL
* WARRANTIES.
*
* Included in SQLite3 port to C# for use in testharness only; 2008 Noah B Hart
*
* RCS @(#) $Id: ClockCmd.java,v 1.6 2003/02/03 04:48:46 mdejong Exp $
*
*/
using System;
using System.Globalization;
using System.Text;
using System.Collections;
namespace tcl.lang
{
/// <summary> This class implements the built-in "clock" command in Tcl.</summary>
class ClockCmd : Command
{
private static readonly string[] validCmds = new string[] { "clicks", "format", "scan", "seconds" };
private const int CMD_CLICKS = 0;
private const int CMD_FORMAT = 1;
private const int CMD_SCAN = 2;
private const int CMD_SECONDS = 3;
private static readonly string[] clicksOpts = new string[] { "-milliseconds" };
private const int OPT_CLICKS_MILLISECONDS = 0;
private static readonly string[] formatOpts = new string[] { "-format", "-gmt" };
private const int OPT_FORMAT_FORMAT = 0;
private const int OPT_FORMAT_GMT = 1;
private static readonly string[] scanOpts = new string[] { "-base", "-gmt" };
private const int OPT_SCAN_BASE = 0;
private const int OPT_SCAN_GMT = 1;
internal const int EPOCH_YEAR = 1970;
internal const int MILLIS_PER_HOUR = 60 * 60 * 1000;
public TCL.CompletionCode cmdProc( Interp interp, TclObject[] objv )
{
int clockVal; // Time value as seconds of epoch.
string dateString; // Time value as string.
int argIx; // Counter over arguments.
string format = null; // User specified format string.
bool useGmt = false; // User specified flag to use gmt.
TclObject baseObj = null; // User specified raw value of baseClock.
System.DateTime baseClock; // User specified time value.
System.DateTime date; // Parsed date value.
if ( objv.Length < 2 )
{
throw new TclNumArgsException( interp, 1, objv, "option ?arg ...?" );
}
int cmd = TclIndex.get( interp, objv[1], validCmds, "option", 0 );
switch ( cmd )
{
case CMD_CLICKS:
{
if ( objv.Length > 3 )
{
throw new TclNumArgsException( interp, 2, objv, "?-milliseconds?" );
}
if ( objv.Length == 3 )
{
// We can safely ignore the -milliseconds options, since
// we measure the clicks in milliseconds anyway...
int clicksOpt = TclIndex.get( interp, objv[2], clicksOpts, "switch", 0 );
}
long millis = ( System.DateTime.Now.Ticks - 621355968000000000 ) / 10000;
int clicks = (int)( millis % System.Int32.MaxValue );
interp.setResult( clicks );
break;
}
case CMD_FORMAT:
{
if ( ( objv.Length < 3 ) || ( objv.Length > 7 ) )
{
throw new TclNumArgsException( interp, 2, objv, "clockval ?-format string? ?-gmt boolean?" );
}
clockVal = TclInteger.get( interp, objv[2] );
for ( argIx = 3; argIx + 1 < objv.Length; argIx += 2 )
{
int formatOpt = TclIndex.get( interp, objv[argIx], formatOpts, "switch", 0 );
switch ( formatOpt )
{
case OPT_FORMAT_FORMAT:
{
format = objv[argIx + 1].ToString();
break;
}
case OPT_FORMAT_GMT:
{
useGmt = TclBoolean.get( interp, objv[argIx + 1] );
break;
}
}
}
if ( argIx < objv.Length )
{
throw new TclNumArgsException( interp, 2, objv, "clockval ?-format string? ?-gmt boolean?" );
}
FormatClock( interp, clockVal, useGmt, format );
break;
}
case CMD_SCAN:
{
if ( ( objv.Length < 3 ) || ( objv.Length > 7 ) )
{
throw new TclNumArgsException( interp, 2, objv, "dateString ?-base clockValue? ?-gmt boolean?" );
}
dateString = objv[2].ToString();
for ( argIx = 3; argIx + 1 < objv.Length; argIx += 2 )
{
int scanOpt = TclIndex.get( interp, objv[argIx], scanOpts, "switch", 0 );
switch ( scanOpt )
{
case OPT_SCAN_BASE:
{
baseObj = objv[argIx + 1];
break;
}
case OPT_SCAN_GMT:
{
useGmt = TclBoolean.get( interp, objv[argIx + 1] );
break;
}
}
}
if ( argIx < objv.Length )
{
throw new TclNumArgsException( interp, 2, objv, "clockval ?-format string? ?-gmt boolean?" );
}
if ( baseObj != null )
{
long seconds = TclInteger.get( interp, baseObj );
baseClock = new System.DateTime( (long)seconds * 10000 * 1000 + 621355968000000000 );
}
else
{
baseClock = System.DateTime.Now;
}
try
{
date = GetDate( dateString, baseClock, useGmt );
}
catch ( FormatException )
{
throw new TclException( interp, "unable to convert date-time string \"" + dateString + "\"" );
}
long millis = ( date.Ticks - 621355968000000000 ) / 10000;
int seconds2 = (int)( millis / 1000 );
interp.setResult( seconds2 );
break;
}
case CMD_SECONDS:
{
if ( objv.Length != 2 )
{
throw new TclNumArgsException( interp, 2, objv, null );
}
long millis = ( System.DateTime.Now.Ticks - 621355968000000000 ) / 10000;
int seconds = (int)( millis / 1000 );
interp.setResult( seconds );
break;
}
}
return TCL.CompletionCode.RETURN;
}
private void FormatClock( Interp interp, int clockVal, bool useGMT, string format )
{
DateTime date = new DateTime( (long)clockVal * 10000 * 1000 + 621355968000000000 );
DateTimeFormatInfo formatInfo = new DateTimeFormatInfo();
string fmt, locFmt;
GregorianCalendar calendar = new GregorianCalendar();
System.Int32[] temp_int_array;
temp_int_array = new System.Int32[3];
temp_int_array[0] = 0;
temp_int_array[1] = 0;
temp_int_array[2] = 0;
System.Int32[] fp = temp_int_array;
StringBuilder result = new StringBuilder();
if ( (System.Object)format == null )
{
format = new StringBuilder( "%a %b %d %H:%M:%S %Z %Y" ).ToString();
}
if ( useGMT )
{
date = date.ToUniversalTime();
}
if ( format.Equals( "%Q" ) )
{
// Enterprise Stardate. (seems to be Star Track fan coding)
// ATK not tested
int trekYear = date.Year + 377 - 2323;
int trekDay = ( date.DayOfYear * 1000 ) / ( calendar.IsLeapYear( date.Year ) ? 366 : 365 );
int trekHour = ( 24 * 60 + date.Minute ) / 144;
interp.setResult( "Stardate " + ( trekYear < 10 ? "0" : "" ) + ( trekYear * 1000 + trekDay ) + '.' + trekHour );
return;
}
for ( int ix = 0; ix < format.Length; ix++ )
{
if ( format[ix] == '%' && ix + 1 < format.Length )
{
switch ( format[++ix] )
{
case '%':
result.Append( '%' );
break;
case 'a':
result.Append( date.ToString( "ddd", formatInfo ) );
break;
case 'A':
result.Append( date.ToString( "dddd", formatInfo ) );
break;
case 'b':
case 'h':
result.Append( date.ToString( "MMM", formatInfo ) );
break;
case 'B':
result.Append( date.ToString( "MMMM", formatInfo ) );
break;
case 'c':
result.Append( date.ToString() );
break;
case 'C':
int century = date.Year / 100;
result.Append( ( century < 10 ? "0" : "" ) + century );
break;
case 'd':
result.Append( date.ToString( "dd", formatInfo ) );
break;
case 'D':
result.Append( date.ToString( "MM/dd/yy", formatInfo ) );
break;
case 'e':
result.Append( date.ToString( "%d", formatInfo ) );
break;
case 'H':
result.Append( date.ToString( "HH", formatInfo ) );
break;
case 'I':
result.Append( date.ToString( "hh", formatInfo ) );
break;
case 'j':
result.Append( date.Year.ToString( "0###" ) );
break;
case 'k':
result.Append( date.ToString( "H", formatInfo ) );
break;
case 'l':
result.Append( date.ToString( "%h", formatInfo ) );
break;
case 'm':
// Month number (01 - 12).
result.Append( date.ToString( "MM", formatInfo ) );
break;
case 'M':
// Minute (00 - 59).
result.Append( date.ToString( "mm", formatInfo ) );
break;
case 'n':
// Insert a newline.
result.Append( '\n' );
break;
case 'p':
// AM/PM indicator.
result.Append( date.ToString( "tt", formatInfo ) );
break;
case 'r':
// %r
//Time in a locale-specific "meridian" format. The "meridian" format in the default "C" locale is "%I:%M:%S %p".
result.Append( date.ToString( "hh:mm:ss tt", formatInfo ) );
break;
case 'R':
//%R
//Time as %H:%M.
result.Append( date.ToString( "HH:MM", formatInfo ) );
break;
case 's':
//%s
//Count of seconds since the epoch, expressed as a decimal integer.
result.Append( ( date.Ticks / 1000 ).ToString() );
break;
case 'S':
//%S
//Seconds (00 - 59).
result.Append( date.ToString( "ss", formatInfo ) );
break;
case 't':
//%t
//Insert a tab.
result.Append( '\t' );
break;
case 'T':
//%T
//Time as %H:%M:%S.
result.Append( date.ToString( "HH:mm:ss", formatInfo ) );
break;
case 'u':
//%u
//Weekday number (Monday = 1, Sunday = 7).
if ( date.DayOfWeek == DayOfWeek.Sunday )
{
result.Append( "7" );
}
else
{
result.Append( ( (int)date.DayOfWeek ).ToString() );
}
break;
case 'U':
//%U
//Week of year (00 - 52), Sunday is the first day of the week.
int weekS = GetWeek( date, System.DayOfWeek.Sunday, false );
result.Append( ( weekS < 10 ? "0" : "" ) + weekS );
break;
case 'V':
//%V
//Week of year according to ISO-8601 rules. Week 1 of a given year is the week containing 4 January.
int isoWeek = GetWeek( date, System.DayOfWeek.Monday, true );
result.Append( ( isoWeek < 10 ? "0" : "" ) + isoWeek );
break;
case 'w':
//%w
//Weekday number (Sunday = 0, Saturday = 6).
result.Append( ( (int)date.DayOfWeek ).ToString() );
break;
case 'W':
//%W
//Week of year (00 - 52), Monday is the first day of the week.
int weekM = GetWeek( date, System.DayOfWeek.Monday, false );
result.Append( ( weekM < 10 ? "0" : "" ) + weekM );
break;
case 'x':
//%x
//Locale specific date format. The format for a date in the default "C" locale for Unix/Mac is "%m/%d/%y". On Windows, this value is the locale specific short date format, as specified in the Regional Options control panel settings.
result.Append( date.ToShortDateString() );
break;
case 'X':
//%X
//Locale specific 24-hour time format. The format for a 24-hour time in the default "C" locale for Unix/Mac is "%H:%M:%S". On Windows, this value is the locale specific time format, as specified in the Regional Options control panel settings.
result.Append( date.ToShortTimeString() );
break;
case 'y':
//%y
//Year without century (00 - 99).
result.Append( date.ToString( "yy", formatInfo ) );
break;
case 'Y':
//%Y
//Year with century (e.g. 1990)
result.Append( date.ToString( "yyyy", formatInfo ) );
break;
case 'Z':
//%Z
//Time zone name.
result.Append( date.ToString( "zzz", formatInfo ) );
break;
default:
result.Append( format[ix] );
break;
}
}
else
{
result.Append( format[ix] );
}
}
interp.setResult( result.ToString() );
}
private int GetWeek( DateTime date, System.DayOfWeek firstDayOfWeek, bool iso )
{
GregorianCalendar cal = new GregorianCalendar();
CalendarWeekRule weekRule = CalendarWeekRule.FirstFullWeek;
if ( iso )
{
firstDayOfWeek = System.DayOfWeek.Monday;
weekRule = CalendarWeekRule.FirstFourDayWeek;
}
return cal.GetWeekOfYear( date, weekRule, firstDayOfWeek );
}
private void SetWeekday( TclDateTime calendar, ClockRelTimespan diff )
// time difference to evaluate
{
int weekday = diff.getWeekday();
int dayOrdinal = diff.DayOrdinal;
// ATK
// while (SupportClass.CalendarManager.manager.Get(calendar, SupportClass.CalendarManager.DAY_OF_WEEK) != weekday)
// {
//
// calendar.add(SupportClass.CalendarManager.DATE, 1);
// }
// if (dayOrdinal > 1)
// {
//
// calendar.add(SupportClass.CalendarManager.DATE, 7 * (dayOrdinal - 1));
// }
}
private void SetOrdMonth( TclDateTime calendar, ClockRelTimespan diff )
// time difference to evaluate
{
int month = diff.Months;
int ordMonth = diff.OrdMonth;
// calendar.add(SupportClass.CalendarManager.MONTH, 1); /* we want to get the next month... */
// while (SupportClass.CalendarManager.manager.Get(calendar, SupportClass.CalendarManager.MONTH) != month)
// {
// calendar.add(SupportClass.CalendarManager.MONTH, 1);
// }
// if (ordMonth > 1)
// {
// calendar.add(SupportClass.CalendarManager.YEAR, ordMonth - 1);
// }
calendar.day = 1;
calendar.hour = 0;
calendar.minute = 0;
calendar.second = 0;
}
private System.DateTime GetDate( string dateString, System.DateTime baseDate, bool useGMT )
{
if ( useGMT )
{
baseDate = baseDate.ToUniversalTime();
}
TclDateTime calendar = new TclDateTime();
calendar.dateTime = baseDate;
calendar.hour = 0;
calendar.minute = 0;
calendar.second = 0;
calendar.millisecond = 0;
ClockToken[] dt = GetTokens( dateString, false );
System.Int32 parsePos = 0;
ClockRelTimespan diff = new ClockRelTimespan();
int hasTime = 0;
int hasZone = 0;
int hasDate = 0;
int hasDay = 0;
int hasOrdMonth = 0;
int hasRel = 0;
while ( parsePos < dt.Length )
{
if ( ParseTime( dt, ref parsePos, calendar ) )
{
hasTime++;
}
else if ( ParseZone( dt, ref parsePos, calendar ) )
{
hasZone++;
}
else if ( ParseIso( dt, ref parsePos, calendar ) )
{
hasDate++;
}
else if ( ParseDate( dt, ref parsePos, calendar ) )
{
hasDate++;
}
else if ( ParseDay( dt, ref parsePos, diff ) )
{
hasDay++;
}
else if ( ParseOrdMonth( dt, ref parsePos, diff ) )
{
hasOrdMonth++;
}
else if ( ParseRelSpec( dt, ref parsePos, diff ) )
{
hasRel++;
}
else if ( ParseNumber( dt, ref parsePos, calendar, hasDate > 0 && hasTime > 0 && hasRel == 0 ) )
{
if ( hasDate == 0 || hasTime == 0 || hasRel > 0 )
{
hasTime++;
}
}
else if ( ParseTrek( dt, ref parsePos, calendar ) )
{
hasDate++;
hasTime++;
}
else
{
goto failed;
}
}
if ( hasTime > 1 || hasZone > 1 || hasDate > 1 || hasDay > 1 || hasOrdMonth > 1 )
{
goto failed;
}
// The following line handles years that are specified using
// only two digits. The line of code below implements a policy
// defined by the X/Open workgroup on the millinium rollover.
// Note: some of those dates may not actually be valid on some
// platforms. The POSIX standard startes that the dates 70-99
// shall refer to 1970-1999 and 00-38 shall refer to 2000-2038.
// This later definition should work on all platforms.
int thisYear = calendar.year;
if ( thisYear < 100 )
{
if ( thisYear >= 69 )
{
calendar.year = thisYear + 1900;
}
else
{
calendar.year = thisYear + 2000;
}
}
if ( hasRel > 0 )
{
if ( hasTime == 0 && hasDate == 0 && hasDay == 0 )
{
calendar.dateTime = baseDate;
}
// Certain JDK implementations are buggy WRT DST.
// Work around this issue by adding a day instead
// of a days worth of seconds.
int seconds_in_day = ( 60 * 60 * 24 );
int seconds = diff.Seconds;
bool negative_seconds = ( seconds < 0 );
int days = 0;
if ( negative_seconds )
seconds *= ( -1 );
while ( seconds >= seconds_in_day )
{
seconds -= seconds_in_day;
days++;
}
if ( negative_seconds )
{
seconds *= ( -1 );
days *= ( -1 );
}
if ( days != 0 )
{
// calendar.add(SupportClass.CalendarManager.DATE, days);
}
if ( seconds != 0 )
{
// calendar.add(SupportClass.CalendarManager.SECOND, seconds);
}
// calendar.add(SupportClass.CalendarManager.MONTH, diff.Months);
}
if ( hasDay > 0 && hasDate == 0 )
{
SetWeekday( calendar, diff );
}
if ( hasOrdMonth > 0 )
{
SetOrdMonth( calendar, diff );
}
try
{
return calendar.dateTime;
}
catch ( Exception )
{
throw new FormatException();
}
failed:
throw new FormatException();
}
private bool ParseTime( ClockToken[] dt, ref System.Int32 parsePos, TclDateTime calendar )
// calendar object to set
{
int pos = parsePos;
if ( pos + 6 < dt.Length && dt[pos].UNumber && dt[pos + 1].is_Renamed( ':' ) && dt[pos + 2].UNumber && dt[pos + 3].is_Renamed( ':' ) && dt[pos + 4].UNumber && dt[pos + 5].is_Renamed( '-' ) && dt[pos + 6].UNumber )
{
ClockToken zone = GetTimeZoneFromRawOffset( ( -dt[pos + 6].Int ) / 100 );
if ( zone != null )
{
calendar.hour = dt[pos].Int;
calendar.minute = dt[pos + 2].Int;
calendar.second = dt[pos + 4].Int;
// TODO
// calendar.setTimeZone(zone.Zone);
parsePos = pos + 7;
return true;
}
}
if ( pos + 4 < dt.Length && dt[pos].UNumber && dt[pos + 1].is_Renamed( ':' ) && dt[pos + 2].UNumber && dt[pos + 3].is_Renamed( ':' ) && dt[pos + 4].UNumber )
{
parsePos = pos + 5;
ParseMeridianAndSetHour( dt, ref parsePos, calendar, dt[pos].Int );
calendar.minute = dt[pos + 2].Int;
calendar.second = dt[pos + 4].Int;
return true;
}
if ( pos + 4 < dt.Length && dt[pos].UNumber && dt[pos + 1].is_Renamed( ':' ) && dt[pos + 2].UNumber && dt[pos + 3].is_Renamed( '-' ) && dt[pos + 4].UNumber )
{
ClockToken zone = GetTimeZoneFromRawOffset( ( -dt[pos + 4].Int ) / 100 );
if ( zone != null )
{
calendar.hour = dt[pos].Int;
calendar.minute = dt[pos + 2].Int;
// calendar.setTimeZone(zone.Zone);
parsePos = pos + 5;
return true;
}
}
if ( pos + 2 < dt.Length && dt[pos].UNumber && dt[pos + 1].is_Renamed( ':' ) && dt[pos + 2].UNumber )
{
parsePos = pos + 3;
ParseMeridianAndSetHour( dt, ref parsePos, calendar, dt[pos].Int );
calendar.minute = dt[pos + 2].Int;
return true;
}
if ( pos + 1 < dt.Length && dt[pos].UNumber && dt[pos + 1].is_Renamed( ClockToken.MERIDIAN ) )
{
parsePos = pos + 1;
ParseMeridianAndSetHour( dt, ref parsePos, calendar, dt[pos].Int );
return true;
}
return false;
}
private bool ParseZone( ClockToken[] dt, ref System.Int32 parsePos, TclDateTime calendar )
// calendar object to set
{
int pos = parsePos;
if ( pos + 1 < dt.Length && dt[pos].is_Renamed( ClockToken.ZONE ) && dt[pos + 1].is_Renamed( ClockToken.DST ) )
{
// calendar.setTimeZone(dt[pos].Zone);
parsePos = pos + 2;
return true;
}
if ( pos < dt.Length && dt[pos].is_Renamed( ClockToken.ZONE ) )
{
// calendar.setTimeZone(dt[pos].Zone);
parsePos = pos + 1;
return true;
}
if ( pos < dt.Length && dt[pos].is_Renamed( ClockToken.DAYZONE ) )
{
// calendar.setTimeZone(dt[pos].Zone);
parsePos = pos + 1;
return true;
}
return false;
}
private bool ParseDay( ClockToken[] dt, ref System.Int32 parsePos, ClockRelTimespan diff )
// time difference to evaluate
{
int pos = parsePos;
if ( pos + 2 < dt.Length && dt[pos].is_Renamed( '+' ) && dt[pos + 1].UNumber && dt[pos + 2].is_Renamed( ClockToken.DAY ) )
{
diff.setWeekday( dt[pos + 2].Int, dt[pos + 1].Int );
parsePos = pos + 3;
return true;
}
if ( pos + 2 < dt.Length && dt[pos].is_Renamed( '-' ) && dt[pos + 1].UNumber && dt[pos + 2].is_Renamed( ClockToken.DAY ) )
{
diff.setWeekday( dt[pos + 2].Int, -dt[pos + 1].Int );
parsePos = pos + 3;
return true;
}
if ( pos + 1 < dt.Length && dt[pos].is_Renamed( ClockToken.NEXT ) && dt[pos + 1].is_Renamed( ClockToken.DAY ) )
{
diff.setWeekday( dt[pos + 1].Int, 2 );
parsePos = pos + 2;
return true;
}
if ( pos + 1 < dt.Length && dt[pos].is_Renamed( ClockToken.DAY ) && dt[pos + 1].is_Renamed( ',' ) )
{
diff.setWeekday( dt[pos].Int );
parsePos = pos + 2;
return true;
}
if ( pos + 1 < dt.Length && dt[pos].UNumber && dt[pos + 1].is_Renamed( ClockToken.DAY ) )
{
diff.setWeekday( dt[pos + 1].Int, dt[pos].Int );
parsePos = pos + 2;
return true;
}
if ( pos < dt.Length && dt[pos].is_Renamed( ClockToken.DAY ) )
{
diff.setWeekday( dt[pos].Int );
parsePos = pos + 1;
return true;
}
return false;
}
private bool ParseDate( ClockToken[] dt, ref System.Int32 parsePos, TclDateTime calendar )
// calendar object to set
{
int pos = parsePos;
if ( pos + 4 < dt.Length && dt[pos].UNumber && dt[pos + 1].is_Renamed( '/' ) && dt[pos + 2].UNumber && dt[pos + 3].is_Renamed( '/' ) && dt[pos + 4].UNumber )
{
calendar.day = dt[pos + 2].Int;
calendar.month = dt[pos].Int;
calendar.year = dt[pos + 4].Int;
parsePos = pos + 5;
return true;
}
if ( pos + 4 < dt.Length && dt[pos].UNumber && dt[pos + 1].is_Renamed( '-' ) && dt[pos + 2].is_Renamed( ClockToken.MONTH ) && dt[pos + 3].is_Renamed( '-' ) && dt[pos + 4].UNumber )
{
calendar.year = dt[pos + 4].Int;
calendar.month = dt[pos + 2].Int;
calendar.day = dt[pos].Int;
parsePos = pos + 5;
return true;
}
if ( pos + 4 < dt.Length && dt[pos].UNumber && dt[pos + 1].is_Renamed( '-' ) && dt[pos + 2].UNumber && dt[pos + 3].is_Renamed( '-' ) && dt[pos + 4].UNumber )
{
calendar.year = dt[pos].Int;
calendar.month = dt[pos + 2].Int;
calendar.day = dt[pos + 4].Int;
parsePos = pos + 5;
return true;
}
if ( pos + 3 < dt.Length && dt[pos].is_Renamed( ClockToken.MONTH ) && dt[pos + 1].UNumber && dt[pos + 2].is_Renamed( ',' ) && dt[pos + 3].UNumber )
{
calendar.day = dt[pos + 1].Int;
calendar.month = dt[pos].Int;
calendar.year = dt[pos + 3].Int;
parsePos = pos + 4;
return true;
}
if ( pos + 2 < dt.Length && dt[pos].UNumber && dt[pos + 1].is_Renamed( '/' ) && dt[pos + 2].UNumber )
{
calendar.day = dt[pos + 2].Int;
calendar.month = dt[pos].Int;
parsePos = pos + 3;
return true;
}
if ( pos + 2 < dt.Length && dt[pos].UNumber && dt[pos + 1].is_Renamed( ClockToken.MONTH ) && dt[pos + 2].UNumber )
{
calendar.day = dt[pos].Int;
calendar.month = dt[pos + 1].Int;
calendar.year = dt[pos + 2].Int;
parsePos = pos + 3;
return true;
}
if ( pos + 1 < dt.Length && dt[pos].is_Renamed( ClockToken.MONTH ) && dt[pos + 1].UNumber )
{
calendar.day = dt[pos + 1].Int;
calendar.month = dt[pos].Int;
parsePos = pos + 2;
return true;
}
if ( pos + 1 < dt.Length && dt[pos].UNumber && dt[pos + 1].is_Renamed( ClockToken.MONTH ) )
{
calendar.day = dt[pos].Int;
calendar.month = dt[pos + 1].Int;
parsePos = pos + 2;
return true;
}
if ( pos < dt.Length && dt[pos].IsoBase )
{
calendar.day = dt[pos].Int % 100;
calendar.month = ( dt[pos].Int % 10000 ) / 100;
calendar.year = dt[pos].Int / 10000;
parsePos = pos + 1;
return true;
}
if ( pos < dt.Length && dt[pos].is_Renamed( ClockToken.EPOCH ) )
{
calendar.day = 1;
calendar.month = 0;
calendar.year = EPOCH_YEAR;
parsePos = pos + 1;
return true;
}
return false;
}
private bool ParseNumber( ClockToken[] dt, ref System.Int32 parsePos, TclDateTime calendar, bool mayBeYear )
// number is considered to be year?
{
int pos = parsePos;
if ( pos < dt.Length && dt[pos].UNumber )
{
parsePos = pos + 1;
if ( mayBeYear )
{
calendar.year = dt[pos].Int;
}
else
{
calendar.hour = dt[pos].Int / 100;
calendar.minute = dt[pos].Int % 100;
calendar.second = 0;
}
return true;
}
return false;
}
private bool ParseRelSpec( ClockToken[] dt, ref System.Int32 parsePos, ClockRelTimespan diff )
// time difference to evaluate
{
if ( !ParseRelUnits( dt, ref parsePos, diff ) )
{
return false;
}
int pos = parsePos;
if ( pos < dt.Length && dt[pos].is_Renamed( ClockToken.AGO ) )
{
diff.negate();
parsePos = pos + 1;
}
return true;
}
private bool ParseRelUnits( ClockToken[] dt, ref System.Int32 parsePos, ClockRelTimespan diff )
// time difference to evaluate
{
int pos = parsePos;
if ( pos + 2 < dt.Length && dt[pos].is_Renamed( '+' ) && dt[pos + 1].UNumber && dt[pos + 2].Unit )
{
diff.addUnit( dt[pos + 2], dt[pos + 1].Int );
parsePos = pos + 3;
return true;
}
if ( pos + 2 < dt.Length && dt[pos].is_Renamed( '-' ) && dt[pos + 1].UNumber && dt[pos + 2].Unit )
{
diff.addUnit( dt[pos + 2], -dt[pos + 1].Int );
parsePos = pos + 3;
return true;
}
if ( pos + 1 < dt.Length && dt[pos].UNumber && dt[pos + 1].Unit )
{
diff.addUnit( dt[pos + 1], dt[pos].Int );
parsePos = pos + 2;
return true;
}
else if ( pos + 2 < dt.Length && dt[pos].is_Renamed( ClockToken.NEXT ) && dt[pos + 1].UNumber && dt[pos + 2].Unit )
{
diff.addUnit( dt[pos + 2], dt[pos + 1].Int );
parsePos = pos + 3;
return true;
}
if ( pos + 1 < dt.Length && dt[pos].is_Renamed( ClockToken.NEXT ) && dt[pos + 1].Unit )
{
diff.addUnit( dt[pos + 1] );
parsePos = pos + 2;
return true;
}
if ( pos < dt.Length && dt[pos].Unit )
{
diff.addUnit( dt[pos] );
parsePos = pos + 1;
return true;
}
return false;
}
private bool ParseOrdMonth( ClockToken[] dt, ref System.Int32 parsePos, ClockRelTimespan diff )
// time difference to evaluate
{
int pos = parsePos;
if ( pos + 2 < dt.Length && dt[pos].is_Renamed( ClockToken.NEXT ) && dt[pos + 1].UNumber && dt[pos + 2].is_Renamed( ClockToken.MONTH ) )
{
diff.addOrdMonth( dt[pos + 2].Int, dt[pos + 1].Int );
parsePos = pos + 3;
return true;
}
if ( pos + 1 < dt.Length && dt[pos].is_Renamed( ClockToken.NEXT ) && dt[pos + 1].is_Renamed( ClockToken.MONTH ) )
{
diff.addOrdMonth( dt[pos + 1].Int, 1 );
parsePos = pos + 2;
return true;
}
return false;
}
private bool ParseIso( ClockToken[] dt, ref System.Int32 parsePos, TclDateTime calendar )
// calendar object to set
{
int pos = parsePos;
if ( pos + 6 < dt.Length && dt[pos].IsoBase && dt[pos + 1].is_Renamed( ClockToken.ZONE ) && dt[pos + 2].UNumber && dt[pos + 3].is_Renamed( ':' ) && dt[pos + 4].UNumber && dt[pos + 5].is_Renamed( ':' ) && dt[pos + 6].UNumber )
{
calendar.day = dt[pos].Int % 100;
calendar.month = ( dt[pos].Int % 10000 ) / 100;
calendar.year = dt[pos].Int / 10000;
calendar.hour = dt[pos + 2].Int;
calendar.minute = dt[pos + 4].Int;
calendar.second = dt[pos + 6].Int;
parsePos = pos + 7;
return true;
}
if ( pos + 2 < dt.Length && dt[pos].IsoBase && dt[pos + 1].is_Renamed( ClockToken.ZONE ) && dt[pos + 1].Zone.GetUtcOffset( calendar.dateTime ).Hours == ( -7 ) * MILLIS_PER_HOUR && dt[pos + 2].IsoBase )
{
calendar.day = dt[pos].Int % 100;
calendar.month = ( dt[pos].Int % 10000 ) / 100;
calendar.year = dt[pos].Int / 10000;
calendar.hour = dt[pos + 2].Int / 10000;
calendar.minute = ( dt[pos + 2].Int % 10000 ) / 100;
calendar.second = dt[pos + 2].Int % 100;
parsePos = pos + 3;
return true;
}
if ( pos + 1 < dt.Length && dt[pos].IsoBase && dt[pos + 1].IsoBase )
{
calendar.day = dt[pos].Int % 100;
calendar.month = ( dt[pos].Int % 10000 ) / 100;
calendar.year = dt[pos].Int / 10000;
calendar.hour = dt[pos + 1].Int / 10000;
calendar.minute = ( dt[pos + 1].Int % 10000 ) / 100;
calendar.second = dt[pos + 1].Int % 100;
parsePos = pos + 2;
return true;
}
return false;
}
private bool ParseTrek( ClockToken[] dt, ref System.Int32 parsePos, TclDateTime calendar )
// calendar object to set
{
int pos = parsePos;
if ( pos + 3 < dt.Length && dt[pos].is_Renamed( ClockToken.STARDATE ) && dt[pos + 1].UNumber && dt[pos + 2].is_Renamed( '.' ) && dt[pos + 3].UNumber )
{
GregorianCalendar gcal = new GregorianCalendar();
int trekYear = dt[pos + 1].Int / 1000 + 2323 - 377;
int trekDay = 1 + ( ( dt[pos + 1].Int % 1000 ) * ( gcal.IsLeapYear( trekYear ) ? 366 : 365 ) ) / 1000;
int trekSeconds = dt[pos + 3].Int * 144 * 60;
calendar.year = trekYear;
calendar.dateTime = gcal.AddDays( calendar.dateTime, trekDay );
calendar.second = trekSeconds;
parsePos = pos + 4;
return true;
}
return false;
}
private void ParseMeridianAndSetHour( ClockToken[] dt, ref System.Int32 parsePos, TclDateTime calendar, int hour )
// hour value (1-12 or 0-23) to set.
{
int pos = parsePos;
int hourField;
if ( pos < dt.Length && dt[pos].is_Renamed( ClockToken.MERIDIAN ) )
{
// SupportClass.CalendarManager.manager.Set(calendar, SupportClass.CalendarManager.AM_PM, dt[pos].Int);
parsePos = pos + 1;
hourField = SupportClass.CalendarManager.HOUR;
}
else
{
hourField = SupportClass.CalendarManager.HOUR_OF_DAY;
}
if ( hourField == SupportClass.CalendarManager.HOUR && hour == 12 )
{
hour = 0;
}
calendar.hour = hour;
}
private ClockToken[] GetTokens( string in_Renamed, bool debug )
// Send the generated token list to stderr?
{
System.Int32 parsePos = 0;
ClockToken dt;
ArrayList tokenVector = new ArrayList( in_Renamed.Length );
while ( ( dt = GetNextToken( in_Renamed, ref parsePos ) ) != null )
{
tokenVector.Add( dt );
}
ClockToken[] tokenArray = new ClockToken[tokenVector.Count];
tokenVector.CopyTo( tokenArray );
#if DEBUG
for ( int ix = 0; ix < tokenArray.Length; ix++ )
{
if ( ix != 0 )
{
System.Console.Error.Write( "," );
}
System.Console.Error.Write( tokenArray[ix].ToString() );
}
System.Console.Error.WriteLine( "" );
#endif
return tokenArray;
}
private ClockToken GetNextToken( string in_Renamed, ref System.Int32 parsePos )
// Current position in input
{
int pos = parsePos;
int sign;
while ( true )
{
while ( pos < in_Renamed.Length && ( System.Char.GetUnicodeCategory( in_Renamed[pos] ) == System.Globalization.UnicodeCategory.SpaceSeparator ) )
{
pos++;
}
if ( pos >= in_Renamed.Length )
{
break;
}
char c = in_Renamed[pos];
if ( System.Char.IsDigit( c ) )
{
int number = 0;
int count = 0;
while ( pos < in_Renamed.Length && System.Char.IsDigit( c = in_Renamed[pos] ) )
{
number = 10 * number + c - '0';
pos++;
count++;
}
parsePos = pos;
return new ClockToken( number, count >= 6 );
}
if ( System.Char.IsLetter( c ) )
{
int beginPos = pos;
while ( ++pos < in_Renamed.Length )
{
c = in_Renamed[pos];
if ( !System.Char.IsLetter( c ) && c != '.' )
{
break;
}
}
parsePos = pos;
return LookupWord( in_Renamed.Substring( beginPos, ( pos ) - ( beginPos ) ) );
}
parsePos = pos + 1;
return new ClockToken( in_Renamed[pos] );
}
parsePos = pos + 1;
return null;
}
private ClockToken LookupWord( string word )
// word to lookup
{
int ix;
string[] names;
string[][] zones;
if ( word.ToUpper().Equals( "am".ToUpper() ) || word.ToUpper().Equals( "a.m.".ToUpper() ) )
{
return new ClockToken( ClockToken.MERIDIAN, SupportClass.CalendarManager.AM );
}
if ( word.ToUpper().Equals( "pm".ToUpper() ) || word.ToUpper().Equals( "p.m.".ToUpper() ) )
{
return new ClockToken( ClockToken.MERIDIAN, SupportClass.CalendarManager.PM );
}
// See if we have an abbreviation for a day or month.
bool abbrev;
if ( word.Length == 3 )
{
abbrev = true;
}
else if ( word.Length == 4 && word[3] == '.' )
{
abbrev = true;
word = word.Substring( 0, ( 3 ) - ( 0 ) );
}
else
{
abbrev = false;
}
DateTimeFormatInfo symbols = new CultureInfo( "en-US" ).DateTimeFormat;
if ( abbrev )
{
names = symbols.AbbreviatedMonthNames;
}
else
{
names = (string[])symbols.MonthNames;
}
for ( ix = 0; ix < names.Length; ix++ )
{
if ( word.ToUpper().Equals( names[ix].ToUpper() ) )
{
return new ClockToken( ClockToken.MONTH, ix + 1 );
}
}
if ( abbrev )
{
names = symbols.AbbreviatedDayNames;
}
else
{
names = symbols.DayNames;
}
for ( ix = 0; ix < names.Length; ix++ )
{
if ( word.ToUpper().Equals( names[ix].ToUpper() ) )
{
return new ClockToken( ClockToken.DAY, ix );
}
}
// Drop out any periods and try the timezone table.
StringBuilder withoutDotsBuf = new StringBuilder( word.Length );
for ( ix = 0; ix < word.Length; ix++ )
{
if ( word[ix] != '.' )
{
withoutDotsBuf.Append( word[ix] );
}
}
string withoutDots = new string( withoutDotsBuf.ToString().ToCharArray() );
// zones = symbols.getZoneStrings();
// for (ix = 0; ix < zones.Length; ix++)
// {
// if (withoutDots.ToUpper().Equals(zones[ix][2].ToUpper()) || withoutDots.ToUpper().Equals(zones[ix][4].ToUpper()))
// {
//
// System.TimeZone zone = TimeZone.getTimeZone(zones[ix][0]);
// return new ClockToken(ClockToken.ZONE, zone);
// }
// }
if ( withoutDots.ToUpper().Equals( "dst".ToUpper() ) )
{
return new ClockToken( ClockToken.DST, null );
}
// Strip off any plural and try the units.
string singular;
if ( word.EndsWith( "s" ) )
{
singular = word.Substring( 0, ( word.Length - 1 ) - ( 0 ) );
}
else
{
singular = word;
}
if ( singular.ToUpper().Equals( "year".ToUpper() ) )
{
return new ClockToken( ClockToken.MONTH_UNIT, 12 );
}
else if ( singular.ToUpper().Equals( "month".ToUpper() ) )
{
return new ClockToken( ClockToken.MONTH_UNIT, 1 );
}
else if ( singular.ToUpper().Equals( "fortnight".ToUpper() ) )
{
return new ClockToken( ClockToken.MINUTE_UNIT, 14 * 24 * 60 );
}
else if ( singular.ToUpper().Equals( "week".ToUpper() ) )
{
return new ClockToken( ClockToken.MINUTE_UNIT, 7 * 24 * 60 );
}
else if ( singular.ToUpper().Equals( "day".ToUpper() ) )
{
return new ClockToken( ClockToken.MINUTE_UNIT, 24 * 60 );
}
else if ( singular.ToUpper().Equals( "hour".ToUpper() ) )
{
return new ClockToken( ClockToken.MINUTE_UNIT, 60 );
}
else if ( singular.ToUpper().Equals( "minute".ToUpper() ) )
{
return new ClockToken( ClockToken.MINUTE_UNIT, 1 );
}
else if ( singular.ToUpper().Equals( "min".ToUpper() ) )
{
return new ClockToken( ClockToken.MINUTE_UNIT, 1 );
}
else if ( singular.ToUpper().Equals( "second".ToUpper() ) )
{
return new ClockToken( ClockToken.SEC_UNIT, 1 );
}
else if ( singular.ToUpper().Equals( "sec".ToUpper() ) )
{
return new ClockToken( ClockToken.SEC_UNIT, 1 );
}
if ( singular.ToUpper().Equals( "tomorrow".ToUpper() ) )
{
return new ClockToken( ClockToken.MINUTE_UNIT, 1 * 24 * 60 );
}
else if ( singular.ToUpper().Equals( "yesterday".ToUpper() ) )
{
return new ClockToken( ClockToken.MINUTE_UNIT, ( -1 ) * 24 * 60 );
}
else if ( singular.ToUpper().Equals( "today".ToUpper() ) )
{
return new ClockToken( ClockToken.MINUTE_UNIT, 0 );
}
else if ( singular.ToUpper().Equals( "now".ToUpper() ) )
{
return new ClockToken( ClockToken.MINUTE_UNIT, 0 );
}
else if ( singular.ToUpper().Equals( "last".ToUpper() ) )
{
return new ClockToken( -1, false );
}
else if ( singular.ToUpper().Equals( "this".ToUpper() ) )
{
return new ClockToken( ClockToken.MINUTE_UNIT, 0 );
}
else if ( singular.ToUpper().Equals( "next".ToUpper() ) )
{
return new ClockToken( ClockToken.NEXT, 1 );
}
else if ( singular.ToUpper().Equals( "ago".ToUpper() ) )
{
return new ClockToken( ClockToken.AGO, 1 );
}
else if ( singular.ToUpper().Equals( "epoch".ToUpper() ) )
{
return new ClockToken( ClockToken.EPOCH, 0 );
}
else if ( singular.ToUpper().Equals( "stardate".ToUpper() ) )
{
return new ClockToken( ClockToken.STARDATE, 0 );
}
// Since a military timezone (T) is used in the clock test of 8.3,
// we can't ignore these timezones any longer...
if ( withoutDots.Length == 1 )
{
int rawOffset = 0;
bool found = true;
char milTz = System.Char.ToLower( withoutDots[0] );
if ( milTz >= 'a' && milTz <= 'm' )
{
rawOffset = milTz - 'a' + 1;
}
else if ( milTz >= 'n' && milTz < 'z' )
{
rawOffset = 'n' - milTz - 1;
}
else if ( milTz != 'z' )
{
found = false;
}
if ( found )
{
ClockToken zone = GetTimeZoneFromRawOffset( rawOffset );
if ( zone != null )
{
return zone;
}
}
}
return new ClockToken( word );
}
private ClockToken GetTimeZoneFromRawOffset( int rawOffset )
{
// string[] tzNames = TimeZone.getAvailableIDs(rawOffset * MILLIS_PER_HOUR);
// if (tzNames.Length > 0)
// {
//
// System.TimeZone zone = TimeZone.getTimeZone(tzNames[0]);
// return new ClockToken(ClockToken.ZONE, zone);
// }
return null;
}
} // end ClockCmd
class ClockToken
{
public bool UNumber
{
get
{
return kind == UNUMBER;
}
}
public bool IsoBase
{
get
{
return kind == ISOBASE;
}
}
public bool Unit
{
get
{
return kind == MINUTE_UNIT || kind == MONTH_UNIT || kind == SEC_UNIT;
}
}
internal int Int
{
get
{
return number;
}
}
internal System.TimeZone Zone
{
get
{
return zone;
}
}
internal const int ISOBASE = 1;
internal const int UNUMBER = 2;
internal const int WORD = 3;
internal const int CHAR = 4;
internal const int MONTH = 5;
internal const int DAY = 6;
internal const int MONTH_UNIT = 7;
internal const int MINUTE_UNIT = 8;
internal const int SEC_UNIT = 9;
internal const int AGO = 10;
internal const int EPOCH = 11;
internal const int ZONE = 12;
internal const int DAYZONE = 13;
internal const int DST = 14;
internal const int MERIDIAN = 15;
internal const int NEXT = 16;
internal const int STARDATE = 17;
internal ClockToken( int number, bool isIsoBase )
{
this.kind = isIsoBase ? ISOBASE : UNUMBER;
this.number = number;
}
internal ClockToken( int kind, int number )
{
this.kind = kind;
this.number = number;
}
internal ClockToken( int kind, System.TimeZone zone )
{
this.kind = kind;
this.zone = zone;
}
internal ClockToken( string word )
{
this.kind = WORD;
this.word = word;
}
internal ClockToken( char c )
{
this.kind = CHAR;
this.c = c;
}
public bool is_Renamed( char c )
{
return this.kind == CHAR && this.c == c;
}
public bool is_Renamed( int kind )
{
return this.kind == kind;
}
public override string ToString()
{
if ( UNumber )
{
return "U" + System.Convert.ToString( Int );
}
else if ( IsoBase )
{
return "I" + System.Convert.ToString( Int );
}
else if ( kind == WORD )
{
return word;
}
else if ( kind == CHAR )
{
return c.ToString();
}
else if ( kind == ZONE || kind == DAYZONE )
{
return zone.StandardName;
}
else
{
return "(" + kind + "," + Int + ")";
}
}
private int kind;
private int number;
private string word;
private char c;
private System.TimeZone zone;
} // end ClockToken
class ClockRelTimespan
{
internal int Seconds
{
get
{
return seconds;
}
}
internal int Months
{
get
{
return months;
}
}
internal int OrdMonth
{
get
{
return ordMonth;
}
}
internal int DayOrdinal
{
get
{
return dayOrdinal;
}
}
internal ClockRelTimespan()
{
seconds = 0;
months = 0;
ordMonth = 0;
weekday = 0;
dayOrdinal = 0;
}
internal void addSeconds( int s )
{
seconds += s;
}
internal void addMonths( int m )
{
months += m;
}
internal void addOrdMonth( int m, int c )
{
months = m;
ordMonth += c;
}
internal void addUnit( ClockToken unit, int amount )
{
if ( unit.is_Renamed( ClockToken.SEC_UNIT ) )
{
addSeconds( unit.Int * amount );
}
else if ( unit.is_Renamed( ClockToken.MINUTE_UNIT ) )
{
addSeconds( unit.Int * 60 * amount );
}
else if ( unit.is_Renamed( ClockToken.MONTH_UNIT ) )
{
addMonths( unit.Int * amount );
}
}
internal void addUnit( ClockToken unit )
{
addUnit( unit, 1 );
}
internal void setWeekday( int w, int ord )
{
weekday = w;
dayOrdinal = ord;
}
internal void setWeekday( int w )
{
setWeekday( w, 1 );
}
internal void negate()
{
seconds = -seconds;
months = -months;
}
internal int getWeekday()
{
return weekday;
}
private int seconds;
private int months;
private int ordMonth;
private int weekday;
private int dayOrdinal;
}
class TclDateTime
{
public int year, month, day, hour, minute, second, millisecond;
public DateTime dateTime
{
get
{
return new DateTime( year, month, day, hour, minute, second, millisecond );
}
set
{
DateTime dt = value;
year = dt.Year;
month = dt.Month;
day = dt.Day;
hour = dt.Hour;
minute = dt.Minute;
second = dt.Second;
millisecond = dt.Millisecond;
}
}
}
}