/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/


// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_codemaker.hxx"

#include <stdio.h>
#include	<rtl/alloc.h>
#include	<rtl/ustring.hxx>
#include	<rtl/strbuf.hxx>

#include	"idltype.hxx"
#include	"idloptions.hxx"

using namespace rtl;

//*************************************************************************
// IdlType
//*************************************************************************
IdlType::IdlType(TypeReader& typeReader,
				   const OString& typeName,
				   const TypeManager& typeMgr,
				   const TypeDependency& typeDependencies)
	: m_inheritedMemberCount(0)
	, m_indentLength(0)
	, m_typeName(typeName)
	, m_reader(typeReader)
	, m_typeMgr((TypeManager&)typeMgr)
	, m_dependencies(typeDependencies)
{
	sal_Int32 i = typeName.lastIndexOf('/');
    m_name = typeName.copy( i != -1 ? i+1 : 0 );
}

IdlType::~IdlType()
{

}

sal_Bool IdlType::dump(IdlOptions* pOptions)
	throw( CannotDumpException )
{
	sal_Bool ret = sal_False;

	OString outPath;
	if (pOptions->isValid("-O"))
		outPath = pOptions->getOption("-O");

	OString tmpFileName;
	OString hFileName = createFileNameFromType(outPath, m_typeName, ".idl");

	sal_Bool bFileExists = sal_False;
	sal_Bool bFileCheck = sal_False;

	if ( pOptions->isValid("-G") || pOptions->isValid("-Gc") )
	{
		bFileExists = fileExists( hFileName );
		ret = sal_True;
	}

	if ( bFileExists && pOptions->isValid("-Gc") )
	{
		tmpFileName	 = createFileNameFromType(outPath, m_typeName, ".tml");
		bFileCheck = sal_True;
	}

	if ( !bFileExists || bFileCheck )
	{
		FileStream hFile;

		if ( bFileCheck )
			hFile.open(tmpFileName);
		else
			hFile.open(hFileName);

		if(!hFile.isValid())
		{
			OString message("cannot open ");
			message += hFileName + " for writing";
			throw CannotDumpException(message);
		}

		ret = dumpHFile(hFile);

		hFile.close();
		if (ret && bFileCheck)
		{
			ret = checkFileContent(hFileName, tmpFileName);
		}
	}

	return ret;
}
sal_Bool IdlType::dumpDependedTypes(IdlOptions* pOptions)
	throw( CannotDumpException )
{
	sal_Bool ret = sal_True;

	TypeUsingSet usingSet(m_dependencies.getDependencies(m_typeName));

	TypeUsingSet::const_iterator iter = usingSet.begin();
	OString typeName;
	sal_uInt32 index = 0;
	while (iter != usingSet.end())
	{
		typeName = (*iter).m_type;
		if ((index = typeName.lastIndexOf(']')) > 0)
			typeName = typeName.copy(index + 1);

		if ( getBaseType(typeName).isEmpty() )
		{
			if (!produceType(typeName,
						   	 m_typeMgr,
							 m_dependencies,
							 pOptions))
			{
				fprintf(stderr, "%s ERROR: %s\n",
						pOptions->getProgramName().getStr(),
						OString("cannot dump Type '" + typeName + "'").getStr());
				exit(99);
			}
		}
		++iter;
	}

	return ret;
}

OString IdlType::dumpHeaderDefine(FileStream& o, sal_Char* prefix )
{
	if (m_typeName.equals("/"))
	{
		m_typeName = "global";
	}

	sal_uInt32 length = 3 + m_typeName.getLength() + strlen(prefix);

	OStringBuffer tmpBuf(length);

	tmpBuf.append('_');
	tmpBuf.append(m_typeName);
	tmpBuf.append('_');
	tmpBuf.append(prefix);
	tmpBuf.append('_');

	OString tmp(tmpBuf.makeStringAndClear().replace('/', '_').toAsciiUpperCase());

	o << "#ifndef " << tmp << "\n#define " << tmp << "\n";

	return tmp;
}

void IdlType::dumpDefaultHIncludes(FileStream& o)
{
}

void IdlType::dumpInclude(FileStream& o, const OString& genTypeName, const OString& typeName, sal_Char* prefix )
{
	sal_uInt32 length = 3+ m_typeName.getLength() + strlen(prefix);

	OStringBuffer tmpBuf(length);

	tmpBuf.append('_');
	tmpBuf.append(typeName);
	tmpBuf.append('_');
	tmpBuf.append(prefix);
	tmpBuf.append('_');

	OString tmp(tmpBuf.makeStringAndClear().replace('/', '_').toAsciiUpperCase());

	length = 1 + typeName.getLength() + strlen(prefix);

	tmpBuf.ensureCapacity(length);
	tmpBuf.append(typeName);
	tmpBuf.append('.');
	tmpBuf.append(prefix);

	o << "#ifndef " << tmp << "\n#include <";
	tmp = tmpBuf.makeStringAndClear();

    sal_Int32 nIndex = 0;
    do
	{
		genTypeName.getToken(0, '/', nIndex);
	 	o << "../";
	} while( nIndex != -1 );

//  	sal_Int32 nSlashes = genTypeName.getTokenCount( '/');
//  	for( sal_Int32 i = 1; i < nSlashes; i++ )
//  		o << "../";
	o << tmp;
	o << ">\n#endif\n";
}

void IdlType::dumpDepIncludes(FileStream& o, const OString& typeName, sal_Char* prefix)
{
	TypeUsingSet usingSet(m_dependencies.getDependencies(typeName));

	TypeUsingSet::const_iterator iter = usingSet.begin();

	OString 	sPrefix(OString(prefix).toAsciiUpperCase());
	sal_uInt32 	index = 0;
	sal_uInt32 	seqNum = 0;
	OString 	relType;
	while (iter != usingSet.end())
	{
		index = (*iter).m_type.lastIndexOf(']');
		seqNum = (index > 0 ? ((index+1) / 2) : 0);

		relType = (*iter).m_type;
		if (index > 0)
			relType = relType.copy(index+1);


		OString defPrefix("IDL");

		if ( getBaseType(relType).isEmpty() &&
			m_typeName != relType)
		{
			if (m_typeMgr.getTypeClass(relType) == RT_TYPE_INTERFACE)
			{
				if (!((*iter).m_use & TYPEUSE_SUPER))
				{
					o << "\n";
					dumpNameSpace(o, sal_True, sal_False, relType);
					o << "\ninterface " << scopedName(m_typeName, relType, sal_True) << ";\n";
					dumpNameSpace(o, sal_False, sal_False, relType);
					o << "\n\n";
				}
			}
			dumpInclude(o, typeName, relType, prefix);
		}
		else if (relType == "type")
		{
			o << "module CORBA {\n"
			  << "\tinterface TypeCode;\n"
			  << "};\n\n";
		}

		if( seqNum != 0 )
		{
			// write typedef for sequences to support Rational Rose 2000 import
			OString aST = relType;
			OString aScope;
			dumpNameSpace( o, sal_True, sal_False, relType );
			for( sal_uInt32 i = 0; i < seqNum; i++ )
			{
				o << "typedef sequence< " << scopedName("", aST) << " > ";

				if( i == 0 )
				{
					aST = aST.replace( '/', '_' );
					aST = aST.replace( ' ', '_' );
				}
				aST = aST + "_Sequence" ;
				o << aST << ";\n";
			}
			dumpNameSpace( o, sal_False, sal_False, relType );
		}
		++iter;
	}
}

void IdlType::dumpNameSpace(FileStream& o, sal_Bool bOpen, sal_Bool bFull, const OString& type)
{
	OString typeName(type);
	sal_Bool bOneLine = sal_True;
	if ( typeName.isEmpty() )
	{
		typeName = m_typeName;
		bOneLine = sal_False;
	}

	if (typeName == "/")
		return;

	if (typeName.indexOf( '/' ) == -1 && !bFull)
		return;

	if (!bFull)
        typeName = typeName.copy( 0, typeName.lastIndexOf( '/' ) );

	if (bOpen)
	{
        sal_Int32 nIndex = 0;
		do
		{
			o << "module " << typeName.getToken(0, '/', nIndex);
			if (bOneLine)
				o << " { ";
			else
			 	o << "\n{\n";
		} while( nIndex != -1 );
	} else
	{
        sal_Int32 nPos = 0;
		do
		{
            nPos = typeName.lastIndexOf( '/' );
            o << "};";
            if( bOneLine )
                o << " ";
            else
                o << " /* " << typeName.copy( nPos+1 ) << " */\n";
            if( nPos != -1 )
                typeName = typeName.copy( 0, nPos );
        } while( nPos != -1 );
	}
}


sal_uInt32 IdlType::getMemberCount()
{
	sal_uInt32 count = m_reader.getMethodCount();

	sal_uInt32 fieldCount = m_reader.getFieldCount();
	RTFieldAccess access = RT_ACCESS_INVALID;
	for (sal_uInt16 i=0; i < fieldCount; i++)
	{
		access = m_reader.getFieldAccess(i);

		if (access != RT_ACCESS_CONST && access != RT_ACCESS_INVALID)
			count++;
	}
	return count;
}

sal_uInt32 IdlType::checkInheritedMemberCount(const TypeReader* pReader)
{
	sal_Bool bSelfCheck = sal_True;
	if (!pReader)
	{
		bSelfCheck = sal_False;
		pReader = &m_reader;
	}

	sal_uInt32 count = 0;
	OString superType(pReader->getSuperTypeName());
	if ( !superType.isEmpty() )
	{
		TypeReader aSuperReader(m_typeMgr.getTypeReader(superType));
		if ( aSuperReader.isValid() )
		{
			count = checkInheritedMemberCount(&aSuperReader);
		}
	}

	if (bSelfCheck)
	{
		count += pReader->getMethodCount();
		sal_uInt32 fieldCount = pReader->getFieldCount();
		RTFieldAccess access = RT_ACCESS_INVALID;
		for (sal_uInt16 i=0; i < fieldCount; i++)
		{
			access = pReader->getFieldAccess(i);

			if (access != RT_ACCESS_CONST && access != RT_ACCESS_INVALID)
			{
				count++;
			}
		}
	}

	return count;
}

sal_uInt32 IdlType::getInheritedMemberCount()
{
	if (m_inheritedMemberCount == 0)
	{
		m_inheritedMemberCount = checkInheritedMemberCount(0);
	}

	return m_inheritedMemberCount;
}


void IdlType::dumpType(FileStream& o, const OString& type )
	throw( CannotDumpException )
{
	OString sType(checkRealBaseType(type, sal_True));
	sal_uInt32 index = sType.lastIndexOf(']');
	sal_uInt32 seqNum = (index > 0 ? ((index+1) / 2) : 0);

	OString relType = (index > 0 ? (sType).copy(index+1) : type);

	RTTypeClass typeClass = m_typeMgr.getTypeClass(relType);

	sal_uInt32 i;
/*
	for (i=0; i < seqNum; i++)
	{
		//o << "sequence< ";
	}
*/
	switch (typeClass)
	{
		case RT_TYPE_INVALID:
			{
				OString tmp(getBaseType(relType));
				if ( !tmp.isEmpty() )
				{
					tmp = tmp.replace( ' ', '_' );
					o << tmp;
				} else
					throw CannotDumpException("Unknown type '" + relType + "', incomplete type library.");
			}
			break;
		case RT_TYPE_INTERFACE:
		case RT_TYPE_STRUCT:
		case RT_TYPE_ENUM:
		case RT_TYPE_TYPEDEF:
		case RT_TYPE_EXCEPTION:
				if( seqNum )
				{
					OString aST = relType.replace( '/', '_' );
					aST = aST.replace( ' ', '_' );
					o << aST;
				}
				else
					o << scopedName(m_typeName, relType);
			break;
	}

	for (i=0; i < seqNum; i++)
	{
		//o << " >";
		// use typedef for sequences to support Rational Rose 2000 import
		o << "_Sequence";
	}
}

OString	IdlType::getBaseType(const OString& type)
{
	if (type.equals("long"))
		return type;
	if (type.equals("short"))
		return type;
	if (type.equals("hyper"))
		return "long long";
	if (type.equals("string"))
		return "string";
	if (type.equals("boolean"))
		return type;
	if (type.equals("char"))
		return "char";
	if (type.equals("byte"))
		return "byte";
	if (type.equals("any"))
		return type;
	if (type.equals("type"))
		return "CORBA::TypeCode";
	if (type.equals("float"))
		return type;
	if (type.equals("double"))
		return type;
	if (type.equals("octet"))
		return type;
	if (type.equals("void"))
		return type;
	if (type.equals("unsigned long"))
		return type;
	if (type.equals("unsigned short"))
		return type;
	if (type.equals("unsigned hyper"))
		return "unsigned long long";

	return OString();
}

void IdlType::dumpIdlGetType(FileStream& o, const OString& type, sal_Bool bDecl, IdlTypeDecl eDeclFlag)
{
	OString sType( checkRealBaseType(type, sal_True) );
	sal_uInt32 index = sType.lastIndexOf(']');
	OString relType = (index > 0 ? (sType).copy(index+1) : type);

	if (eDeclFlag == CPPUTYPEDECL_ONLYINTERFACES)
	{
	 	if (m_typeMgr.getTypeClass(relType) == RT_TYPE_INTERFACE)
		{
			o << indent() << "getIdlType( (";
			dumpType(o, type);
			o << "*)0 )";

			if (bDecl)
				o << ";\n";
		}
	} else
	{
		if (isBaseType(type))
		{
			return;
		} else
		{
			if (eDeclFlag == CPPUTYPEDECL_NOINTERFACES &&
				m_typeMgr.getTypeClass(relType) == RT_TYPE_INTERFACE)
				return;

//			if (m_typeMgr.getTypeClass(type) == RT_TYPE_TYPEDEF)
//			{
//				o << indent() << "get_" << type.replace('/', '_') << "_Type()";
//			} else
//			{
				o << indent() << "getIdlType( (";
				dumpType(o, type);
				o << "*)0 )";
//			}
		}
		if (bDecl)
			o << ";\n";
	}
}

BASETYPE IdlType::isBaseType(const OString& type)
{
	if (type.equals("long"))
		return BT_LONG;
	if (type.equals("short"))
		return BT_SHORT;
	if (type.equals("hyper"))
		return BT_HYPER;
	if (type.equals("string"))
		return BT_STRING;
	if (type.equals("boolean"))
		return BT_BOOLEAN;
	if (type.equals("char"))
		return BT_CHAR;
	if (type.equals("byte"))
		return BT_BYTE;
	if (type.equals("any"))
		return BT_ANY;
	if (type.equals("float"))
		return BT_FLOAT;
	if (type.equals("double"))
		return BT_DOUBLE;
	if (type.equals("void"))
		return BT_VOID;
	if (type.equals("unsigned long"))
		return BT_UNSIGNED_LONG;
	if (type.equals("unsigned short"))
		return BT_UNSIGNED_SHORT;
	if (type.equals("unsigned hyper"))
		return BT_UNSIGNED_HYPER;

	return BT_INVALID;
}

OString	IdlType::checkSpecialIdlType(const OString& type)
{
	OString baseType(type);

	RegistryTypeReaderLoader & rReaderLoader = getRegistryTypeReaderLoader();

	RegistryKey 	key;
	sal_uInt8*		pBuffer=NULL;
	RTTypeClass 	typeClass;
	sal_Bool 		isTypeDef = (m_typeMgr.getTypeClass(baseType) == RT_TYPE_TYPEDEF);
	TypeReader		reader;

	while (isTypeDef)
	{
		reader = m_typeMgr.getTypeReader(baseType);

		if (reader.isValid())
		{
			typeClass = reader.getTypeClass();

			if (typeClass == RT_TYPE_TYPEDEF)
				baseType = reader.getSuperTypeName();
			else
				isTypeDef = sal_False;
		} else
		{
			break;
		}
	}

	return baseType;
}

OString	IdlType::checkRealBaseType(const OString& type, sal_Bool bResolveTypeOnly)
{
	sal_uInt32 index = type.lastIndexOf(']');
	OString baseType = (index > 0 ? ((OString)type).copy(index+1) : type);
	OString seqPrefix = (index > 0 ? ((OString)type).copy(0, index+1) : OString());

	RegistryTypeReaderLoader & rReaderLoader = getRegistryTypeReaderLoader();

	RegistryKey 	key;
	sal_uInt8*		pBuffer=NULL;
	RTTypeClass 	typeClass;
	sal_Bool 		mustBeChecked = (m_typeMgr.getTypeClass(baseType) == RT_TYPE_TYPEDEF);
	TypeReader		reader;

	while (mustBeChecked)
	{
		reader = m_typeMgr.getTypeReader(baseType);

		if (reader.isValid())
		{
			typeClass = reader.getTypeClass();

			if (typeClass == RT_TYPE_TYPEDEF)
			{
				baseType = reader.getSuperTypeName();
				index = baseType.lastIndexOf(']');
		  		if (index > 0)
				{
					seqPrefix += baseType.copy(0, index+1);
					baseType = baseType.copy(index+1);
				}
			} else
				mustBeChecked = sal_False;
		} else
		{
			break;
		}
	}

	if ( bResolveTypeOnly )
		baseType = seqPrefix + baseType;

	return baseType;
}

void IdlType::dumpConstantValue(FileStream& o, sal_uInt16 index)
{
	RTConstValue constValue = m_reader.getFieldConstValue(index);

	switch (constValue.m_type)
	{
		case RT_TYPE_BOOL:
			if (constValue.m_value.aBool)
				o << "true";
			else
				o << "false";
			break;
		case RT_TYPE_BYTE:
			{
				char tmp[16];
                snprintf(tmp, sizeof(tmp), "0x%x", (sal_Int8)constValue.m_value.aByte);
				o << tmp;
			}
			break;
		case RT_TYPE_INT16:
			o << constValue.m_value.aShort;
			break;
		case RT_TYPE_UINT16:
			o << constValue.m_value.aUShort;
			break;
		case RT_TYPE_INT32:
			o << constValue.m_value.aLong;
			break;
		case RT_TYPE_UINT32:
			o << constValue.m_value.aULong;
			break;
		case RT_TYPE_INT64:
            {
                ::rtl::OString tmp( OString::valueOf(constValue.m_value.aHyper) );
                o << tmp.getStr();
            }
			break;
		case RT_TYPE_UINT64:
            {
                ::rtl::OString tmp( OString::valueOf((sal_Int64)constValue.m_value.aUHyper) );
                o << tmp.getStr();
            }
			break;
		case RT_TYPE_FLOAT:
            {
                ::rtl::OString tmp( OString::valueOf(constValue.m_value.aFloat) );
                o << tmp.getStr();
            }
			break;
		case RT_TYPE_DOUBLE:
            {
                ::rtl::OString tmp( OString::valueOf(constValue.m_value.aDouble) );
                o << tmp.getStr();
            }
			break;
		case RT_TYPE_STRING:
			{
				::rtl::OUString aUStr(constValue.m_value.aString);
				::rtl::OString aStr = ::rtl::OUStringToOString(aUStr, RTL_TEXTENCODING_ASCII_US);
				o << "\"" << aStr.getStr() << "\")";
			}
			break;
	}
}

void IdlType::inc(sal_uInt32 num)
{
	m_indentLength += num;
}

void IdlType::dec(sal_uInt32 num)
{
	if (m_indentLength - num < 0)
		m_indentLength = 0;
	else
		m_indentLength -= num;
}

OString IdlType::indent()
{
	OStringBuffer tmp(m_indentLength);

	for (sal_uInt32 i=0; i < m_indentLength; i++)
	{
		tmp.append(' ');
	}
	return tmp.makeStringAndClear();
}

OString	IdlType::indent(sal_uInt32 num)
{
	OStringBuffer tmp(m_indentLength + num);

	for (sal_uInt32 i=0; i < m_indentLength + num; i++)
	{
		tmp.append(' ');
	}
	return tmp.makeStringAndClear();
}

//*************************************************************************
// InterfaceType
//*************************************************************************
InterfaceType::InterfaceType(TypeReader& typeReader,
			 				 const OString& typeName,
							 const TypeManager& typeMgr,
							 const TypeDependency& typeDependencies)
	: IdlType(typeReader, typeName, typeMgr, typeDependencies)
{
	m_inheritedMemberCount = 0;
	m_hasAttributes = sal_False;
	m_hasMethods = sal_False;
}

InterfaceType::~InterfaceType()
{

}

sal_Bool InterfaceType::dumpHFile(FileStream& o)
	throw( CannotDumpException )
{
	OString headerDefine(dumpHeaderDefine(o, "IDL"));
	o << "\n";

	dumpDefaultHIncludes(o);
	o << "\n";
	dumpDepIncludes(o, m_typeName, "idl");
	o << "\n";
	dumpNameSpace(o);

	// write documentation
	OString aDoc = m_reader.getDoku();
	if( !aDoc.isEmpty() )
		o << "/**\n" << aDoc << "\n*/";
	o << "\ninterface " << m_name;

	OString superType(m_reader.getSuperTypeName());
	if ( !superType.isEmpty() )
		o << " : " << scopedName(m_typeName, superType);

	o << "\n{\n";
	inc();

	dumpAttributes(o);
	dumpMethods(o);

	dec();
	o << "};\n\n";

	dumpNameSpace(o, sal_False);

//	o << "\nnamespace com { namespace sun { namespace star { namespace uno {\n"
//	  << "class Type;\n} } } }\n\n";

	o << "#endif /* "<< headerDefine << "*/" << "\n";
	return sal_True;
}

void InterfaceType::dumpAttributes(FileStream& o)
{
	sal_uInt32 fieldCount = m_reader.getFieldCount();
	sal_Bool first=sal_True;

	RTFieldAccess access = RT_ACCESS_INVALID;
	OString fieldName;
	OString fieldType;
	for (sal_uInt16 i=0; i < fieldCount; i++)
	{
		access = m_reader.getFieldAccess(i);

		if (access == RT_ACCESS_CONST || access == RT_ACCESS_INVALID)
			continue;

		fieldName = m_reader.getFieldName(i);
		fieldType = m_reader.getFieldType(i);

		if (first)
		{
			first = sal_False;
			o << "\n";
		}

		// write documentation
		OString aDoc = m_reader.getFieldDoku(i);
		if( !aDoc.isEmpty() )
			o << "/**\n" << aDoc << "\n*/\n";

		if (access == RT_ACCESS_READONLY)
			o << indent() << "readonly attribute ";
		else
			o << indent() << "attribute ";
		dumpType(o, fieldType);
		o << " " << fieldName << ";\n";
	}
}

void InterfaceType::dumpMethods(FileStream& o)
{
	sal_uInt32 methodCount = m_reader.getMethodCount();

	OString methodName, returnType, paramType, paramName;
	sal_uInt32 paramCount = 0;
	sal_uInt32 excCount = 0;
	RTMethodMode methodMode = RT_MODE_INVALID;
	RTParamMode	 paramMode = RT_PARAM_INVALID;

	sal_Bool bRef = sal_False;
	sal_Bool bConst = sal_False;
	sal_Bool bWithRunTimeExcp = sal_True;

	for (sal_Int16 i=0; i < methodCount; i++)
	{
		methodName = m_reader.getMethodName(i);
		returnType = m_reader.getMethodReturnType(i);
		paramCount = m_reader.getMethodParamCount(i);
		excCount = m_reader.getMethodExcCount(i);
		methodMode = m_reader.getMethodMode(i);

		if ( methodName.equals("acquire") || methodName.equals("release") )
		{
			bWithRunTimeExcp = sal_False;
		}

		// write documentation
		OString aDoc = m_reader.getMethodDoku(i);
		if( !aDoc.isEmpty() )
			o << "/**\n" << aDoc << "\n*/\n";

		o << indent();
		dumpType(o, returnType);
		o << " " << methodName << "( ";
		sal_uInt16 j;
		for (j=0; j < paramCount; j++)
		{
			paramName =	m_reader.getMethodParamName(i, j);
			paramType =	m_reader.getMethodParamType(i, j);
			paramMode = m_reader.getMethodParamMode(i, j);

			switch (paramMode)
			{
				case RT_PARAM_IN:
					o << "in ";
					break;
				case RT_PARAM_OUT:
					o << "out ";
					break;
				case RT_PARAM_INOUT:
					o << "inout ";
					break;
					break;
			}

			dumpType(o, paramType);
			if( paramName == "Object" )
				o << " _Object";
			else
				o << " " << paramName;

			if (j+1 < paramCount) o << ", ";
		}
		o << " )";

		if( excCount )
		{
			o << " raises(";
			OString excpName;
			sal_Bool bWriteComma = sal_False;
			sal_Bool bRTExceptionWritten = sal_False;
			for (j=0; j < excCount; j++)
			{
				excpName = m_reader.getMethodExcType(i, j);
				if( bWriteComma )
					o << ", ";
				o << scopedName(m_typeName, excpName);
				bWriteComma = sal_True;

				if(excpName == "com/sun/star/uno/RuntimeException")
					bRTExceptionWritten = sal_True;
			}

			if ( bWithRunTimeExcp && !bRTExceptionWritten )
			{
				if( bWriteComma )
					o << ", ";
				o << "::com::sun::star::uno::RuntimeException";
			}

			o << ");\n";
		}
		else if ( bWithRunTimeExcp )
		{
			o << "raises( ::com::sun::star::uno::RuntimeException );\n";
		}
		else
		{
			o << ";\n";
		}
	}
}


sal_uInt32 InterfaceType::getMemberCount()
{
	sal_uInt32 count = m_reader.getMethodCount();

	if (count)
		m_hasMethods = sal_True;

	sal_uInt32 fieldCount = m_reader.getFieldCount();
	RTFieldAccess access = RT_ACCESS_INVALID;
	for (sal_uInt16 i=0; i < fieldCount; i++)
	{
		access = m_reader.getFieldAccess(i);

		if (access != RT_ACCESS_CONST && access != RT_ACCESS_INVALID)
		{
			m_hasAttributes = sal_True;
			count++;
		}
	}
	return count;
}

sal_uInt32 InterfaceType::checkInheritedMemberCount(const TypeReader* pReader)
{
	sal_uInt32 cout = 0;
	sal_Bool bSelfCheck = sal_True;
	if (!pReader)
	{
		bSelfCheck = sal_False;
		pReader = &m_reader;
	}

	sal_uInt32 count = 0;
	OString superType(pReader->getSuperTypeName());
	if ( !superType.isEmpty() )
	{
		TypeReader aSuperReader(m_typeMgr.getTypeReader(superType));
		if (aSuperReader.isValid())
		{
			count = checkInheritedMemberCount(&aSuperReader);
		}
	}

	if (bSelfCheck)
	{
		count += pReader->getMethodCount();
		sal_uInt32 fieldCount = pReader->getFieldCount();
		RTFieldAccess access = RT_ACCESS_INVALID;
		for (sal_uInt16 i=0; i < fieldCount; i++)
		{
			access = pReader->getFieldAccess(i);

			if (access != RT_ACCESS_CONST && access != RT_ACCESS_INVALID)
			{
				count++;
			}
		}
	}

	return count;
}

sal_uInt32 InterfaceType::getInheritedMemberCount()
{
	if (m_inheritedMemberCount == 0)
	{
		m_inheritedMemberCount = checkInheritedMemberCount(0);
	}

	return m_inheritedMemberCount;
}


//*************************************************************************
// ModuleType
//*************************************************************************
ModuleType::ModuleType(TypeReader& typeReader,
			 		   const OString& typeName,
					   const TypeManager& typeMgr,
					   const TypeDependency& typeDependencies)
	: IdlType(typeReader, typeName, typeMgr, typeDependencies)
{
}

ModuleType::~ModuleType()
{

}

sal_Bool ModuleType::dump(IdlOptions* pOptions)
	throw( CannotDumpException )
{
	sal_Bool ret = sal_False;

	OString outPath;
	if (pOptions->isValid("-O"))
		outPath = pOptions->getOption("-O");

	OString tmpName(m_typeName);

	if (tmpName.equals("/"))
		tmpName = "global";
	else
//		tmpName += "/" + m_typeName.getToken(m_typeName.getTokenCount('/') - 1, '/');
		tmpName += "/" + m_name;

	OString tmpFileName;
	OString hFileName = createFileNameFromType(outPath, tmpName, ".idl");

	sal_Bool bFileExists = sal_False;
	sal_Bool bFileCheck = sal_False;

	if ( pOptions->isValid("-G") || pOptions->isValid("-Gc") )
	{
		bFileExists = fileExists( hFileName );
		ret = sal_True;
	}

	if ( bFileExists && pOptions->isValid("-Gc") )
	{
		tmpFileName	 = createFileNameFromType(outPath, m_typeName, ".tml");
		bFileCheck = sal_True;
	}

	if ( !bFileExists || bFileCheck )
	{
		FileStream hFile;

		if ( bFileCheck )
			hFile.open(tmpFileName);
		else
			hFile.open(hFileName);

		if(!hFile.isValid())
		{
			OString message("cannot open ");
			message += hFileName + " for writing";
			throw CannotDumpException(message);
		}

		ret = dumpHFile(hFile);

		hFile.close();
		if (ret && bFileCheck)
		{
			ret = checkFileContent(hFileName, tmpFileName);
		}
	}

	return ret;
}

sal_Bool ModuleType::dumpHFile(FileStream& o)
	throw( CannotDumpException )
{
	OString headerDefine(dumpHeaderDefine(o, "IDL"));
	o << "\n";

	dumpDefaultHIncludes(o);
	o << "\n";
	dumpDepIncludes(o, m_typeName, "idl");
	o << "\n";

	dumpNameSpace(o, sal_True, sal_True);
	o << "\n";

	sal_uInt32 		fieldCount = m_reader.getFieldCount();
	RTFieldAccess 	access = RT_ACCESS_INVALID;
	OString 		fieldName;
	OString 		fieldType;
	for (sal_uInt16 i=0; i < fieldCount; i++)
	{
		access = m_reader.getFieldAccess(i);

		if (access == RT_ACCESS_CONST)
		{
			fieldName = m_reader.getFieldName(i);
			fieldType = m_reader.getFieldType(i);

			o << "const ";
			dumpType(o, fieldType);
			o << " " << fieldName << " = ";
			dumpConstantValue(o, i);
			o << ";\n";
		}
	}

	o << "\n";
	dumpNameSpace(o, sal_False, sal_True);
	o << "\n#endif /* "<< headerDefine << "*/" << "\n";

	return sal_True;
}

sal_Bool ModuleType::hasConstants()
{
	sal_uInt32 		fieldCount = m_reader.getFieldCount();
	RTFieldAccess 	access = RT_ACCESS_INVALID;

	for (sal_uInt16 i=0; i < fieldCount; i++)
	{
		access = m_reader.getFieldAccess(i);

		if (access == RT_ACCESS_CONST)
			return sal_True;
	}

	return sal_False;
}

//*************************************************************************
// ConstantsType
//*************************************************************************
ConstantsType::ConstantsType(TypeReader& typeReader,
				 		     const OString& typeName,
						     const TypeManager& typeMgr,
						     const TypeDependency& typeDependencies)
	: ModuleType(typeReader, typeName, typeMgr, typeDependencies)
{
}

ConstantsType::~ConstantsType()
{

}

sal_Bool ConstantsType::dump(IdlOptions* pOptions)
	throw( CannotDumpException )
{
	sal_Bool ret = sal_False;

	OString outPath;
	if (pOptions->isValid("-O"))
		outPath = pOptions->getOption("-O");

	OString tmpFileName;
	OString hFileName = createFileNameFromType(outPath, m_typeName, ".idl");

	sal_Bool bFileExists = sal_False;
	sal_Bool bFileCheck = sal_False;

	if ( pOptions->isValid("-G") || pOptions->isValid("-Gc") )
	{
		bFileExists = fileExists( hFileName );
		ret = sal_True;
	}

	if ( bFileExists && pOptions->isValid("-Gc") )
	{
		tmpFileName	 = createFileNameFromType(outPath, m_typeName, ".tml");
		bFileCheck = sal_True;
	}

	if ( !bFileExists || bFileCheck )
	{
		FileStream hFile;

		if ( bFileCheck )
			hFile.open(tmpFileName);
		else
			hFile.open(hFileName);

		if(!hFile.isValid())
		{
			OString message("cannot open ");
			message += hFileName + " for writing";
			throw CannotDumpException(message);
		}

		ret = dumpHFile(hFile);

		hFile.close();
		if (ret && bFileCheck)
		{
			ret = checkFileContent(hFileName, tmpFileName);
		}
	}

	return ret;
}

//*************************************************************************
// StructureType
//*************************************************************************
StructureType::StructureType(TypeReader& typeReader,
			 				 const OString& typeName,
							 const TypeManager& typeMgr,
							 const TypeDependency& typeDependencies)
	: IdlType(typeReader, typeName, typeMgr, typeDependencies)
{
}

StructureType::~StructureType()
{

}

sal_Bool StructureType::dumpHFile(FileStream& o)
	throw( CannotDumpException )
{
	OString headerDefine(dumpHeaderDefine(o, "IDL"));
	o << "\n";

	dumpDefaultHIncludes(o);
	o << "\n";
	dumpDepIncludes(o, m_typeName, "idl");
	o << "\n";

	dumpNameSpace(o);

	// write documentation
	OString aDoc = m_reader.getDoku();
	if( !aDoc.isEmpty() )
		o << "/**\n" << aDoc << "\n*/";

	o << "\nstruct " << m_name;
	o << "\n{\n";
	inc();

	OString superType(m_reader.getSuperTypeName());
	if ( !superType.isEmpty() )
		dumpSuperMember(o, superType);

	sal_uInt32 		fieldCount = m_reader.getFieldCount();
	RTFieldAccess 	access = RT_ACCESS_INVALID;
	OString 		fieldName;
	OString 		fieldType;
	sal_uInt16 		i=0;

	for (i=0; i < fieldCount; i++)
	{
		access = m_reader.getFieldAccess(i);

		if (access == RT_ACCESS_CONST || access == RT_ACCESS_INVALID)
			continue;

		fieldName = m_reader.getFieldName(i);
		fieldType = m_reader.getFieldType(i);

		// write documentation
		OString aDoc = m_reader.getFieldDoku(i);
		if( !aDoc.isEmpty() )
			o << "/**\n" << aDoc << "\n*/";

		o << indent();
		dumpType(o, fieldType);
		o << " " << fieldName << ";\n";
	}

	dec();
	o << "};\n\n";

	dumpNameSpace(o, sal_False);

	o << "#endif /* "<< headerDefine << "*/" << "\n";

	return sal_True;
}

void StructureType::dumpSuperMember(FileStream& o, const OString& superType)
{
	if ( !superType.isEmpty() )
	{
		TypeReader aSuperReader(m_typeMgr.getTypeReader(superType));

		if (aSuperReader.isValid())
		{
			dumpSuperMember(o, aSuperReader.getSuperTypeName());

			sal_uInt32 		fieldCount = aSuperReader.getFieldCount();
			RTFieldAccess 	access = RT_ACCESS_INVALID;
			OString 		fieldName;
			OString 		fieldType;
			for (sal_uInt16 i=0; i < fieldCount; i++)
			{
				access = aSuperReader.getFieldAccess(i);

				if (access == RT_ACCESS_CONST || access == RT_ACCESS_INVALID)
					continue;

				fieldName = aSuperReader.getFieldName(i);
				fieldType = aSuperReader.getFieldType(i);

				// write documentation
				OString aDoc = aSuperReader.getFieldDoku(i);
				if( !aDoc.isEmpty() )
					o << "/**\n" << aDoc << "\n*/";

				o << indent();
				dumpType(o, fieldType);
				o << " ";
				o << fieldName << ";\n";
			}
		}
	}
}

//*************************************************************************
// ExceptionType
//*************************************************************************
ExceptionType::ExceptionType(TypeReader& typeReader,
			 				 const OString& typeName,
							 const TypeManager& typeMgr,
							 const TypeDependency& typeDependencies)
	: IdlType(typeReader, typeName, typeMgr, typeDependencies)
{
}

ExceptionType::~ExceptionType()
{

}

sal_Bool ExceptionType::dumpHFile(FileStream& o)
	throw( CannotDumpException )
{
	OString headerDefine(dumpHeaderDefine(o, "IDL"));
	o << "\n";

	dumpDefaultHIncludes(o);
	o << "\n";
	dumpDepIncludes(o, m_typeName, "idl");
	o << "\n";

	dumpNameSpace(o);

	// write documentation
	OString aDoc = m_reader.getDoku();
	if( !aDoc.isEmpty() )
		o << "/**\n" << aDoc << "\n*/";

	o << "\nexception " << m_name;
	o << "\n{\n";
	inc();

	// Write extra member for derived exceptions
	o << indent() << "/*extra member to hold a derived exception */\n";
	o << indent() << "any _derivedException;\n";
	OString superType(m_reader.getSuperTypeName());
	if ( !superType.isEmpty() )
		dumpSuperMember(o, superType);

	sal_uInt32 		fieldCount = m_reader.getFieldCount();
	RTFieldAccess 	access = RT_ACCESS_INVALID;
	OString 		fieldName;
	OString 		fieldType;
	sal_uInt16 		i = 0;

	for (i=0; i < fieldCount; i++)
	{
		access = m_reader.getFieldAccess(i);

		if (access == RT_ACCESS_CONST || access == RT_ACCESS_INVALID)
			continue;

		fieldName = m_reader.getFieldName(i);
		fieldType = m_reader.getFieldType(i);

		// write documentation
		OString aDoc = m_reader.getFieldDoku(i);
		if( !aDoc.isEmpty() )
			o << "/**\n" << aDoc << "\n*/";

		o << indent();
		dumpType(o, fieldType);
		o << " " << fieldName << ";\n";
	}


	dec();
	o << "};\n\n";

	dumpNameSpace(o, sal_False);

	o << "#endif /* "<< headerDefine << "*/" << "\n";

	return sal_True;
}

void ExceptionType::dumpSuperMember(FileStream& o, const OString& superType)
{
	if ( !superType.isEmpty() )
	{
		TypeReader aSuperReader(m_typeMgr.getTypeReader(superType));

		if (aSuperReader.isValid())
		{
			dumpSuperMember(o, aSuperReader.getSuperTypeName());

			sal_uInt32 		fieldCount = aSuperReader.getFieldCount();
			RTFieldAccess 	access = RT_ACCESS_INVALID;
			OString 		fieldName;
			OString 		fieldType;
			for (sal_uInt16 i=0; i < fieldCount; i++)
			{
				access = aSuperReader.getFieldAccess(i);

				if (access == RT_ACCESS_CONST || access == RT_ACCESS_INVALID)
					continue;

				fieldName = aSuperReader.getFieldName(i);
				fieldType = aSuperReader.getFieldType(i);

				// write documentation
				OString aDoc = aSuperReader.getFieldDoku(i);
				if( !aDoc.isEmpty() )
					o << "/**\n" << aDoc << "\n*/";

				o << indent();
				dumpType(o, fieldType);
				o << " ";
				o << fieldName << ";\n";
			}
		}
	}
}

//*************************************************************************
// EnumType
//*************************************************************************
EnumType::EnumType(TypeReader& typeReader,
			 	   const OString& typeName,
				   const TypeManager& typeMgr,
				   const TypeDependency& typeDependencies)
	: IdlType(typeReader, typeName, typeMgr, typeDependencies)
{
}

EnumType::~EnumType()
{

}

sal_Bool EnumType::dumpHFile(FileStream& o)
	throw( CannotDumpException )
{
	OString headerDefine(dumpHeaderDefine(o, "IDL"));
	o << "\n";

	dumpDefaultHIncludes(o);
	o << "\n";

	dumpNameSpace(o);

	// write documentation
	OString aDoc = m_reader.getDoku();
	if( !aDoc.isEmpty() )
		o << "/**\n" << aDoc << "\n*/";

	o << "\nenum " << m_name << "\n{\n";
	inc();

	sal_uInt32 		fieldCount = m_reader.getFieldCount();
	RTFieldAccess 	access = RT_ACCESS_INVALID;
	RTConstValue	constValue;
	OString 		fieldName;
	sal_uInt32		value=0;
	for (sal_uInt16 i=0; i < fieldCount; i++)
	{
		access = m_reader.getFieldAccess(i);

		if (access != RT_ACCESS_CONST)
			continue;

		fieldName = m_reader.getFieldName(i);
		constValue = m_reader.getFieldConstValue(i);

		if (constValue.m_type == RT_TYPE_INT32)
			value = constValue.m_value.aLong;
		else
			value++;

		/* doesn't work with rational rose 2000
		// write documentation
		OString aDoc = m_reader.getFieldDoku(i);
		if( aDoc.getLength() )
		*/
		//	o << "/**\n" << aDoc << "\n*/\n";
		o << indent() << fieldName;
		if( i +1 < fieldCount )
			o << ",\n";
	}

	dec();
	o << "\n};\n\n";

	dumpNameSpace(o, sal_False);

	o << "#endif /* "<< headerDefine << "*/" << "\n";

	return sal_True;
}


//*************************************************************************
// TypeDefType
//*************************************************************************
TypeDefType::TypeDefType(TypeReader& typeReader,
			 	   		 const OString& typeName,
				   		 const TypeManager& typeMgr,
				   		 const TypeDependency& typeDependencies)
	: IdlType(typeReader, typeName, typeMgr, typeDependencies)
{
}

TypeDefType::~TypeDefType()
{

}

sal_Bool TypeDefType::dumpHFile(FileStream& o)
	throw( CannotDumpException )
{
	OString headerDefine(dumpHeaderDefine(o, "IDL"));
	o << "\n";

	dumpDefaultHIncludes(o);
	o << "\n";
	dumpDepIncludes(o, m_typeName, "idl");
	o << "\n";

	dumpNameSpace(o);

	o << "\ntypedef ";
	dumpType(o, m_reader.getSuperTypeName());
	o << " " << m_name << ";\n\n";

	dumpNameSpace(o, sal_False);

	o << "#endif /* "<< headerDefine << "*/" << "\n";

	return sal_True;
}


//*************************************************************************
// produceType
//*************************************************************************
sal_Bool produceType(const OString& typeName,
					 TypeManager& typeMgr,
					 TypeDependency& typeDependencies,
					 IdlOptions* pOptions)
	throw( CannotDumpException )
{
	if (typeDependencies.isGenerated(typeName))
		return sal_True;

	TypeReader reader(typeMgr.getTypeReader(typeName));

	if (!reader.isValid())
	{
		if (typeName.equals("/"))
			return sal_True;
		else
			return sal_False;
	}

	if( !checkTypeDependencies(typeMgr, typeDependencies, typeName))
		return sal_False;

	RTTypeClass typeClass = reader.getTypeClass();
	sal_Bool 	ret = sal_False;
	switch (typeClass)
	{
		case RT_TYPE_INTERFACE:
			{
				InterfaceType iType(reader, typeName, typeMgr, typeDependencies);
				ret = iType.dump(pOptions);
				if (ret) typeDependencies.setGenerated(typeName);
				ret = iType.dumpDependedTypes(pOptions);
			}
			break;
		case RT_TYPE_MODULE:
			{
				ModuleType mType(reader, typeName, typeMgr, typeDependencies);
				if (mType.hasConstants())
				{
					ret = mType.dump(pOptions);
					if (ret) typeDependencies.setGenerated(typeName);
//					ret = mType.dumpDependedTypes(pOptions);
				} else
				{
					typeDependencies.setGenerated(typeName);
					ret = sal_True;
				}
			}
			break;
		case RT_TYPE_STRUCT:
			{
				StructureType sType(reader, typeName, typeMgr, typeDependencies);
				ret = sType.dump(pOptions);
				if (ret) typeDependencies.setGenerated(typeName);
				ret = sType.dumpDependedTypes(pOptions);
			}
			break;
		case RT_TYPE_ENUM:
			{
				EnumType enType(reader, typeName, typeMgr, typeDependencies);
				ret = enType.dump(pOptions);
				if (ret) typeDependencies.setGenerated(typeName);
				ret = enType.dumpDependedTypes(pOptions);
			}
			break;
		case RT_TYPE_EXCEPTION:
			{
				ExceptionType eType(reader, typeName, typeMgr, typeDependencies);
				ret = eType.dump(pOptions);
				if (ret) typeDependencies.setGenerated(typeName);
				ret = eType.dumpDependedTypes(pOptions);
			}
			break;
		case RT_TYPE_TYPEDEF:
			{
				TypeDefType tdType(reader, typeName, typeMgr, typeDependencies);
				ret = tdType.dump(pOptions);
				if (ret) typeDependencies.setGenerated(typeName);
				ret = tdType.dumpDependedTypes(pOptions);
			}
			break;
		case RT_TYPE_CONSTANTS:
			{
				ConstantsType cType(reader, typeName, typeMgr, typeDependencies);
				if (cType.hasConstants())
				{
					ret = cType.dump(pOptions);
					if (ret) typeDependencies.setGenerated(typeName);
//					ret = cType.dumpDependedTypes(pOptions);
				} else
				{
					typeDependencies.setGenerated(typeName);
					ret = sal_True;
				}
			}
			break;
		case RT_TYPE_SERVICE:
		case RT_TYPE_OBJECT:
			ret = sal_True;
			break;
	}

	return ret;
}

//*************************************************************************
// scopedName
//*************************************************************************
OString scopedName(const OString& scope, const OString& type,
				   sal_Bool bNoNameSpace)
{
    sal_Int32 nPos = type.lastIndexOf( '/' );
	if (nPos == -1)
		return type;

	if (bNoNameSpace)
		return type.copy(nPos+1);

	OStringBuffer tmpBuf(type.getLength()*2);
    nPos = 0;
    do
	{
		tmpBuf.append("::");
		tmpBuf.append(type.getToken(0, '/', nPos));
	} while( nPos != -1 );

	return tmpBuf.makeStringAndClear();
}

//*************************************************************************
// shortScopedName
//*************************************************************************
OString scope(const OString& scope, const OString& type )
{
    sal_Int32 nPos = type.lastIndexOf( '/' );
    if( nPos == -1 )
        return OString();

	// scoped name only if the namespace is not equal
	if (scope.lastIndexOf('/') > 0)
	{
		OString tmpScp(scope.copy(0, scope.lastIndexOf('/')));
		OString tmpScp2(type.copy(0, nPos));

		if (tmpScp == tmpScp2)
			return OString();
	}

    OString aScope( type.copy( 0, nPos ) );
	OStringBuffer tmpBuf(aScope.getLength()*2);

    nPos = 0;
    do
	{
		tmpBuf.append("::");
		tmpBuf.append(aScope.getToken(0, '/', nPos));
	} while( nPos != -1 );

	return tmpBuf.makeStringAndClear();
}