diff options
| -rw-r--r-- | compilerplugins/clang/fieldcanbelocal.cxx | 464 | ||||
| -rwxr-xr-x | compilerplugins/clang/fieldcanbelocal.py | 123 | ||||
| -rw-r--r-- | compilerplugins/clang/fieldcanbelocal.results | 123 | ||||
| -rw-r--r-- | cui/source/inc/chardlg.hxx | 1 | ||||
| -rw-r--r-- | cui/source/tabpages/chardlg.cxx | 4 | ||||
| -rw-r--r-- | include/vcl/tabpage.hxx | 2 | ||||
| -rw-r--r-- | vcl/source/window/tabpage.cxx | 10 |
7 files changed, 717 insertions, 10 deletions
diff --git a/compilerplugins/clang/fieldcanbelocal.cxx b/compilerplugins/clang/fieldcanbelocal.cxx new file mode 100644 index 000000000000..ae1af187befb --- /dev/null +++ b/compilerplugins/clang/fieldcanbelocal.cxx @@ -0,0 +1,464 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ + +#if !defined _WIN32 //TODO, #include <sys/file.h> + +#include <cassert> +#include <string> +#include <iostream> +#include <fstream> +#include <unordered_set> +#include <vector> +#include <algorithm> +#include <sys/file.h> +#include <unistd.h> + +#include "config_clang.h" + +#include "plugin.hxx" +#include "compat.hxx" +#include "check.hxx" + +#include "clang/AST/ParentMapContext.h" + +/** + Look for fields on objects that can be local variables. + Not a particularly smart plugin, generates a lot of false positives, and requires review of the output. + Mostly looks for fields that are only accessed within a single method. +*/ + +namespace +{ +struct MyFuncInfo +{ + std::string returnType; + std::string nameAndParams; + std::string sourceLocation; +}; + +struct MyFieldInfo +{ + std::string parentClass; + std::string fieldName; + std::string fieldType; + std::string sourceLocation; +}; + +// try to limit the voluminous output a little +// if the value is nullptr, that indicates that we touched that field from more than one function +static std::unordered_map<const FieldDecl*, const FunctionDecl*> touchedMap; + +class FieldCanBeLocal : public loplugin::FilteringPlugin<FieldCanBeLocal> +{ +public: + explicit FieldCanBeLocal(loplugin::InstantiationData const& data) + : FilteringPlugin(data) + { + } + + virtual void run() override; + + bool shouldVisitTemplateInstantiations() const { return true; } + bool shouldVisitImplicitCode() const { return true; } + + bool TraverseCXXConstructorDecl(CXXConstructorDecl*); + bool TraverseCXXMethodDecl(CXXMethodDecl*); + bool TraverseFunctionDecl(FunctionDecl*); + + bool VisitMemberExpr(const MemberExpr*); + bool VisitDeclRefExpr(const DeclRefExpr*); + bool VisitInitListExpr(const InitListExpr*); + bool VisitCXXConstructorDecl(const CXXConstructorDecl*); + +private: + MyFieldInfo niceName(const FieldDecl*); + MyFuncInfo niceName(const FunctionDecl*); + std::string toString(SourceLocation loc); + void checkTouched(const FieldDecl* fieldDecl, const FunctionDecl*); + bool isSomeKindOfConstant(const Expr* arg); + + RecordDecl* insideMoveOrCopyOrCloneDeclParent = nullptr; + RecordDecl* insideStreamOutputOperator = nullptr; + // For reasons I do not understand, parentFunctionDecl() is not reliable, so + // we store the parent function on the way down the AST. + FunctionDecl* insideFunctionDecl = nullptr; +}; + +void FieldCanBeLocal::run() +{ + handler.enableTreeWideAnalysisMode(); + + TraverseDecl(compiler.getASTContext().getTranslationUnitDecl()); + + if (!isUnitTestMode()) + { + // dump all our output in one write call - this is to try and limit IO "crosstalk" between multiple processes + // writing to the same logfile + std::string output; + output.reserve(64 * 1024); + for (const auto& pair : touchedMap) + { + if (pair.first->getParent()->isLambda()) + continue; + MyFieldInfo s = niceName(pair.first); + output += "definition:\t" + s.parentClass // + + "\t" + s.fieldName // + + "\t" + s.fieldType // + + "\t" + s.sourceLocation // + + "\n"; + // we have to output a negative, in case, in some other file, it is touched only once + if (!pair.second) + output += "touched:\t" + s.parentClass // + + "\t" + s.fieldName // + + "\tNegative" // + + "\tnowhere.cxx" // + + "\n"; + else + { + MyFuncInfo s2 = niceName(pair.second); + output += "touched:\t" + s.parentClass // + + "\t" + s.fieldName // + + "\t" + s2.returnType + " " + s2.nameAndParams // + + "\t" + s2.sourceLocation // + + "\n"; + } + } + std::ofstream myfile; + myfile.open(WORKDIR "/loplugin.fieldcanbelocal.log", std::ios::app | std::ios::out); + myfile << output; + myfile.close(); + } + else + { + // for (const MyFieldInfo & s : readFromSet) + // report( + // DiagnosticsEngine::Warning, + // "read %0", + // s.parentRecord->getBeginLoc()) + // << s.fieldName; + } +} + +MyFieldInfo FieldCanBeLocal::niceName(const FieldDecl* fieldDecl) +{ + MyFieldInfo aInfo; + + const RecordDecl* recordDecl = fieldDecl->getParent(); + + if (const CXXRecordDecl* cxxRecordDecl = dyn_cast<CXXRecordDecl>(recordDecl)) + { + if (cxxRecordDecl->getTemplateInstantiationPattern()) + cxxRecordDecl = cxxRecordDecl->getTemplateInstantiationPattern(); + aInfo.parentClass = cxxRecordDecl->getQualifiedNameAsString(); + } + else + { + aInfo.parentClass = recordDecl->getQualifiedNameAsString(); + } + + aInfo.fieldName = fieldDecl->getNameAsString(); + // sometimes the name (if it's an anonymous thing) contains the full path of the build folder, which we don't need + size_t idx = aInfo.fieldName.find(SRCDIR); + if (idx != std::string::npos) + { + aInfo.fieldName = aInfo.fieldName.replace(idx, strlen(SRCDIR), ""); + } + aInfo.fieldType = fieldDecl->getType().getAsString(); + + SourceLocation expansionLoc + = compiler.getSourceManager().getExpansionLoc(fieldDecl->getLocation()); + StringRef name = getFilenameOfLocation(expansionLoc); + aInfo.sourceLocation + = std::string(name.substr(strlen(SRCDIR) + 1)) + ":" + + std::to_string(compiler.getSourceManager().getSpellingLineNumber(expansionLoc)); + loplugin::normalizeDotDotInFilePath(aInfo.sourceLocation); + + return aInfo; +} + +MyFuncInfo FieldCanBeLocal::niceName(const FunctionDecl* functionDecl) +{ + if (functionDecl->getInstantiatedFromMemberFunction()) + functionDecl = functionDecl->getInstantiatedFromMemberFunction(); + else if (functionDecl->getTemplateInstantiationPattern()) + functionDecl = functionDecl->getTemplateInstantiationPattern(); + + MyFuncInfo aInfo; + if (!isa<CXXConstructorDecl>(functionDecl)) + { + aInfo.returnType = functionDecl->getReturnType().getCanonicalType().getAsString(); + } + else + { + aInfo.returnType = ""; + } + + if (isa<CXXMethodDecl>(functionDecl)) + { + const CXXRecordDecl* recordDecl = dyn_cast<CXXMethodDecl>(functionDecl)->getParent(); + aInfo.nameAndParams += recordDecl->getQualifiedNameAsString(); + aInfo.nameAndParams += "::"; + } + aInfo.nameAndParams += functionDecl->getNameAsString() + "("; + bool bFirst = true; + for (const ParmVarDecl* pParmVarDecl : functionDecl->parameters()) + { + if (bFirst) + bFirst = false; + else + aInfo.nameAndParams += ","; + aInfo.nameAndParams += pParmVarDecl->getType().getCanonicalType().getAsString(); + } + aInfo.nameAndParams += ")"; + if (isa<CXXMethodDecl>(functionDecl) && dyn_cast<CXXMethodDecl>(functionDecl)->isConst()) + { + aInfo.nameAndParams += " const"; + } + + aInfo.sourceLocation = toString(functionDecl->getLocation()); + + return aInfo; +} + +std::string FieldCanBeLocal::toString(SourceLocation loc) +{ + SourceLocation expansionLoc = compiler.getSourceManager().getExpansionLoc(loc); + StringRef name = getFilenameOfLocation(expansionLoc); + std::string sourceLocation + = std::string(name.substr(strlen(SRCDIR) + 1)) + ":" + + std::to_string(compiler.getSourceManager().getSpellingLineNumber(expansionLoc)); + loplugin::normalizeDotDotInFilePath(sourceLocation); + return sourceLocation; +} + +bool FieldCanBeLocal::TraverseCXXConstructorDecl(CXXConstructorDecl* cxxConstructorDecl) +{ + auto copy = insideMoveOrCopyOrCloneDeclParent; + if (!ignoreLocation(cxxConstructorDecl->getBeginLoc()) + && cxxConstructorDecl->isThisDeclarationADefinition()) + { + if (cxxConstructorDecl->isCopyOrMoveConstructor()) + insideMoveOrCopyOrCloneDeclParent = cxxConstructorDecl->getParent(); + } + bool ret = RecursiveASTVisitor::TraverseCXXConstructorDecl(cxxConstructorDecl); + insideMoveOrCopyOrCloneDeclParent = copy; + return ret; +} + +bool FieldCanBeLocal::TraverseCXXMethodDecl(CXXMethodDecl* cxxMethodDecl) +{ + auto copy1 = insideMoveOrCopyOrCloneDeclParent; + auto copy2 = insideFunctionDecl; + if (!ignoreLocation(cxxMethodDecl->getBeginLoc()) + && cxxMethodDecl->isThisDeclarationADefinition()) + { + if (cxxMethodDecl->isCopyAssignmentOperator() || cxxMethodDecl->isMoveAssignmentOperator() + || (cxxMethodDecl->getIdentifier() + && (cxxMethodDecl->getName().startswith("Clone") + || cxxMethodDecl->getName().startswith("clone") + || cxxMethodDecl->getName().startswith("createClone")))) + insideMoveOrCopyOrCloneDeclParent = cxxMethodDecl->getParent(); + // these are similar in that they tend to simply enumerate all the fields of an object without putting + // them to some useful purpose + auto op = cxxMethodDecl->getOverloadedOperator(); + if (op == OO_EqualEqual || op == OO_ExclaimEqual) + insideMoveOrCopyOrCloneDeclParent = cxxMethodDecl->getParent(); + } + insideFunctionDecl = cxxMethodDecl; + bool ret = RecursiveASTVisitor::TraverseCXXMethodDecl(cxxMethodDecl); + insideMoveOrCopyOrCloneDeclParent = copy1; + insideFunctionDecl = copy2; + return ret; +} + +bool FieldCanBeLocal::TraverseFunctionDecl(FunctionDecl* functionDecl) +{ + auto copy1 = insideStreamOutputOperator; + auto copy2 = insideFunctionDecl; + auto copy3 = insideMoveOrCopyOrCloneDeclParent; + if (functionDecl->getLocation().isValid() && !ignoreLocation(functionDecl->getBeginLoc()) + && functionDecl->isThisDeclarationADefinition()) + { + auto op = functionDecl->getOverloadedOperator(); + if (op == OO_LessLess && functionDecl->getNumParams() == 2) + { + QualType qt = functionDecl->getParamDecl(1)->getType(); + insideStreamOutputOperator + = qt.getNonReferenceType().getUnqualifiedType()->getAsCXXRecordDecl(); + } + // these are similar in that they tend to simply enumerate all the fields of an object without putting + // them to some useful purpose + if (op == OO_EqualEqual || op == OO_ExclaimEqual) + { + QualType qt = functionDecl->getParamDecl(1)->getType(); + insideMoveOrCopyOrCloneDeclParent + = qt.getNonReferenceType().getUnqualifiedType()->getAsCXXRecordDecl(); + } + } + insideFunctionDecl = functionDecl; + bool ret = RecursiveASTVisitor::TraverseFunctionDecl(functionDecl); + insideStreamOutputOperator = copy1; + insideFunctionDecl = copy2; + insideMoveOrCopyOrCloneDeclParent = copy3; + return ret; +} + +bool FieldCanBeLocal::VisitMemberExpr(const MemberExpr* memberExpr) +{ + const ValueDecl* decl = memberExpr->getMemberDecl(); + const FieldDecl* fieldDecl = dyn_cast<FieldDecl>(decl); + if (!fieldDecl) + { + return true; + } + fieldDecl = fieldDecl->getCanonicalDecl(); + if (ignoreLocation(fieldDecl->getBeginLoc())) + { + return true; + } + // ignore stuff that forms part of the stable URE interface + if (isInUnoIncludeFile(compiler.getSourceManager().getSpellingLoc(fieldDecl->getLocation()))) + { + return true; + } + + if (insideMoveOrCopyOrCloneDeclParent || insideStreamOutputOperator) + { + RecordDecl const* cxxRecordDecl1 = fieldDecl->getParent(); + // we don't care about reads from a field when inside the copy/move constructor/operator= for that field + if (cxxRecordDecl1 && (cxxRecordDecl1 == insideMoveOrCopyOrCloneDeclParent)) + return true; + // we don't care about reads when the field is being used in an output operator, this is normally + // debug stuff + if (cxxRecordDecl1 && (cxxRecordDecl1 == insideStreamOutputOperator)) + return true; + } + + checkTouched(fieldDecl, insideFunctionDecl); + + return true; +} + +bool FieldCanBeLocal::VisitDeclRefExpr(const DeclRefExpr* declRefExpr) +{ + const Decl* decl = declRefExpr->getDecl(); + const FieldDecl* fieldDecl = dyn_cast<FieldDecl>(decl); + if (!fieldDecl) + { + return true; + } + fieldDecl = fieldDecl->getCanonicalDecl(); + if (ignoreLocation(fieldDecl->getBeginLoc())) + { + return true; + } + // ignore stuff that forms part of the stable URE interface + if (isInUnoIncludeFile(compiler.getSourceManager().getSpellingLoc(fieldDecl->getLocation()))) + { + return true; + } + + checkTouched(fieldDecl, insideFunctionDecl); + + return true; +} + +// fields that are assigned via member initialisers do not get visited in VisitDeclRef, so +// have to do it here +bool FieldCanBeLocal::VisitCXXConstructorDecl(const CXXConstructorDecl* cxxConstructorDecl) +{ + if (ignoreLocation(cxxConstructorDecl->getBeginLoc())) + { + return true; + } + // ignore stuff that forms part of the stable URE interface + if (isInUnoIncludeFile( + compiler.getSourceManager().getSpellingLoc(cxxConstructorDecl->getLocation()))) + { + return true; + } + + // templates make EvaluateAsInt crash inside clang + if (cxxConstructorDecl->isDependentContext()) + return true; + + // we don't care about writes to a field when inside the copy/move constructor/operator= for that field + if (insideMoveOrCopyOrCloneDeclParent + && cxxConstructorDecl->getParent() == insideMoveOrCopyOrCloneDeclParent) + return true; + + for (auto it = cxxConstructorDecl->init_begin(); it != cxxConstructorDecl->init_end(); ++it) + { + const CXXCtorInitializer* init = *it; + const FieldDecl* fieldDecl = init->getMember(); + if (!fieldDecl) + continue; + if (init->getInit() && isSomeKindOfConstant(init->getInit())) + checkTouched(fieldDecl, cxxConstructorDecl); + else + touchedMap[fieldDecl] = nullptr; + } + return true; +} + +// Fields that are assigned via init-list-expr do not get visited in VisitDeclRef, so +// have to do it here. +bool FieldCanBeLocal::VisitInitListExpr(const InitListExpr* initListExpr) +{ + if (ignoreLocation(initListExpr->getBeginLoc())) + return true; + + QualType varType = initListExpr->getType().getDesugaredType(compiler.getASTContext()); + auto recordType = varType->getAs<RecordType>(); + if (!recordType) + return true; + + auto recordDecl = recordType->getDecl(); + for (auto it = recordDecl->field_begin(); it != recordDecl->field_end(); ++it) + { + checkTouched(*it, insideFunctionDecl); + } + + return true; +} + +void FieldCanBeLocal::checkTouched(const FieldDecl* fieldDecl, const FunctionDecl* functionDecl) +{ + auto methodDecl = dyn_cast_or_null<CXXMethodDecl>(functionDecl); + if (!methodDecl) + { + touchedMap[fieldDecl] = nullptr; + return; + } + if (methodDecl->getParent() != fieldDecl->getParent()) + { + touchedMap[fieldDecl] = nullptr; + return; + } + auto it = touchedMap.find(fieldDecl); + if (it == touchedMap.end()) + touchedMap.emplace(fieldDecl, functionDecl); + else if (it->second != functionDecl) + it->second = nullptr; +} + +bool FieldCanBeLocal::isSomeKindOfConstant(const Expr* arg) +{ + assert(arg); + if (arg->isValueDependent()) + return false; + return arg->isCXX11ConstantExpr(compiler.getASTContext()); +} + +loplugin::Plugin::Registration<FieldCanBeLocal> X("fieldcanbelocal", false); +} + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/compilerplugins/clang/fieldcanbelocal.py b/compilerplugins/clang/fieldcanbelocal.py new file mode 100755 index 000000000000..3266574445c5 --- /dev/null +++ b/compilerplugins/clang/fieldcanbelocal.py @@ -0,0 +1,123 @@ +#!/usr/bin/python3 + +import re +import io + +definitionSet = set() +definitionToSourceLocationMap = dict() +definitionToTypeMap = dict() +touchedMap = dict() +excludeSet = set() +sourceLocationSet = set() + +# clang does not always use exactly the same numbers in the type-parameter vars it generates +# so I need to substitute them to ensure we can match correctly. +normalizeTypeParamsRegex = re.compile(r"type-parameter-\d+-\d+") +def normalizeTypeParams( line ): + return normalizeTypeParamsRegex.sub("type-parameter-?-?", line) + + +with io.open("workdir/loplugin.fieldcanbelocal.log", "r", buffering=1024*1024) as txt: + for line in txt: + tokens = line.strip().split("\t") + if tokens[0] == "definition:": + fieldInfo = (normalizeTypeParams(tokens[1]), tokens[2]) + fieldType = tokens[3] + srcLoc = tokens[4] + # ignore external source code + if srcLoc.startswith("external/"): + continue + # ignore build folder + if srcLoc.startswith("workdir/"): + continue + definitionSet.add(fieldInfo) + definitionToTypeMap[fieldInfo] = fieldType + definitionToSourceLocationMap[fieldInfo] = srcLoc + elif tokens[0] == "touched:": + fieldInfo = (normalizeTypeParams(tokens[1]), tokens[2]) + touchedByFunction = normalizeTypeParams(tokens[3]) + touchedByFunctionSrcLoc = tokens[4] + if fieldInfo in excludeSet: + continue + if touchedByFunction == "Negative": + excludeSet.add(fieldInfo) + if fieldInfo in touchedMap: + touchedMap.pop(fieldInfo) + elif fieldInfo in touchedMap: + if touchedMap[fieldInfo] != touchedByFunction: + excludeSet.add(fieldInfo) + touchedMap.pop(fieldInfo) + else: + touchedMap[fieldInfo] = touchedByFunction + else: + print( "unknown line: " + line) + +outputSet = set() +for d in definitionSet: + if not d in touchedMap: + continue + fieldType = definitionToTypeMap[d] + # ignore some types that are known false+ + if (fieldType.startswith("std::unique_ptr<") + or fieldType == "std::mutex" + or "Mutex" in fieldType + or "union" in fieldType + or "anonymous namespace" in fieldType + or "unnamed struct" in fieldType): + continue + # ignore some field names that are known false+ + if (d[1] == "mbDisposing" + or d[1] == "bInDispose" + or d[1] == "m_bDisposing" + or d[1].startswith("m_bIn")): + continue + srcLoc = definitionToSourceLocationMap[d] + # ignore some types in the system libraries we somehow pick up + if srcLoc.startswith(".") or srcLoc.startswith("/") or srcLoc.startswith("lib/"): + continue + # part of the URE + if srcLoc.startswith("include/cppuhelper/"): + continue + # on-disk structures + if srcLoc.startswith("hwpfilter/"): + continue + if srcLoc.startswith("include/osl/"): + continue + if srcLoc.startswith("include/sal/"): + continue + if srcLoc.startswith("sw/source/filter/ww8/ww8struc.hxx"): + continue + if srcLoc.startswith("sd/source/filter/ppt/ppt97animations.hxx"): + continue + if srcLoc.startswith("lotuswordpro/"): + continue + if srcLoc.startswith("include/filter/msfilter/svdfppt.hxx"): + continue + if srcLoc.startswith("filter/source/graphicfilter/icgm/chart.hxx"): + continue + # most of this code is only compiled on windows, so we don't have decent results + if srcLoc.startswith("include/svl/svdde.hxx"): + continue + touchedByFunction = touchedMap[d] + outputSet.add((d[0] + " " + d[1] + " " + definitionToTypeMap[d], srcLoc, touchedByFunction)) + +# sort the results using a "natural order" so sequences like [item1,item2,item10] sort nicely +def natural_sort_key(s, _nsre=re.compile('([0-9]+)')): + return [int(text) if text.isdigit() else text.lower() + for text in re.split(_nsre, s)] +# sort by both the source-line and the datatype, so the output file ordering is stable +# when we have multiple items on the same source line +def v_sort_key(v): + return natural_sort_key(v[1]) + [v[0]] + +# sort results by name and line number +tmp1list = sorted(outputSet, key=lambda v: v_sort_key(v)) + +# print out the results +with open("compilerplugins/clang/fieldcanbelocal.results", "wt") as f: + for t in tmp1list: + f.write( t[1] + "\n" ) + f.write( " " + t[0] + "\n" ) + f.write( " " + t[2] + "\n" ) + + diff --git a/compilerplugins/clang/fieldcanbelocal.results b/compilerplugins/clang/fieldcanbelocal.results new file mode 100644 index 000000000000..6b5ae55214e1 --- /dev/null +++ b/compilerplugins/clang/fieldcanbelocal.results @@ -0,0 +1,123 @@ +chart2/source/inc/CachedDataSequence.hxx:128 + chart::CachedDataSequence m_nNumberFormatKey sal_Int32 + void chart::CachedDataSequence::registerProperties() +connectivity/source/drivers/firebird/ResultSet.hxx:85 + connectivity::firebird::OResultSet m_statusVector ISC_STATUS_ARRAY + unsigned char connectivity::firebird::OResultSet::next() +connectivity/source/inc/FDatabaseMetaDataResultSet.hxx:114 + connectivity::ODatabaseMetaDataResultSet m_nFetchSize sal_Int32 + void connectivity::ODatabaseMetaDataResultSet::construct() +connectivity/source/inc/FDatabaseMetaDataResultSet.hxx:115 + connectivity::ODatabaseMetaDataResultSet m_nResultSetType sal_Int32 + void connectivity::ODatabaseMetaDataResultSet::construct() +connectivity/source/inc/FDatabaseMetaDataResultSet.hxx:116 + connectivity::ODatabaseMetaDataResultSet m_nFetchDirection sal_Int32 + void connectivity::ODatabaseMetaDataResultSet::construct() +connectivity/source/inc/FDatabaseMetaDataResultSet.hxx:117 + connectivity::ODatabaseMetaDataResultSet m_nResultSetConcurrency sal_Int32 + void connectivity::ODatabaseMetaDataResultSet::construct() +cppuhelper/inc/interfacecontainer4.hxx:267 + cppuhelper::OInterfaceContainerHelper4::NotifySingleListener m_rEvent const EventT & + void cppuhelper::OInterfaceContainerHelper4::NotifySingleListener::operator()(const Reference<type-parameter-?-?> &) const +cui/source/inc/chardlg.hxx:170 + SvxCharEffectsPage m_nHtmlMode sal_uInt16 + void SvxCharEffectsPage::Initialize() +embeddedobj/source/msole/olecomponent.hxx:73 + OleComponent m_bWorkaroundActive _Bool + _Bool OleComponent::IsWorkaroundActive() const +include/editeng/adjustitem.hxx:37 + SvxAdjustItem bLeft _Bool + void SvxAdjustItem::SetAdjust(const enum SvxAdjust) +include/o3tl/enumarray.hxx:130 + o3tl::enumarray_const_iterator m_buf const EA * + const typename type-parameter-?-?::value_type & o3tl::enumarray_const_iterator::operator*() const +include/oox/dump/oledumper.hxx:743 + oox::dump::VbaDirStreamObject mnCurrOffset sal_Int32 + void oox::dump::VbaDirStreamObject::implDumpRecordBody() +include/salhelper/dynload.hxx:82 + salhelper::ORealDynamicLoader m_refCount sal_uInt32 + salhelper::ORealDynamicLoader::ORealDynamicLoader(class salhelper::ORealDynamicLoader **,const class rtl::OUString &,const class rtl::OUString &,void *,void *) +include/sfx2/msg.hxx:104 + SfxType createSfxPoolItemFunc std::function<SfxPoolItem *(void)> + class std::unique_ptr<class SfxPoolItem> SfxType::CreateItem() const +include/sfx2/msg.hxx:105 + SfxType pType const std::type_info * + const class std::type_info * SfxType::Type() const +include/sfx2/msg.hxx:117 + SfxType0 pType const std::type_info * + const class std::type_info * SfxType0::Type() const +include/test/sheet/xdatapilottable.hxx:31 + apitest::XDataPilotTable xCellForChange css::uno::Reference<css::table::XCell> + void apitest::XDataPilotTable::testRefresh() +include/test/sheet/xdatapilottable.hxx:32 + apitest::XDataPilotTable xCellForCheck css::uno::Reference<css::table::XCell> + void apitest::XDataPilotTable::testRefresh() +include/vcl/tabpage.hxx:43 + TabPage mbHasHoriBar _Bool + void TabPage::ImplInit(class vcl::Window *,long) +include/vcl/tabpage.hxx:44 + TabPage mbHasVertBar _Bool + void TabPage::ImplInit(class vcl::Window *,long) +jvmfwk/plugins/sunmajor/pluginlib/util.cxx:205 + jfw_plugin::(anonymous namespace)::FileHandleReader m_aBuffer char[1024] + enum jfw_plugin::(anonymous namespace)::FileHandleReader::Result jfw_plugin::(anonymous namespace)::FileHandleReader::readLine(class rtl::OString *) +sc/source/ui/inc/datastream.hxx:104 + sc::DataStream mnSettings sal_uInt32 + void sc::DataStream::Decode(const class rtl::OUString &,const class ScRange &,int,enum sc::DataStream::MoveType,const unsigned int) +sc/source/ui/inc/tabvwsh.hxx:99 + ScTabViewShell eFormObjKind SdrObjKind + void ScTabViewShell::ExecDraw(class SfxRequest &) +sc/source/ui/inc/tabvwsh.hxx:144 + ScTabViewShell bActiveEditSh _Bool + void ScTabViewShell::SetEditShell(class EditView *,_Bool) +sd/source/filter/html/htmlex.hxx:59 + HtmlExport mnPagesWritten sal_uInt16 + void HtmlExport::ExportSingleDocument() +sfx2/source/appl/lnkbase2.cxx:82 + sfx2::(anonymous namespace)::ImplDdeItem aData DdeData + class DdeData * sfx2::(anonymous namespace)::ImplDdeItem::Get(enum SotClipboardFormatId) +sfx2/source/appl/lnkbase2.cxx:83 + sfx2::(anonymous namespace)::ImplDdeItem aSeq Sequence<sal_Int8> + class DdeData * sfx2::(anonymous namespace)::ImplDdeItem::Get(enum SotClipboardFormatId) +svl/source/misc/inethist.cxx:45 + INetURLHistory_Impl::head_entry m_nMagic sal_uInt32 + void INetURLHistory_Impl::head_entry::initialize() +sw/inc/viewopt.hxx:50 + ViewOptFlags1 bRef _Bool + ViewOptFlags1::ViewOptFlags1() +sw/source/core/text/txtdrop.cxx:702 + SwDropCapCache m_aFactor sal_uInt16[10] + void SwDropCapCache::CalcFontSize(class SwDropPortion *,class SwTextFormatInfo &) +sw/source/core/text/txtdrop.cxx:704 + SwDropCapCache m_aDescent short[10] + void SwDropCapCache::CalcFontSize(class SwDropPortion *,class SwTextFormatInfo &) +sw/source/filter/ww8/ww8par.hxx:663 + WW8FormulaControl mfUnknown sal_uInt8 + WW8FormulaControl::WW8FormulaControl(class rtl::OUString,class SwWW8ImplReader &) +sw/source/filter/ww8/ww8par.hxx:1067 + WW8TabBandDesc bCantSplit90 _Bool + WW8TabBandDesc::WW8TabBandDesc() +sw/source/filter/ww8/ww8scan.hxx:440 + WW8PLCFx_PCDAttrs m_aShortSprm SVBT32 + void WW8PLCFx_PCDAttrs::GetSprms(struct WW8PLCFxDesc *) +sw/source/uibase/inc/fldmgr.hxx:112 + SwFieldMgr m_nCurFormat sal_uInt32 + class SwField * SwFieldMgr::GetCurField() +unoidl/source/unoidlprovider.cxx:89 + unoidl::detail::(anonymous namespace)::Memory16 byte unsigned char[2] + unsigned short unoidl::detail::(anonymous namespace)::Memory16::getUnsigned16() const +vcl/inc/sft.hxx:178 + vcl::TTGlobalFontInfo_ fsSelection sal_uInt16 + vcl::TTGlobalFontInfo_::TTGlobalFontInfo_() +vcl/inc/unx/sessioninhibitor.hxx:46 + SessionManagerInhibitor mbDPMSWasEnabled BOOL + void SessionManagerInhibitor::inhibitDPMS(_Bool,struct _XDisplay *) +vcl/inc/unx/sessioninhibitor.hxx:47 + SessionManagerInhibitor mnDPMSStandbyTimeout CARD16 + void SessionManagerInhibitor::inhibitDPMS(_Bool,struct _XDisplay *) +vcl/inc/unx/sessioninhibitor.hxx:48 + SessionManagerInhibitor mnDPMSSuspendTimeout CARD16 + void SessionManagerInhibitor::inhibitDPMS(_Bool,struct _XDisplay *) +vcl/inc/unx/sessioninhibitor.hxx:49 + SessionManagerInhibitor mnDPMSOffTimeout CARD16 + void SessionManagerInhibitor::inhibitDPMS(_Bool,struct _XDisplay *) diff --git a/cui/source/inc/chardlg.hxx b/cui/source/inc/chardlg.hxx index b1fd167d6a72..6d6bf958c2e2 100644 --- a/cui/source/inc/chardlg.hxx +++ b/cui/source/inc/chardlg.hxx @@ -167,7 +167,6 @@ private: bool m_bNewFontColor; bool m_bEnableNoneFontColor; Color m_aOrigFontColor; - sal_uInt16 m_nHtmlMode; weld::TriStateEnabled m_aOutlineState; weld::TriStateEnabled m_aShadowState; diff --git a/cui/source/tabpages/chardlg.cxx b/cui/source/tabpages/chardlg.cxx index d8ea76e9a9d4..e851816c1787 100644 --- a/cui/source/tabpages/chardlg.cxx +++ b/cui/source/tabpages/chardlg.cxx @@ -1368,8 +1368,8 @@ void SvxCharEffectsPage::Initialize() } if (pHtmlModeItem) { - m_nHtmlMode = pHtmlModeItem->GetValue(); - if ( ( m_nHtmlMode & HTMLMODE_ON ) == HTMLMODE_ON ) + sal_uInt16 nHtmlMode = pHtmlModeItem->GetValue(); + if ( ( nHtmlMode & HTMLMODE_ON ) == HTMLMODE_ON ) { //!!! hide some controls please } diff --git a/include/vcl/tabpage.hxx b/include/vcl/tabpage.hxx index e06c4c1a7750..79e0b5a3c201 100644 --- a/include/vcl/tabpage.hxx +++ b/include/vcl/tabpage.hxx @@ -40,8 +40,6 @@ private: VclPtr<ScrollBar> m_pVScroll; VclPtr<ScrollBar> m_pHScroll; Size maScrollArea; - bool mbHasHoriBar; - bool mbHasVertBar; Point mnScrollPos; tools::Long mnScrWidth; diff --git a/vcl/source/window/tabpage.cxx b/vcl/source/window/tabpage.cxx index 90abeaa25968..612b17d2729e 100644 --- a/vcl/source/window/tabpage.cxx +++ b/vcl/source/window/tabpage.cxx @@ -32,8 +32,8 @@ void TabPage::ImplInit( vcl::Window* pParent, WinBits nStyle ) Window::ImplInit( pParent, nStyle, nullptr ); - mbHasHoriBar = false; - mbHasVertBar = false; + bool bHasHoriBar = false; + bool bHasVertBar = false; Link<ScrollBar*,void> aLink( LINK( this, TabPage, ScrollBarHdl ) ); @@ -41,21 +41,21 @@ void TabPage::ImplInit( vcl::Window* pParent, WinBits nStyle ) { if ( nStyle & WB_AUTOHSCROLL ) { - mbHasHoriBar = true; + bHasHoriBar = true; m_pHScroll.set(VclPtr<ScrollBar>::Create(this, (WB_HSCROLL | WB_DRAG))); m_pHScroll->Show(); m_pHScroll->SetScrollHdl(aLink); } if ( nStyle & WB_AUTOVSCROLL ) { - mbHasVertBar = true; + bHasVertBar = true; m_pVScroll.set(VclPtr<ScrollBar>::Create(this, (WB_VSCROLL | WB_DRAG))); m_pVScroll->Show(); m_pVScroll->SetScrollHdl(aLink); } } - if ( mbHasHoriBar || mbHasVertBar ) + if ( bHasHoriBar || bHasVertBar ) { SetStyle( GetStyle() | WB_CLIPCHILDREN ); } |