diff -r 000000000000 -r 044383f39525 bintools/rcomp/src/RESOURCE.CPP
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/bintools/rcomp/src/RESOURCE.CPP	Tue Oct 27 16:36:35 2009 +0000
@@ -0,0 +1,411 @@
+/*
+* Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the License "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: 
+*
+*/
+
+
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "RESOURCE.H"
+#include "TOKENS.H"  
+#include "ERRORHAN.H"
+
+// ResourceItem
+
+ResourceItem::ResourceItem(const String& aLabelToSet, int aResourceItemType):
+	iLabel(aLabelToSet),
+	iLineNumber(0),
+	iResourceItemType(aResourceItemType)
+	{}
+
+ResourceItem & ResourceItem::operator= ( const ResourceItem &)
+	{
+	assert(0);
+	return * this;
+	}
+
+void ResourceItem::Set(const String* aFileNameToSet, int aLineNumberToSet)
+	{
+	iFileName = aFileNameToSet;
+	iLineNumber = aLineNumberToSet;
+	}
+
+void ResourceItem::RegisterErrorLocation()
+	{
+	ErrorHandler::Register(iFileName,iLineNumber);
+	}
+
+int ResourceItem::GetResourceItemType()
+	{
+	return iResourceItemType;
+	}
+
+String ResourceItem::GetLabel()
+	{
+	return iLabel;
+	}
+
+/***************************************************************/
+/* SimpleResourceItem                                          */
+/***************************************************************/
+SimpleResourceItem::SimpleResourceItem(SimpleStructItem* aItem):
+	ResourceItem(aItem->iLabel, ESimpleResourceItem),
+	iStructItem(aItem),
+	iValueSet(0)
+	{}	
+
+void SimpleResourceItem::Set(const String& aValueToSet)
+	{
+	ResourceItem::Set( ErrorHandler::GetFileName(), ErrorHandler::GetLineNumber() );
+	
+	unsigned long lengthLimit = 0;	// max length of string, 0 = unchecked
+	switch ( iStructItem->iItemType)
+		{
+		case L_LTEXT8:
+		case L_LTEXT16:
+			lengthLimit = 255;	// length encoded as a single byte
+			// fall through...
+		case L_TEXT8:
+		case L_BUF8:
+		case L_TEXT16:
+		case L_BUF16:
+			if ( iStructItem->iLengthLimit.Length() > 0)
+			{
+				NumericValue limit(iStructItem->iLengthLimit, L_LONG);
+				lengthLimit = limit.GetULong();
+			}
+			if ( lengthLimit && aValueToSet.ExportLength(TargetCharacterSet,SourceCharacterSet) > lengthLimit )
+			{
+				char buf[256];
+				sprintf(buf, "Text length exceeds specified limit of %lx", lengthLimit);
+				ErrorHandler::OutputErrorLine( buf);
+				exit(1);
+			}
+		}
+	
+	iValue = aValueToSet;
+	iValueSet = 1;
+	}
+
+void SimpleResourceItem::Set(const StringArray& /*aValues*/)
+	{
+	// Can't store array of values
+	ErrorHandler::OutputErrorLine( "SimpleResourceItem cannot hold array of values");
+	exit(1);
+	}
+
+ResourceItemArray * SimpleResourceItem::GetRIA()
+	{
+	assert(0);	// Don't have RIA in this class.
+	return NULL;
+	}
+
+void SimpleResourceItem::AddDefault()
+	{
+	if(!iValueSet)
+		iValue = iStructItem->iDefault;
+	}
+
+void SimpleResourceItem::SetSRLink(unsigned long aSRLinkToSet)
+	{
+	if(iStructItem->iItemType == L_SRLINK)
+		iLinkValue = aSRLinkToSet;
+	}
+
+// ArrayResourceItem
+
+ArrayResourceItem::ArrayResourceItem( ArrayStructItem * p):
+	ResourceItem( p->iLabel, EArrayResourceItem),
+	iStructItem(p)
+	{}	
+
+ArrayResourceItem::~ArrayResourceItem()
+	{
+	iValues.DeleteAll();
+	}
+
+void ArrayResourceItem::Set(const String& /*aValue*/)
+	{
+	// Can't store single value
+	ErrorHandler::OutputErrorLine( "ArrayResourceItem requires array of values");
+	exit(1);
+	}
+
+void ArrayResourceItem::Set(const StringArray& aValuesToSet)
+	{
+	ResourceItem::Set(ErrorHandler::GetFileName(),ErrorHandler::GetLineNumber());
+	iValues = aValuesToSet;
+	}
+
+ResourceItemArray * ArrayResourceItem::GetRIA()
+	{
+	assert(0);	// Don't have RIA in this class.
+	return NULL;
+	}
+
+void ArrayResourceItem::AddDefault()
+	{
+	StringArrayIterator NextActual(iValues);
+	String* actualvalue;
+	StringArrayIterator NextDefault( iStructItem->iDefaults);
+	String* defaultvalue;
+	// Iterate through actual values and default values.
+	while((actualvalue = NextActual()) != NULL)
+		{
+		if((defaultvalue = NextDefault()) == NULL)
+			return;	// Stop if end of defaults reached.
+		}
+	// Having reached the end of the actual values see if there are any
+	// default values to add.
+	while((defaultvalue = NextDefault()) != NULL)
+		iValues.Add(new String (*defaultvalue));
+	}
+
+void ArrayResourceItem::SetSRLink(unsigned long /*aSRLinkToSet*/)
+	{}
+
+// StructTypeResourceItem
+
+StructTypeResourceItem::StructTypeResourceItem(StructTypeStructItem* p):
+	ResourceItem( p->iLabel, EStructTypeResourceItem),
+	iStructItem(p)
+	{}	
+
+void StructTypeResourceItem::Set(const String& aStructName)
+	{
+	ResourceItem::Set(ErrorHandler::GetFileName(),ErrorHandler::GetLineNumber());
+	iResourceItems.FillFromStruct(aStructName);
+	}
+
+void StructTypeResourceItem::Set(const StringArray& /*aValues*/)
+	{
+	// Can't store array of values
+	ErrorHandler::OutputErrorLine( "StructTypeResourceItem cannot hold array of values");
+	exit(1);
+	}
+
+ResourceItemArray * StructTypeResourceItem::GetRIA()
+	{
+	return& iResourceItems;
+	}
+
+void StructTypeResourceItem::AddDefault()
+	{
+	ResourceItemArrayIterator NextActualItem(iResourceItems);
+	ResourceItem * pActualItem;
+	
+	// Add defaults to each of the items already set up.
+	while( ( pActualItem = NextActualItem() ) != NULL)
+		pActualItem->AddDefault();
+	}
+
+void StructTypeResourceItem::SetSRLink(unsigned long /*aSRLinkToSet*/)
+	{}
+
+// StructArrayResourceItem
+
+StructArrayResourceItem::StructArrayResourceItem(StructArrayStructItem* p):
+	ResourceItem(p->iLabel, EStructArrayResourceItem),
+	iStructItem(p),
+	iLastRIA( NULL)
+	{}	
+
+void StructArrayResourceItem::Set( const String & StructName)
+	{
+	ResourceItem::Set( ErrorHandler::GetFileName(), ErrorHandler::GetLineNumber() );
+	ResourceItemArray* p = new ResourceItemArray;
+	iArrayOfResourceItemArrays.Add(p);
+	p->FillFromStruct( StructName);
+	iLastRIA = p;
+	}
+
+void StructArrayResourceItem::Set(const StringArray& /*aValues*/)
+	{}
+
+ResourceItemArray * StructArrayResourceItem::GetRIA()
+	{
+	return iLastRIA;
+	}
+
+void StructArrayResourceItem::AddDefault()
+	{
+	ResourceItemArrayArrayIterator next(iArrayOfResourceItemArrays);
+	ResourceItemArray * p;
+	while( ( p = next() ) != NULL)
+		p->AddDefault();
+	}
+
+void StructArrayResourceItem::SetSRLink(unsigned long /*aSRLinkToSet*/)
+	{}
+
+// ResourceItemArray
+
+ResourceItemArray::ResourceItemArray():
+	iLenType(0)
+	{}
+	
+ResourceItemArray::~ResourceItemArray()
+	{
+	DeleteAll();
+	}
+	
+void ResourceItemArray::Add( ResourceItem * p)
+	{
+	Array::Add( p);
+	}
+
+void ResourceItemArray::FillFromStruct(const String& aStructName)
+	{
+	extern StructHeaderArray * pSHA;
+	StructHeader * pSH = pSHA->Find(aStructName);
+	StructItemArrayIterator next( pSH->iSIA);
+	StructItem * pItem;
+	while ( ( pItem = next() ) != NULL)
+		Add( pItem->NewResourceItem() );
+	iLenType = pSH->iLenType;
+	}
+
+void ResourceItemArray::Set( const String & Label, const String & Value)
+	{
+	ResourceItem * p = Find( Label);
+	p->Set( Value);
+	}
+
+void ResourceItemArray::Set( const String & Label, const StringArray & Values)
+	{
+	ResourceItem * p = Find( Label);
+	p->Set( Values);
+	}
+
+ResourceItem * ResourceItemArray::Find( const String & LabelSought)
+	{
+	ResourceItemArrayIterator next( * this);
+	ResourceItem * p;
+	
+	while( ( p = next() ) != NULL)
+		if ( p->iLabel == LabelSought)
+			return p;
+	
+	ErrorHandler::OutputErrorLine( "Label not found");
+	exit(1);
+	}
+
+void ResourceItemArray::AddDefault()
+	{
+	ResourceItemArrayIterator next( * this);
+	ResourceItem * p;
+	
+	while( ( p = next() ) != NULL)
+		p->AddDefault();
+	}
+
+// ResourceHeader
+
+ResourceHeader::ResourceHeader(String aLabelToSet):
+	iLabel(aLabelToSet),
+	iLocal(0),
+	iResourceId(0xdeaddead),
+	iFormatAsHex(0),
+	iContainsCompressedUnicode(false)
+	{
+	}
+
+ResourceHeader::ResourceHeader():
+	iLocal(0),
+	iResourceId(0xdeaddead),
+	iFormatAsHex(0),
+	iContainsCompressedUnicode(false)
+	{
+	}
+
+ResourceHeader::~ResourceHeader()
+	{
+	}
+
+void ResourceHeader::AddDefault()
+	{
+	iRIA.AddDefault();
+	}
+
+void ResourceHeader::SetResourceId(NameIdMap& aMap, unsigned long aId, int aFormatAsHex)
+	{
+	iResourceId = aId;
+	iFormatAsHex = aFormatAsHex;
+	if (iLabel.Length() > 0)
+		aMap.Add(iLabel, aId);
+
+	ResourceItemArrayIterator next(iRIA);
+	ResourceItem * pItem;
+	while( ( pItem = next() ) != NULL)
+		pItem->SetSRLink(aId);
+	}
+
+void ResourceHeader::StreamOut(RCBinaryStream& aStream, int& aSizeOfLargestResourceWhenUncompressed, const char* aDumpFile)
+	{
+	ResourceDataStream stream;
+	iRIA.StreamOut(stream);
+	if (aDumpFile!=NULL)
+		{
+		// dump the resource to aDumpFile in its uncompressed and unpadded state - LINKs, LLINKs, etc will be undefined
+		stream.Dump(aDumpFile);
+		}
+	int sizeWhenUncompressed=0;
+	iContainsCompressedUnicode=stream.StreamOutReturningWhetherContainsCompressedUnicode(aStream, sizeWhenUncompressed);
+	// this check is unnecessary, zero size resources are allowed so
+	// there is no benefit to this assert. 
+
+	if (aSizeOfLargestResourceWhenUncompressed<sizeWhenUncompressed)
+		{
+		aSizeOfLargestResourceWhenUncompressed=sizeWhenUncompressed;
+		}
+	}
+
+// ResourceItemArrayArray
+
+ResourceItemArrayArray::ResourceItemArrayArray()
+	{}
+
+ResourceItemArrayArray::~ResourceItemArrayArray()
+	{
+	DeleteAll();
+	}
+	
+void ResourceItemArrayArray::Add( ResourceItemArray * pNewItem)
+	{
+	Array::Add( pNewItem);
+	}
+
+// ResourceItemArrayIterator
+
+ResourceItemArrayIterator::ResourceItemArrayIterator( const ResourceItemArray & c):
+	ArrayIterator( c)
+	{}
+
+ResourceItem * ResourceItemArrayIterator::operator()()
+	{
+	return (ResourceItem *) ArrayIterator::operator()();
+	}
+
+// ResourceItemArrayArrayIterator
+
+ResourceItemArrayArrayIterator::ResourceItemArrayArrayIterator(const ResourceItemArrayArray & c):
+	ArrayIterator( c)
+	{}
+
+ResourceItemArray* ResourceItemArrayArrayIterator::operator()()
+	{
+	return (ResourceItemArray*) ArrayIterator::operator()();
+	}