mir/libreoffice
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

new loplugin:unuseddefaultparams

Browse Source 
Change-Id: I2c3e7d66be9e3883ea2801ff394948cc580d1e44
This commit is contained in:
Noel Grandin
2016-02-25 11:33:33 +02:00
parent f66d734bcd
commit 4fbf95deba
14 changed files with 347 additions and 91 deletions
Download Patch File Download Diff File Expand all files Collapse all files

215
compilerplugins/clang/unuseddefaultparams.cxx Normal file
View File

@@ -0,0 +1,215 @@
/* -*- 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/.
*/
#include <string>
#include <set>
#include <iostream>
#include <fstream>
#include "plugin.hxx"
#include "compat.hxx"
/*
Find methods with default params, where the callers never specify the default param i.e.
might as well remove it.
The process goes something like this:
$ make check
$ make FORCE_COMPILE_ALL=1 COMPILER_PLUGIN_TOOL='unusedmethods' check
$ ./compilerplugins/clang/unuseddefaultparams.py unuseddefaultparams.log
*/
namespace {
struct MyFuncInfo
{
std::string access;
std::string returnType;
std::string nameAndParams;
std::string sourceLocation;
};
bool operator < (const MyFuncInfo &lhs, const MyFuncInfo &rhs)
{
return lhs.sourceLocation < rhs.sourceLocation;
}
// try to limit the voluminous output a little
static std::set<MyFuncInfo> callSet;
static std::set<MyFuncInfo> definitionSet;
class UnusedDefaultParams:
public RecursiveASTVisitor<UnusedDefaultParams>, public loplugin::Plugin
{
public:
explicit UnusedDefaultParams(InstantiationData const & data): Plugin(data) {}
virtual void run() override
{
TraverseDecl(compiler.getASTContext().getTranslationUnitDecl());
// 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;
for (const MyFuncInfo & s : definitionSet)
output += "defn:\t" + s.access + "\t" + s.returnType + "\t" + s.nameAndParams + "\t" + s.sourceLocation + "\n";
for (const MyFuncInfo & s : callSet)
output += "call:\t" + s.returnType + "\t" + s.nameAndParams + "\n";
ofstream myfile;
myfile.open( SRCDIR "/unuseddefaultparams.log", ios::app | ios::out);
myfile << output;
myfile.close();
}
bool VisitCallExpr(CallExpr * callExpr);
bool VisitFunctionDecl( const FunctionDecl* functionDecl );
private:
MyFuncInfo niceName(const FunctionDecl* functionDecl);
};
MyFuncInfo UnusedDefaultParams::niceName(const FunctionDecl* functionDecl)
{
if (functionDecl->getInstantiatedFromMemberFunction())
functionDecl = functionDecl->getInstantiatedFromMemberFunction();
else if (functionDecl->getClassScopeSpecializationPattern())
functionDecl = functionDecl->getClassScopeSpecializationPattern();
// workaround clang-3.5 issue
#if __clang_major__ > 3 || ( __clang_major__ == 3 && __clang_minor__ >= 6 )
else if (functionDecl->getTemplateInstantiationPattern())
functionDecl = functionDecl->getTemplateInstantiationPattern();
#endif
MyFuncInfo aInfo;
switch (functionDecl->getAccess())
{
case AS_public: aInfo.access = "public"; break;
case AS_private: aInfo.access = "private"; break;
case AS_protected: aInfo.access = "protected"; break;
default: aInfo.access = "unknown"; break;
}
aInfo.returnType = compat::getReturnType(*functionDecl).getCanonicalType().getAsString();
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->params()) {
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";
}
SourceLocation expansionLoc = compiler.getSourceManager().getExpansionLoc( functionDecl->getLocation() );
StringRef name = compiler.getSourceManager().getFilename(expansionLoc);
aInfo.sourceLocation = std::string(name.substr(strlen(SRCDIR)+1)) + ":" + std::to_string(compiler.getSourceManager().getSpellingLineNumber(expansionLoc));
return aInfo;
}
bool UnusedDefaultParams::VisitCallExpr(CallExpr * callExpr) {
if (ignoreLocation(callExpr)) {
return true;
}
if (callExpr->getDirectCallee() == nullptr) {
return true;
}
const FunctionDecl* functionDecl = callExpr->getDirectCallee()->getCanonicalDecl();
auto n = functionDecl->getNumParams();
if (n == 0 || !functionDecl->getParamDecl(n - 1)->hasDefaultArg()) {
return true;
}
// method overrides don't always specify the same default params (althogh they probably should)
// so we need to work our way up to the root method
while (isa<CXXMethodDecl>(functionDecl)) {
const CXXMethodDecl* methodDecl = dyn_cast<CXXMethodDecl>(functionDecl);
if (methodDecl->size_overridden_methods()==0)
break;
functionDecl = *methodDecl->begin_overridden_methods();
}
assert(callExpr->getNumArgs() <= n); // can be < in template code
for (unsigned i = callExpr->getNumArgs(); i != 0;) {
--i;
Expr* arg = callExpr->getArg(i);
if (arg->isDefaultArgument()) {
continue;
}
// ignore this, it seems to trigger an infinite recursion
if (isa<UnaryExprOrTypeTraitExpr>(arg))
break;
const ParmVarDecl* parmVarDecl = functionDecl->getParamDecl(i);
if (!parmVarDecl->hasDefaultArg()
|| parmVarDecl->hasUninstantiatedDefaultArg())
{
break;
}
const Expr* defaultArgExpr = parmVarDecl->getDefaultArg();
if (!defaultArgExpr) {
break;
}
MyFuncInfo funcInfo = niceName(functionDecl);
callSet.insert(funcInfo);
break;
}
return true;
}
bool UnusedDefaultParams::VisitFunctionDecl( const FunctionDecl* functionDecl )
{
functionDecl = functionDecl->getCanonicalDecl();
if( !functionDecl || !functionDecl->getLocation().isValid() || ignoreLocation( functionDecl )) {
return true;
}
const CXXMethodDecl* methodDecl = dyn_cast_or_null<CXXMethodDecl>(functionDecl);
// ignore method overrides, since the call will show up as being directed to the root method
if (methodDecl && (methodDecl->size_overridden_methods() != 0 || methodDecl->hasAttr<OverrideAttr>())) {
return true;
}
// ignore stuff that forms part of the stable URE interface
if (isInUnoIncludeFile(compiler.getSourceManager().getSpellingLoc(
functionDecl->getNameInfo().getLoc()))) {
return true;
}
if (isa<CXXDestructorDecl>(functionDecl)) {
return true;
}
if (isa<CXXConstructorDecl>(functionDecl)) {
return true;
}
if (functionDecl->isDeleted()) {
return true;
}
auto n = functionDecl->getNumParams();
if (n == 0 || !functionDecl->getParamDecl(n - 1)->hasDefaultArg()) {
return true;
}
if( functionDecl->getLocation().isValid() )
{
MyFuncInfo funcInfo = niceName(functionDecl);
definitionSet.insert(funcInfo);
}
return true;
}
loplugin::Plugin::Registration< UnusedDefaultParams > X("unuseddefaultparams", true);
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

78
compilerplugins/clang/unuseddefaultparams.py Executable file
View File

@@ -0,0 +1,78 @@
#!/usr/bin/python
import sys
import re
import io
definitionSet = set()
definitionToSourceLocationMap = dict()
callSet = set()
# things we need to exclude for reasons like :
# - it's a weird template thingy that confuses the plugin
exclusionSet = 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)
# The parsing here is designed to avoid grabbing stuff which is mixed in from gbuild.
# I have not yet found a way of suppressing the gbuild output.
with io.open(sys.argv[1], "rb", buffering=1024*1024) as txt:
for line in txt:
if line.startswith("defn:\t"):
idx1 = line.find("\t",6)
idx2 = line.find("\t",idx1+1)
idx3 = line.find("\t",idx2+1)
access = line[6:idx1]
returnType = line[idx1+1:idx2]
nameAndParams = line[idx2+1:idx3]
sourceLocation = line[idx3+1:].strip()
funcInfo = (normalizeTypeParams(returnType), normalizeTypeParams(nameAndParams))
definitionSet.add(funcInfo)
definitionToSourceLocationMap[funcInfo] = sourceLocation
elif line.startswith("call:\t"):
idx1 = line.find("\t",6)
returnType = line[6:idx1]
nameAndParams = line[idx1+1:].strip()
callSet.add((normalizeTypeParams(returnType), normalizeTypeParams(nameAndParams)))
# Invert the definitionToSourceLocationMap.
# If we see more than one method at the same sourceLocation, it's being autogenerated as part of a template
# and we should just ignore it.
sourceLocationToDefinitionMap = {}
for k, v in definitionToSourceLocationMap.iteritems():
sourceLocationToDefinitionMap[v] = sourceLocationToDefinitionMap.get(v, [])
sourceLocationToDefinitionMap[v].append(k)
for k, definitions in sourceLocationToDefinitionMap.iteritems():
if len(definitions) > 1:
for d in definitions:
definitionSet.remove(d)
tmp1set = set()
for d in definitionSet:
clazz = d[0] + " " + d[1]
if clazz in exclusionSet:
continue
if d in callSet:
continue
tmp1set.add((clazz, definitionToSourceLocationMap[d]))
# 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 results by name and line number
tmp1list = sorted(tmp1set, key=lambda v: natural_sort_key(v[1]))
# print out the results
with open("unused.defaultparams", "wt") as f:
for t in tmp1list:
f.write(t[1] + "\n")
f.write(" " + t[0] + "\n")

19
compilerplugins/clang/unusedfields.cxx
View File

@@ -47,17 +47,16 @@ struct MyFieldInfo
std::string fieldName;
std::string fieldType;
std::string sourceLocation;
bool operator < (const MyFieldInfo &other) const
{
if (parentClass < other.parentClass)
return true;
else if (parentClass == other.parentClass)
return fieldName < other.fieldName;
else
return false;
}
};
bool operator < (const MyFieldInfo &lhs, const MyFieldInfo &rhs)
{
if (lhs.parentClass < rhs.parentClass)
return true;
else if (lhs.parentClass == rhs.parentClass)
return lhs.fieldName < rhs.fieldName;
else
return false;
}
// try to limit the voluminous output a little

14
compilerplugins/clang/unusedmethods.cxx
View File

@@ -52,17 +52,11 @@ struct MyFuncInfo
std::string nameAndParams;
std::string sourceLocation;
bool operator < (const MyFuncInfo &other) const
{
if (returnType < other.returnType)
return true;
else if (returnType == other.returnType)
return nameAndParams < other.nameAndParams;
else
return false;
}
};
bool operator < (const MyFuncInfo &lhs, const MyFuncInfo &rhs)
{
return lhs.sourceLocation < rhs.sourceLocation;
}
// try to limit the voluminous output a little

25
xmloff/inc/txtflde.hxx
View File

@@ -229,9 +229,7 @@ protected:
/// export an element with string content
void ExportElement(enum ::xmloff::token::XMLTokenEnum eElement, /// element token
const OUString& sContent, /// element content
bool bAddSpace = false); /// add blanks around
/// element?
const OUString& sContent); /// element content
/// export a macro (as used in the macro field)
void ExportMacro( const css::uno::Reference< css::beans::XPropertySet> & rPropSet,
@@ -278,16 +276,14 @@ protected:
void ProcessString(
enum ::xmloff::token::XMLTokenEnum eXmlName, /// attribute token (namespace text)
const OUString& sValue, /// attribute value
const OUString& sDefault, /// default value; omit if equal
sal_uInt16 nPrefix = XML_NAMESPACE_TEXT); /// attribute name prefix
const OUString& sDefault); /// default value; omit if equal
/// export a string attribute, omit if default
void ProcessString(
enum ::xmloff::token::XMLTokenEnum eXmlName, /// attribute token (namespace text)
sal_uInt16 nValuePrefix,
const OUString& sValue, /// attribute value
const OUString& sDefault, /// default value; omit if equal
sal_uInt16 nPrefix = XML_NAMESPACE_TEXT); /// attribute name prefix
const OUString& sDefault); /// default value; omit if equal
/// export a string attribute
void ProcessString(
@@ -300,8 +296,7 @@ protected:
void ProcessString(
enum ::xmloff::token::XMLTokenEnum eXmlName, /// attribute token (namespace text)
enum ::xmloff::token::XMLTokenEnum eValue, /// attribute value token
enum ::xmloff::token::XMLTokenEnum eDefault, /// default value token
sal_uInt16 nPrefix = XML_NAMESPACE_TEXT); /// attribute name prefix
enum ::xmloff::token::XMLTokenEnum eDefault); /// default value token
/// export a string as a sequence of paragraphs
void ProcessParagraphSequence(
@@ -314,8 +309,7 @@ protected:
/// export display attribute (value, formula, none)
void ProcessDisplay(bool bIsVisible, /// is visible?
bool bIsCommand, /// is show command/show name?
bool bDefault = true); /// omit, if default
bool bIsCommand); /// is show command/show name?
/// export all data-style related attributes
void ProcessValueAndType(
@@ -345,21 +339,18 @@ protected:
sal_Int32 nMinutes, /// date/time value in minutes
bool bIsDate, /// export as date?
bool bIsDuration, /// export as duration?
bool bOmitDurationIfZero, /// omit zero-length durations
sal_uInt16 nPrefix = XML_NAMESPACE_TEXT); /// attribute name prefix
bool bOmitDurationIfZero); /// omit zero-length durations
/// export times, dates and durations according to ISO 8601
void ProcessDateTime(
enum ::xmloff::token::XMLTokenEnum eXMLName, /// attribute token
const css::util::DateTime& rTime, /// date/time value
bool bIsDate, /// export as date (rather than date/time)?
sal_uInt16 nPrefix = XML_NAMESPACE_TEXT); /// attribute name prefix
bool bIsDate); /// export as date (rather than date/time)?
/// export time or dateTime
void ProcessTimeOrDateTime(
enum ::xmloff::token::XMLTokenEnum eXMLName, /// attribute token
const css::util::DateTime& rTime, /// date/time value
sal_uInt16 nPrefix = XML_NAMESPACE_TEXT); /// attribute name prefix
const css::util::DateTime& rTime); /// date/time value
/// export all attributes for bibliography data fields
void ProcessBibliographyData(

12
xmloff/source/chart/SchXMLExport.cxx
View File

@@ -237,9 +237,9 @@ public:
void addPosition( css::uno::Reference< css::drawing::XShape > xShape );
/// add svg size as attribute for current element
void addSize( const css::awt::Size & rSize, bool bIsOOoNamespace = false );
void addSize( css::uno::Reference< css::drawing::XShape > xShape, bool bIsOOoNamespace = false );
void addSize( css::uno::Reference< css::drawing::XShape > xShape );
/// exports a string as a paragraph element
void exportText( const OUString& rText, bool bConvertTabsLFs = false );
void exportText( const OUString& rText );
public:
SvXMLExport& mrExport;
@@ -3476,10 +3476,10 @@ void SchXMLExportHelper_Impl::addSize( const awt::Size & rSize, bool bIsOOoNames
mrExport.AddAttribute( bIsOOoNamespace ? XML_NAMESPACE_CHART_EXT : XML_NAMESPACE_SVG, XML_HEIGHT, msString );
}
void SchXMLExportHelper_Impl::addSize( Reference< drawing::XShape > xShape, bool bIsOOoNamespace )
void SchXMLExportHelper_Impl::addSize( Reference< drawing::XShape > xShape )
{
if( xShape.is())
addSize( xShape->getSize(), bIsOOoNamespace );
addSize( xShape->getSize() );
}
awt::Size SchXMLExportHelper_Impl::getPageSize( const Reference< chart2::XChartDocument > & xChartDoc )
@@ -3510,9 +3510,9 @@ void SchXMLExportHelper_Impl::AddAutoStyleAttribute( const std::vector< XMLPrope
}
}
void SchXMLExportHelper_Impl::exportText( const OUString& rText, bool bConvertTabsLFs )
void SchXMLExportHelper_Impl::exportText( const OUString& rText )
{
SchXMLTools::exportText( mrExport, rText, bConvertTabsLFs );
SchXMLTools::exportText( mrExport, rText, false/*bConvertTabsLFs*/ );
}
// class SchXMLExport

9
xmloff/source/chart/SchXMLSeries2Context.cxx
View File

@@ -179,15 +179,10 @@ void lcl_resetSymbolSizeForPointsIfNecessary( const uno::Reference< beans::XProp
void lcl_insertErrorBarLSequencesToMap(
tSchXMLLSequencesPerIndex & rInOutMap,
const uno::Reference< beans::XPropertySet > & xSeriesProp,
bool bYError = true )
const uno::Reference< beans::XPropertySet > & xSeriesProp )
{
Reference< chart2::data::XDataSource > xErrorBarSource;
const OUString aPropName(
bYError
? OUString( "ErrorBarY" )
: OUString( "ErrorBarX" ));
if( ( xSeriesProp->getPropertyValue( aPropName ) >>= xErrorBarSource ) &&
if( ( xSeriesProp->getPropertyValue( "ErrorBarY" ) >>= xErrorBarSource ) &&
xErrorBarSource.is() )
{
Sequence< Reference< chart2::data::XLabeledDataSequence > > aLSequences(

2
xmloff/source/forms/formcellbinding.cxx
View File

@@ -113,7 +113,7 @@ bool FormCellBindingHelper::livesInSpreadsheetDocument( const Reference< XProper
return xDocument.is();
}
bool FormCellBindingHelper::convertStringAddress( const OUString& _rAddressDescription, CellAddress& /* [out] */ _rAddress, sal_Int16 /*_nAssumeSheet*/ ) const
bool FormCellBindingHelper::convertStringAddress( const OUString& _rAddressDescription, CellAddress& /* [out] */ _rAddress ) const
{
Any aAddress;
return doConvertAddressRepresentations(

3
xmloff/source/forms/formcellbinding.hxx
View File

@@ -183,8 +183,7 @@ namespace xmloff
*/
bool convertStringAddress(
const OUString& _rAddressDescription,
css::table::CellAddress& /* [out] */ _rAddress,
sal_Int16 _nAssumeSheet = -1
css::table::CellAddress& /* [out] */ _rAddress
) const;
/** creates an address range object from a string representation of a cell range address

4
xmloff/source/forms/propertyexport.cxx
View File

@@ -473,10 +473,10 @@ namespace xmloff
void OPropertyExport::exportStringSequenceAttribute(const sal_uInt16 _nAttributeNamespaceKey, const sal_Char* _pAttributeName,
const OUString& _rPropertyName,
const sal_Unicode _aQuoteCharacter, const sal_Unicode _aListSeparator)
const sal_Unicode _aQuoteCharacter)
{
const sal_Unicode _aListSeparator = ',';
DBG_CHECK_PROPERTY( _rPropertyName, Sequence< OUString > );
OSL_ENSURE(_aListSeparator != 0, "OPropertyExport::exportStringSequenceAttribute: invalid separator character!");
Sequence< OUString > aItems;
m_xProps->getPropertyValue( _rPropertyName ) >>= aItems;

5
xmloff/source/forms/propertyexport.hxx
View File

@@ -298,15 +298,12 @@ namespace xmloff
the name of the property to ask the object for
@param _aQuoteCharacter
the character to use to quote the sequence elements with. May be 0, in this case no quoting happens
@param _aListSeparator
the character to use to separate the list entries
*/
void exportStringSequenceAttribute(
const sal_uInt16 _nAttributeNamespaceKey,
const sal_Char* _pAttributeName,
const OUString& _rPropertyName,
const sal_Unicode _aQuoteCharacter = '"',
const sal_Unicode _aListSeparator = ',');
const sal_Unicode _aQuoteCharacter = '"');
/** determines whether the given property is to be exported

42
xmloff/source/text/txtflde.cxx
View File

@@ -2227,8 +2227,7 @@ void XMLTextFieldExport::ExportElement(enum XMLTokenEnum eElementName,
}
void XMLTextFieldExport::ExportElement(enum XMLTokenEnum eElementName,
const OUString& sContent,
bool bAddSpace)
const OUString& sContent)
{
DBG_ASSERT(eElementName != XML_TOKEN_INVALID, "invalid element name!");
if (eElementName != XML_TOKEN_INVALID)
@@ -2239,7 +2238,7 @@ void XMLTextFieldExport::ExportElement(enum XMLTokenEnum eElementName,
if (SvtSaveOptions().GetODFDefaultVersion() > SvtSaveOptions::ODFVER_012)
{
SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_LO_EXT,
eElementName, bAddSpace, bAddSpace );
eElementName, false, false );
// export content
GetExport().Characters(sContent);
}
@@ -2247,7 +2246,7 @@ void XMLTextFieldExport::ExportElement(enum XMLTokenEnum eElementName,
else
{
SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_TEXT,
eElementName, bAddSpace, bAddSpace );
eElementName, false, false );
// export content
GetExport().Characters(sContent);
}
@@ -2426,8 +2425,7 @@ void XMLTextFieldExport::ProcessValueAndType(
/// process display related properties
void XMLTextFieldExport::ProcessDisplay(bool bIsVisible,
bool bIsCommand,
bool bValueDefault)
bool bIsCommand)
{
enum XMLTokenEnum eValue;
@@ -2441,7 +2439,7 @@ void XMLTextFieldExport::ProcessDisplay(bool bIsVisible,
}
// omit attribute if default
if (!bValueDefault || (eValue != XML_VALUE))
if (eValue != XML_VALUE)
{
GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_DISPLAY, eValue);
}
@@ -2497,12 +2495,11 @@ void XMLTextFieldExport::ProcessString(enum XMLTokenEnum eName,
/// export a string attribute
void XMLTextFieldExport::ProcessString(enum XMLTokenEnum eName,
const OUString& sValue,
const OUString& sDefault,
sal_uInt16 nPrefix)
const OUString& sDefault)
{
if (sValue != sDefault)
{
ProcessString(eName, sValue, false, nPrefix);
ProcessString(eName, sValue);
}
}
@@ -2510,12 +2507,11 @@ void XMLTextFieldExport::ProcessString(enum XMLTokenEnum eName,
void XMLTextFieldExport::ProcessString(enum XMLTokenEnum eName,
sal_uInt16 nValuePrefix,
const OUString& sValue,
const OUString& sDefault,
sal_uInt16 nPrefix)
const OUString& sDefault)
{
if (sValue != sDefault)
{
ProcessString(eName, nValuePrefix, sValue, false, nPrefix);
ProcessString(eName, nValuePrefix, sValue);
}
}
@@ -2544,11 +2540,10 @@ void XMLTextFieldExport::ProcessString(
void XMLTextFieldExport::ProcessString(
enum XMLTokenEnum eName,
enum XMLTokenEnum eValue,
enum XMLTokenEnum eDefault,
sal_uInt16 nPrefix)
enum XMLTokenEnum eDefault)
{
if ( eValue != eDefault )
ProcessString( eName, eValue, false, nPrefix);
ProcessString( eName, eValue);
}
@@ -2650,8 +2645,7 @@ void XMLTextFieldExport::ProcessDateTime(enum XMLTokenEnum eName,
/// export a date or time
void XMLTextFieldExport::ProcessDateTime(enum XMLTokenEnum eName,
const util::DateTime& rTime,
bool bIsDate,
sal_uInt16 nPrefix)
bool bIsDate)
{
OUStringBuffer aBuffer;
@@ -2670,7 +2664,7 @@ void XMLTextFieldExport::ProcessDateTime(enum XMLTokenEnum eName,
::sax::Converter::convertDateTime(aBuffer, aDateTime, nullptr);
// output attribute
ProcessString(eName, aBuffer.makeStringAndClear(), true, nPrefix);
ProcessString(eName, aBuffer.makeStringAndClear(), true);
}
/// export a date, time, or duration
@@ -2678,21 +2672,19 @@ void XMLTextFieldExport::ProcessDateTime(enum XMLTokenEnum eName,
sal_Int32 nMinutes,
bool bIsDate,
bool bIsDuration,
bool bOmitDurationIfZero,
sal_uInt16 nPrefix)
bool bOmitDurationIfZero)
{
// handle bOmitDurationIfZero here, because we can precisely compare ints
if (!(bIsDuration && bOmitDurationIfZero && (nMinutes==0)))
{
ProcessDateTime(eName, (double)nMinutes / (double)(24*60),
bIsDate, bIsDuration, bOmitDurationIfZero, nPrefix);
bIsDate, bIsDuration, bOmitDurationIfZero);
}
}
/// export a time or dateTime
void XMLTextFieldExport::ProcessTimeOrDateTime(enum XMLTokenEnum eName,
const util::DateTime& rTime,
sal_uInt16 nPrefix)
const util::DateTime& rTime)
{
OUStringBuffer aBuffer;
@@ -2700,7 +2692,7 @@ void XMLTextFieldExport::ProcessTimeOrDateTime(enum XMLTokenEnum eName,
::sax::Converter::convertTimeOrDateTime(aBuffer, rTime, nullptr);
// output attribute
ProcessString(eName, aBuffer.makeStringAndClear(), true, nPrefix);
ProcessString(eName, aBuffer.makeStringAndClear(), true);
}

5
xmlscript/source/inc/xml_import.hxx
View File

@@ -43,16 +43,13 @@ namespace xmlscript
@param xRoot
initial object being called for root context
@param bSingleThreadedUse
flag whether context management is synchronized.
@return
document handler for parser
*/
css::uno::Reference< css::xml::sax::XDocumentHandler >
SAL_CALL createDocumentHandler(
css::uno::Reference<
css::xml::input::XRoot > const & xRoot,
bool bSingleThreadedUse = true );
css::xml::input::XRoot > const & xRoot );
}

5
xmlscript/source/xml_helper/xml_impctx.cxx
View File

@@ -789,14 +789,13 @@ OUString ExtendedAttributes::getValueByUidName(
}
Reference< xml::sax::XDocumentHandler > SAL_CALL createDocumentHandler(
Reference< xml::input::XRoot > const & xRoot,
bool bSingleThreadedUse )
Reference< xml::input::XRoot > const & xRoot )
{
SAL_WARN_IF( !xRoot.is(), "xmlscript.xmlhelper", "xRoot is NULL" );
if (xRoot.is())
{
return static_cast< xml::sax::XDocumentHandler * >(
new DocumentHandlerImpl( xRoot, bSingleThreadedUse ) );
new DocumentHandlerImpl( xRoot, true /* mt use */ ) );
}
return Reference< xml::sax::XDocumentHandler >();
}