--- /dev/null
+//####COPYRIGHTBEGIN####
+//
+// ----------------------------------------------------------------------------
+// Copyright (C) 1998, 1999, 2000 Red Hat, Inc.
+//
+// This program is part of the eCos host tools.
+//
+// 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.
+//
+// ----------------------------------------------------------------------------
+//
+//####COPYRIGHTEND####
+// Properties.cpp: implementation of the CProperties class.
+//
+//////////////////////////////////////////////////////////////////////
+#include "Properties.h"
+#include "eCosTrace.h"
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+
+CProperties::CProperties()
+{
+}
+
+CProperties::~CProperties()
+{
+}
+
+#ifdef _WIN32
+bool CProperties::LoadFromRegistry(HKEY hTopKey,LPCTSTR szRegKey)
+{
+ HKEY hKey;
+ LONG l=RegOpenKeyEx (hTopKey, szRegKey, 0L, KEY_QUERY_VALUE, &hKey);
+ bool rc=(ERROR_SUCCESS==l);
+ if(rc){
+ TCHAR szName[256];
+ DWORD dwSizeName=sizeof szName;
+ DWORD dwMaxDatalen;
+ DWORD dwType;
+ if(ERROR_SUCCESS==RegQueryInfoKey(hKey,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,&dwMaxDatalen,NULL,NULL)){
+ char *Data=new char[dwMaxDatalen];
+ DWORD dwDatalen=dwMaxDatalen;
+ for(DWORD dwIndex=0;ERROR_SUCCESS==RegEnumValue(hKey, dwIndex, szName, &dwSizeName, NULL, &dwType, (LPBYTE)Data, &dwDatalen);dwIndex++){
+
+ CProperties::CProperty *p=Lookup(szName);
+ if(p){
+ switch(p->Type){
+ case CProperty::Integer:
+ if(REG_DWORD==dwType){
+ p->SetValue(*(int *)Data);
+ } else {
+ TRACE(_T("Type mismatch - %s: expected REG_DWORD, got %d\n"),(LPCTSTR)p->strName,dwType);
+ rc=false;
+ }
+ break;
+ case CProperty::Bool:
+ if(REG_DWORD==dwType){
+ p->SetValue((bool)0!=*(int *)Data);
+ } else {
+ TRACE(_T("Type mismatch - %s: expected REG_DWORD, got %d\n"),(LPCTSTR)p->strName,dwType);
+ rc=false;
+ }
+ break;
+ case CProperty::Char:
+ if(REG_DWORD==dwType){
+ p->SetValue(*(char *)Data);
+ } else {
+ TRACE(_T("Type mismatch - %s: expected REG_DWORD, got %d\n"),(LPCTSTR)p->strName,dwType);
+ rc=false;
+ }
+ break;
+ case CProperty::Short:
+ if(REG_DWORD==dwType){
+ p->SetValue(*(short *)Data);
+ } else {
+ TRACE(_T("Type mismatch - %s: expected REG_DWORD, got %d\n"),(LPCTSTR)p->strName,dwType);
+ rc=false;
+ }
+ break;
+ case CProperty::Float:
+ case CProperty::Double:
+ case CProperty::szString:
+ if(REG_SZ==dwType){
+ rc&=p->SetValue((LPCTSTR)Data);
+ } else {
+ TRACE(_T("Type mismatch - %s: expected REG_SZ, got %d\n"),(LPCTSTR)p->strName,dwType);
+ rc=false;
+ }
+ break;
+ case CProperty::Void:
+ if(REG_BINARY==dwType){
+ memcpy(p->pData,Data,MIN(dwDatalen,p->nLength));
+ } else {
+ TRACE(_T("Type mismatch - %s: expected REG_BINARY, got %d\n"),(LPCTSTR)p->strName,dwType);
+ rc=false;
+ }
+ break;
+ }
+ } else {
+ TRACE(_T("CProperties::LoadFromRegistry - unrecognized value %s in key %s\n"),szName,szRegKey);
+ rc=false;
+ }
+ dwSizeName=sizeof szName;
+ dwDatalen=dwMaxDatalen;
+ }
+ delete [] Data;
+ dwSizeName=sizeof szName;
+ }
+ RegCloseKey(hKey);
+ } else {
+ TRACE(_T("Failed to open %s\n"),szRegKey);
+ }
+
+ return rc;
+}
+
+bool CProperties::SaveToRegistry(HKEY hTopKey,LPCTSTR szRegKey) const
+{
+ HKEY hKey;
+ CreateKey(szRegKey);
+ bool rc=(ERROR_SUCCESS==RegOpenKeyEx (hTopKey, szRegKey, 0L, KEY_SET_VALUE, &hKey));
+ if(rc){
+ for(int i=ar.size()-1;i>=0;--i){
+ // Initializations are simply to avoid compiler warnings.
+ DWORD dwDatalen=0;
+ DWORD dwType=REG_DWORD;
+ BYTE *Data=0;
+ // strValue and dw *must* be in scope for RegSetValueEx below.
+ DWORD dw;
+ String strValue;
+ const CProperty &p=ar[i];
+ switch(p.Type){
+ case CProperties::CProperty::Integer:
+ case CProperties::CProperty::Bool:
+ case CProperties::CProperty::Char:
+ case CProperties::CProperty::Short:
+ dwType=REG_DWORD;
+ dwDatalen=sizeof(DWORD);
+ dw=p.GetValue();
+ Data=(BYTE *)&dw;
+ break;
+ case CProperties::CProperty::Float:
+ case CProperties::CProperty::Double:
+ case CProperties::CProperty::szString:
+ strValue=p.GetStringValue();
+ Data=(BYTE *)(LPCTSTR)strValue;
+ dwType=REG_SZ;
+ dwDatalen=(1+strValue.size())*sizeof(_TCHAR);
+ break;
+ case CProperties::CProperty::Void:
+ Data=(BYTE *)p.pData;
+ dwType=REG_BINARY;
+ dwDatalen=p.nLength;
+ break;
+ default:
+ assert(false);
+ break;
+ }
+ rc&=(ERROR_SUCCESS==RegSetValueEx(hKey,p.strName,0,dwType,Data,dwDatalen));
+ }
+ }
+ RegCloseKey(hKey);
+ return rc;
+}
+
+// Create all keys down to the one specified
+bool CProperties::CreateKey(LPCTSTR pszKey,HKEY hKey/*=HKEY_CURRENT_USER*/)
+{
+ bool rc=true;
+ LPCTSTR pcStart=pszKey;
+ LPCTSTR pcEnd;
+ do {
+ HKEY hKey2;
+ pcEnd=_tcschr(pcStart,_TCHAR('\\'));
+ if(NULL==pcEnd){
+ pcEnd=pcStart+_tcslen(pcStart);
+ }
+ String strKey(pcStart,pcEnd-pcStart);
+ if(ERROR_SUCCESS!=RegCreateKeyEx(hKey, // handle to an open key
+ strKey, // address of subkey name
+ 0, // reserved
+ 0, // address of class string
+ REG_OPTION_NON_VOLATILE, // special options flag
+ KEY_ALL_ACCESS, // desired security access
+ NULL,
+ // address of key security structure
+ &hKey2, // address of buffer for opened handle
+ NULL// address of disposition value buffer);
+ )){
+ rc=false;
+ break;
+ }
+ RegCloseKey(hKey);
+ hKey=hKey2;
+ pcStart=pcEnd+1;
+ } while (_TCHAR('\0')!=*pcEnd);
+ RegCloseKey(hKey);
+ return rc;
+}
+
+#endif
+
+bool CProperties::LoadFromCommandString(LPCTSTR psz)
+{
+ bool rc=true;
+ const TCHAR *cNext;
+ for(LPCTSTR c=_tcschr(psz,_TCHAR('-'));c;c=_tcschr(cNext,_TCHAR('-'))){
+ c++;
+ const TCHAR *pEq=_tcschr(c,_TCHAR('='));
+ if(NULL==pEq){
+ TRACE(_T("Failed to find '=' after %s\n"),c);
+ rc=false;
+ break;
+ }
+ String strName(c,pEq-c);
+ CProperties::CProperty *p=Lookup(strName);
+ c=pEq+1;
+ String str;
+ if(_TCHAR('"')==*c){
+ // Value is a quoted string
+ for(cNext=c+1;_TCHAR('"')!=*cNext;cNext++){
+ if(_TCHAR('\\')==*cNext){
+ cNext++;
+ }
+ str+=*cNext;
+ }
+ } else {
+ // Value is simply terminated by whitespace
+ for(cNext=c;_TCHAR('\0')!=*cNext && !_istspace(*cNext);cNext++);
+ str=String(c,cNext-c);
+ }
+ if(p){
+ rc&=p->SetValue(str);
+ } else {
+ TRACE(_T("Properties: unrecognized attribute %s in command string\n"),(LPCTSTR)strName);
+ rc=false;
+ }
+ c=cNext;
+ }
+ return rc;
+}
+
+CProperties::CProperty * CProperties::Lookup(LPCTSTR pszName)
+{
+ for(int i=ar.size()-1;i>=0;--i){
+ CProperties::CProperty &p=ar[i];
+ if(0==_tcsicmp(p.strName,pszName)){
+ return &p;
+ }
+ }
+ return NULL;
+}
+
+String CProperties::MakeCommandString() const
+{
+ String strResult;
+ bool bFirst=true;
+ for(int i=ar.size()-1;i>=0;--i){
+ String str;
+ const CProperty &p=ar[i];
+ switch(p.Type){
+ case CProperties::CProperty::Integer:
+ case CProperties::CProperty::Bool:
+ case CProperties::CProperty::Char:
+ case CProperties::CProperty::Short:
+ str.Format(_T("-%s=%u"),(LPCTSTR)p.strName,p.GetValue());
+ break;
+ case CProperties::CProperty::szString:
+ {
+ // Quote the string, escaping existing quotes as necessary
+ str.Format(_T("-%s=\""),(LPCTSTR)p.strName);
+ for(LPCTSTR c=p.GetStringValue();*c;c++){
+ if(_TCHAR('"')==*c){
+ str+=_TCHAR('\\');
+ }
+ str+=*c;
+ }
+ str+=_TCHAR('"');
+ }
+ break;
+ case CProperties::CProperty::Float:
+ case CProperties::CProperty::Double:
+ case CProperties::CProperty::Void:
+ str.Format(_T("-%s=%s"),(LPCTSTR)p.GetStringValue());
+ break;
+ }
+ if(!bFirst){
+ strResult+=_TCHAR(' ');
+ }
+ bFirst=false;
+ strResult+=str;
+ }
+ return strResult;
+}
+
+bool CProperties::CreatePathToFile(LPCTSTR pszDir)
+{
+ // Create intermediate directories
+#ifdef _WIN32
+ const TCHAR cSep='\\';
+#else // UNIX
+ const TCHAR cSep='/';
+#endif
+ for(LPCTSTR c=_tcschr(pszDir,cSep);c;c=_tcschr(c+1,cSep)){
+#ifdef _WIN32
+ if(c==pszDir+2 && _istalpha(pszDir[0]) && _TCHAR(':')==pszDir[1]){
+ continue; // don't attempt to create "C:"
+ }
+#endif
+ String strDir(pszDir,c-pszDir);
+ struct _stat buf;
+ if(!(0==_tstat(strDir,&buf) && (S_IFDIR&buf.st_mode))){
+ // Need to create directory
+ bool b=(0==_tmkdir(strDir));
+ TRACE(_T("Create directory %s rc=%d\n"),(LPCTSTR)strDir,b);
+ if(!b){
+ return false;
+ }
+ }
+ }
+ return true;
+}
+
+bool CProperties::SaveToFile(LPCTSTR pszFileName) const
+{
+ CreatePathToFile(pszFileName);
+ FILE *f=_tfopen(pszFileName,_T("w") MODE_TEXT);
+ if(f){
+ for(int i=ar.size()-1;i>=0;--i){
+ const CProperty &p=ar[i];
+ String str(p.strName);
+ str+=_TCHAR('=');
+ switch(p.Type){
+ case CProperties::CProperty::Integer:
+ case CProperties::CProperty::Bool:
+ case CProperties::CProperty::Char:
+ case CProperties::CProperty::Short:
+ str+=String::SFormat(_T("%u"),p.GetValue());
+ break;
+ case CProperties::CProperty::Float:
+ case CProperties::CProperty::Double:
+ case CProperties::CProperty::szString:
+ case CProperties::CProperty::Void:
+ str+=p.GetStringValue();
+ break;
+ }
+ str+=_TCHAR('\n');
+ _fputts(str,f);
+ }
+ fclose(f);
+ }
+ return (0!=f);
+}
+
+bool CProperties::LoadFromFile(LPCTSTR pszFileName)
+{
+ FILE *f=_tfopen(pszFileName,_T("r") MODE_TEXT);
+ bool rc=(0!=f);
+ if(rc){
+ TCHAR buf[4096];
+ int nLine=0;
+ String str;
+ while(_fgetts(buf,sizeof(buf)-1,f)){
+
+ nLine++;
+ int nLen=_tcslen(buf);
+ if(nLen>0){
+ // Remove trailing '\n'
+ if(_TCHAR('\n')==buf[nLen-1]){
+ buf[--nLen]=_TCHAR('\0');
+ }
+ // Remove trailing '\r'
+ if(_TCHAR('\r')==buf[nLen-1]){
+ buf[--nLen]=_TCHAR('\0');
+ }
+
+ // Check for continuation lines
+ if(_TCHAR('\\')==buf[nLen-1]){
+ buf[--nLen]=_TCHAR('\0');
+ str+=buf;
+ } else {
+ str+=buf;
+ LPCTSTR c=(LPCTSTR)str;
+ const TCHAR *pEq=_tcschr(c,_TCHAR('='));
+ if(pEq){
+ const String strName(c,pEq-c);
+ CProperties::CProperty *p=Lookup(strName);
+ if(p){
+ pEq++;
+ rc&=p->SetValue(pEq);
+ } else {
+ ERROR(_T("Unknown attribute %s found in %s line %d\n"),(LPCTSTR)strName,pszFileName,nLine);
+ rc=false;
+ }
+ }
+ str=_T("");
+ }
+ }
+ }
+ fclose(f);
+ }
+ return rc;
+}
+
+CProperties::CProperty::CProperty(LPCTSTR pszName,Typetype type,void *_pData):
+ strName(pszName),
+ Type(type),
+ pData(_pData)
+{
+}
+
+CProperties::CProperty::~CProperty()
+{
+}
+
+void CProperties::Add(LPCTSTR pszName,int &n)
+{
+ CProperty p(pszName,CProperty::Integer,&n);
+ ar.push_back(p);
+}
+
+void CProperties::Add(LPCTSTR pszName,unsigned int &n)
+{
+ CProperty p(pszName,CProperty::Integer,&n);
+ ar.push_back(p);
+}
+
+void CProperties::Add(LPCTSTR pszName,bool &b)
+{
+ CProperty p(pszName,CProperty::Bool,&b);
+ ar.push_back(p);
+}
+
+void CProperties::Add(LPCTSTR pszName,char &c)
+{
+ CProperty p(pszName,CProperty::Char,&c);
+ ar.push_back(p);
+}
+
+void CProperties::Add(LPCTSTR pszName,unsigned char &c)
+{
+ CProperty p(pszName,CProperty::Char,&c);
+ ar.push_back(p);
+}
+
+void CProperties::Add(LPCTSTR pszName,short &s)
+{
+ CProperty p(pszName,CProperty::Short,&s);
+ ar.push_back(p);
+}
+
+void CProperties::Add(LPCTSTR pszName,unsigned short &s)
+{
+ CProperty p(pszName,CProperty::Short,&s);
+ ar.push_back(p);
+}
+
+void CProperties::Add(LPCTSTR pszName,float &f)
+{
+ CProperty p(pszName,CProperty::Float,&f);
+ ar.push_back(p);
+}
+
+void CProperties::Add(LPCTSTR pszName,double &f)
+{
+ CProperty p(pszName,CProperty::Double,&f);
+ ar.push_back(p);
+}
+
+void CProperties::Add(LPCTSTR pszName,void *pv,unsigned int _nLength)
+{
+ CProperty p(pszName,CProperty::Void,pv);
+ p.nLength=_nLength;
+ ar.push_back(p);
+}
+
+void CProperties::Add(LPCTSTR pszName,String &s)
+{
+ CProperty p(pszName,CProperty::szString,(void *)&s);
+ ar.push_back(p);
+}
+
+unsigned long CProperties::CProperty::GetValue() const
+{
+ unsigned long dw;
+ switch(Type){
+ case Integer:
+ dw=*(int *)pData;
+ break;
+ case Bool:
+ dw=*(bool *)pData;
+ break;
+ case Char:
+ dw=*(char *)pData;
+ break;
+ case Short:
+ dw=*(short *)pData;
+ break;
+ default:
+ dw=0;
+ assert(false);
+ }
+ return dw;
+}
+
+const String CProperties::CProperty::GetStringValue() const
+{
+ String str;
+ switch(Type){
+ case szString:
+ str=*(String *)pData;
+ break;
+ case CProperties::CProperty::Integer:
+ case CProperties::CProperty::Bool:
+ case CProperties::CProperty::Char:
+ case CProperties::CProperty::Short:
+ str.Format(_T("%u"),GetValue());
+ break;
+ case CProperties::CProperty::Float:
+ str.Format(_T("%e"),*(float *)(pData));
+ break;
+ case CProperties::CProperty::Double:
+ str.Format(_T("%e"),*(double *)(pData));
+ break;
+ case CProperties::CProperty::Void:
+ {
+ unsigned char *c=(unsigned char *)pData;
+ for(unsigned int i=0;i<nLength;i++){
+ TCHAR buf[3];
+ _tprintf(buf,_T("%02x"),c[i]);
+ str+=buf;
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ return str;
+}
+
+bool CProperties::CProperty::SetValue(int n)
+{
+ bool rc=true;
+ switch(Type){
+ case Integer:
+ *(int *)(pData)=n;
+ break;
+ case Bool:
+ *(bool *)(pData)=(0!=n);
+ break;
+ case Char:
+ *(char *)(pData)=(char)n; //FIXME: range checks
+ break;
+ case Short:
+ *(short *)(pData)=(short)n;//FIXME: range checks
+ break;
+ default:
+ TRACE(_T("Failed to set '%s' to integer value '%d'\n"),(LPCTSTR)strName,n);
+ break;
+ }
+ return rc;
+}
+
+bool CProperties::CProperty::SetValue(double n)
+{
+ bool rc=true;
+ switch(Type){
+ case Double:
+ *(float *)(pData)=(float)n;//FIXME: range checks?
+ break;
+ case Float:
+ *(double *)(pData)=n;
+ break;
+ default:
+ TRACE(_T("Failed to set '%s' to double value '%f'\n"),(LPCTSTR)strName,n);
+ rc=false;
+ break;
+ }
+
+ return rc;
+}
+
+bool CProperties::CProperty::SetValue(LPCTSTR psz)
+{
+ bool rc=false;
+ TCHAR *pEnd;
+ double d=0.0;
+ long l=0;
+ switch(Type){
+ case szString:
+ *(String *)pData=psz;
+ rc=true;
+ break;
+ case Float:
+ d=_tcstod(psz,&pEnd);
+ rc=(_TCHAR('\0')==*pEnd);
+ if(rc){
+ SetValue((float)d);
+ }
+ break;
+ case Double:
+ d=_tcstod(psz,&pEnd);
+ rc=(_TCHAR('\0')==*pEnd);
+ if(rc){
+ SetValue(d);
+ }
+ break;
+ case Integer:
+ case Bool:
+ case Char:
+ case Short:
+ l=_tcstol(psz,&pEnd,10);
+ rc=(_TCHAR('\0')==*pEnd);
+ if(rc){
+ SetValue((int)l);
+ }
+ break;
+ default:
+ TRACE(_T("Failed to set '%s' to string value '%s'\n"),(LPCTSTR)strName,psz);
+ break;
+ }
+ return rc;
+}
+
projects / karo-tx-redboot.git / blobdiff