time.cpp

GNU ccScript is a C++ class framework for creating a virtual machine execution system for use with a

// Copyright (C) 1999-2005 Open Source Telecom Corporation.
//  
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software 
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
// 
// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// This exception applies only to the code released under the name GNU
// ccScript.  If you copy code from other releases into a copy of GNU
// ccScript, as the General Public License permits, the exception does
// not apply to the code that you add in this way.  To avoid misleading
// anyone as to the status of such modified files, you must delete
// this exception notice from them.
//
// If you write modifications of your own for GNU ccScript, it is your choice
// whether to permit this exception to apply to your modifications.
// If you do not wish that, delete this exception notice.
//

#include "script3.h"

namespace ccscript3Extension {

using namespace std;
using namespace ost;

class TimeProperty : public ScriptProperty
{
public:
	TimeProperty();

	void set(const char *data, char *temp, unsigned size);

	long getValue(const char *data);

	char token(void);

	void clear(char *data, unsigned size);

        static bool testLocaltime(ScriptInterp *interp, const char *v);
};

class DateProperty : public ScriptProperty
{
public:
        DateProperty();

        void set(const char *data, char *temp, unsigned size);

        long getValue(const char *data);

        char token(void);

        void clear(char *data, unsigned size);
};

class TimeMethods : public ScriptMethods
{
public:
	bool scrTime(void);
	bool scrDate(void);
};

class TimeChecks : public ScriptChecks
{
public:
};

static Script::Define runtime[] = {
        {"time", true, (Script::Method)&TimeMethods::scrTime,
                (Script::Check)&ScriptChecks::chkType},
	{"date", true, (Script::Method)&TimeMethods::scrDate,
		(Script::Check)&ScriptChecks::chkType},
        {NULL, false, NULL, NULL}};   

static ScriptBinder bindTime(runtime);
static TimeProperty typeTime;
static DateProperty typeDate;

DateProperty::DateProperty() :
ScriptProperty("date")
{
}

char DateProperty::token(void)
{
	return '-';
}

long DateProperty::getValue(const char *date)
{
	long year, month, day;
	const char *fp, *lp;

	fp = strchr(date, '-');
	lp = strrchr(date, '-');

	if(fp && fp != lp)
	{
		year = atol(date);
		month = atol(++fp);
		day = atol(++lp);
		goto jul;
	}
		
	fp = strchr(date, '/');
	lp = strrchr(date, '/');
	
	if(fp && fp != lp)
	{
		year = atol(++lp);
		month = atol(date);
		day = atol(++fp);
		goto jul;
	}

	fp = strchr(date, '.');
	lp = strrchr(date, '.');
	if(fp && fp != lp)
	{
		year = atol(++lp);
		month = atol(++fp);
		day = atol(date);
		goto jul;
	}

	return atol(date);

jul:
	if(year < 10)
		year += 2000;
	else if(year < 100)
		year += 1900;

	return day - 32075l +
                1461l * (year + 4800l + ( month - 14l) / 12l) / 4l +
                367l * (month - 2l - (month - 14l) / 12l * 12l) / 12l -
                3l * ((year + 4900l + (month - 14l) / 12l) / 100l) / 4l;
}

void DateProperty::set(const char *data, char *save, unsigned size)
{
	long julian = getValue(data);
	long year, month, day;

	if(size < 11)
	{
		snprintf(save, size, "%ld", julian);
		return;
	}

        double i, j, k, l, n;

        l = julian + 68569.0;
        n = int( 4 * l / 146097.0);
        l = l - int( (146097.0 * n + 3)/ 4 );
        i = int( 4000.0 * (l+1)/1461001.0);
        l = l - int(1461.0*i/4.0) + 31.0;
        j = int( 80 * l/2447.0);
        k = l - int( 2447.0 * j / 80.0);
        l = int(j/11);
        j = j+2-12*l;
        i = 100*(n - 49) + i + l;
        year = int(i);
        month = int(j);
        day = int(k);

	snprintf(save, size, "%04ld-%02ld-%02ld", year, month, day);
}	

TimeProperty::TimeProperty() :
ScriptProperty("time")
{
        addConditional("localtime", &testLocaltime);
}

char TimeProperty::token(void)
{
	return ':';
}

long TimeProperty::getValue(const char *data)
{
	long val;

	const char *mp = strchr(data, ':');
	const char *sp = strrchr(data, ':');

	if(mp == sp)
		sp = NULL;

	if(!mp)
		return atol(data);

	val = atol(data) * 3600l;
	if(mp)
		val += atol(++mp) * 60l;

	if(sp)
		val += atol(++sp);

	return val;
}

void DateProperty::clear(char *data, unsigned size)
{
	if(!size)	
		size = 11;

	if(size < 11)
		data[0] = 0;
	else
		strcpy(data, "0000-00-00");
}

void TimeProperty::set(const char *data, char *save, unsigned size)
{
	long val = getValue(data);

	val %= 86400l;

	if(size < 6)
		snprintf(save, size, "%ld", val);
	else if(size < 9)
		snprintf(save, size, "%02ld:%02ld",
			val / 3600l, (val / 60l) % 60);
	else
		snprintf(save, size, "%02ld:%02ld:%02ld",
			val / 3600l, (val / 60l) % 60, val % 60);
}

void TimeProperty::clear(char *data, unsigned size)
{
	if(!size)
		size = 9;

	if(size < 6)	
	{
		strcpy(data, "0");
		return;
	}
	else if(size < 9)
		snprintf(data, size, "00:00");
	else
		snprintf(data, size, "00:00:00");
}	

bool TimeMethods::scrDate(void)
{
	const char *cp;
        ScriptProperty *p = &typeDate;
        Symbol *sym;
        time_t now;
        struct tm *dt, dtd;
        char dts[12];

        time(&now);
        dt = localtime_r(&now, &dtd);
	if(dt->tm_year < 500)
		dt->tm_year += 1900;

	snprintf(dts, sizeof(dts), "%04d-%02d-%02d",
		dt->tm_year, dt->tm_mon + 1, dt->tm_mday);


        while(NULL != (cp = getOption(NULL)))
        {
                sym = mapSymbol(cp, 11 + sizeof(p));
                if(!sym)
                        continue;

                if(sym->type != symINITIAL)
                {
                        commit(sym, dts);
                        continue;
                }

                sym->type = symPROPERTY;
                memcpy(sym->data, &p, sizeof(p));
                strcpy(sym->data + sizeof(p), dts);
        }
        advance();
        return true;
}

bool TimeMethods::scrTime(void)
{
	const char *cp;
	ScriptProperty *p = &typeTime;
	Symbol *sym;
	time_t now;
	struct tm *dt, dtd;
	char dts[10];

	time(&now);
	dt = localtime_r(&now, &dtd);
	snprintf(dts, sizeof(dts), "%02d:%02d:%02d", 
		dt->tm_hour, dt->tm_min, dt->tm_sec);

	while(NULL != (cp = getOption(NULL)))
	{
		sym = mapSymbol(cp, 9 + sizeof(p));
		if(!sym)
			continue;

		if(sym->type != symINITIAL)
		{
			commit(sym, dts);
			continue;
		}

		sym->type = symPROPERTY;
		memcpy(sym->data, &p, sizeof(p));
		strcpy(sym->data + sizeof(p), dts);			
	}
	advance();
	return true;
}

bool TimeProperty::testLocaltime(ScriptInterp *interp, const char *v)
{
        char *tok;
        char *tp;
        struct tm *dt, dtp;
        time_t now;
        char buf[256];
        long ftime;
        long ltime;
        long ntime;
        bool day[7] = {false, false, false, false, false, false, false};
	static char *dayname[7] = {"sun", "mon", "tue", "wed", "thu", "fri", "sat"};
        unsigned idx;

        time(&now);
        dt = localtime_r(&now, &dtp);
        setString(buf, sizeof(buf), v);
        ntime = dt->tm_hour * 60 + dt->tm_min;
        bool weekday = false;

        tok = strtok_r(buf, ", ;\t", &tp);
        while(NULL != tok)
        {
                if(strchr(tok, ':'))
                {     
                        ftime = 0;
                        ltime = 24 * 60;
                        if(*tok != '-')
                        {
                                ftime = 60 * atoi(tok);
                                tok = strchr(tok, ':');
                                if(tok)
                                        ftime += atoi(++tok);
                                else
                                        tok = "";
                        }

                        tok = strchr(tok, '-');
                        if(tok)
                        {
                                ltime = 60 * atoi(++tok);
                                tok = strchr(tok, ':');  
                                if(tok)
                                        ltime += atoi(++tok);
                        }

                        if(ntime < ftime || ntime > ltime)
                                return false;

                        goto loop;
                }


                for(idx = 0 ; idx < 7; ++idx)
                {
                        if(!strnicmp(dayname[idx], tok, 3))
                                break;
                }

                if(idx < 7)
                {
                        weekday = true;
                        day[idx] = true;
                        goto loop;
                }

                if(!stricmp(tok, "weekday"))
                {
                        weekday = true;
                        day[1] = day[2] = day[3] = day[4] = day[5] = true;
                        goto loop;
                }

                if(!stricmp(tok, "weekend"))
                {
                        weekday = true;
                        day[0] = day[6] = true;
                        goto loop;
                }
loop:
                tok = strtok_r(NULL, ", ;\t", &tp);
        }
        if(weekday)
                return day[dt->tm_wday];
        return true;
}

}; // namespace