mirror of
https://github.com/eclipse-cdt/cdt
synced 2025-08-24 00:33:48 +02:00
219 lines
16 KiB
Properties
219 lines
16 KiB
Properties
###############################################################################
|
|
# Copyright (c) 2010, 2011 Alena Laskavaia and others.
|
|
#
|
|
# This program and the accompanying materials
|
|
# are made available under the terms of the Eclipse Public License 2.0
|
|
# which accompanies this distribution, and is available at
|
|
# https://www.eclipse.org/legal/epl-2.0/
|
|
#
|
|
# SPDX-License-Identifier: EPL-2.0
|
|
#
|
|
# Contributors:
|
|
# Alena Laskavaia - initial API and implementation
|
|
###############################################################################
|
|
#Properties file for org.eclipse.cdt.codan.checkers
|
|
Bundle-Vendor = Eclipse CDT
|
|
Bundle-Name = Codan Checkers
|
|
checker.name.AssignmentInCondition = Assignment in condition
|
|
problem.description.AssignmentInCondition = Finds statements like 'if (a=b)'
|
|
problem.messagePattern.AssignmentInCondition = Possible assignment in condition ''{0}''
|
|
problem.name.AssignmentInCondition = Assignment in condition
|
|
checker.name.StatementHasNoEffect = StatementHasNoEffectChecker
|
|
problem.description.StatementHasNoEffect = Finds statements like 'a;' or '-a;' or 'a-b;' which do no seems to have any side effect therefore suspicious
|
|
problem.messagePattern.StatementHasNoEffect = Statement has no effect ''{0}''
|
|
problem.name.StatementHasNoEffect = Statement has no effect
|
|
checker.name.NonVirtualDestructor = NonVirtualDestructorChecker
|
|
problem.description.NonVirtualDestructor = If destructor is not declared virtual - destructor of derived class would not be called.
|
|
problem.messagePattern.NonVirtualDestructor = Class ''{0}'' has virtual method ''{1}'' but non-virtual destructor
|
|
problem.name.NonVirtualDestructor = Class has a virtual method and non-virtual destructor
|
|
checker.name.CatchByReference = CatchByReferenceChecker
|
|
problem.description.CatchByReference = Catching by reference is recommended by C++ experts, "Throw by value, catch by reference". For one thing, this avoids copying and potentially slicing the exception.
|
|
problem.messagePattern.CatchByReference = Catching by reference is recommended ''{0}''
|
|
problem.name.CatchByReference = Catching by reference is recommended
|
|
checker.name.SuggestedParenthesis = SuggestedParenthesisChecker
|
|
problem.description.SuggestedParenthesis = This checker finds problems related to either lack of understanding precedence of operators or misspelling of operators in expression. For example (!a<10) or (a && b & c)
|
|
problem.messagePattern.SuggestedParenthesis = Suggested parenthesis around expression ''{0}''
|
|
problem.name.SuggestedParenthesis = Suggested parenthesis around expression
|
|
checker.name.NamingConventionFunction = NamingConventionFunctionChecker
|
|
problem.description.NamingConventionFunction = Finds and reports functions name of which does not match pattern parameter
|
|
problem.messagePattern.NamingConventionFunction = Bad function name "{0}" (pattern /{1}/)
|
|
problem.name.NamingConventionFunction = Name convention for function
|
|
checker.name.ReturnChecker = Return inconsistencies
|
|
problem.description.NoReturnValue = Return statement has no return value, if somebody would use return value from this function it would be random
|
|
problem.messagePattern.NoReturnValue = Return without value, in function returning non-void
|
|
problem.name.NoReturnValue = No return value
|
|
problem.description.UnusedReturnValue = Return statement has a value, but function is declared to return void. Did you mean to declare function with return value?
|
|
problem.messagePattern.UnusedReturnValue = Return has value, in function returning void
|
|
problem.name.UnusedReturnValue = Unused return value
|
|
problem.description.NoReturn = No return statement in a function which is declared to return value
|
|
problem.messagePattern.NoReturn = No return, in function returning non-void
|
|
problem.name.NoReturn = No return
|
|
problem.description.LocalVarReturn = Returning the address of a local variable
|
|
problem.messagePattern.LocalVarReturn = Returning the address of local variable ''{0}''
|
|
problem.name.LocalVarReturn = Returning the address of a local variable
|
|
checker.name.FormatString = Format String
|
|
problem.description.FormatString = Finds statements lead to format string vulnerability (e.g. 'char[5] str; scanf("%10s", str);'\u0020
|
|
problem.messagePattern.FormatString = Format string vulnerability in ''{0}''
|
|
problem.name.FormatString = Format String Vulnerability
|
|
checker.name.AssignmentToItself = Assignment to itself
|
|
problem.messagePattern.AssignmentToItself = Assignment to itself ''{0}''
|
|
problem.name.AssignmentToItself = Assignment to itself
|
|
problem.description.AssignmentToItself = Finds expression where left and right sides of the assignment are the same, i.e. 'var = var'
|
|
checker.name.ReturnStyle = Return with parenthesis
|
|
problem.name.ReturnStyle = Return with parenthesis
|
|
problem.messagePattern.ReturnStyle = Return statement has invalid style. Return value should be surrounded by parenthesis
|
|
problem.description.ReturnStyle = Checks for return statements that do no return the value in parenthesis. For example 'return 0;' \u0020
|
|
checker.name.SuspiciousSemicolon = Suspicious semicolon
|
|
problem.name.SuspiciousSemicolon = Suspicious semicolon
|
|
problem.messagePattern.SuspiciousSemicolon = Suspicious semicolon
|
|
problem.description.SuspiciousSemicolon = A semicolon is used as a null statement in a condition. For example, 'if (expression);'
|
|
checker.name.CaseBreak = No break at end of case
|
|
problem.description.CaseBreak = Looks for "case" statements which end without a "break" statement
|
|
problem.messagePattern.CaseBreak = No break at the end of case
|
|
binding.checker.name = Problem Binding Checker
|
|
problem.description.G = Name resolution problem found by the indexer
|
|
problem.messagePattern.G = Symbol ''{0}'' could not be resolved
|
|
problem.name.G = Symbol is not resolved
|
|
problem.description.0 = Name resolution problem found by the indexer
|
|
problem.messagePattern.0 = Invalid overload of ''{0}''
|
|
problem.name.0 = Invalid overload
|
|
problem.description.1 = Name resolution problem found by the indexer
|
|
problem.messagePattern.1 = ''{0}'' is ambiguous ''{1}''
|
|
problem.name.1 = Ambiguous problem
|
|
problem.description.2 = Name resolution problem found by the indexer
|
|
problem.messagePattern.2 = Circular inheritance encountered in ''{0}''
|
|
problem.name.2 = Circular inheritance
|
|
problem.description.3 = Name resolution problem found by the indexer
|
|
problem.messagePattern.3 = Invalid redeclaration of ''{0}''
|
|
problem.name.3 = Invalid redeclaration
|
|
problem.description.4 = Name resolution problem found by the indexer
|
|
problem.messagePattern.4 = Invalid redefinition of ''{0}''
|
|
problem.name.4 = Invalid redefinition
|
|
problem.description.5 = Name resolution problem found by the indexer
|
|
problem.messagePattern.5 = Member declaration not found
|
|
problem.name.5 = Member declaration not found
|
|
problem.description.6 = Name resolution problem found by the indexer
|
|
problem.messagePattern.6 = Label ''{0}'' not found
|
|
problem.name.6 = Label statement not found
|
|
problem.description.7 = Name resolution problem found by the indexer
|
|
problem.messagePattern.7 = Invalid template arguments
|
|
problem.name.7 = Invalid template argument
|
|
problem.description.8 = Name resolution problem found by the indexer
|
|
problem.messagePattern.8 = Type ''{0}'' could not be resolved
|
|
problem.name.8 = Type cannot be resolved
|
|
problem.description.9 = Name resolution problem found by the indexer
|
|
problem.messagePattern.9 = Function ''{0}'' could not be resolved
|
|
problem.name.9 = Function cannot be resolved
|
|
problem.description.10 = Name resolution problem found by the indexer
|
|
problem.messagePattern.10 = Invalid arguments ''{0}''
|
|
problem.name.10 = Invalid arguments
|
|
problem.description.11 = Name resolution problem found by the indexer
|
|
problem.messagePattern.11 = Method ''{0}'' could not be resolved
|
|
problem.name.11 = Method cannot be resolved
|
|
problem.description.12 = Name resolution problem found by the indexer
|
|
problem.messagePattern.12 = Field ''{0}'' could not be resolved
|
|
problem.name.12 = Field cannot be resolved
|
|
checker.name.AbstractClassCreation = Abstract class cannot be instantiated
|
|
problem.name.AbstractClassCreation = Abstract class cannot be instantiated
|
|
problem.messagePattern.AbstractClassCreation = The type ''{0}'' must implement the inherited pure virtual method ''{1}''\u0020
|
|
problem.description.AbstractClassCreation = All inherited pure virtual methods must be implemented to allow instantiation of the class
|
|
checker.name.ClassMembersInitialization = Class members should be properly initialized
|
|
problem.name.ClassMembersInitialization = Class members should be properly initialized
|
|
problem.messagePattern.ClassMembersInitialization = Member ''{0}'' was not initialized in this constructor\u0020
|
|
problem.description.ClassMembersInitialization = Class members should be properly initialized to avoid random behavior \u0020
|
|
|
|
checker.name.UnusedSymbolInFileScopeChecker = Unused symbols and declarations in file scope
|
|
problem.description.UnusedVariableDeclarationProblem = Finds unused global variable declarations in file scope
|
|
problem.messagePattern.UnusedVariableDeclarationProblem = Unused declaration of variable ''{0}''
|
|
problem.name.UnusedVariableDeclarationProblem = Unused variable declaration in file scope
|
|
problem.description.UnusedFunctionDeclarationProblem = Finds unused function declarations
|
|
problem.messagePattern.UnusedFunctionDeclarationProblem = Unused declaration of function ''{0}''
|
|
problem.name.UnusedFunctionDeclarationProblem = Unused function declaration
|
|
problem.description.UnusedStaticFunctionProblem = Finds static functions which cannot be possible used not being referenced inside the file
|
|
problem.messagePattern.UnusedStaticFunctionProblem = Unused static function ''{0}''
|
|
problem.name.UnusedStaticFunctionProblem = Unused static function
|
|
|
|
checker.name.DecltypeAutoChecker = Invalid 'decltype(auto)' specifier checker
|
|
problem.name.DecltypeAutoProblem = Invalid 'decltype(auto)' specifier
|
|
problem.messagePattern.DecltypeAutoProblem = Combining 'decltype(auto)' with other type specifiers is not allowed
|
|
problem.description.DecltypeAutoProblem = This rule will flag 'decltype(auto)' if combined with other type specifiers
|
|
|
|
checker.name.UsingInHeaderChecker = Using directive in header files checker
|
|
problem.name.UsingInHeaderProblem = Using directive in header
|
|
problem.messagePattern.UsingInHeaderProblem = Using directive in header files can cause name clashes in other files
|
|
problem.description.UsingInHeaderProblem = This rule will flag 'using' directive in header files
|
|
|
|
|
|
checker.name.CStyleCastChecker = C-Style cast
|
|
problem.name.CStyleCastProblem = C-Style cast instead of C++ cast
|
|
problem.messagePattern.CStyleCastProblem = C++ style casts express the intent of the programmer more clearly and they can be checked by compiler
|
|
problem.description.CStyleCastProblem = This rule will flag C-style cast expressions in C++ files
|
|
|
|
checker.name.GotoStatementChecker = Goto statement in source files checker
|
|
problem.name.GotoStatementProblem = Goto statement used
|
|
problem.messagePattern.GotoStatementProblem = Code that uses goto statements is harder to understand than alternative constructions
|
|
problem.description.GotoStatementProblem = This rule will flag goto statements in source files
|
|
|
|
checker.name.CopyrightChecker = Copyright in source code checker
|
|
problem.name.CopyrightProblem = Lack of copyright information
|
|
problem.messagePattern.CopyrightProblem = Copyright information missing
|
|
problem.description.CopyrightProblem = This rule will flag files without copyright information
|
|
|
|
checker.name.SwitchCaseChecker = Missing cases in switch statements checker
|
|
problem.name.MissCaseProblem = Missing cases in switch
|
|
problem.messagePattern.MissCaseProblem = Not all enumeration values are present in the switch statement
|
|
problem.description.MissCaseProblem = This rule will flag switch statements with missing case where enumerations have been used
|
|
problem.name.MissDefaultProblem = Missing default in switch
|
|
problem.messagePattern.MissDefaultProblem = When default case is missing the switch is not complete for all values
|
|
problem.description.MissDefaultProblem = This rule will flag switch statements without a default case
|
|
|
|
checker.name.VirtualMethodCallChecker = Virtual method call checker
|
|
problem.name.VirtualMethodCallProblem = Virtual method call in constructor/destructor
|
|
problem.messagePattern.VirtualMethodCallProblem = Calling a virtual method in constructor or destructor can cause crashes and unexpected behavior
|
|
problem.description.VirtualMethodCallProblem = This rule will flag constructor and destructor with virtual method calls
|
|
|
|
checker.name.AssignmentOperatorChecker = Assignment operator checker
|
|
problem.name.MissSelfCheckProblem = Missing self check in assignment operator
|
|
problem.messagePattern.MissSelfCheckProblem = Self assignment checks improves performance and avoid to unexpected behavior
|
|
problem.description.MissSelfCheckProblem = This rule will flag assignment operators without a self assignment check
|
|
problem.name.MissReferenceProblem = Missing reference return value in assignment operator
|
|
problem.messagePattern.MissReferenceProblem = Assignment operators should return by reference
|
|
problem.description.MissReferenceProblem = This rule will flag assignment operators not returning by reference
|
|
|
|
checker.name.BlacklistChecker = Function or method in blacklist checker
|
|
problem.name.BlacklistProblem = Function or method is blacklisted
|
|
problem.messagePattern.BlacklistProblem = Function or method ''{0}'' is blacklisted
|
|
problem.description.BlacklistProblem = This rule will flag the use of functions or methods in blacklist
|
|
|
|
checker.name.VariablesChecker = Variable checker
|
|
problem.name.StaticVariableInHeaderProblem = Static variable in header file
|
|
problem.messagePattern.StaticVariableInHeaderProblem = Variable ''{0}'' is duplicated in each translation unit
|
|
problem.description.StaticVariableInHeaderProblem = This rule will flag static variable declarations in header files
|
|
problem.name.MultipleDeclarationsProblem = Multiple variable declaration
|
|
problem.messagePattern.MultipleDeclarationsProblem = Variables should be declared one per line to improve readability
|
|
problem.description.MultipleDeclarationsProblem = This rule will flag multiple declarations on one line
|
|
|
|
checker.name.FloatCompareChecker = Float compare checker
|
|
problem.name.FloatCompareProblem = Direct float comparison
|
|
problem.messagePattern.FloatCompareProblem = Float numbers should be compared using an epsilon
|
|
problem.description.FloatCompareProblem = This rule will flag direct float or double comparison
|
|
|
|
checker.name.SymbolShadowing = Symbol shadowing checker
|
|
problem.description.SymbolShadowing = This rule will flag symbols, like local variables, class fields or method parameters, shadowing another symbol in upper scope
|
|
problem.messagePattern.SymbolShadowing = Symbol "{0}" is masking symbol declared in upper scope
|
|
problem.name.SymbolShadowing = Symbol shadowing
|
|
|
|
checker.name.ShallowCopyChecker = Copy ctor and assignment operator checker
|
|
problem.name.ShallowCopyProblem = Miss copy constructor or assignment operator
|
|
problem.messagePattern.ShallowCopyProblem = Shallow copy can have negative run-time effects, explicit copy constructors/assignment operators for classes with references/pointers should be used
|
|
problem.description.ShallowCopyProblem = This rule will flag classes with pointer members without copy constructor or assignment operator
|
|
|
|
checker.name.MagicNumberChecker = Magic numbers checker
|
|
problem.name.MagicNumberProblem = Avoid magic numbers
|
|
problem.messagePattern.MagicNumberProblem = Avoid constant literals
|
|
problem.description.MagicNumberProblem = This rule will flag all constant literals numbers
|
|
|
|
checker.name.NoDiscard = NoDiscardChecker
|
|
problem.description.NoDiscard = This rule will flag the use of functions marked as 'no discard' without taking into account return value
|
|
problem.messagePattern.NoDiscard = Return value from ''{0}'' not evaluated
|
|
problem.name.NoDiscard = Return value not evaluated
|