/* Load svchost group specified on the command line via the /k option */
int wmain(int argc, WCHAR *argv[])
{
int option_index;
WINE_TRACE("\n");
for (option_index = 1; option_index < argc; option_index++)
{
if (lstrcmpiW(argv[option_index], ks) == 0 ||
lstrcmpiW(argv[option_index], kd) == 0)
{
++option_index;
if (option_index >= argc)
{
WINE_ERR("Must specify group to initialize\n");
return 0;
}
if (!LoadGroup(argv[option_index]))
{
WINE_ERR("Failed to load requested group: %s\n",
wine_dbgstr_w(argv[option_index]));
return 0;
}
}
else
{
WINE_FIXME("Unrecognized option: %s\n",
wine_dbgstr_w(argv[option_index]));
return 0;
}
}
return 0;
}
bool CTextFileLoader::Load(const char * c_szFileName)
{
m_strFileName = c_szFileName;
m_dwcurLineIndex = 0;
FILE* fp = fopen(c_szFileName, "rb");
if (NULL == fp)
return false;
fseek(fp, 0L, SEEK_END);
const size_t fileSize = ftell(fp);
fseek(fp, 0, SEEK_SET);
char * pData = M2_NEW char[fileSize];
fread(pData, fileSize, 1, fp);
fclose(fp);
m_fileLoader.Bind(fileSize, pData);
M2_DELETE_ARRAY(pData);
LoadGroup(&m_globalNode);
return true;
}
struct GroupData *ServerDB::GroupDB::GenerateGroup() const {
struct GroupData *ret = new struct GroupData();
ret->UID = GenerateUID();
LoadGroup(ret, GetPreferences());
return ret;
}
/* only 1 or zero is valid, more than 1 is an error */
bool kGUIDBRecord::Loadz(const char *tablename,kGUIDbQuery *q)
{
m_unique=false;
m_keyname.Clear();
m_key.Clear();
LoadGroup(tablename,q);
assert(m_numentries<2,"Error: Too many matching records, use LoadGroup");
return(m_numentries==1);
}
ee::SprPtr LoadFromPSD::LoadItem(const Json::Value& value, const std::string& dir, int tw, int th)
{
std::string type = value["type"].asString();
if (type == "layer") {
return LoadLayer(value, dir, tw, th);
} else if (type == ee::SYM_GROUP_TAG) {
return LoadGroup(value, dir, tw, th);
} else {
return NULL;
}
}
bool TextureGroupHandler::Load(const char *fn)
{
CfgList *cfg = CfgValue::LoadFile (fn);
if (!cfg)
return false;
for (list<CfgListElem>::iterator li = cfg->childs.begin(); li != cfg->childs.end(); ++li) {
CfgList *gc = dynamic_cast<CfgList*>(li->value);
if (!gc) continue;
LoadGroup (gc);
}
delete cfg;
return true;
}
void kGUIDBRecord::LoadGroup(const char *tablename,const char *keyname,const char *key,const char *sort)
{
kGUIDbQuery *q;
m_keyname.SetString(keyname);
if(key)
m_key.SetString(key);
m_unique=false;
if(strlen(keyname) && key)
{
if(sort)
q=new kGUIDbQuery(m_db,"SELECT * from %s WHERE %s='%s' ORDER BY %s",tablename,keyname,key,sort);
else
q=new kGUIDbQuery(m_db,"SELECT * from %s WHERE %s='%s'",tablename,keyname,key);
}
else
q=new kGUIDbQuery(m_db,"SELECT * from %s",tablename);
LoadGroup(tablename,q);
delete q;
}
int _CRTAPI1 main(
int argc,
char *argv[],
char *envp[])
{
char *s, *s1;
PGROUP_DEF Group32;
PGROUP_DEF16 Group16;
BOOL bDumpConvertedGroup;
HKEY PersonalGroupsKey;
HKEY CommonGroupsKey;
DWORD rc;
FILE *fh;
LONG ValueLength;
char Group32Name[ MAX_PATH ];
char Group32FileName[ MAX_PATH ];
s = "Program Groups";
rc = RegOpenKey( HKEY_CURRENT_USER, s, &PersonalGroupsKey );
if (rc != 0) {
fprintf( stderr, "DUMPGRP: Unable to open %s key.\n", s );
PersonalGroupsKey = NULL;
}
s = "Software\\Program Groups";
rc = RegOpenKey( HKEY_LOCAL_MACHINE, s, &CommonGroupsKey );
if (rc != 0) {
fprintf( stderr, "DUMPGRP: Unable to open %s key.\n", s );
CommonGroupsKey = NULL;
}
bDumpConvertedGroup = FALSE;
while (--argc) {
s = *++argv;
_strupr( s );
if (!strcmp( s, "-C" ) || !strcmp( s, "/C" )) {
bDumpConvertedGroup = TRUE;
}
else
if (Group32 = LoadGroup( PersonalGroupsKey, s )) {
DumpGroup( s, FALSE, Group32 );
UnloadGroup( Group32 );
}
else
if (Group32 = LoadGroup( CommonGroupsKey, s )) {
DumpGroup( s, TRUE, Group32 );
UnloadGroup( Group32 );
}
else
if (Group16 = LoadGroup16( s )) {
DumpGroup16( s, Group16 );
if (bDumpConvertedGroup) {
strcpy( Group32Name, PTR( Group16, Group16->pName ) );
strcat( Group32Name, " (16-bit)" );
Group32 = CreateGroupFromGroup16( Group32Name, Group16 );
if (Group32 != NULL) {
DumpGroup( Group32Name, FALSE, Group32 );
s1 = strstr( strcpy( Group32FileName, s ), ".GRP" );
strcpy( s1, ".G32" );
fh = fopen( Group32FileName, "wb" );
if (fh != NULL) {
ValueLength = (LONG)((ULONG)Group32->wReserved);
Group32->wReserved = 0;
Group32->wCheckSum = (WORD)-ValueLength;
fwrite( Group32, ValueLength, 1, fh );
fclose( fh );
}
else {
fprintf( stderr, "DUMPGRP: Unable to create 32 bit group file - %s\n", Group32FileName );
}
UnloadGroup( Group32 );
}
else {
fprintf( stderr, "DUMPGRP: Unable to convert %s from 16 to 32-bits\n", s );
}
}
UnloadGroup16( Group16 );
}
else {
fprintf( stderr, "DUMPGRP: %s is not a valid group file.\n", s );
}
}
return 0;
}
bool CTextFileLoader::LoadGroup(TGroupNode * pGroupNode)
{
TTokenVector stTokenVector;
for (; m_dwcurLineIndex < m_fileLoader.GetLineCount(); ++m_dwcurLineIndex)
{
if (!m_fileLoader.SplitLine(m_dwcurLineIndex, &stTokenVector))
continue;
stl_lowers(stTokenVector[0]);
if ('{' == stTokenVector[0][0])
continue;
if ('}' == stTokenVector[0][0])
break;
// Group
if (0 == stTokenVector[0].compare("group"))
{
if (2 != stTokenVector.size())
{
sys_err("Invalid group syntax token size: %u != 2 (DO NOT SPACE IN NAME)", stTokenVector.size());
for (unsigned int i = 0; i < stTokenVector.size(); ++i)
sys_err(" %u %s", i, stTokenVector[i].c_str());
exit(1);
continue;
}
TGroupNode * pNewNode = ms_groupNodePool.Alloc();
pNewNode->pParentNode = pGroupNode;
pNewNode->strGroupName = stTokenVector[1];
stl_lowers(pNewNode->strGroupName);
pGroupNode->ChildNodeVector.push_back(pNewNode);
++m_dwcurLineIndex;
LoadGroup(pNewNode);
}
// List
else if (0 == stTokenVector[0].compare("list"))
{
if (2 != stTokenVector.size())
{
assert(!"There is no list name!");
continue;
}
TTokenVector stSubTokenVector;
stl_lowers(stTokenVector[1]);
std::string key = stTokenVector[1];
stTokenVector.clear();
++m_dwcurLineIndex;
for (; m_dwcurLineIndex < m_fileLoader.GetLineCount(); ++m_dwcurLineIndex)
{
if (!m_fileLoader.SplitLine(m_dwcurLineIndex, &stSubTokenVector))
continue;
if ('{' == stSubTokenVector[0][0])
continue;
if ('}' == stSubTokenVector[0][0])
break;
for (DWORD j = 0; j < stSubTokenVector.size(); ++j)
{
stTokenVector.push_back(stSubTokenVector[j]);
}
}
pGroupNode->LocalTokenVectorMap.insert(std::make_pair(key, stTokenVector));
}
else
{
std::string key = stTokenVector[0];
if (1 == stTokenVector.size())
{
sys_err("CTextFileLoader::LoadGroup : must have a value (filename: %s line: %d key: %s)",
m_strFileName.c_str(),
m_dwcurLineIndex,
key.c_str());
break;
}
stTokenVector.erase(stTokenVector.begin());
pGroupNode->LocalTokenVectorMap.insert(std::make_pair(key, stTokenVector));
}
}
return true;
}
