Files
qt-creator/src/libs/3rdparty/cplusplus/Symbol.cpp
Nikolai Kosjar 587eb49c4e C++: TranslationUnit::getPosition takes utf16char offsets
...and not byte offsets anymore. This is necessary in order to calculate
the line and column numbers correctly with respect to unicode code
points.

Change-Id: I5d79857b3eaefeb8d563b4f1e3938a64debc5e08
Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>
2014-05-23 14:23:24 +02:00

438 lines
10 KiB
C++

// Copyright (c) 2008 Roberto Raggi <roberto.raggi@gmail.com>
//
// 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 "Symbol.h"
#include "Symbols.h"
#include "Control.h"
#include "Names.h"
#include "TranslationUnit.h"
#include "Literals.h"
#include "MemoryPool.h"
#include "SymbolVisitor.h"
#include "NameVisitor.h"
#include "Scope.h"
#include "Templates.h"
#include "cppassert.h"
using namespace CPlusPlus;
class Symbol::HashCode: protected NameVisitor
{
public:
HashCode()
: _value(0)
{ }
virtual ~HashCode()
{ }
unsigned operator()(const Name *name)
{
unsigned previousValue = switchValue(0);
accept(name);
return switchValue(previousValue);
}
protected:
unsigned switchValue(unsigned value)
{
unsigned previousValue = _value;
_value = value;
return previousValue;
}
virtual void visit(const Identifier *name)
{ _value = name->identifier()->hashCode(); }
virtual void visit(const TemplateNameId *name)
{ _value = name->identifier()->hashCode(); }
virtual void visit(const DestructorNameId *name)
{ _value = name->identifier()->hashCode(); }
virtual void visit(const OperatorNameId *name)
{ _value = unsigned(name->kind()); }
virtual void visit(const ConversionNameId *)
{ _value = 0; } // ### TODO: implement me
virtual void visit(const QualifiedNameId *name)
{ _value = operator()(name->name()); }
virtual void visit(const SelectorNameId *name)
{ _value = name->identifier()->hashCode(); }
private:
unsigned _value;
};
Symbol::Symbol(TranslationUnit *translationUnit, unsigned sourceLocation, const Name *name)
: _name(0),
_enclosingScope(0),
_next(0),
_fileId(0),
_sourceLocation(0),
_hashCode(0),
_storage(Symbol::NoStorage),
_visibility(Symbol::Public),
_index(0),
_line(0),
_column(0),
_isGenerated(false),
_isDeprecated(false),
_isUnavailable(false)
{
setSourceLocation(sourceLocation, translationUnit);
setName(name);
}
Symbol::Symbol(Clone *clone, Subst *subst, Symbol *original)
: _name(clone->name(original->_name, subst)),
_enclosingScope(0),
_next(0),
_fileId(clone->control()->stringLiteral(original->fileName(), original->fileNameLength())),
_sourceLocation(original->_sourceLocation),
_hashCode(original->_hashCode),
_storage(original->_storage),
_visibility(original->_visibility),
_index(0),
_line(original->_line),
_column(original->_column),
_isGenerated(original->_isGenerated),
_isDeprecated(original->_isDeprecated),
_isUnavailable(original->_isUnavailable)
{
}
Symbol::~Symbol()
{ }
void Symbol::visitSymbol(SymbolVisitor *visitor)
{
if (visitor->preVisit(this))
visitSymbol0(visitor);
visitor->postVisit(this);
}
void Symbol::visitSymbol(Symbol *symbol, SymbolVisitor *visitor)
{
if (! symbol)
return;
symbol->visitSymbol(visitor);
}
unsigned Symbol::sourceLocation() const
{ return _sourceLocation; }
bool Symbol::isGenerated() const
{ return _isGenerated; }
bool Symbol::isDeprecated() const
{ return _isDeprecated; }
void Symbol::setDeprecated(bool isDeprecated)
{ _isDeprecated = isDeprecated; }
bool Symbol::isUnavailable() const
{ return _isUnavailable; }
void Symbol::setUnavailable(bool isUnavailable)
{ _isUnavailable = isUnavailable; }
void Symbol::setSourceLocation(unsigned sourceLocation, TranslationUnit *translationUnit)
{
_sourceLocation = sourceLocation;
if (translationUnit) {
const Token &tk = translationUnit->tokenAt(sourceLocation);
_isGenerated = tk.generated();
translationUnit->getPosition(tk.utf16charsBegin(), &_line, &_column, &_fileId);
} else {
_isGenerated = false;
_line = 0;
_column = 0;
_fileId = 0;
}
}
unsigned Symbol::line() const
{
return _line;
}
unsigned Symbol::column() const
{
return _column;
}
const StringLiteral *Symbol::fileId() const
{
return _fileId;
}
const char *Symbol::fileName() const
{ return fileId()->chars(); }
unsigned Symbol::fileNameLength() const
{ return fileId()->size(); }
const Name *Symbol::unqualifiedName() const
{
if (! _name)
return 0;
else if (const QualifiedNameId *q = _name->asQualifiedNameId())
return q->name();
return _name;
}
const Name *Symbol::name() const
{ return _name; }
void Symbol::setName(const Name *name)
{
_name = name;
if (! _name)
_hashCode = 0;
else {
HashCode hh;
_hashCode = hh(unqualifiedName());
}
}
const Identifier *Symbol::identifier() const
{
if (_name)
return _name->identifier();
return 0;
}
Scope *Symbol::enclosingScope() const
{ return _enclosingScope; }
void Symbol::setEnclosingScope(Scope *scope)
{
CPP_CHECK(! _enclosingScope);
_enclosingScope = scope;
}
void Symbol::resetEnclosingScope()
{
_enclosingScope = 0;
}
Namespace *Symbol::enclosingNamespace() const
{
for (Scope *s = _enclosingScope; s; s = s->enclosingScope()) {
if (Namespace *ns = s->asNamespace())
return ns;
}
return 0;
}
Template *Symbol::enclosingTemplate() const
{
for (Scope *s = _enclosingScope; s; s = s->enclosingScope()) {
if (Template *templ = s->asTemplate())
return templ;
}
return 0;
}
Class *Symbol::enclosingClass() const
{
for (Scope *s = _enclosingScope; s; s = s->enclosingScope()) {
if (Class *klass = s->asClass())
return klass;
}
return 0;
}
Enum *Symbol::enclosingEnum() const
{
for (Scope *s = _enclosingScope; s; s = s->enclosingScope()) {
if (Enum *e = s->asEnum())
return e;
}
return 0;
}
Function *Symbol::enclosingFunction() const
{
for (Scope *s = _enclosingScope; s; s = s->enclosingScope()) {
if (Function *fun = s->asFunction())
return fun;
}
return 0;
}
Block *Symbol::enclosingBlock() const
{
for (Scope *s = _enclosingScope; s; s = s->enclosingScope()) {
if (Block *block = s->asBlock())
return block;
}
return 0;
}
unsigned Symbol::index() const
{ return _index; }
Symbol *Symbol::next() const
{ return _next; }
unsigned Symbol::hashCode() const
{ return _hashCode; }
int Symbol::storage() const
{ return _storage; }
void Symbol::setStorage(int storage)
{ _storage = storage; }
int Symbol::visibility() const
{ return _visibility; }
void Symbol::setVisibility(int visibility)
{ _visibility = visibility; }
bool Symbol::isFriend() const
{ return _storage == Friend; }
bool Symbol::isRegister() const
{ return _storage == Register; }
bool Symbol::isStatic() const
{ return _storage == Static; }
bool Symbol::isExtern() const
{ return _storage == Extern; }
bool Symbol::isMutable() const
{ return _storage == Mutable; }
bool Symbol::isTypedef() const
{ return _storage == Typedef; }
bool Symbol::isPublic() const
{ return _visibility == Public; }
bool Symbol::isProtected() const
{ return _visibility == Protected; }
bool Symbol::isPrivate() const
{ return _visibility == Private; }
bool Symbol::isScope() const
{ return asScope() != 0; }
bool Symbol::isEnum() const
{ return asEnum() != 0; }
bool Symbol::isFunction() const
{ return asFunction() != 0; }
bool Symbol::isNamespace() const
{ return asNamespace() != 0; }
bool Symbol::isTemplate() const
{ return asTemplate() != 0; }
bool Symbol::isClass() const
{ return asClass() != 0; }
bool Symbol::isForwardClassDeclaration() const
{ return asForwardClassDeclaration() != 0; }
bool Symbol::isQtPropertyDeclaration() const
{ return asQtPropertyDeclaration() != 0; }
bool Symbol::isQtEnum() const
{ return asQtEnum() != 0; }
bool Symbol::isBlock() const
{ return asBlock() != 0; }
bool Symbol::isUsingNamespaceDirective() const
{ return asUsingNamespaceDirective() != 0; }
bool Symbol::isUsingDeclaration() const
{ return asUsingDeclaration() != 0; }
bool Symbol::isDeclaration() const
{ return asDeclaration() != 0; }
bool Symbol::isArgument() const
{ return asArgument() != 0; }
bool Symbol::isTypenameArgument() const
{ return asTypenameArgument() != 0; }
bool Symbol::isBaseClass() const
{ return asBaseClass() != 0; }
bool Symbol::isObjCBaseClass() const
{ return asObjCBaseClass() != 0; }
bool Symbol::isObjCBaseProtocol() const
{ return asObjCBaseProtocol() != 0; }
bool Symbol::isObjCClass() const
{ return asObjCClass() != 0; }
bool Symbol::isObjCForwardClassDeclaration() const
{ return asObjCForwardClassDeclaration() != 0; }
bool Symbol::isObjCProtocol() const
{ return asObjCProtocol() != 0; }
bool Symbol::isObjCForwardProtocolDeclaration() const
{ return asObjCForwardProtocolDeclaration() != 0; }
bool Symbol::isObjCMethod() const
{ return asObjCMethod() != 0; }
bool Symbol::isObjCPropertyDeclaration() const
{ return asObjCPropertyDeclaration() != 0; }
void Symbol::copy(Symbol *other)
{
_sourceLocation = other->_sourceLocation;
_name = other->_name;
_hashCode = other->_hashCode;
_storage = other->_storage;
_visibility = other->_visibility;
_enclosingScope = other->_enclosingScope;
_index = other->_index;
_next = other->_next;
_fileId = other->_fileId;
_line = other->_line;
_column = other->_column;
_isGenerated = other->_isGenerated;
_isDeprecated = other->_isDeprecated;
}