Initial commit

ClassicShellSrc/ClassicShellLib/SettingsParser.cpp

@@ -0,0 +1,553 @@
+// Classic Shell (c) 2009-2016, Ivo Beltchev
+// Confidential information of Ivo Beltchev. Not for disclosure or distribution without prior written consent from the author
+
+#include <stdafx.h>
+#include "SettingsParser.h"
+#include "ResourceHelper.h"
+#include "StringUtils.h"
+#include <algorithm>
+
+const int MAX_TREE_LEVEL=10;
+
+// Reads a file into m_Text
+bool CSettingsParser::LoadText( const wchar_t *fname )
+{
+	// read settings file into buf
+	FILE *f=NULL;
+	if (_wfopen_s(&f,fname,L"rb")) return false;
+	if (!f) return false;
+	fseek(f,0,SEEK_END);
+	int size=ftell(f);
+	fseek(f,0,SEEK_SET);
+	std::vector<unsigned char> buf(size);
+	if (size<4 || fread(&buf[0],1,size,f)!=size)
+	{
+		fclose(f);
+		return false;
+	}
+	fclose(f);
+	LoadText(&buf[0],size);
+	return true;
+}
+
+// Reads a text resource into m_Text
+bool CSettingsParser::LoadText( HMODULE hMod, HRSRC hResInfo )
+{
+	HGLOBAL hRes=LoadResource(hMod,hResInfo);
+	int size=SizeofResource(hMod,hResInfo);
+	unsigned char *buf=(unsigned char*)LockResource(hRes);
+	if (!buf) return false;
+	LoadText(buf,size);
+	return true;
+}
+
+void CSettingsParser::LoadText( const unsigned char *buf, int size )
+{
+	// copy buf to text and convert to UTF16
+	if (buf[0]==0xFF && buf[1]==0xFE)
+	{
+		// UTF16
+		int len=(size-2)/2;
+		m_Text.resize(len+1);
+		memcpy(&m_Text[0],&buf[2],size-2);
+		m_Text[len]=0;
+	}
+	else if (buf[0]==0xEF && buf[1]==0xBB && buf[2]==0xBF)
+	{
+		// UTF8
+		int len=MultiByteToWideChar(CP_UTF8,0,(const char*)&buf[3],size-3,NULL,0);
+		m_Text.resize(len+1);
+		MultiByteToWideChar(CP_UTF8,0,(const char*)&buf[3],size-3,&m_Text[0],len);
+		m_Text[len]=0;
+	}
+	else
+	{
+		// ACP
+		int len=MultiByteToWideChar(CP_ACP,0,(const char*)&buf[0],size,NULL,0);
+		m_Text.resize(len+1);
+		MultiByteToWideChar(CP_UTF8,0,(const char*)&buf[0],size,&m_Text[0],len);
+		m_Text[len]=0;
+	}
+}
+
+void CSettingsParser::LoadText( const wchar_t *buf, int size )
+{
+	m_Text.resize(size+1);
+	memcpy(&m_Text[0],buf,size*2);
+	m_Text[size]=0;
+}
+
+// Splits m_Text into m_Lines
+void CSettingsParser::ParseText( void )
+{
+	if (m_Text.empty()) return;
+	// split into lines
+	wchar_t *str=&m_Text[0];
+	while (*str)
+	{
+		if (*str!=';') // ignore lines starting with ;
+		{
+			// trim leading whitespace
+			while (*str==' ' || *str=='\t')
+				str++;
+			m_Lines.push_back(str);
+		}
+		wchar_t *p1=wcschr(str,'\r');
+		wchar_t *p2=wcschr(str,'\n');
+		wchar_t *end=&m_Text[m_Text.size()-1];
+		if (p1) end=p1;
+		if (p2 && p2<end) end=p2;
+
+		wchar_t *next=end;
+		while (*next=='\r' || *next=='\n')
+			next++;
+
+		// trim trailing whitespace
+		while (end>str && (*end==' ' || *end=='\t'))
+			end--;
+		*end=0;
+		str=next;
+	}
+}
+
+// Filters the settings that belong to the given language
+// languages is a 00-terminated list of language names ordered by priority
+void CSettingsParser::FilterLanguages( const wchar_t *languages )
+{
+	std::vector<const wchar_t*> lines;
+	lines.swap(m_Lines);
+	for (const wchar_t *lang=languages;*lang;lang+=wcslen(lang)+1)
+	{
+		size_t langLen=wcslen(lang);
+		for (size_t i=0;i<lines.size();i++)
+		{
+			const wchar_t *line=lines[i];
+			if (*line=='[' && _wcsnicmp(line+1,lang,langLen)==0 && line[langLen+1]==']')
+			{
+				for (i++;i<lines.size();i++)
+				{
+					line=lines[i];
+					if (*line=='[') break;
+					m_Lines.push_back(line);
+				}
+				break;
+			}
+		}
+	}
+	std::reverse(m_Lines.begin(),m_Lines.end());
+}
+
+// Returns a setting with the given name. If no setting is found, returns def
+const wchar_t *CSettingsParser::FindSetting( const wchar_t *name, const wchar_t *def )
+{
+	const wchar_t *str=FindSettingInt(name,wcslen(name));
+	return (str && *str)?str:def;
+}
+
+const wchar_t *CSettingsParser::FindSettingDirect( const wchar_t *name )
+{
+	return FindSettingInt(name,wcslen(name));
+}
+
+const wchar_t *CSettingsParser::FindSettingInt( const wchar_t *name, size_t len )
+{
+	for (std::vector<const wchar_t*>::const_reverse_iterator it=m_Lines.rbegin();it!=m_Lines.rend();++it)
+	{
+		const wchar_t *str=*it;
+		if (_wcsnicmp(name,str,len)==0)
+		{
+			str+=len;
+			while (*str==' ' || *str=='\t')
+				str++;
+			if (*str!='=') continue;
+			str++;
+			while (*str==' ' || *str=='\t')
+				str++;
+			return str;
+		}
+	}
+
+	return NULL;
+}
+
+// Frees all resources
+void CSettingsParser::Reset( void )
+{
+	m_Lines.clear();
+	m_Text.clear();
+}
+
+// Parses a tree structure of items. The rootName setting must be a list of item names.
+void CSettingsParser::ParseTree( const wchar_t *rootName, std::vector<TreeItem> &items )
+{
+	const wchar_t *str=FindSetting(rootName);
+	if (str)
+	{
+		CString names[MAX_TREE_LEVEL];
+		ParseTreeRec(str,items,names,0);
+	}
+	else
+	{
+		TreeItem last={L"",-1};
+		items.push_back(last);
+	}
+}
+
+int CSettingsParser::ParseTreeRec( const wchar_t *str, std::vector<TreeItem> &items, CString *names, int level )
+{
+	size_t start=items.size();
+	while (*str)
+	{
+		wchar_t token[256];
+		str=GetToken(str,token,_countof(token),L", \t");
+		if (token[0])
+		{
+			// 
+			bool bFound=false;
+			for (int i=0;i<level;i++)
+				if (_wcsicmp(token,names[i])==0)
+				{
+					bFound=true;
+					break;
+				}
+				if (!bFound)
+				{
+					TreeItem item={token,-1};
+					items.push_back(item);
+				}
+		}
+	}
+	size_t end=items.size();
+	if (start==end) return -1;
+
+	TreeItem item={L"",-1};
+	items.push_back(item);
+
+	if (level<MAX_TREE_LEVEL-1)
+	{
+		for (size_t i=start;i<end;i++)
+		{
+			wchar_t buf[266];
+			Sprintf(buf,_countof(buf),L"%s.Items",items[i].name);
+			const wchar_t *str2=FindSetting(buf);
+			if (str2)
+			{
+				names[level]=items[i].name;
+				// these two statements must be on separate lines. otherwise items[i] is evaluated before ParseTreeRec, but
+				// the items vector can be reallocated inside ParseTreeRec, causing the address to be invalidated -> crash!
+				int idx=ParseTreeRec(str2,items,names,level+1);
+				items[i].children=idx;
+			}
+		}
+	}
+	return (int)start;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool CSkinParser::LoadVariation( const wchar_t *fname )
+{
+	m_VarText.swap(m_Text);
+	bool res=LoadText(fname);
+	if (res)
+	{
+		std::vector<const wchar_t*> lines;
+		lines.swap(m_Lines);
+		lines.push_back(L"[TRUE]");
+		ParseText();
+		m_Lines.insert(m_Lines.begin(),lines.begin(),lines.end());
+	}
+	m_VarText.swap(m_Text);
+	return res;
+}
+
+bool CSkinParser::LoadVariation( HMODULE hMod, HRSRC hResInfo )
+{
+	m_VarText.swap(m_Text);
+	bool res=LoadText(hMod,hResInfo);
+	if (res)
+	{
+		std::vector<const wchar_t*> lines;
+		lines.swap(m_Lines);
+		lines.push_back(L"[TRUE]");
+		ParseText();
+		m_Lines.insert(m_Lines.begin(),lines.begin(),lines.end());
+	}
+	m_VarText.swap(m_Text);
+	return res;
+}
+
+void CSkinParser::Reset( void )
+{
+	CSettingsParser::Reset();
+	m_VarText.clear();
+}
+
+static const wchar_t *g_OptionNames[SKIN_OPTION_TYPE_COUNT]={
+	L"OPTION ",
+	L"OPTION_NUMBER ",
+	L"OPTION_STRING ",
+	L"OPTION_COLOR ",
+	L"OPTION_IMAGE ",
+};
+
+// Parses the option from m_Lines[index]. Returns false if index is out of bounds
+bool CSkinParser::ParseOption( CString &name, TSkinOptionType &type, CString &label, bool &value, CString &condition, CString &disValue, int index )
+{
+	if (index<0 || index>=(int)m_Lines.size())
+		return false;
+	name.Empty();
+	wchar_t buf[256];
+	const wchar_t *line=m_Lines[index];
+	if (_wcsnicmp(line,L"OPTION",6)!=0)
+		return true;
+	type=SKIN_OPTION_NONE;
+	for (int i=0;i<SKIN_OPTION_TYPE_COUNT;i++)
+	{
+		int len=Strlen(g_OptionNames[i]);
+		if (_wcsnicmp(line,g_OptionNames[i],len)==0)
+		{
+			type=(TSkinOptionType)i;
+			line+=len;
+			break;
+		}
+	}
+	if (type==SKIN_OPTION_NONE)
+		return true;
+
+	const wchar_t *end=wcschr(line,'=');
+	if (!end) return true;
+	line=GetToken(line,buf,_countof(buf),L" \t=");
+	name=buf;
+	line=GetToken(line,buf,_countof(buf),L",");
+	if (buf[0]=='#')
+		label=LoadStringEx(_wtol(buf+1));
+	else
+		label=buf;
+	if (label.IsEmpty())
+		name.Empty();
+	line=GetToken(line,buf,_countof(buf),L" \t,");
+	value=_wtol(buf)!=0;
+	line=GetToken(line,buf,_countof(buf),L",");
+	condition=buf;
+	line=GetToken(line,buf,_countof(buf),L" \t,");
+	disValue=buf;
+	if (type==SKIN_OPTION_BOOL && name==L"RADIOGROUP")
+		type=SKIN_OPTION_GROUP;
+	return true;
+}
+
+// Filters the conditional groups
+// values/count - list of true options. the rest are assumed to be false
+void CSkinParser::FilterConditions( const wchar_t **values, int count )
+{
+	std::vector<const wchar_t*> lines;
+	lines.swap(m_Lines);
+
+	bool bEnable=true;
+
+	for (size_t i=0;i<lines.size();i++)
+	{
+		const wchar_t *line=lines[i];
+		if (*line=='[')
+		{
+			bEnable=false;
+			wchar_t condition[256];
+			const wchar_t *end=wcschr(line,']');
+			if (!end) continue; // not closed
+			int len=(int)(end-line)-1;
+			if (len>_countof(condition)-1)
+				continue; // too long
+			memcpy(condition,line+1,len*2);
+			condition[len]=0;
+
+			// evaluate condition
+			if (EvalCondition(condition,values,count)==1)
+				bEnable=true;
+			continue;
+		}
+		if (bEnable)
+			m_Lines.push_back(line);
+	}
+}
+
+// Substitutes the provided macro strings
+void CSkinParser::ApplyMacros( const std::vector<std::pair<CString,CString>> &macros )
+{
+	std::vector<CString> names;
+	for (std::vector<std::pair<CString,CString>>::const_iterator it=macros.begin();it!=macros.end();++it)
+	{
+		wchar_t name[256];
+		Sprintf(name,_countof(name),L"@%s@",it->first);
+		names.push_back(name);
+	}
+
+	for (std::vector<const wchar_t*>::iterator it=m_Lines.begin();it!=m_Lines.end();++it)
+	{
+		if (wcschr(*it,'@'))
+		{
+			CString string=*it;
+			for (size_t i=0;i<names.size();i++)
+				string.Replace(names[i],macros[i].second);
+
+			m_ExtraStrings.push_back(string);
+			*it=string;
+		}
+	}
+}
+
+// Returns a setting with the given name
+const wchar_t *CSkinParser::FindSetting( const wchar_t *name )
+{
+	const wchar_t *str=CSettingsParser::FindSetting(name);
+	if (!str && m_Aliases)
+	{
+		for (int i=0;m_Aliases[i];i+=2)
+		{
+			if (wcscmp(name,m_Aliases[i])==0)
+				return CSettingsParser::FindSetting(m_Aliases[i+1]);
+		}
+	}
+	return str;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enum TType
+{
+	TYPE_AND,
+	TYPE_OR,
+	TYPE_NOT,
+	TYPE_PAR, // '('
+};
+
+static bool ApplyOperator( bool *valStack, int &vsp, TType op )
+{
+	switch (op)
+	{
+	case TYPE_AND:
+		if (vsp<2) return false;
+		vsp--;
+		valStack[vsp-1]=valStack[vsp-1] && valStack[vsp];
+		return true;
+	case TYPE_OR:
+		if (vsp<2) return false;
+		vsp--;
+		valStack[vsp-1]=valStack[vsp-1] || valStack[vsp];
+		return true;
+	case TYPE_NOT:
+		if (vsp<1) return false;
+		valStack[vsp-1]=!valStack[vsp-1];
+		return true;
+	}
+	return false;
+}
+
+// Evaluates a boolean condition. vars/count - a list of variable names that are TRUE. The rest are assumed FALSE
+// Returns: 0 - false, 1 - true, -1 - error
+int EvalCondition( const wchar_t *condition, const wchar_t *const *values, int count )
+{
+	wchar_t token[256];
+	TType opStack[16];
+	int osp=0;
+	bool valStack[16];
+	int vsp=0;
+
+	while (1)
+	{
+		// skip leading whitespace
+		while (*condition==' ' || *condition=='\t')
+			condition++;
+		if (!*condition) break;
+
+		if (*condition=='(')
+		{
+			if (osp>=_countof(opStack)) return -1; // too much nesting
+			opStack[osp]=TYPE_PAR;
+			osp++;
+			condition++;
+			continue;
+		}
+
+		if (*condition==')')
+		{
+			bool found=false;
+			while (osp>0)
+			{
+				osp--;
+				if (opStack[osp]==TYPE_PAR)
+				{
+					found=true;
+					break;
+				}
+				if (!ApplyOperator(valStack,vsp,opStack[osp])) return -1; // invalid operation
+			}
+			if (!found) return -1; // too many )
+			condition++;
+			continue;
+		}
+
+		// find token
+		const wchar_t *end=condition;
+		while (*end && *end!=' ' && *end!='\t' && *end!='(' && *end!=')')
+			end++;
+
+		int len=(int)(end-condition);
+		if (len>=sizeof(token)) return -1; // too long token
+		memcpy(token,condition,len*2);
+		token[len]=0;
+		condition=end;
+		while (*condition==' ' || *condition=='\t')
+			condition++;
+
+		if (_wcsicmp(token,L"and")==0 || _wcsicmp(token,L"or")==0)
+		{
+			while (osp>0 && opStack[osp-1]!=TYPE_PAR)
+			{
+				osp--;
+				if (!ApplyOperator(valStack,vsp,opStack[osp])) return -1; // invalid operation
+			}
+			if (osp>=_countof(opStack)) return -1; // too much nesting
+			opStack[osp]=(token[0]=='a' || token[0]=='A')?TYPE_AND:TYPE_OR;
+			osp++;
+		}
+		else if (_wcsicmp(token,L"not")==0)
+		{
+			while (osp>0 && opStack[osp-1]==TYPE_NOT)
+			{
+				osp--;
+				if (!ApplyOperator(valStack,vsp,opStack[osp])) return -1; // invalid operation
+			}
+			if (osp>=_countof(opStack)) return -1; // too much nesting
+			opStack[osp]=TYPE_NOT;
+			osp++;
+		}
+		else
+		{
+			if (vsp>=_countof(valStack)) return -1; // too much nesting
+			bool bValue=false;
+			if (_wcsicmp(token,L"true")==0)
+				bValue=true;
+			else
+			{
+				for (int i=0;i<count;i++)
+					if (_wcsicmp(token,values[i])==0)
+					{
+						bValue=true;
+						break;
+					}
+			}
+			valStack[vsp++]=bValue;
+		}
+	}
+
+	while (osp>0)
+	{
+		osp--;
+		if (opStack[osp]==TYPE_PAR) return -1; // unclosed (
+		if (!ApplyOperator(valStack,vsp,opStack[osp])) return -1; // invalid operation
+	}
+
+	if (vsp!=1) return -1; // unbalanced expression
+	return valStack[0]?1:0;
+}