xref: /aoo41x/main/idlc/source/astscope.cxx (revision 2fe1ca3d)

/**************************************************************
 *
 * 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_idlc.hxx"
#include <idlc/astscope.hxx>
#include <idlc/astbasetype.hxx>
#ifndef _IDLC_ASTINERFACE_HXX_
#include <idlc/astinterface.hxx>
#endif
#include <idlc/errorhandler.hxx>


using namespace ::rtl;

sal_Bool isGlobal(const OString& scopedName)
{
	if ((scopedName.getLength() == 0) || (scopedName.indexOf(':') == 0))
	{
		return sal_True;
	}
	return sal_False;
}

AstScope::AstScope(NodeType nodeType)
	: m_nodeType(nodeType)
{

}

AstScope::~AstScope()
{

}

AstDeclaration* AstScope::addDeclaration(AstDeclaration* pDecl)
{
	AstDeclaration* pDeclaration = NULL;

	if ((pDeclaration = lookupForAdd(pDecl)) != NULL)
	{
		if (pDecl->getNodeType() == NT_union_branch )
		{
			m_declarations.push_back(pDecl);
			return pDecl;
		}
		if ( pDecl->hasAncestor(pDeclaration) )
		{
			idlc()->error()->error2(EIDL_REDEF_SCOPE, pDecl, pDeclaration);
			return NULL;
		}
		if ( (pDecl->getNodeType() == pDeclaration->getNodeType()) &&
			 (pDecl->getNodeType() == NT_sequence
              || pDecl->getNodeType() == NT_array
              || pDecl->getNodeType() == NT_instantiated_struct) )
		{
			return pDeclaration;
		}
		if ( (pDeclaration->getNodeType() == NT_interface)
			 && (pDecl->getNodeType() == NT_interface)
			 && !((AstInterface*)pDeclaration)->isDefined() )
		{
			m_declarations.push_back(pDecl);
			return pDecl;
		}
		if ( (NT_service == m_nodeType) &&
			 ( ((pDecl->getNodeType() == NT_interface_member)
			    && (pDeclaration->getNodeType() == NT_interface)) ||
               ((pDecl->getNodeType() == NT_service_member)
			    && (pDeclaration->getNodeType() == NT_service)) )
            )
		{
			m_declarations.push_back(pDecl);
			return pDecl;
		}

		idlc()->error()->error2(EIDL_REDEF_SCOPE, scopeAsDecl(this), pDecl);
		return NULL;
	}

	m_declarations.push_back(pDecl);
	return pDecl;
}

sal_uInt16 AstScope::getNodeCount(NodeType nodeType)
{
	DeclList::const_iterator iter = getIteratorBegin();
	DeclList::const_iterator end = getIteratorEnd();
	AstDeclaration* pDecl = NULL;
	sal_uInt16 count = 0;

	while ( iter != end )
	{
		pDecl = *iter;
		if ( pDecl->getNodeType() == nodeType )
			count++;
		++iter;
	}
	return count;
}

AstDeclaration* AstScope::lookupByName(const OString& scopedName)
{
	AstDeclaration* pDecl = NULL;
	AstScope*		pScope = NULL;
	if (scopedName.getLength() == 0)
		return NULL;

	// If name starts with "::" start look up in global scope
	if ( isGlobal(scopedName) )
	{
		pDecl = scopeAsDecl(this);
		if ( !pDecl )
			return NULL;

		pScope = pDecl->getScope();
		// If this is the global scope ...
		if ( !pScope )
		{
			// look up the scopedName part after "::"
			OString subName = scopedName.copy(2);
			pDecl = lookupByName(subName);
			return pDecl;
			//return pScope->lookupByName();
		}
		// OK, not global scope yet, so simply iterate with parent scope
		pDecl = pScope->lookupByName(scopedName);
		return pDecl;
	}

	// The name does not start with "::"
	// Look up in the local scope and start with the first scope
    sal_Int32 nIndex = scopedName.indexOf(':');
	OString firstScope =  nIndex > 0 ? scopedName.copy(0, nIndex) : scopedName;
	sal_Bool	bFindFirstScope = sal_True;
	pDecl = lookupByNameLocal(firstScope);
	if ( !pDecl )
	{
		bFindFirstScope = sal_False;

		// OK, not found. Go down parent scope chain
		pDecl = scopeAsDecl(this);
		if ( pDecl )
		{
			pScope = pDecl->getScope();
			if ( pScope )
	   			pDecl = pScope->lookupByName(scopedName);
			else
				pDecl = NULL;

		 	// Special case for scope which is an interface. We
		 	// have to look in the inherited interfaces as well.
			if ( !pDecl )
			{
				if (m_nodeType == NT_interface)
					pDecl = lookupInInherited(scopedName);
			}
	   }
	}

	if ( bFindFirstScope && (firstScope != scopedName) )
	{
        sal_Int32 i = 0;
        sal_Int32 nOffset = 2;
        do
        {
            pScope = declAsScope(pDecl);
            if( pScope )
            {
                pDecl = pScope->lookupByNameLocal(scopedName.getToken(nOffset, ':', i ));
                nOffset = 1;
            }
            if( !pDecl )
                break;
        } while( i != -1 );

        if ( !pDecl )
        {
            // last try if is not the global scope and the scopeName isn't specify global too
            pDecl = scopeAsDecl(this);
            if ( pDecl && (pDecl->getLocalName() != "") )
            {
                pScope = pDecl->getScope();
                if ( pScope )
                    pDecl = pScope->lookupByName(scopedName);
            } else
            {
                pDecl = NULL;
            }
        }

	}

	return pDecl;
}

AstDeclaration* AstScope::lookupByNameLocal(const OString& name) const
{
	DeclList::const_iterator iter(m_declarations.begin());
	DeclList::const_iterator end(m_declarations.end());
	AstDeclaration* pDecl = NULL;

	while ( iter != end )
	{
		pDecl = *iter;
		if ( pDecl->getLocalName() == name )
			return pDecl;
		++iter;
	}
	return NULL;
}

AstDeclaration* AstScope::lookupInInherited(const OString& scopedName) const
{
	AstInterface* pInterface = (AstInterface*)this;

	if ( !pInterface )
		return NULL;

	// Can't look in an interface which was not yet defined
	if ( !pInterface->getScope() )
	{
		idlc()->error()->forwardLookupError(pInterface, scopedName);
	}

	// OK, loop through inherited interfaces. Stop when you find it
    AstInterface::InheritedInterfaces::const_iterator iter(
        pInterface->getAllInheritedInterfaces().begin());
    AstInterface::InheritedInterfaces::const_iterator end(
        pInterface->getAllInheritedInterfaces().end());
    while ( iter != end )
    {
        AstInterface const * resolved = iter->getResolved();
        AstDeclaration* pDecl = resolved->lookupByNameLocal(scopedName);
        if ( pDecl )
            return pDecl;
        pDecl = resolved->lookupInInherited(scopedName);
        if ( pDecl )
            return pDecl;
        ++iter;
    }
	// Not found
	return NULL;
}

AstDeclaration* AstScope::lookupPrimitiveType(ExprType type)
{
	AstDeclaration* pDecl = NULL;
	AstScope*		pScope = NULL;
	AstBaseType*	pBaseType = NULL;
	OString			typeName;
	pDecl = scopeAsDecl(this);
	if ( !pDecl )
		return NULL;
	pScope = pDecl->getScope();
	if ( pScope)
		return pScope->lookupPrimitiveType(type);

	switch (type)
	{
        case ET_none:
            OSL_ASSERT(false);
            break;
		case ET_short:
			typeName = OString("short");
			break;
		case ET_ushort:
			typeName = OString("unsigned short");
			break;
		case ET_long:
			typeName = OString("long");
			break;
		case ET_ulong:
			typeName = OString("unsigned long");
			break;
		case ET_hyper:
			typeName = OString("hyper");
			break;
		case ET_uhyper:
			typeName = OString("unsigned hyper");
			break;
		case ET_float:
			typeName = OString("float");
			break;
		case ET_double:
			typeName = OString("double");
			break;
		case ET_char:
			typeName = OString("char");
			break;
		case ET_byte:
			typeName = OString("byte");
			break;
		case ET_boolean:
			typeName = OString("boolean");
			break;
		case ET_any:
			typeName = OString("any");
			break;
		case ET_void:
			typeName = OString("void");
			break;
		case ET_type:
			typeName = OString("type");
			break;
		case ET_string:
			typeName = OString("string");
			break;
	}

	pDecl = lookupByNameLocal(typeName);

	if ( pDecl && (pDecl->getNodeType() == NT_predefined) )
	{
		pBaseType = (AstBaseType*)pDecl;

		if ( pBaseType->getExprType() == type )
			return pDecl;
	}

	return NULL;
}

AstDeclaration* AstScope::lookupForAdd(AstDeclaration* pDecl)
{
	if ( !pDecl )
		return NULL;

	AstDeclaration* pRetDecl = lookupByNameLocal(pDecl->getLocalName());

   return pRetDecl;
}