diff -r 000000000000 -r 876b1a06bc25 tools/icheck/parser/src/shared/cplusplus/Scope.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tools/icheck/parser/src/shared/cplusplus/Scope.cpp Wed Aug 25 15:49:42 2010 +0300 @@ -0,0 +1,341 @@ +/**************************************************************************** +** +** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt Mobility Components. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ +// Copyright (c) 2008 Roberto Raggi +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +#include "Scope.h" +#include "Symbols.h" +#include "Names.h" +#include "Literals.h" +#include +#include + +using namespace CPlusPlus; + +Scope::Scope(ScopedSymbol *owner) + : _owner(owner), + _symbols(0), + _allocatedSymbols(0), + _symbolCount(-1), + _hash(0), + _hashSize(0) +{ } + +Scope::~Scope() +{ + if (_symbols) + free(_symbols); + if (_hash) + free(_hash); +} + +ScopedSymbol *Scope::owner() const +{ return _owner; } + +void Scope::setOwner(ScopedSymbol *owner) +{ _owner = owner; } + +Scope *Scope::enclosingScope() const +{ + if (! _owner) + return 0; + + return _owner->scope(); +} + +Scope *Scope::enclosingNamespaceScope() const +{ + Scope *scope = enclosingScope(); + for (; scope; scope = scope->enclosingScope()) { + if (scope->owner()->isNamespace()) + break; + } + return scope; +} + +Scope *Scope::enclosingClassScope() const +{ + Scope *scope = enclosingScope(); + for (; scope; scope = scope->enclosingScope()) { + if (scope->owner()->isClass()) + break; + } + return scope; +} + +Scope *Scope::enclosingEnumScope() const +{ + Scope *scope = enclosingScope(); + for (; scope; scope = scope->enclosingScope()) { + if (scope->owner()->isEnum()) + break; + } + return scope; +} + +Scope *Scope::enclosingFunctionScope() const +{ + Scope *scope = enclosingScope(); + for (; scope; scope = scope->enclosingScope()) { + if (scope->owner()->isFunction()) + break; + } + return scope; +} + +Scope *Scope::enclosingBlockScope() const +{ + Scope *scope = enclosingScope(); + for (; scope; scope = scope->enclosingScope()) { + if (scope->owner()->isBlock()) + break; + } + return scope; +} + +bool Scope::isNamespaceScope() const +{ + if (_owner) + return _owner->isNamespace(); + return false; +} + +bool Scope::isClassScope() const +{ + if (_owner) + return _owner->isClass(); + return false; +} + +bool Scope::isEnumScope() const +{ + if (_owner) + return _owner->isEnum(); + return false; +} + +bool Scope::isBlockScope() const +{ + if (_owner) + return _owner->isBlock(); + return false; +} + +bool Scope::isPrototypeScope() const +{ + Function *f = 0; + if (_owner && 0 != (f = _owner->asFunction())) + return f->arguments() == this; + return false; +} + +bool Scope::isObjCClassScope() const +{ + if (_owner) + return _owner->isObjCClass(); + return false; +} + +bool Scope::isFunctionScope() const +{ + Function *f = 0; + if (_owner && 0 != (f = _owner->asFunction())) + return f->arguments() != this; + return false; +} + +bool Scope::isObjCMethodScope() const +{ + ObjCMethod *m = 0; + if (_owner && 0 != (m = _owner->asObjCMethod())) + return m->arguments() != this; + return false; +} + +void Scope::enterSymbol(Symbol *symbol) +{ + if (++_symbolCount == _allocatedSymbols) { + _allocatedSymbols <<= 1; + if (! _allocatedSymbols) + _allocatedSymbols = DefaultInitialSize; + + _symbols = reinterpret_cast(realloc(_symbols, sizeof(Symbol *) * _allocatedSymbols)); + } + + assert(! symbol->_scope || symbol->scope() == this); + symbol->_index = _symbolCount; + symbol->_scope = this; + _symbols[_symbolCount] = symbol; + + if (_symbolCount >= _hashSize * 0.6) + rehash(); + else { + const unsigned h = hashValue(symbol); + symbol->_next = _hash[h]; + _hash[h] = symbol; + } +} + +Symbol *Scope::lookat(const Name *name) const +{ + if (! name) + return 0; + + else if (const OperatorNameId *opId = name->asOperatorNameId()) + return lookat(opId->kind()); + + else if (const Identifier *id = name->identifier()) + return lookat(id); + + else + return 0; +} + +Symbol *Scope::lookat(const Identifier *id) const +{ + if (! _hash || ! id) + return 0; + + const unsigned h = id->hashCode() % _hashSize; + Symbol *symbol = _hash[h]; + for (; symbol; symbol = symbol->_next) { + const Name *identity = symbol->identity(); + if (! identity) { + continue; + } else if (const NameId *nameId = identity->asNameId()) { + if (nameId->identifier()->isEqualTo(id)) + break; + } else if (const TemplateNameId *t = identity->asTemplateNameId()) { + if (t->identifier()->isEqualTo(id)) + break; + } else if (const DestructorNameId *d = identity->asDestructorNameId()) { + if (d->identifier()->isEqualTo(id)) + break; + } else if (identity->isQualifiedNameId()) { + return 0; + } else if (const SelectorNameId *selectorNameId = identity->asSelectorNameId()) { + if (selectorNameId->identifier()->isEqualTo(id)) + break; + } + } + return symbol; +} + +Symbol *Scope::lookat(int operatorId) const +{ + if (! _hash) + return 0; + + const unsigned h = operatorId % _hashSize; + Symbol *symbol = _hash[h]; + for (; symbol; symbol = symbol->_next) { + const Name *identity = symbol->identity(); + if (const OperatorNameId *op = identity->asOperatorNameId()) { + if (op->kind() == operatorId) + break; + } + } + return symbol; +} + +void Scope::rehash() +{ + _hashSize <<= 1; + + if (! _hashSize) + _hashSize = DefaultInitialSize; + + _hash = reinterpret_cast(realloc(_hash, sizeof(Symbol *) * _hashSize)); + std::memset(_hash, 0, sizeof(Symbol *) * _hashSize); + + for (int index = 0; index < _symbolCount + 1; ++index) { + Symbol *symbol = _symbols[index]; + const unsigned h = hashValue(symbol); + symbol->_next = _hash[h]; + _hash[h] = symbol; + } +} + +unsigned Scope::hashValue(Symbol *symbol) const +{ + if (! symbol) + return 0; + + return symbol->hashCode() % _hashSize; +} + +bool Scope::isEmpty() const +{ return _symbolCount == -1; } + +unsigned Scope::symbolCount() const +{ return _symbolCount + 1; } + +Symbol *Scope::symbolAt(unsigned index) const +{ + if (! _symbols) + return 0; + return _symbols[index]; +} + +Scope::iterator Scope::firstSymbol() const +{ return _symbols; } + +Scope::iterator Scope::lastSymbol() const +{ return _symbols + _symbolCount + 1; } + +