//=============================================================================
//
//   File : kvi_kvs_corefunctions_gl.cpp
//   Created on Fri 31 Oct 2003 01:52:04 by Szymon Stefanek
//
//   This file is part of the KVIrc IRC client distribution
//   Copyright (C) 2003-2005 Szymon Stefanek <pragma at kvirc dot net>
//
//   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 opinion) 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. ,51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
//
//=============================================================================

#define __KVIRC__

#include "kvi_kvs_corefunctions.h"

#include "kvi_kvs_kernel.h"

#include "kvi_kvs_timermanager.h"
#include "kvi_kvs_arraycast.h"
#include "kvi_locale.h"
#include "kvi_input.h"
#include "kvi_app.h"
#include "kvi_channel.h"
#include "kvi_console.h"
#include "kvi_iconmanager.h"
#include "kvi_mirccntrl.h"
#include "kvi_frame.h"
#include "kvi_time.h"
#include "kvi_kvs_eventmanager.h"
#include "kvi_kvs_eventhandler.h"
#include <tqregexp.h>
#include "kvi_lagmeter.h"

namespace KviKvsCoreFunctions
{
	///////////////////////////////////////////////////////////////////////////////////////////////

	/*
		@doc: hash
		@type:
			function
		@title:
			$hash
		@short:
			Explicitly creates a hash
		@syntax:
			<hash> $hash([<key:string>,<value:variant>,[<key:string>,<value:variant>]],...)
		@description:
			Returns a hash with the specified items. Each <value> is indexed by the preceeding <key>.
			This is just an explicit way of creating a hash with a defined set of items,
			useful for increasing readability.
		@examples:
			[example]
				[cmd]alias[/cmd](test){ [cmd]return[/cmd] $hash(1,X,2,Y,3,Z); };
				%x = $test();
				[cmd]foreach[/cmd](%y,%x)
				{
					[cmd]echo[/cmd] %y;
				}
				[cmd]foreach[/cmd](%y,[fnc]$keys[/fnc](%x))
				{
					[cmd]echo[/cmd] %y
				}
			[/example]
		@seealso:
			[fnc]$array[/fnc]
	*/

	KVSCF(hash)
	{
#ifdef COMPILE_NEW_KVS
		KviKvsHash * a = new KviKvsHash();

		for(KviKvsVariant * key = KVSCF_pParams->first();key;key = KVSCF_pParams->next())
		{
			KviKvsVariant * val = KVSCF_pParams->next();
			if(!val)break;
			TQString sz;
			key->asString(sz);
			a->set(sz,new KviKvsVariant(*val));
		}

		KVSCF_pRetBuffer->setHash(a);
#endif
		return true;
	}

	///////////////////////////////////////////////////////////////////////////////////////////////

	/*
		@doc: hextoAscii
		@type:
			function
		@title:
			$hexToAscii
		@short:
			Returns a decoded hex string
		@syntax:
			$hexToAscii(<hex_encoded_string>)
		@description:
			Decodes the <hex_encoded_string> to its ASCII representation.
		@examples:
			[example]
				[cmd]echo[/cmd] $hexToAscii(6B76697263)
			[/example]
		@seealso:
			[fnc]$asciiToHex[/fnc]
	*/

	KVSCF(hexToAscii)
	{
		TQString szHex;
		KVSCF_PARAMETERS_BEGIN
			KVSCF_PARAMETER("hex_encoded_string",KVS_PT_STRING,0,szHex)
		KVSCF_PARAMETERS_END

		KviStr tmp1(szHex);
		char * buf;
		int len = tmp1.hexToBuffer(&buf,true);
		KVSCF_pRetBuffer->setString(TQString(KviTQCString(buf,len+1)));
		KviStr::freeBuffer(buf);
		return true;
	}

	///////////////////////////////////////////////////////////////////////////////////////////////

	/*
		@doc: hostname
		@type:
			function
		@title:
			$hostname
		@short:
			Returns the hostname of the specified user
		@syntax:
			<string> $hostname(<nickname:string>)
		@description:
			Returns the hostname of the specified IRC user IF it is known.[br]
			The hostname is known if [fnc]$isWellKnown[/fnc] returns 1.[br]
			The hostname is generally known if the user is on a channel with you
			or has an open query with you.[br]
			Detailed explaination:[br]
			KVIrc has an internal database of users that are currently
			visible by *this client*: this includes users on open channels
			and queries.[br] The other IRC users are NOT in the database:
			this means that KVIrc knows NOTHING about them and can't return
			any information immediately. In this case this function will return
			an EMPTY string.[br]
			If a user is in the database, at least his nickname is known.[br]
			The username and hostname are known only if the server provides that information
			spontaneously or after a KVIrc request.[br]
			KVIrc requests user information for all the users in open queries
			and channels. This information takes some time to be retrieved,
			in this interval of time KVIrc knows only the user's nickname.
			This function will return the string "*" in this case.[br]
		@seealso:
			[fnc]$isWellKnown[/fnc], [fnc]$username[/fnc], [cmd]awhois[/cmd]
	*/

	KVSCF(hostname)
	{
		TQString szNick;

		KVSCF_PARAMETERS_BEGIN
			KVSCF_PARAMETER("nick",KVS_PT_NONEMPTYSTRING,0,szNick)
		KVSCF_PARAMETERS_END

		if(KVSCF_pContext->window()->console())
		{
			if(KVSCF_pContext->window()->console()->isConnected())
			{
				KviIrcUserEntry * e = KVSCF_pContext->window()->connection()->userDataBase()->find(szNick);
				if(e)
				{
					KVSCF_pRetBuffer->setString(e->host());
					return true;
				}
			}
		}

		KVSCF_pRetBuffer->setNothing();
		return true;
	}
	
	//-------------------------------------------------
	/*
 	    @doc: lag
 	    @type:
			function
 	    @title:
 	    		$lag
 	    @short:
	 	        Returns the lag on the current server
 	    @syntax:
 		        <integer> lag
 	    @description:
 	    		This function returns the lag in the current server, in milliseconds.[br]
	*/
	
	KVSCF(lag)
	{
	        if(!KVSCF_pContext->window()->console()) return KVSCF_pContext->errorNoIrcContext();
 	        if(!KVSCF_pContext->window()->console()->connection())  return KVSCF_pContext->warningNoIrcConnection();
 	        if(!KVSCF_pContext->window()->console()->connection()->lagMeter())
 	        {
 	            KVSCF_pContext->warning(__tr2qs("Lag meter was not enabled"));
 	            return false;
 	        }
 	        
 	        KVSCF_pRetBuffer->setInteger( KVSCF_pContext->window()->console()->connection()->lagMeter()->lag());
 	        return true;
	}
	/////////////////////////////////////////////////////////////////////////////////////////

	/*
		@doc: hptimestamp
		@type:
			function
		@title:
			$hptimestamp
		@short:
			Returns a high precision timestamp
		@syntax:
			<float> $hptimestamp
		@description:
			Returns a high precision timestamp as a floaint point value.
			The timestamp rappresent the number of seconds elapsed since
			a certain moment in the past. The number of seconds
			contains a "high precision" fractional part. The "certain moment" definition
			depends on the platform KVIrc is executed. This means that
			this timestamp is totally useless to rappresent a time value
			but is useful to compute time intervals with sub-second precision.
		@examples:
			[example]
				%tmp = $hptimestamp
				[cmd]echo[/cmd] $($hptimestamp - %tmp)
			[/example]
		@seealso:
			[fnc]$unixTime[/fnc], [fnc]$date[/fnc]
	*/

	KVSCF(hptimestamp)
	{
		struct timeval tv;
		kvi_gettimeofday(&tv,0);
		kvs_real_t dTimestamp = (kvs_real_t)(tv.tv_sec);
		dTimestamp += (((kvs_real_t)(tv.tv_usec)) / 1000000.0);
		KVSCF_pRetBuffer->setReal(dTimestamp);
		return true;
	}

	///////////////////////////////////////////////////////////////////////////////////////////////

	/*
		@doc: icon
		@type:
			function
		@title:
			$icon
		@short:
			Returns the ID of an icon
		@syntax:
			<integer> $icon(<iconname:string>)
		@description:
			Returns the ID of the icon <iconname>.
			You should always use this function where an <image_id> is required
			and you want to use an internal icon.
			See [fnc]$iconname[/fnc] for a list of the icon names supported by kvirc.[br]
		@examples:
			[example]
				[cmd]echo[/cmd] $icon(linux)
			[/example]
		@seealso:
			[fnc]$iconName[/fnc]
	*/

	KVSCF(icon)
	{
		TQString szName;
		KVSCF_PARAMETERS_BEGIN
			KVSCF_PARAMETER("iconName",KVS_PT_NONEMPTYSTRING,0,szName)
		KVSCF_PARAMETERS_END

		KVSCF_pRetBuffer->setInteger(g_pIconManager->getSmallIconIdFromName(szName));
		return true;
	}

	///////////////////////////////////////////////////////////////////////////////////////////////

	/*
		@doc: iconname
		@type:
			function
		@title:
			$iconname
		@short:
			Returns the name of an icon
		@syntax:
			$iconname(<iconid>)
		@description:
			Returns the name of a builtin icon given an <iconid>.
			The <iconid> is returned by the function [fnc]$icon[/fnc].
			If the <iconid> is not valid, an empty name is returned.[br]
			The following code will list all the available icon names:[br]
			[example]
				%i = 0
				[cmd]do[/cmd] {
					%name = $iconname(%i)
					echo The icon by ID %i is named %name
					%i++
				} [cmd]while[/cmd](%name != "")
			[/example]
		@examples:
			[example]
				[cmd]echo[/cmd] $iconname(24)
				[cmd]echo[/cmd] $iconname([fnc]$icon[/fnc](linux))
			[/example]
		@seealso:
			[fnc]$iconName[/fnc]
	*/

	KVSCF(iconName)
	{
		kvs_uint_t uIco;
		KVSCF_PARAMETERS_BEGIN
			KVSCF_PARAMETER("iconid",KVS_PT_UINT,0,uIco)
		KVSCF_PARAMETERS_END

		if(uIco < KVI_NUM_SMALL_ICONS)
		{
			KVSCF_pRetBuffer->setString(g_pIconManager->getSmallIconName(uIco));
		} else {
			KVSCF_pRetBuffer->setNothing();
		}
		return true;
	}


	///////////////////////////////////////////////////////////////////////////////////////////////

	/*
		@doc: integer
		@type:
			function
		@title:
			$integer
		@short:
			Casts a variable to an integer
		@syntax:
			<integer> $integer(<data:variant>)
		@description:
			Forces <data> to be an integer data type with the following
			semantics:[br]
			[ul]
				[li]If <data> is an integer, <data> itself is returned.[/li]
				[li]If <data> is a boolean, its numeric value is returned (either 1 or 0).[/li]
				[li]If <data> is a real, its integer part is returned.[/li]
				[li]If <data> is an array, the count of its items is returned.[/li]
				[li]If <data> is a hash, the count of its items is returned.[/li]
				[li]If <data> is a string, its length is returned.[/li]
				[li]If <data> is an object, 0 is returned if the reference is null (invalid) and 1 otherwise[/li]
			[/ul]
			This function is similar to the C (int) cast and is internally
			aliased to [fnc]$int[/fnc]() too.
			Note that since KVIrc does most of the casting work automatically
			you shouldn't need to use this function.
		@seealso:
			[fnc]$real[/fnc]
			[fnc]$boolean[/fnc]
	*/

	/*
		@doc: int
		@type:
			function
		@title:
			$int
		@short:
			Casts a variable to an integer
		@syntax:
			<integer> $int(<data:variant>)
		@description:
			This is an internal alias to [fnc]$integer[/fnc]().
		@seealso:
			[fnc]$real[/fnc]
			[fnc]$boolean[/fnc]
	*/

	KVSCF(integer)
	{
		KviKvsVariant * v;
		KVSCF_PARAMETERS_BEGIN
			KVSCF_PARAMETER("data",KVS_PT_VARIANT,0,v)
		KVSCF_PARAMETERS_END

		kvs_int_t iVal;
		v->castToInteger(iVal);
		KVSCF_pRetBuffer->setInteger(iVal);
		return true;
	}

	///////////////////////////////////////////////////////////////////////////////////////////////

	/*
		@doc: isMainWindowActive
		@type:
			function
		@title:
			$isMainWindowActive
		@short:
			Checks if main KVirc window is active
		@syntax:
			<boolean> $isMainWindowActive()
		@description:
			Returns true if the KVIrc's window is currently
			the active window on the current desktop.
	*/

	KVSCF(isMainWindowActive)
	{
		KVSCF_pRetBuffer->setBoolean(g_pFrame->isActiveWindow());
		return true;
	}

	///////////////////////////////////////////////////////////////////////////////////////////////

	/*
		@doc: isMainWindowMinimized
		@type:
			function
		@title:
			$isMainWindowMinimized
		@short:
			Checks if main KVirc window is minimized
		@syntax:
			<boolean> $isMainWindowMinimized()
		@description:
			Returns true if main KVirc window is minimized and false otherwise.
	*/

	KVSCF(isMainWindowMinimized)
	{
		KVSCF_pRetBuffer->setBoolean(g_pFrame->isMinimized());
		return true;
	}

	///////////////////////////////////////////////////////////////////////////////////////////////

	/*
		@doc: isempty
		@type:
			function
		@title:
			$isEmpty
		@short:
			Checks if a variable is set (empty or non empty)
		@syntax:
			<boolean> $isEmpty(<data:variant>)
		@description:
			Returns 0 if <data> is actually set to some non-empty value
			and 1 otherwise. Since KVIrc treats unset variables as empty
			ones then this function is the exact opposite of [fnc]$isSet[/fnc].
		@seealso:
			[fnc]$isSet[/fnc]
	*/

	KVSCF(isEmpty)
	{
#ifdef COMPILE_NEW_KVS
		KviKvsVariant * v;
		KVSCF_PARAMETERS_BEGIN
			KVSCF_PARAMETER("data",KVS_PT_VARIANT,0,v)
		KVSCF_PARAMETERS_END

		KVSCF_pRetBuffer->setBoolean(v->isEmpty());
#endif
		return true;
	}
	//FIXME: documentation

	///////////////////////////////////////////////////////////////////////////////////////////////

	/*
		@doc: iseventenabled
		@type:
			function
		@title:
			$isEventEnabled
		@short:
			Checks if an event enabled
		@syntax:
			<boolean> $isEventEnabled(<event_name:string>,<handler_name:string>)
		@description:
			Returns 1 if the event handler enabled
	*/

	///////////////////////////////////////////////////////////////////////////////////////////////

	KVSCF(isEventEnabled)
	{
		TQString szEventName,szHandlerName;
		KviKvsScriptEventHandler *h=0;

		KVSCF_PARAMETERS_BEGIN
			KVSCF_PARAMETER("event_name",KVS_PT_NONEMPTYSTRING,0,szEventName)
			KVSCF_PARAMETER("handler_name",KVS_PT_NONEMPTYSTRING,0,szHandlerName)
		KVSCF_PARAMETERS_END

		bool bOk;
		int iNumber = szEventName.toInt(&bOk);
		bool bIsRaw = (bOk && (iNumber >= 0) && (iNumber < 1000));

		if(bIsRaw)
		{
			if(!KviKvsEventManager::instance()->isValidRawEvent(iNumber))
			{
					KVSCF_pContext->warning(__tr2qs("No such event (%Q)"),&szEventName);
			} else {
				h=KviKvsEventManager::instance()->findScriptRawHandler(iNumber,szHandlerName);
			}
		} else {
			iNumber = KviKvsEventManager::instance()->findAppEventIndexByName(szEventName);
			if(!KviKvsEventManager::instance()->isValidAppEvent(iNumber))
			{
					KVSCF_pContext->warning(__tr2qs("No such event (%Q)"),&szEventName);
			} else {
				h=KviKvsEventManager::instance()->findScriptAppHandler(iNumber,szHandlerName);
			}
		}
		if(h)
			KVSCF_pRetBuffer->setBoolean(h->isEnabled());
		else
			KVSCF_pContext->warning(__tr2qs("No such event handler (%Q) for event %Q"),&szHandlerName,&szEventName);

		return true;
	}

	///////////////////////////////////////////////////////////////////////////////////////////////

	/*
		@doc: isnumeric
		@type:
			function
		@title:
			$isNumeric
		@syntax:
			<boolean> $isNumeric(<data:variant>)
		@short:
			Finds whether a variable contains a rappresentation of a number
		@description:
			Returns 1 if the <data> is an integer or a real number, 0 otherwise.
	*/

	KVSCF(isNumeric)
	{
#ifdef COMPILE_NEW_KVS
		KviKvsVariant * v;
		KVSCF_PARAMETERS_BEGIN
			KVSCF_PARAMETER("data",KVS_PT_VARIANT,0,v)
		KVSCF_PARAMETERS_END

		KviKvsNumber n;
		KVSCF_pRetBuffer->setBoolean(v->asNumber(n));
#endif
		return true;
	}

	///////////////////////////////////////////////////////////////////////////////////////////////

	/*
		@doc: isset
		@type:
			function
		@title:
			$isSet
		@short:
			Checks if a variable is set (non-empty)
		@syntax:
			<boolean> $isSet(<data:variant>)
		@description:
			Returns 1 if <data> is actually set to some non-empty value
			and 0 otherwise. If <data> is a variable , then this function
			simply checks if the variable is set. If <data> is a constant
			then this function checks if the constant is non empty.
			Since KVIrc treats empty strings as "unset" values then
			this function could be also called "isNonEmpty" and it is
			the perfect opposite of [fnc]$isEmpty[/fnc]
		@seealso:
			[fnc]$isEmpty[/fnc], [cmd]unset[/cmd]
	*/

	KVSCF(isSet)
	{
#ifdef COMPILE_NEW_KVS
		KviKvsVariant * v;
		KVSCF_PARAMETERS_BEGIN
			KVSCF_PARAMETER("data",KVS_PT_VARIANT,0,v)
		KVSCF_PARAMETERS_END

		KVSCF_pRetBuffer->setBoolean(!v->isEmpty());
#endif
		return true;
	}

	///////////////////////////////////////////////////////////////////////////////////////////////

	/*
		@doc: istimer
		@type:
			function
		@title:
			$isTimer
		@short:
			Checks for a timer existence
		@syntax:
			<boolean> $istimer(<name:string>)
		@description:
			Returns 1 if the timer named <name> is actually running, else 0
		@seealso:
			[cmd]timer[/cmd], [cmd]killtimer[/cmd]
	*/

	KVSCF(isTimer)
	{
		TQString szName;

		KVSCF_PARAMETERS_BEGIN
			KVSCF_PARAMETER("timerName",KVS_PT_NONEMPTYSTRING,0,szName)
		KVSCF_PARAMETERS_END
		KVSCF_pRetBuffer->setBoolean(KviKvsTimerManager::instance()->timerExists(szName));
		return true;
	}

	///////////////////////////////////////////////////////////////////////////////////////////////

	/*
		@doc: iswellknown
		@type:
			function
		@title:
			$isWellKnown
		@short:
			Returns $true if the specified user is well known
		@syntax:
			<bool> $isWellKnown(<nickname:string>)
		@description:
			Returns 1 if KVIrc has the basic user information about the specified <nickname>.[br]
			The basic information include the username and hostname.[br]
			This is almost always true if the user is on a channel with you or
			you have an open query with him.[br]
			If $isWellKnown returns 0, [fnc]$username[/fnc] and [fnc]$hostname[/fnc]
			will return empty strings.[br]
			In this case you must use [cmd]awhois[/cmd] to obtain the user basic information.[br]
	*/

	KVSCF(isWellKnown)
	{
		TQString szNick;

		KVSCF_PARAMETERS_BEGIN
			KVSCF_PARAMETER("nick",KVS_PT_NONEMPTYSTRING,0,szNick)
		KVSCF_PARAMETERS_END

		if(KVSCF_pContext->window()->console())
		{
			if(KVSCF_pContext->window()->console()->isConnected())
			{
				KviIrcUserEntry * e = KVSCF_pContext->window()->connection()->userDataBase()->find(szNick);
				if(e)
				{
					KVSCF_pRetBuffer->setBoolean(e->hasHost() && e->hasUser());
					return true;
				}
			}
		}

		KVSCF_pRetBuffer->setBoolean(false);
		return true;
	}

	///////////////////////////////////////////////////////////////////////////////////////////////

	/*
		@doc: k
		@type:
			function
		@title:
			$k
		@short:
			Returns the COLOR mIRC control character
		@syntax:
			<string> $k(<foreground:integer>[,<background:integer>])
			<string> $k
		@description:
			Returns the COLOR mIRC control character (TQt::CTRL+K).[br]
			If <foreground> and <background> are passed, a standard mIRC
			color escape is returned.[br]
		@seealso:
			[fnc]$b[/fnc]
	*/

	KVSCF(k)
	{
		kvs_uint_t iFore,iBack;
		KVSCF_PARAMETERS_BEGIN
			KVSCF_PARAMETER("foreground",KVS_PT_UINT,KVS_PF_OPTIONAL,iFore)
			KVSCF_PARAMETER("background",KVS_PT_UINT,KVS_PF_OPTIONAL,iBack)
		KVSCF_PARAMETERS_END

		TQString szRet = TQChar(KVI_TEXT_COLOR);
		if(KVSCF_pParams->count() > 0)
		{
			KviTQString::appendFormatted(szRet,"%u",iFore);
			if(KVSCF_pParams->count() > 1)
				KviTQString::appendFormatted(szRet,",%u",iBack);
		}
		KVSCF_pRetBuffer->setString(szRet);
		return true;
	}

	///////////////////////////////////////////////////////////////////////////////////////////////

	/*
		@doc: keys
		@type:
			function
		@title:
			$keys
		@short:
			Returns the array of keys of a hash
		@syntax:
			<array> $keys(<hash_value:hash>)
		@description:
			Returns an array with the keys of the <hash> parameter.
			<hash> must be obviously a hash (or eventually an empty variable
			that is treated as an empty hash).
		@seealso:
			[cmd]foreach[/cmd]
	*/

	KVSCF(keys)
	{
#ifdef COMPILE_NEW_KVS
		KviKvsHash * pHash;
		KVSCF_PARAMETERS_BEGIN
			KVSCF_PARAMETER("hash",KVS_PT_HASH,0,pHash)
		KVSCF_PARAMETERS_END

		KviKvsArray * a = new KviKvsArray();
		kvs_int_t idx = 0;
		KviKvsHashIterator it(*(pHash->dict()));
		while(it.current())
		{
			a->set(idx,new KviKvsVariant(it.currentKey()));
			idx++;
			++it;
		}
		KVSCF_pRetBuffer->setArray(a);
#endif
		return true;
	}
	///////////////////////////////////////////////////////////////////////////////////////////////

	/*
		@doc: lang
		@type:
			function
		@title:
			$lang
		@short:
			Returns name of currently used language
		@syntax:
			<string> $lang([<type:string>])
		@description:
			Returns the short name of currently used language
			Type <type> should be one of: [br]
			"full"  - returns full locale name, such as ru_RU.UTF-8 (default)
			"lang"  - return language name, such as "ru_RU"
			"short" - returns only language group such as "ru"
	*/

	KVSCF(lang)
	{
		TQString szType;

		KVSCF_PARAMETERS_BEGIN
			KVSCF_PARAMETER("type",KVS_PT_NONEMPTYSTRING,KVS_PF_OPTIONAL,szType)
		KVSCF_PARAMETERS_END

		TQString szLocale(KviLocale::localeName().ptr());
		if(szType=="lang") KVSCF_pRetBuffer->setString(szLocale.left(5));
		else if(szType=="short") KVSCF_pRetBuffer->setString(szLocale.left(2));
		else KVSCF_pRetBuffer->setString(szLocale);
		return true;
	}




	///////////////////////////////////////////////////////////////////////////////////////////////

	/*
		@doc: length
		@type:
			function
		@title:
			$length
		@short:
			Returns the length of a variable
		@syntax:
			<integer> $length(<value:variant>)
		@description:
			When <value> is an array or a hash, it returns the number
			of its elements. When <value> is an object reference it returns 0.
			In all the other cases <value> is interpreted
			as a string and its length is returned.
		@seealso:
			[fnc]$str.len[/fnc]
	*/

	KVSCF(length)
	{
		KviKvsVariant * pVar;
		KVSCF_PARAMETERS_BEGIN
			KVSCF_PARAMETER("value",KVS_PT_VARIANT,0,pVar)
		KVSCF_PARAMETERS_END

		switch(pVar->type())
		{
			case KviKvsVariantData::Array:
				KVSCF_pRetBuffer->setInteger(pVar->array()->size());
			break;
			case KviKvsVariantData::Hash:
				KVSCF_pRetBuffer->setInteger(pVar->hash()->size());
			break;
			case KviKvsVariantData::HObject:
				KVSCF_pRetBuffer->setInteger(0);
			break;
			default:
			{
				TQString tmp;
				pVar->asString(tmp);
				KVSCF_pRetBuffer->setInteger(tmp.length());
			}
			break;
		}
		return true;
	}

	///////////////////////////////////////////////////////////////////////////////////////////////

	/*
		@doc: lf
		@type:
			function
		@title:
			$lf
		@short:
			Returns a line feed character
		@syntax:
			<string> $lf
		@description:
			Returns a line feed character
		@seealso:
			[fnc]$cr[/fnc], [fnc]$ascii[/fnc], [fnc]$char[/fnc]
	*/

	KVSCF(lf)
	{
		KVSCF_pRetBuffer->setString(TQString(TQChar('\n')));
		return true;
	}

};