FCL/sf/mw/uitools: comparison aknlayoutcompiler/src/MLCompCdl2InstO.cpp

equal deleted inserted replaced

-:f58d6ec98e88
+:b700e12870ca
 #include "MLAttributesParse.h"
 #include "MLAttributes.h"
 #include "CodeGenConsts.h"
 #include "UsefulDefinitions.h"
-#include <akndef.hrh>
+#include <AknDef.hrh>
 #include <fstream>
 #include <algorithm>
 #include <iostream>
 #include <numeric> // accumulate
 const string KSpace = " ";
 const string KComma = ",";
 const string KTheWordBlank("blank");
 const string KParentRelativeMarker("Pp");
 const string KCellNameJustification("J");
-const string KCompDataFileNameSuffix("compData");
+const string KCompDataFileNameSuffix("compdata");
 const string KAttributesFileNameSuffix("attributes");
 // this is the addressable area for each instance, as the lookup table is 16bit
 const int KAddressableBytecodedData = 0xFFFF;
 	string iDefn;
 	string iPtrRef;
 	SCompDataImplFunc(TFuncType aType, string aDefn, string aPtrRef, CCdlTkApiParams& aParams)
 		:
 		iType(aType),
+		iParams(aParams),
 		iDefn(aDefn),
-		iPtrRef(aPtrRef),
+		iPtrRef(aPtrRef)
-		iParams(aParams)
 		{
 		}
 	SCompDataImplFunc(TFuncType aType, string aDefn, string aPtrRef)
 	bool IsSimilar(TFuncType aType, CCdlTkApiParams& aParams)
 		{
 		if(iType != aType)
 			return false;
-		int size = iParams.size();
+		unsigned int size = iParams.size();
 		if(size != aParams.size())
 			return false;
-		for(int ii = 0; ii < size; ii++)
+		for(unsigned int ii = 0; ii < size; ii++)
 			{
 			CCdlTkApiParam& thisParam = iParams[ii];
 			CCdlTkApiParam& otherParam = aParams[ii];
 			if(thisParam.Name() != otherParam.Name())
 				return false;
 /**
 *  gTheFuncs
 *  This is a collection of all SCompDataImplFunc objects that a layout instance needs, initialised
 *  so that there are up to four integer parameters per API type.
 */
-CAllCompDataFuncs gTheFuncs;
+CAllCompDataFuncs gTheCompDataFuncs;
 //
 // CAllCompDataFuncs
 //
 	while(next_permutation(pattern.begin(), pattern.end()));
 	for(set< Seq >::iterator pPattern = subPatterns.begin(); pPattern != subPatterns.end(); ++pPattern)
 		{
 		CCdlTkApiParams params;
-		for(Seq::iterator pParam = pPattern->begin(); pParam != pPattern->end(); ++pParam)
+		for(Seq::const_iterator pParam = pPattern->begin(); pParam != pPattern->end(); ++pParam)
 			{
-			int& param = (*pParam);
+			int param = (*pParam);
 			string name = paramNames[param];
 			params.push_back(CCdlTkApiParam(KTypeInt, name));
 			}
 		AddFunc(SCompDataImplFunc::EWindowLine, params, KTypeWindowComponentLayout, KFuncWindowLine, true);
 		AddFunc(SCompDataImplFunc::ETextLine, params, KTypeTextComponentLayout, KFuncTextLine, true);
 CMLCompDataSubTableInstOptImpl::CMLCompDataSubTableInstOptImpl(
 	TMLCompDataTable* aTable,
 	TMLCompDataTable::TMLCompDataSubTable* aSubTable,
 	CCdlTkImplementation* aImpl)
 	:
+	CMLCompDataInstOptImpl(aImpl),
 	iTable(aTable),
-	CMLCompDataInstOptImpl(aImpl),
 	iSubTable(aSubTable)
 	{
 	}
 CMLCompDataSubTableInstOptImpl::~CMLCompDataSubTableInstOptImpl()
 CMLCompDataInstOpt::CMLCompDataInstOpt(MLCompDataCdlInstanceOpt& aInstances, TMLCompData* aLayout, const string& aInstName, const string& aZoomName, int aZoomLevel, bool aAllParams, bool aNonCompleteInstance)
 	:
 	iInstances(aInstances),
 	iLayout(aLayout),
 	iName(aInstName),
 	iZoomName(aZoomName),
+	iInterface(iInstances.Interface()),
 	iZoomLevel(aZoomLevel),
-	iInterface(iInstances.Interface()),
 	iAllParams(aAllParams),
 	iBaseOffset(0)
 	{
 	string zoomInstName = aInstName;
 	if(aZoomName.length() > 0)
 CMLCompDataInstOpt::~CMLCompDataInstOpt()
 	{
 	delete iInstance;
 	for (CMLCompDataInstOptImpls::iterator pImpl = iImpls.begin(); pImpl != iImpls.end(); ++pImpl)
 		delete *pImpl;
-	for (pImpl = iTableImpls.begin(); pImpl != iTableImpls.end(); ++pImpl)
+	for (CMLCompDataInstOptImpls::iterator pImpl = iTableImpls.begin(); pImpl != iTableImpls.end(); ++pImpl)
 		delete *pImpl;
 	}
 void CMLCompDataInstOpt::Process(const string& aFirstInstName)
 	{
 	for (TMLCompData::iterator pTab = iLayout->begin(); pTab != iLayout->end(); ++pTab)
 		{
 		ProcessLines(**pTab);
 		}
-	for (pTab = iLayout->begin(); pTab != iLayout->end(); ++pTab)
+	for (TMLCompData::iterator pTab = iLayout->begin(); pTab != iLayout->end(); ++pTab)
 		{
 		ProcessTables(**pTab);
 		}
 	// update the base offset to include all the data added, including reserving space for the tables
 	UpdateBaseOffset();
 	// with the correct base offset, the definitions can be updated
 	UpdateLineImpls();
-	for (pTab = iLayout->begin(); pTab != iLayout->end(); ++pTab)
+	for (TMLCompData::iterator pTab = iLayout->begin(); pTab != iLayout->end(); ++pTab)
 		{
 		// now that the rest of the data is stable, we can add the tables at the end
 		UpdateTables(**pTab);
 		}
 void CMLCompDataInstOpt::UpdateLineImplDefn(CMLCompDataInstOptImpl& aImpl)
 	{
 	if(!CheckByteCodeIndexInRange(aImpl.iByteCodeIndex))
 		throw GeneralErr(aImpl.iName + " in interface " + iInterface.FileName());
 	// the base offset has been updated, so all definitions must be refreshed
-	int adjustedIndex = aImpl.iByteCodeIndex - iBaseOffset;
+	//int adjustedIndex = aImpl.iByteCodeIndex - iBaseOffset;
 	aImpl.iImpl->SetDefinition(DefinitionString(aImpl.iByteCodeIndex, aImpl.iName));
 	UpdateParamLimits(aImpl.iName);
 	}
 void CMLCompDataInstOpt::UpdateTables(TMLCompDataTable& aTable)
 		}
 	// calculate the number of values
 	bool needsHeader = line.NeedsOptions() || line.NeedsCols() || line.NeedsRows();
 	unsigned int nextCellFlag = 1;	// bit flag for the next cell, note it can get bigger than a char
-	for (cell = 0; cell < aOutputOrder.size(); cell++)
+	for (unsigned int cell = 0; cell < aOutputOrder.size(); cell++)
 		{
 		string cellName = aOutputOrder[cell];
 		TMLCompDataValues::TCompDataCellType type = TMLCompDataValues::Type(cellName);
 		if(!needsHeader && type == TMLCompDataValues::ECellTypeParamLimit)
 			{
 	// also build up the found valid values in case we can't optimize
 	vector<string> foundValues;
 	bool optimizeVarieties = true;
 	bool optimizeCalcs = true;
-	int numCalcs = 0;
+	unsigned int numCalcs = 0;
 	int* largestParamLimitPtr = max_element(aParamLimitVarieties.begin(), aParamLimitVarieties.end());
-	int largestParamLimit = largestParamLimitPtr != aParamLimitVarieties.end() ? *largestParamLimitPtr : 0;
+	unsigned int largestParamLimit = largestParamLimitPtr != aParamLimitVarieties.end() ? *largestParamLimitPtr : 0;
 	// in the case of there being no calcs at all, we don't want to be optimizing,
 	// in order to avoid wasted flags.
 	if(largestParamLimit == 1)
 		optimizeCalcs = false;
 		if(!calcs->size())
 			calcs = &(zoomLevels[EAknUiZoomNormal]);
 		numCalcs = calcs->size();
 		string value;
 		vector<string> foundCalcs;
-		int paramLimit = aParamLimitVarieties[varietyIndex];
+		unsigned int paramLimit = aParamLimitVarieties[varietyIndex];
 		if(numCalcs == 0)
 			{
 			if(varietyIndex == 0)
 				optimizedValues.push_back(value);
 			if(varietyIndex > 0 && !(optimizedValues[0].empty()))
 				optimizeVarieties = false;
 			foundCalcs.push_back(value);
 			}
 		else
 			{
-			for(int index = 0; index < numCalcs; index++)
+			for(unsigned int index = 0; index < numCalcs; index++)
 				{
 				bool needToCheckIndexValidity = !isColRow || (index < paramLimit);
 				value = (*calcs)[index];
 				value = aMirrorJustification ? TMLCompDataValues::MirrorJustificationValue(value) : value;
 		{
 		// now that we know the optimized values, fill missing values by repeating the last one.
 		// but if we're optimizing the calcs, then we don't want to expand them after all
 		if(!optimizeCalcs)
 			{
-			int optimal = optimizedValues.size();
+			unsigned int optimal = optimizedValues.size();
 			string value = optimal > 0 ? optimizedValues[optimal-1] : string();
 			for(; optimal < largestParamLimit; optimal++)
 				{
 				optimizedValues.push_back(value);
 				}
 		SCompDataImplFunc& func = **pFunc;
 		if(func.IsSimilar(aType, aParams))
 			return func;
 		}
-	int count = gTheFuncs.size();
+	int count = gTheCompDataFuncs.size();
 	for (int ii=0; ii<count; ii++)
 		{
-		SCompDataImplFunc* func = &gTheFuncs[ii];
+		SCompDataImplFunc* func = &gTheCompDataFuncs[ii];
 		if(func->IsSimilar(aType, aParams))
 			{
 			iFuncs.push_back(func);
 			return *func;
 			}
 		}
 	throw NotFoundErr("implementation function");
-	return gTheFuncs[0];
+	return gTheCompDataFuncs[0];
 	}
 void CMLCompDataInstOpt::SetGenericAPI(SCompDataImplFunc::TFuncType aType, const string& aName)
 	{
 	CCdlTkImplementation* impl = iInstance->Impl().Find(aName);
 	int nParams;
 	CountApiParams(impl, nParams);
 	nParams--;	// don't count the aLineIndex param
 	SCompDataImplFunc::TFuncType type = SCompDataImplFunc::EWindowTable;
 	TMLCompDataLine::TComponentType subTableType = aTable[aSub[0]]->iType;
-	switch(subTableType)
+//	switch(subTableType)
-		{
+//		{
-		case TMLCompDataLine::ETextComponent:
+//		case TMLCompDataLine::ETextComponent:
-			{
+//			{
-			type = SCompDataImplFunc::ETextTable;
+//			type = SCompDataImplFunc::ETextTable;
-			break;
+//			break;
-			}
+//			}
+//		}
+	if ( TMLCompDataLine::ETextComponent == subTableType )
+		{
+		type = SCompDataImplFunc::ETextTable;
 		}
 	CCdlTkFunctionApi& api = const_cast<CCdlTkFunctionApi&>(impl.Api().AsFunc());
 	CCdlTkApiParams& params = api.Params();
 	ValidateRequiredParams(
 		aApiName,
 		params,
 		iAllParams || aSub.iNeedsOption,
 		iAllParams || aSub.iNeedsCol,
 		iAllParams || aSub.iNeedsRow);
-	SCompDataImplFunc& func = AddImplFunc(type, params);
+	AddImplFunc(type, params);
 	}
 void CMLCompDataInstOpt::AddParamLimits(TMLCompDataLine& aLine, bool aNeedsOptions)
 	{
 	string apiName = MLCompDataToCdl::LineApiName(aLine) ;
 extern const int gIdToIntTableCount;
 extern void TranslateValue(string& aValue);
 void CMLCompDataInstOpt::EncodeValue(vector<char>& aBytes, string aValue)
 	{
-	int pos = 0;
+	string::size_type pos = 0;
 	TranslateValue(aValue);
 	if (aValue == "")
 		{
 		aBytes.push_back(KByteEmpty);
 		}
 		}
 	}
 void MLCompDataCdlInstanceOpt::ProcessSeparators(vector<string>& args, vector<int>& aSeparators)
 	{
-for(int arg = 3; arg < args.size(); arg++)
+for(unsigned int arg = 3; arg < args.size(); arg++)
 {
 if(args[arg] == "-a")
 aSeparators.push_back(arg);
 }
 throw MLCompDataCdlInstanceOptArgsErr();
 // check that the distance between each separator is not a multiple of 2
 // i.e. counting the steps between aSeparators ( sep -> xml -> inst -> sep) is 3 steps
 // i.e. counting the steps between aSeparators ( sep -> xml -> inst -> xml -> inst -> sep) is 5 steps
-for(int sep = 0; sep < aSeparators.size() - 1; sep++)
+for(unsigned int sep = 0; sep < aSeparators.size() - 1; sep++)
 {
 int delta = aSeparators[sep+1] - aSeparators[sep];
 	    if (delta%2 == 0)
 		    throw MLCompDataCdlInstanceOptArgsErr();
 }
 	for (int arg = aSeparators[aSepIndex] + 1; arg < aSeparators[aSepIndex+1]; arg += 2)
 		{
 		string layoutName = aArgs[arg];
 		string instName = aArgs[arg+1];
 		string attribsName = CdlTkUtil::Replace(KCompDataFileNameSuffix, KAttributesFileNameSuffix, layoutName);
 		auto_ptr<TMLCompDataParseLayout> layoutParse = TMLCompDataParseLayout::Parse(layoutName);
 		auto_ptr<TMLCompData> layout(layoutParse.get());
 		layoutParse.release();
 		auto_ptr<TMLAttributesParse> attribsParse = TMLAttributesParse::Parse(attribsName);
 		auto_ptr<TMLAttributes> attribs(attribsParse.get());
 		attribsParse.release();
 		InstStruct instStruct(instName, layout.get(), attribs.get());
 	// start with the non-mirrored instances
 	for(int count = 0; count < 2; count++)
 		{
 		bool isMirrored = (count != 0);
 		// first iterate through the layouts, we will generate one instance per layout
-		for(int instIndex = 0; instIndex < aInstances.size(); instIndex++)
+		for(unsigned int instIndex = 0; instIndex < aInstances.size(); instIndex++)
 			{
 			const InstStruct& instStruct = aInstances[instIndex];
-			string targetInstName = instStruct.iInstName;
+			string targetInstName = CdlTkUtil::Replace("\r","",instStruct.iInstName);
+			targetInstName = CdlTkUtil::Replace("\n","",targetInstName);
 			TMLCompData& targetLayout = *(instStruct.iInst);
 			TMLAttributes& targetAttribs = *(instStruct.iAttribs);
 			bool required = false;
 			for(CZoomLevelNames::const_iterator pZoomLevel = aZoomLevelNames.begin(); pZoomLevel != aZoomLevelNames.end(); ++pZoomLevel)
 	int extraArgs = args.size() - 3;
 	if (extraArgs < 0)
 		throw MLCompDataCdlInstanceOptArgsErr();
 	// check for optional flags
-int arg = 2;
+	int arg = 2;
 	bool allParams = false;
 	if (args[arg] == "-allparams")
 		{
 		allParams = true;
 		arg++;
 	MLCompDataCdlInstanceOpt process(*iface);
 // the separators divide the layout instances that are aggregated together
 vector<int> separators;
 	ProcessSeparators(args, separators);
-for(int sep = 0; sep < separators.size() - 1; sep++)
+for(unsigned int sep = 0; sep < separators.size() - 1; sep++)
 {
 		if(!CheckForUsedInstances(instUsedList, zoomLevelNames, args, separators, sep))
 			continue;
 // start from after the next separator, and continue until before the next one
 	    InstList instances;
 			{
 			process.AddInst(*pMergedLayout, zoomLevelNames, allParams, nonCompleteInstance); // pass ownership of mergedLayout
 			pMergedLayout = mergedLayouts.erase(pMergedLayout);
 			}
 }
 	process.Process();
 	process.WriteInstances();
 	return 0;
 	}
 		CCompDatas& compDatas = pZoomLevel->second;
 		if(compDatas.size() == 0)
 			continue;
 		CMLCompDataInstOpt* firstInstOpt = compDatas[0];
 		cout << "processing instances for zoom level: " << firstInstOpt->ZoomName() << endl;
 		string firstInstName = firstInstOpt->Name();
 		for (CCompDatas::iterator pLayout = compDatas.begin(); pLayout != compDatas.end(); ++pLayout)
 			(*pLayout)->Process(firstInstName);
 		}
 	ProcessCommonImpl();
 	}
 void MLCompDataCdlInstanceOpt::WriteInstances()
-	{
+	{	bool found = false;
-	bool found = false;
 	for(CCompDataZoomLevelDatas::iterator pZoomLevel = iZoomLevelDatas.begin(); pZoomLevel != iZoomLevelDatas.end(); ++pZoomLevel)
 		{
 		CCompDatas& compDatas = pZoomLevel->second;
 		if(!found && compDatas.size() > 0)
 			{

changeset 1	b700e12870ca
parent 0	f58d6ec98e88
child 29	e21deeeacad2
child 44	8b4f687b7a95