idlc/source/astscope.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <idlc/astscope.hxx>
  21 #include <idlc/astbasetype.hxx>
  22 #include <idlc/astinterface.hxx>
  23 #include <idlc/errorhandler.hxx>
  24
  25
  26 using namespace ::rtl;
  27
  28 bool isGlobal(const OString& scopedName)
  29 {
  30     return scopedName.isEmpty() || scopedName.startsWith(":");
  31 }
  32
  33 AstScope::AstScope(NodeType nodeType)
  34     : m_nodeType(nodeType)
  35 {
  36
  37 }
  38
  39 AstScope::~AstScope()
  40 {
  41
  42 }
  43
  44 AstDeclaration* AstScope::addDeclaration(AstDeclaration* pDecl)
  45 {
  46     AstDeclaration* pDeclaration = NULL;
  47
  48     if ((pDeclaration = lookupForAdd(pDecl)) != NULL)
  49     {
  50         if ( pDecl->hasAncestor(pDeclaration) )
  51         {
  52             idlc()->error()->error2(EIDL_REDEF_SCOPE, pDecl, pDeclaration);
  53             return NULL;
  54         }
  55         if ( (pDecl->getNodeType() == pDeclaration->getNodeType()) &&
  56              (pDecl->getNodeType() == NT_sequence
  57               || pDecl->getNodeType() == NT_instantiated_struct) )
  58         {
  59             return pDeclaration;
  60         }
  61         if ( (pDeclaration->getNodeType() == NT_interface)
  62              && (pDecl->getNodeType() == NT_interface)
  63              && !((AstInterface*)pDeclaration)->isDefined() )
  64         {
  65             m_declarations.push_back(pDecl);
  66             return pDecl;
  67         }
  68         if ( (NT_service == m_nodeType) &&
  69              ( ((pDecl->getNodeType() == NT_interface_member)
  70                 && (pDeclaration->getNodeType() == NT_interface)) ||
  71                ((pDecl->getNodeType() == NT_service_member)
  72                 && (pDeclaration->getNodeType() == NT_service)) )
  73             )
  74         {
  75             m_declarations.push_back(pDecl);
  76             return pDecl;
  77         }
  78
  79         idlc()->error()->error2(EIDL_REDEF_SCOPE, scopeAsDecl(this), pDecl);
  80         return NULL;
  81     }
  82
  83     m_declarations.push_back(pDecl);
  84     return pDecl;
  85 }
  86
  87 sal_uInt16 AstScope::getNodeCount(NodeType nodeType)
  88 {
  89     DeclList::const_iterator iter = getIteratorBegin();
  90     DeclList::const_iterator end = getIteratorEnd();
  91     AstDeclaration* pDecl = NULL;
  92     sal_uInt16 count = 0;
  93
  94     while ( iter != end )
  95     {
  96         pDecl = *iter;
  97         if ( pDecl->getNodeType() == nodeType )
  98             count++;
  99         ++iter;
 100     }
 101     return count;
 102 }
 103
 104 AstDeclaration* AstScope::lookupByName(const OString& scopedName)
 105 {
 106     AstDeclaration* pDecl = NULL;
 107     AstScope*       pScope = NULL;
 108     if (scopedName.isEmpty())
 109         return NULL;
 110
 111     // If name starts with "::" start look up in global scope
 112     if ( isGlobal(scopedName) )
 113     {
 114         pDecl = scopeAsDecl(this);
 115         if ( !pDecl )
 116             return NULL;
 117
 118         pScope = pDecl->getScope();
 119         // If this is the global scope ...
 120         if ( !pScope )
 121         {
 122             // look up the scopedName part after "::"
 123             OString subName = scopedName.copy(2);
 124             pDecl = lookupByName(subName);
 125             return pDecl;
 126             //return pScope->lookupByName();
 127         }
 128         // OK, not global scope yet, so simply iterate with parent scope
 129         pDecl = pScope->lookupByName(scopedName);
 130         return pDecl;
 131     }
 132
 133     // The name does not start with "::"
 134     // Look up in the local scope and start with the first scope
 135     sal_Int32 nIndex = scopedName.indexOf(':');
 136     OString firstScope =  nIndex > 0 ? scopedName.copy(0, nIndex) : scopedName;
 137     bool    bFindFirstScope = true;
 138     pDecl = lookupByNameLocal(firstScope);
 139     if ( !pDecl )
 140     {
 141         bFindFirstScope = false;
 142
 143         // OK, not found. Go down parent scope chain
 144         pDecl = scopeAsDecl(this);
 145         if ( pDecl )
 146         {
 147             pScope = pDecl->getScope();
 148             if ( pScope )
 149                    pDecl = pScope->lookupByName(scopedName);
 150             else
 151                 pDecl = NULL;
 152
 153              // Special case for scope which is an interface. We
 154              // have to look in the inherited interfaces as well.
 155             if ( !pDecl )
 156             {
 157                 if (m_nodeType == NT_interface)
 158                     pDecl = lookupInInherited(scopedName);
 159             }
 160        }
 161     }
 162
 163     if ( bFindFirstScope && (firstScope != scopedName) )
 164     {
 165         sal_Int32 i = 0;
 166         sal_Int32 nOffset = 2;
 167         do
 168         {
 169             pScope = declAsScope(pDecl);
 170             if( pScope )
 171             {
 172                 pDecl = pScope->lookupByNameLocal(scopedName.getToken(nOffset, ':', i ));
 173                 nOffset = 1;
 174             }
 175             if( !pDecl )
 176                 break;
 177         } while( i != -1 );
 178
 179         if ( !pDecl )
 180         {
 181             // last try if is not the global scope and the scopeName isn't specify global too
 182             pDecl = scopeAsDecl(this);
 183             if ( pDecl && (pDecl->getLocalName() != "") )
 184             {
 185                 pScope = pDecl->getScope();
 186                 if ( pScope )
 187                     pDecl = pScope->lookupByName(scopedName);
 188             } else
 189             {
 190                 pDecl = NULL;
 191             }
 192         }
 193
 194     }
 195
 196     return pDecl;
 197 }
 198
 199 AstDeclaration* AstScope::lookupByNameLocal(const OString& name) const
 200 {
 201     DeclList::const_iterator iter(m_declarations.begin());
 202     DeclList::const_iterator end(m_declarations.end());
 203     AstDeclaration* pDecl = NULL;
 204
 205     while ( iter != end )
 206     {
 207         pDecl = *iter;
 208         if ( pDecl->getLocalName() == name )
 209             return pDecl;
 210         ++iter;
 211     }
 212     return NULL;
 213 }
 214
 215 AstDeclaration* AstScope::lookupInInherited(const OString& scopedName) const
 216 {
 217     AstInterface* pInterface = (AstInterface*)this;
 218
 219     if ( !pInterface )
 220         return NULL;
 221
 222     // Can't look in an interface which was not yet defined
 223     if ( !pInterface->getScope() )
 224     {
 225         idlc()->error()->forwardLookupError(pInterface, scopedName);
 226     }
 227
 228     // OK, loop through inherited interfaces. Stop when you find it
 229     AstInterface::InheritedInterfaces::const_iterator iter(
 230         pInterface->getAllInheritedInterfaces().begin());
 231     AstInterface::InheritedInterfaces::const_iterator end(
 232         pInterface->getAllInheritedInterfaces().end());
 233     while ( iter != end )
 234     {
 235         AstInterface const * resolved = iter->getResolved();
 236         AstDeclaration* pDecl = resolved->lookupByNameLocal(scopedName);
 237         if ( pDecl )
 238             return pDecl;
 239         pDecl = resolved->lookupInInherited(scopedName);
 240         if ( pDecl )
 241             return pDecl;
 242         ++iter;
 243     }
 244     // Not found
 245     return NULL;
 246 }
 247
 248 AstDeclaration* AstScope::lookupPrimitiveType(ExprType type)
 249 {
 250     AstDeclaration* pDecl = NULL;
 251     AstScope*       pScope = NULL;
 252     OString         typeName;
 253     pDecl = scopeAsDecl(this);
 254     if ( !pDecl )
 255         return NULL;
 256     pScope = pDecl->getScope();
 257     if ( pScope)
 258         return pScope->lookupPrimitiveType(type);
 259
 260     switch (type)
 261     {
 262         case ET_none:
 263             OSL_ASSERT(false);
 264             break;
 265         case ET_short:
 266             typeName = OString("short");
 267             break;
 268         case ET_ushort:
 269             typeName = OString("unsigned short");
 270             break;
 271         case ET_long:
 272             typeName = OString("long");
 273             break;
 274         case ET_ulong:
 275             typeName = OString("unsigned long");
 276             break;
 277         case ET_hyper:
 278             typeName = OString("hyper");
 279             break;
 280         case ET_uhyper:
 281             typeName = OString("unsigned hyper");
 282             break;
 283         case ET_float:
 284             typeName = OString("float");
 285             break;
 286         case ET_double:
 287             typeName = OString("double");
 288             break;
 289         case ET_char:
 290             typeName = OString("char");
 291             break;
 292         case ET_byte:
 293             typeName = OString("byte");
 294             break;
 295         case ET_boolean:
 296             typeName = OString("boolean");
 297             break;
 298         case ET_any:
 299             typeName = OString("any");
 300             break;
 301         case ET_void:
 302             typeName = OString("void");
 303             break;
 304         case ET_type:
 305             typeName = OString("type");
 306             break;
 307         case ET_string:
 308             typeName = OString("string");
 309             break;
 310     }
 311
 312     pDecl = lookupByNameLocal(typeName);
 313
 314     if ( pDecl && (pDecl->getNodeType() == NT_predefined) )
 315     {
 316         AstBaseType* pBaseType = (AstBaseType*)pDecl;
 317
 318         if ( pBaseType->getExprType() == type )
 319             return pDecl;
 320     }
 321
 322     return NULL;
 323 }
 324
 325 AstDeclaration* AstScope::lookupForAdd(AstDeclaration* pDecl)
 326 {
 327     if ( !pDecl )
 328         return NULL;
 329
 330     AstDeclaration* pRetDecl = lookupByNameLocal(pDecl->getLocalName());
 331
 332    return pRetDecl;
 333 }
 334
 335 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */