winamp/Src/tagz/functions.cpp

#include "functions.h"
#include "string.h"
#include "varlist.h"
#include <windows.h>
#include <stddef.h>
#include <shlwapi.h>
#include "api__tagz.h"
#include "resource.h"
#include <strsafe.h>
#define MAKEFUNC(X) static void X(size_t n_src, wchar_t **src,size_t *found_src, tagz_::string *out, VarList *vars)

static bool StringMatch(const wchar_t *string1, const wchar_t *string2)
{
	int comp = CompareStringW(LOCALE_USER_DEFAULT,  NORM_IGNORECASE | /*NORM_IGNOREKANATYPE |*/ NORM_IGNOREWIDTH, string1, -1, string2, -1);
	return comp == CSTR_EQUAL;
}

/* ------ Logic ------ */
#if 0
MAKEFUNC(And)
{
	if (n_src != 2)
		out->AddString("[INVALID $and SYNTAX]");
	else
		if (found_src[0] && found_src[1])
			out->AddString("true");

}

MAKEFUNC(Greater)
{
	if (n_src != 2)
		out->AddString("[INVALID $greater SYNTAX]");
	else
	{
		if (_wtoi(src[0])>_wtoi(src[1]))
			out->AddString("true");
	}

}
#endif
#if 0
MAKEFUNC(_StrCmp)
{
	if (n_src != 2)
		out->AddString("[INVALID $STRCMP SYNTAX]");
	else
	{
		int comp = CompareString(LOCALE_USER_DEFAULT, NORM_IGNORECASE | /*NORM_IGNOREKANATYPE |*/ NORM_IGNOREWIDTH, string1, -1, string2, -1);
		return comp == CSTR_EQUAL;
	}
}
#endif

MAKEFUNC(IfStrEqual)
{
	if (n_src != 3)
		out->AddString(WASABI_API_LNGSTRINGW(IDS_INVALID_IF_SYNTAX));
	else
	{
		if (StringMatch(src[0], src[1]))
			out->AddString(src[2]);
	}
}

MAKEFUNC(IfStrNotEqual)
{
	if (n_src != 3)
		out->AddString(WASABI_API_LNGSTRINGW(IDS_INVALID_IF_SYNTAX));
	else
	{
		if (!StringMatch(src[0], src[1]))
			out->AddString(src[2]);
	}
}

MAKEFUNC(IfStrEqual2)
{
	if (n_src != 4)
		out->AddString(WASABI_API_LNGSTRINGW(IDS_INVALID_IF_SYNTAX));
	else
	{
		if (StringMatch(src[0], src[1]))
			out->AddString(src[2]);
		else
			out->AddString(src[3]);
	}
}

MAKEFUNC(If)
{
	if (n_src != 3)
		out->AddString(WASABI_API_LNGSTRINGW(IDS_INVALID_IF_SYNTAX));
	else
		out->AddString(src[found_src[0] ? 1 : 2]);
}

MAKEFUNC(If2)
{
	if (n_src != 2)
		out->AddString(WASABI_API_LNGSTRINGW(IDS_INVALID_IF_SYNTAX));
	else
		out->AddString(src[found_src[0] ? 0 : 1]);
}

MAKEFUNC(If3)
{
	if (!n_src)
		return;
	for (size_t i = 0; i != (n_src-1); i++)
	{
		if (found_src[i])
		{
			out->AddString(src[i]);
			return;
		}
	}
	out->AddString(src[n_src-1]);
}

MAKEFUNC(Decode)
{
	if (n_src == 0)
		return;

	for (size_t s=1;s!=n_src;s+=2)
	{
		if ((s + 1) == n_src) // last (default) parameter
		{
			out->AddString(src[s]);
			return;
		}

		if (StringMatch(src[0], src[s]))
		{
			out->AddString(src[s+1]); // last parameter check (see above) ensures that this is safe
			return;
		}
	}
}

MAKEFUNC(Select)
{
	size_t select = (src[0] ? _wtoi(src[0]) : 0);

	if (select<n_src)
	{
		out->AddString(src[select]);
	}
}

/* ------ Length ------ */
static int NumChars(const wchar_t *x)
{
	int count = 0;
	while (x && *x)
	{
		x = CharNext(x);
		count++;
	}
	return count;
}

MAKEFUNC(Iflonger)
{
	if (n_src != 4) out->AddString(WASABI_API_LNGSTRINGW(IDS_INVALID_IFLONGER_SYNTAX));
	else
	{
		if (NumChars(src[0]) > _wtoi(src[1]))
			out->AddString(src[2]);
		else
			out->AddString(src[3]);
	}
}

MAKEFUNC(PadLeft)
{
	if (n_src >= 2)
	{
		LPTSTR fill = L" ";
		if (n_src >= 3 && src[2][0])
			fill = src[2];
		int num = (src[1] ? _wtoi(src[1]) : 0);
		wchar_t *p = src[0];
		int strChars = NumChars(p);
		if (strChars<num)
		{
			size_t fl = lstrlen(fill);
			while (strChars != num)
			{
				out->AddChar(fill[(--num) % fl]);
			}
		}
		while (p && *p)
		{
			out->AddDBChar(p);
			p = CharNext(p);
		}
	}
}

MAKEFUNC(Pad)
{
	if (n_src >= 2)
	{
		LPTSTR fill = L" ";
		if (n_src >= 3 && src[2][0])
			fill = src[2];
		int num = (src[1] ? _wtoi(src[1]) : 0);
		LPTSTR p = src[0];
		while (p && *p)
		{
			out->AddDBChar(p);
			p = CharNext(p);
			num--;
		}
		size_t fl = lstrlen(fill);
		while (num > 0)
		{
			out->AddChar(fill[(--num) % fl]);
		}
	}
}

MAKEFUNC(Cut)
{
	if (n_src >= 2)
	{
		size_t num = (src[1] ? _wtoi(src[1]) : 0);
		LPTSTR p = src[0];
		while (p && *p && num)
		{
			out->AddDBChar(p);
			p = CharNext(p);
			num--;
		}
	}
}

// todo: benski> there's no way this works (fixed by DrO Mar 2009)
MAKEFUNC(Right)
{
	if (n_src >= 2)
	{
		size_t num = (src[1] ? _wtoi(src[1]) : 0);
		int offset = NumChars(src[0]) - (int)num;
		LPTSTR p = src[0];
		while (p && *p && offset--)
		{
			p = CharNext(p);
		}
		while (p && *p && num)
		{
			out->AddDBChar(p);
			p = CharNext(p);
			num--;
		}
	}
}

MAKEFUNC(PadCut)
{
	if (n_src >= 2)
	{
		LPTSTR fill = L" ";
		if (n_src >= 3 && src[2][0]) fill = src[3];
		size_t num = (src[1] ? _wtoi(src[1]) : 0);
		LPTSTR p = src[0];
		while (p && *p && num > 0)
		{
			out->AddDBChar(p);
			p = CharNext(p);
			num--;
		}
		size_t fl = lstrlen(fill);
		while (num > 0)
		{
			out->AddChar(fill[(--num) % fl]);
		}
	}
}

MAKEFUNC(Longest)
{
	LPTSTR ptr = 0;
	size_t m = 0;
	for (size_t n = 0;n != n_src;n++)
	{
		size_t l = NumChars(src[n]);
		if (l > m)
		{
			m = l;
			ptr = src[n];
		}
	}
	if (ptr)
		out->AddString(ptr);
}

MAKEFUNC(Shortest)
{
	LPTSTR ptr = 0;
	size_t m = (size_t)(-1);
	for (size_t n = 0;n != n_src;n++)
	{
		size_t l = NumChars(src[n]);
		if (l < m)
		{
			m = l;
			ptr = src[n];
		}
	}
	if (ptr)
		out->AddString(ptr);
}

MAKEFUNC(Len)
{
	if (n_src >= 1)
		out->AddInt(NumChars(src[0]));
}

/* ------ Case ------ */
static void DBUpper(LPTSTR x)
{
	LPTSTR end = CharNext(x);
	DWORD count = (DWORD)(end - x);
	CharUpperBuff(x, count);
}

static bool IsSpace(LPTSTR x)
{
	LPTSTR end = CharNext(x);
	int count = (int)(end - x);
	WORD charType = 0;
	GetStringTypeEx(LOCALE_USER_DEFAULT,
	                CT_CTYPE1,
	                x,
	                count,
	                &charType);

	return !!(charType & C1_SPACE);
}

static bool IsWordEnd(LPTSTR x)
{
	/* TODO: decide if we want to do this
	if (x == '\'')
		return false; // keeps words like "isn't" from capitalizing incorrectly, although it does break single quoted strings
		*/

	LPTSTR end = CharNext(x);
	int count = (int)(end - x);
	WORD charType = 0;
	GetStringTypeEx(LOCALE_USER_DEFAULT,
	                CT_CTYPE1,
	                x,
	                count,
	                &charType);

	return !!(charType & C1_SPACE) || !!(charType & C1_PUNCT);
}

static int separator(TCHAR x)
{
	if (!x
	    || x == L' '
	    || x == L'\t') return 1;
	if (x == L'\'' || x == L'_') return 0;
	return 0;
}

MAKEFUNC(Upper)
{
	if (n_src >= 1)
	{
		CharUpper(src[0]);
		out->AddString(src[0]);
	}
}

MAKEFUNC(Lower)
{
	if (n_src >= 1)
	{
		CharLower(src[0]);
		out->AddString(src[0]);
	}
}

MAKEFUNC(Caps)
{
	if (n_src < 1) return ;

	int firstLetter = 1;
	CharLower(src[0]);
	LPTSTR sp = src[0];
	while (sp && *sp)
	{
		bool isSep = IsWordEnd(sp);
		if (!isSep && firstLetter)
			DBUpper(sp);

		sp = CharNext(sp);
		firstLetter = isSep;
	}
	out->AddString(src[0]);
}

MAKEFUNC(Caps2)
{
	if (n_src < 1) return ;

	int firstLetter = 1;
	LPTSTR sp = src[0];
	while (sp && *sp)
	{
		int isSep = IsWordEnd(sp);
		if (!isSep && firstLetter)
			DBUpper(sp);

		sp = CharNext(sp);
		firstLetter = isSep;

	}
	out->AddString(src[0]);
}

/* ------ Numbers ------ */

MAKEFUNC(Num)
{
	if (n_src == 2)
	{
		wchar_t tmp[16] = {0};
		StringCbPrintfW(tmp, sizeof(tmp), L"%0*u", (src[1] ? _wtoi(src[1]) : 0), (src[0] ? _wtoi(src[0]) : 0));
		out->AddString(tmp);
	}
}

MAKEFUNC(Hex)
{
	if (n_src == 2)
	{
		wchar_t tmp[16] = {0};
		StringCbPrintfW(tmp, sizeof(tmp), L"%0*x", (src[1] ? _wtoi(src[1]) : 0), (src[0] ? _wtoi(src[0]) : 0));
		out->AddString(tmp);
	}
}

/* ------ Time ------ */


MAKEFUNC(SysTime_year)
{
	SYSTEMTIME st = {0};
	GetLocalTime(&st);
	wchar_t tmp[16] = {0};
	StringCbPrintfW(tmp, sizeof(tmp), L"%u",st.wYear);
	out->AddString(tmp);
}

MAKEFUNC(SysTime_month) //these are for stream saving, time in filenames
{
	SYSTEMTIME st = {0};
	GetLocalTime(&st);
	wchar_t tmp[16] = {0};
	StringCbPrintfW(tmp, sizeof(tmp), L"%02u",st.wMonth);
	out->AddString(tmp);
}

MAKEFUNC(SysTime_day)
{
	SYSTEMTIME st = {0};
	GetLocalTime(&st);
	wchar_t tmp[16] = {0};
	StringCbPrintfW(tmp, sizeof(tmp), L"%02u",st.wDay);
	out->AddString(tmp);
}

MAKEFUNC(SysTime_hour)
{
	SYSTEMTIME st = {0};
	GetLocalTime(&st);
	wchar_t tmp[16] = {0};
	StringCbPrintfW(tmp, sizeof(tmp), L"%02u",st.wHour);
	out->AddString(tmp);
}

MAKEFUNC(SysTime_minute)
{
	SYSTEMTIME st = {0};
	GetLocalTime(&st);
	wchar_t tmp[16] = {0};
	StringCbPrintfW(tmp, sizeof(tmp), L"%02u",st.wMinute);
	out->AddString(tmp);
}

MAKEFUNC(SysTime_second)
{
	SYSTEMTIME st = {0};
	GetLocalTime(&st);
	wchar_t tmp[16] = {0};
	StringCbPrintfW(tmp, sizeof(tmp), L"%02u",st.wSecond);
	out->AddString(tmp);
}

/* ------ Math ------ */
MAKEFUNC(Ifgreater)
{
	if (n_src!=4)
		out->AddString(WASABI_API_LNGSTRINGW(IDS_INVALID_IFGREATER_SYNTAX));
	else
	{
		if ((src[0] ? _wtoi(src[0]) : 0) > (src[1] ? _wtoi(src[1]) : 0))
			out->AddString(src[2]);
		else
			out->AddString(src[3]);
	}
}

MAKEFUNC(Add)
{
	int s=0;
	for (size_t n=0;n!=n_src;n++)
	{
		s += (src[n] ? _wtoi(src[n]) : 0);
	}
	out->AddInt(s);
}

MAKEFUNC(Sub)
{
	if (n_src>=1)
	{
		int s = (src[0] ? _wtoi(src[0]) : 0);
		for (size_t n=1;n!=n_src;n++)
		{
			s -= (src[n] ? _wtoi(src[n]) : 0);
		}
		out->AddInt(s);
	}
}

MAKEFUNC(Mul)
{
	int s=1;
	for (size_t n=0;n!=n_src;n++)
	{
		s *= (src[n] ? _wtoi(src[n]) : 1);
	}
	out->AddInt(s);
}

MAKEFUNC(Div)
{
	if (n_src>=1)
	{
		int s = (src[0] ? _wtoi(src[0]) : 0);
		for (size_t n = 1; n != n_src; n++)
		{
			int t = (src[n] ? _wtoi(src[n]) : 0);
			if (t) s /= t;
			else t = 0;
		}
		out->AddInt(s);
	}
}

MAKEFUNC(Mod)
{
	if (n_src>=1)
	{
		int s = (src[0] ? _wtoi(src[0]) : 0);
		for (size_t n = 1; n != n_src; n++)
		{
			int t = (src[n] ? _wtoi(src[n]) : 0);
			if (t) s %= t;
			else t = 0;
		}
		out->AddInt(s);
	}
}

MAKEFUNC(_MulDiv)
{
	if (n_src == 3)
	{
		out->AddInt(MulDiv(_wtoi(src[0]), _wtoi(src[1]), _wtoi(src[2])));
	}
}

MAKEFUNC(Max)
{
	if (!n_src) return;
	int m = (src[0] ? _wtoi(src[0]) : 0);
	for (size_t n = 1; n < n_src; n++)
	{
		int t = (src[n] ? _wtoi(src[n]) : 0);
		if (t > m) m = t;
	}
	out->AddInt(m);
}

MAKEFUNC(Min)
{
	if (!n_src) return;
	int m = (src[0] ? _wtoi(src[0]) : 0);
	for (size_t n = 1; n < n_src; n++)
	{
		int t = (src[n] ? _wtoi(src[n]) : 0);
		if (t < m) m = t;
	}
	out->AddInt(m);
}

/* ------ Path ------ */
MAKEFUNC(PathSafe)
{
	LPTSTR p=src[0];
	while (p && *p)
	{
		if (*p <= 31 && *p >= 0)
		{
			// we'll just skip these characters
		}
		else switch (*p)
		{
			case L'?':
			case L'*':
			case  L'|':
				out->AddDBChar(L"_");
				break;
			case '/':
			case L'\\':
			case L':':
				out->AddDBChar(L"-");
				break;
			case L'\"': 
				out->AddDBChar(L"\'");
				break;
			case L'<':
				out->AddDBChar(L"(");
				break;
			case L'>': 
				out->AddDBChar(L")");
				break;
			default:
				out->AddDBChar(p);
		}
		p = CharNext(p);
	}
}

MAKEFUNC(FileName)
{
	if (n_src < 1) return ;
	out->AddString(PathFindFileName(src[0]));
}

MAKEFUNC(FilePart)
{
	if (n_src < 1) return;
	LPTSTR beg = PathFindFileName(src[0]);
	LPTSTR end = PathFindExtension(beg);
	while (beg != end)
	{
		out->AddChar(*beg++);
	}
}

MAKEFUNC(PathRTrim)
{
	if (n_src < 1) return;
	int cut=1;
	if (n_src>=2)
		cut = (src[1] ? _wtoi(src[1]) : 0);
	if (cut<0)
		cut=0;
	wchar_t folder[MAX_PATH] = {0};
	lstrcpyn(folder, src[0], MAX_PATH);
	while (cut--)
	{
		PathRemoveFileSpec(folder);
		PathRemoveBackslash(folder);
	}

	out->AddString(folder);
}

MAKEFUNC(PathLPart)
{
	if (n_src < 1) return;
	int cut=1;
	if (n_src>=2)
		cut = (src[1] ? _wtoi(src[1]) : 0);
	if (cut<0)
		cut=0;
	wchar_t *p = src[0];
	while (cut-- && p)
	{
		p = PathFindNextComponent(p);
	}
	if (p)
		*p = 0;
	PathRemoveBackslash(src[0]);
	out->AddString(src[0]);
}

MAKEFUNC(PathRPart)
{
	if (n_src < 1) return;
	int cut=1;
	if (n_src>=2)
		cut = (src[1] ? _wtoi(src[1]) : 0);
	if (cut<0)
		cut=0;
	wchar_t temp[MAX_PATH] = {0};
	lstrcpyn(temp, src[0], MAX_PATH);
	while (cut--)
	{
		PathRemoveBackslash(temp);
		PathRemoveFileSpec(temp);
		PathAddBackslash(temp);
	}

	out->AddString(&(src[0][lstrlenW(temp)]));
}

MAKEFUNC(PathLTrim)
{
	if (n_src < 1) return;
	int cut=1;
	if (n_src>=2)
		cut = (src[1] ? _wtoi(src[1]) : 0);
	if (cut<0)
		cut=0;
	wchar_t *p = src[0];
	while (cut-- && p)
	{
		p = PathFindNextComponent(p);
	}
	if (p)
		out->AddString(p);
}

MAKEFUNC(FileExt)
{
	if (n_src < 1) return ;
	LPTSTR ext = PathFindExtension(src[0]);
	if (ext) ext = CharNext(ext);
	out->AddString(ext);
}

/* ------ Strings ------ */

static wchar_t roman_num[]=
{
	L'I',L'V',L'X',L'L',L'C',L'D',L'M'
};

static bool IsRoman(LPTSTR ptr)//could be more smart i think
{
	if (ptr[0]==']' && ptr[1]=='[' && IsSpace(ptr+2))
		return true;
	while (!IsSpace(ptr))
	{
		bool found = 0;
		for (size_t n = 0; n < TABSIZE(roman_num); n++)
		{
			if (*ptr==roman_num[n])
			{
				found=1;
				break;
			}
		}
		if (!found)
			return false;
		ptr=CharNext(ptr);
	}
	return true;
}

static bool IsDigit(LPTSTR x)
{
	LPTSTR end = CharNext(x);
	int count = (int)(end - x);
	WORD charType = 0;
	GetStringTypeEx(LOCALE_USER_DEFAULT,
	                CT_CTYPE1,
	                x,
	                count,
	                &charType);

	return !!(charType & C1_DIGIT);
}

// TODO: what's this do exactly???
static bool sepcmp(LPTSTR src, LPTSTR val)
{
	int l=lstrlen(val);
	return !StrCmpNI(src,val,l) && IsSpace(&src[l]);
}

static bool need_full(LPTSTR ptr)
{
	if (IsRoman(ptr))
		return true;
	if (sepcmp(ptr, L"RPG"))
		return true;
	while (ptr && !IsSpace(ptr))
	{
		if (!ptr || !*ptr || !IsDigit(ptr))
			return false;
		ptr = CharNext(ptr);
	}
	return true;
}

static bool CharMatch(LPTSTR string1, LPTSTR string2)
{
	LPTSTR end1 = CharNext(string1);
	LPTSTR end2 = CharNext(string2);

	int count1 = (int)(end1 - string1);
	int count2 = (int)(end2 - string2);
	if (count1 == count2)
	{
		int comp = CompareString(LOCALE_USER_DEFAULT,  /*NORM_IGNORECASE |*/ /*NORM_IGNOREKANATYPE |*/ NORM_IGNOREWIDTH, string1, count1, string2, count2);
		return comp == CSTR_EQUAL;
	}
	else
		return false;
}

MAKEFUNC(_StrChr)
{
	if (n_src == 2)
	{
		LPTSTR p = src[0];
		LPTSTR s = src[1];
		while (p && *p)
		{
			if (CharMatch(p, s))
			{
				out->AddInt(1 + (int)(p - src[0]));
				return ;
			}
			p = CharNext(p);
		}

		out->AddChar('0');
	}
}

MAKEFUNC(_StrRChr)
{
	if (n_src == 2)
	{
		LPTSTR p = src[0], p1 = p;
		LPTSTR s = src[1];

		while (p && *p)
		{
			p1 = p;
			p = CharNext(p);
		}

		while (1)
		{
			if (CharMatch(p1, s))
			{
				out->AddInt(1 + (int)(p1 - src[0]));
				return ;
			}
			if (src[0] == p1)
				break;
			p1 = CharPrev(src[0], p1);
		}
		out->AddChar(L'0');
	}
}

MAKEFUNC(_StrStr)
{
	// TODO: not multi-byte or unicode correct, but we'll deal for now
	if (n_src == 2)
	{
		LPTSTR p = StrStr(src[0], src[1]);
		if (p)
			out->AddInt(1 + (int)(p - src[0]));
		else
			out->AddChar(L'0');
	}
}

MAKEFUNC(SubStr)
{
	int n1, n2;
	if (n_src < 2)
		return ;
	n1 = (src[1] ? _wtoi(src[1]) : 0);
	if (n_src >= 3)
	{
		n2 = (src[2] ? _wtoi(src[2]) : 0);
	}
	else
		n2 = n1;
	if (n1 < 1)
		n1 = 1;
	if (n2 >= n1)
	{
		n1--;
		n2--;
		LPTSTR p=src[0];
		while (n1 <= n2 && p && *p)
		{
			out->AddDBChar(p);
			p = CharNext(p);
		}
	}
}

MAKEFUNC(Split)
{
	if (n_src!=3 || !src[0])
		return;

	LPTSTR p=src[0];
	LPTSTR split=src[1];
	int which = (src[2] ? _wtoi(src[2]) : 0);
	if (which)
	{
		LPCTSTR where = wcsstr(p, split);
		if (where)
		{
			where += wcslen(split);
			out->AddString(where);
		}
	}
	else
	{
		LPCTSTR where = wcsstr(p, split);
		if (where)
		{
			while (p != where)
				out->AddChar(*p++);
		}
		else
			out->AddString(p);
	}
}

MAKEFUNC(Replace)
{
	if (n_src<3 || !src[0])
		return;

	LPTSTR p=src[0];
	while (p && *p)
	{
		LPTSTR p2 = p;
		LPTSTR src1 = src[1];

		while (src1 && *src1 && CharMatch(src1, p2))
		{
			p2 = CharNext(p2);
			src1 = CharNext(src1);
		}

		if (!*src1)
		{
			out->AddString(src[2]);
			p = p2;
		}
		else
		{
			out->AddDBChar(p);
			p = CharNext(p);
		}
	}
}

MAKEFUNC(Trim)
{
	LPTSTR stringStart = src[0];

	// trim from beginning
	while (IsSpace(stringStart))
		stringStart = CharNext(stringStart);

	// trim from end
	LPTSTR stringLast = stringStart+lstrlen(stringStart)+1;
	stringLast=CharPrev(stringStart, stringLast); // have to go back from the null terminator in case the last char is multibyte

	while (IsSpace(stringLast))
	{
		stringLast= CharPrev(stringStart, stringLast);
	}
	stringLast = CharNext(stringLast);
	while (stringStart != stringLast)
	{
		out->AddChar(*stringStart++);
	}
}

/* ------ Generators ------ */

MAKEFUNC(Tab)
{
	int num=1;
	if (n_src == 1)
		num = (src[0] ? _wtoi(src[0]) : 0);
	while (num--)
		out->AddChar(L'\t');
}

MAKEFUNC(Crlf)
{
	out->AddString(L"\r\n");
}

MAKEFUNC(Char)
{
	if (n_src != 1)
		return;

	wchar_t wide[2]={ (wchar_t)(src[0] ? _wtoi(src[0]) : 0),(wchar_t)0};
	out->AddString(wide);
	/* below doesn't seem to work.  not sure why
	wchar_t wide[5]={0,}; // 5 words just in case we go outside the BMP
	int ucs4[2] = {0,0}; // incoming value is encoded in UCS-4 (little endian)
	ucs4[0] = _wtoi(src[0]);
	int x = MultiByteToWideChar(12000, 0, (char*)ucs4, 4, wide, 5); // convert from UCS-4 to UTF-16
	int error = GetLastError();
	*/
}

MAKEFUNC(Repeat)
{
	if (n_src!=2)
		return;

	LPTSTR fillChar=src[0];
	int fillCount=(src[1] ? _wtoi(src[1]) : 0);
	if (fillCount<0)
		return;
	while (fillCount--)
	{
		out->AddString(fillChar);
	}
}

/* ------ Misc ------ */

MAKEFUNC(Abbr)
{
	//abbr(string,len)
	if (n_src == 0 || n_src > 2)
		return;

	if (n_src==2 && NumChars(src[0]) < (src[1] ? _wtoi(src[1]) : 0))
	{
		out->AddString(src[0]);
		return;
	}
	LPTSTR meta=src[0];
	bool w=0,r=0;
	while (meta && *meta)
	{
		bool an=!IsSpace(meta) || *meta==']' || *meta=='[';
		if (w && !an)
		{
			w=0;
		}
		else if (!w && an)
		{
			w=1;
			r=need_full(meta)?1:0;
			out->AddDBChar(meta);
		}
		else if (w && r)
		{
			out->AddDBChar(meta);
		}
		meta=CharNext(meta);
	}
}

MAKEFUNC(Get)
{
	if (n_src >= 1)
	{
		wchar_t *p = vars->Get(src[0]);
		if (p)
			out->AddString(p);
	}
}

MAKEFUNC(Put)
{
	if (n_src >= 2)
	{
		vars->Put(src[0], src[1]);
		out->AddString(src[1]);
	}
}

MAKEFUNC(PutQ)
{
	if (n_src >= 2)
	{
		vars->Put(src[0], src[1]);
	}
}

MAKEFUNC(Null)
{
}

MAKEFUNC(Directory)
{
	int numLevels=1;
	if (n_src == 2)
		numLevels = (src[1] ? _wtoi(src[1]) : 0);

	wchar_t folder[MAX_PATH] = {0};
	lstrcpyn(folder, (src[0] ? src[0] : L""), MAX_PATH);
	while (numLevels--)
	{
		PathRemoveFileSpec(folder);
		PathRemoveBackslash(folder);
	}
	PathStripPath(folder);
	out->AddString(folder);
}

// TODO: order these or sort these, and use a binary search
TextFunction FUNCS[]=
{
	//	Blah,"blah",
	//	Nop,"nop",
	If,L"if",
	If2,L"if2",
	If3, L"if3",
	Upper,L"upper",
	Lower,L"lower",
	Pad,L"pad",
	Cut,L"cut",
	Cut,L"left",
	PadCut,L"padcut",
	Abbr,L"abbr",
	FilePart,L"filepart",
	FilePart,L"filename",
	FileExt,L"fileext",
	FileExt,L"ext",
	PathLTrim,L"PathLTrim",
	PathLPart,L"PathLPart",
	PathRTrim,L"PathRTrim",
	PathRPart,L"PathRPart",
	Caps,L"caps",
	Caps2,L"caps2",
	Longest,L"longest",
	Shortest,L"shortest",
	Iflonger,L"iflonger",
	Ifgreater,L"ifgreater",
	Num,L"num",Num,L"dec",
	Hex,L"hex",
	_StrChr,L"strchr",
	_StrChr,L"strlchr",
	_StrRChr,L"strrchr",
	_StrStr,L"strstr",
	SubStr,L"substr",
	Len,L"len",
	Add,L"add",
	Sub,L"sub",
	Mul,L"mul",
	Div,L"div",
	Mod,L"mod",
	_MulDiv, L"muldiv",
	FileName,L"filename",
	Min,L"min",
	Max,L"max",
	Get,L"get",
	Put,L"put",
	PutQ,L"puts",
	Null,L"null",
	SysTime_year,L"systime_year",
	SysTime_month,L"systime_month",
	SysTime_day,L"systime_day",
	SysTime_hour,L"systime_hour",
	SysTime_minute,L"systime_minute",
	SysTime_second,L"systime_second",
	Replace,L"replace",
	Repeat, L"repeat",
	PadLeft, L"lpad",
	IfStrEqual, L"IfStrEqual",
	IfStrEqual2, L"IfStrEqual2",
	IfStrNotEqual, L"IfStrNotEqual",
	Decode, L"decode",
	//And, L"and",
	//Greater,L"greater",
	Char, L"char",
	Crlf, L"crlf",
	Directory, L"directory",
	Right, L"right",
	Tab, L"tab",
	Trim, L"trim",
	Select, L"select",
	PathSafe, L"pathsafe",
	Split, L"split",
	0,0,
};