ErrorParser.ProecessError=Cannot run CodeScanner. Please make sure CodeScanner is on your PATH or go to the Carbide.c++ > CodeScanner Preferences panel and set the CodeScanner Directory.

CSConfigSettings.LoadConfigErrorTitle=Error

CSConfigSettings.LoadConfigErrorMessage=Error reading file 

CSConfigSettings.SaveConfigErrorTitle=Error

CSConfigSettings.SaveConfigErrorMessage=Error saving file 

CSGeneralTabPage.CSDirLabel=CodeScanner directory:

CSGeneralTabPage.CSDirBrowseLabel=Browse...

CSGeneralTabPage.CSDirBrowseMessage=Choose the directory where codescanner.exe lives

CSGeneralTabPage.HTMLResultsLabel=Generate HTML report

CSGeneralTabPage.HTMLResultsMessage=When enabled, output report files in HTML format

CSGeneralTabPage.XMLResultsLabel=Generate XML report

CSGeneralTabPage.XMLResultsMessage=When enabled, output report files in XML format

CSGeneralTabPage.ResultsDirLabel=Reports directory:

CSGeneralTabPage.ResultsDirBrowseLabel=Browse...

CSGeneralTabPage.ResultsDirBrowseMessage=Choose the directory where the generated report files are stored

CSGeneralTabPage.SelectDirTitle=Select a directory...

CSGeneralTabPage.SelectCSDirMessage=Select the location of the CodeScanner command-line tool:

CSGeneralTabPage.SelectResultsDirMessage=Select the output directory for HTML/XML results:

CSGeneralTabPage.AutoscanLabel=Scan project automatically

CSGeneralTabPage.AutoscanMessage=Run CodeScanner on project automatically after each build

CSGeneralTabPage.KbScanLabel=Enable Knowledge Base Scanning

CSGeneralTabPage.KbScanMessage=Scan SDK specific porting issues

CSGeneralTabPage.MissingResultsDirTitle=Missing Reports Directory

CSGeneralTabPage.MissingResultsDirMessage=Please specify a directory for CodeScanner generated reports.

CSPreferencPage.ProjectSettingsLabel=<a href="com.nokia.carbide.cpp.codescanner.ui.CSPropertyPage">Configure Project Specific Settings...</a>

CSPreferencPage.GeneralTabLabel=General

CSPreferencPage.GeneralTabMessage=Configure general CodeScanner options

CSPreferencPage.FileFiltersTabLabel=File Filters

CSPreferencPage.FileFiltersTabMessage=Configure file filters used by CodeScanner

CSPreferencPage.RulesTabLabel=Rules

CSPreferencPage.RulesTabMessage=Configure rules used by CodeScanner

CSPreferencPage.ImportSettingsLabel=Import Settings...

CSPreferencPage.ImportSettingsMessage=Import CodeScanner configuration settings from a file

CSPreferencPage.ExportSettingsLabel=Export Settings...

CSPreferencPage.ExportSettingsMessage=Export CodeScanner configuration settings to a file

CSPreferencPage.ExportDefaultFilename=export_cs_config.xml

CSPreferencPage.SelectImportSettingsMessage=Select a configuration file to import

CSPreferencPage.SelectExportSettingsMessage=Select a configuration file to export

CSPreferencPage.ImportConfigFileErrorTitle=Error

CSPreferencPage.ImportConfigFileErrorMessage=Cannot find the file 

CSPropertyPage.ProjSettingsLabel=Enable Project Specific Settings

CSPropertyPage.WorkspaceSettingslabel=<a href="com.nokia.carbide.cpp.codescanner.ui.CSPreferencePage">Configure Workspace Settings...</a>

CSScanner.ScanningProjectMessage=Running CodeScanner on Project: {0}

CSScanner.ScanningResourceMessage=Running codescanner on \"{0}\".

CSScanner.ProjectInfoErrorMessage=Unable to retrieve project info.

CSScanner.ConfigSettingsErrorMessage=Unable to load CodeScanner settings.

CSScanner.TaskTitle=Running CodeScanner.

CSScanner.ScanCompletedMessage=CodeScanner completed scanning.

FileFiltersTabPage.FileFiltersLabel=Files patterns to filter out

FileFiltersTabPage.AddFileFilterLabel=Add...

FileFiltersTabPage.AddFileFilterMessage=Add a file filter to the list

FileFiltersTabPage.EditFileFilterLabel=Edit...

FileFiltersTabPage.EditFileFilterMessage=Edit selected file filter

FileFiltersTabPage.RemoveFileFilterLabel=Remove

FileFiltersTabPage.RemoveFileFilterMessage=Remove file filter from the list

FileFiltersTabPage.RemoveAllFileFiltersLabel=Remove All

FileFiltersTabPage.RemoveAllFileFiltersMessage=Remove all file filters

FileFiltersTabPage.FileFilterExistTitle=Duplicate File Filter

FileFiltersTabPage.FileFilterExistMessage=File filter already exists

FileFiltersEdit.DialogTitle=Edit File Filter

FileFiltersEdit.EditFileFilterMessage=Enter a regular expression to specify a file filter

FileFiltersEdit.FileFilterLabel=File filter:

KbManager.LoadFailMessage=Unable to load XML file {0} from plugin {1}.

MarkerDetails.CSDialogTitle=CodeScanner information

MarkerDetails.KBDialogTitle=Knowledge base information

MarkerDetails.ReferenceLabel=Reference >>

MarkerDetails.UnknownRuleMessage=Unknown error/warning.

RulesEdit.CategoryTitle=Category:

RulesEdit.SeverityTitle=Severity:

RulesTabPage.RulesTableMessage=CodeScanner rules

RulesTabPage.RulesTableRulesLabel=Rules

RulesTabPage.RulesTableCategoriesLabel=Categories

RulesTabPage.RulesTableSeveritiesLabel=Severities

RulesTabPage.EditForbiddenWordsLabel=Forbidden words :

RulesTabPage.EditIconsLabel=Icons:

RulesTabPage.EditLFunctionCantLeaveLabel=LFunction ignore :

RulesTabPage.EditLongLinesLabel=Long lines length :

RulesTabPage.EditMissingCClassLabel=C Class ignore :

RulesTabPage.EditOpenLabel=Open() ignore :

RulesTabPage.EditWorryingCommentsLabel=Worrying comments :

RulesTabPage.EditRuleLabel=Edit...

RulesTabPage.EditRuleMessage=Edit selected rule

RulesTabPage.EnableAllRulesLabel=Enable All

RulesTabPage.EnableAllRulesMessage=Enable all the rules

RulesTabPage.DisableAllRulesLabel=Disable All

RulesTabPage.DisableAllRulesMessage=Disable all the rules

RulesTabPage.DetailsLabel=Details:

CSRule.AccessArrayElementWithoutCheck=Whenever an element in an array is accessed using At(), the index should be checked to ensure that it is less than array.Count(). Accessing an invalid index can cause a panic.

CSRule.AccessArrayElementWithoutCheck2=Whenever an element in an array is accessed using [], the index should first be checked to ensure that it is within range. Accessing an invalid index can cause a panic.

CSRule.Activestart=Using CActiveScheduler::Start() can mean that something asynchronous is being made synchronous. Instead, use active objects correctly in an asynchronous way.

CSRule.Activestop=Using CActiveScheduler::Stop() can mean that something asynchronous is being made synchronous. Instead, use active objects correctly in an asynchronous way.

CSRule.Arraypassing=Passing arrays by value is inefficient, causing needless copies and takes up time and memory. Recommend using references instead.

CSRule.Arrayptrcleanup=It is not enough to push a local CArrayPtr class onto the cleanup stack. A TCleanupItem and callback function must be used to avoid leaking the elements.

CSRule.Assertdebuginvariant=Replace __ASSERT_DEBUG(<condition>, User::Invariant()) with ASSERT(<condition>), because it is easier to read.

CSRule.Baddefines=Badly-named definitions using only lowercase letters makes the code harder to maintain and can lead to defects.

CSRule.Baseconstruct=If a leaving method is called before BaseConstructL(), the system can panic as it is trying to clean up an application that has not been fully initialised.

CSRule.CallActiveObjectWithoutCheckingOrStopping=A panic occurs if an active object is started twice. In general, if starting a timer, IsActive() should be called to ensure that the timer is not already running.

CSRule.Changenotification=Using RSAVarChangeNotify to see System Agent changes

CSRule.Cleanup=CleanupStack::Pop() functions should be called with explicit variable parameters to avoid misalignment.

CSRule.Commentcode=Instances of commented out code make the code hard to maintain or interpret clearly, and should be removed.

CSRule.Connect=Ignoring the error value returned by the Connect() function means that an OOM failure or other problem will cause a panic the next time the function is accessed.

CSRule.ConnectAndDontCloseMemberVariable=Calling Connect() or Open() on a member variable without calling Close() in the destructor.

CSRule.Constnames=A badly-named constant will make the source code harder to maintain and make defects more likely.

CSRule.Consttdescptr=Using const descriptor pointer as an argument. For example: use 'const TDesC&' instead of 'const TDesC*'.

CSRule.Controlornull=You should always check the return value of ControlOrNull() for NULL before attempting to access it.

CSRule.Crepository=Independent application cannot assume that the Central Repository is set up fully. This means the return value of CRepository::get() cannot be ignored.

CSRule.Ctltargettype=The ctl targettype should not be used. Instead, use DLL and explicitly refer to the Control Panel\u2019s DEF file.

CSRule.Customizableicons=Due to device customization requirements, independent application must not remove any customization done by the variant team. This means customizable icons cannot be used.

CSRule.Debugrom=Debug versions of components in the ROM mean that ROM space is being taken up with debugging information or that logging is still being output. Only release versions should be in the ROM.

CSRule.Declarename=The __DECLARE_NAME macro is historical and serves no purpose anymore and should be removed.

CSRule.DeleteMemberVariable=The Member variable was deleted incorrectly by not assigning it to NULL or another value to prevent accidental access of the deleted object.

CSRule.Destructor=Destructor is accessing/dereferencing data member

CSRule.DoubleSemiColon=Double semicolons at the end of a line are not necessary and can cause a compiler error.

CSRule.Driveletters=Drive letters should not be hard-coded.

CSRule.Eikbuttons=R_EIK_BUTTONS_* resources will not be internationalised, and should not be used. Instead, create your own button resource.

CSRule.Eikonenvstatic=Keep all CEikonEnv::Static() calls to a minimum, because it involves TLS. All apps, controls, and dialogs already contain a pointer to the instance of CEikonEnv as a member variable. If a class does not have access to a CEikonEnv and needs one, it should store it.

CSRule.Enummembers=Badly-named enum members make the code harder to maintain and may cause defects.

CSRule.Enumnames=Badly-named enums make the code harder to maintain and may cause defects.

CSRule.Exportinline=Exporting inline functions can cause those that link to the DLL to fail to build. Exporting functions limits future changes due to considerations of binary-compatibility.

CSRule.Exportpurevirtual=The exporting of pure virtual functions is not recommended by Symbian.

CSRule.Flags=Independent application must not use R&D flags nor feature flags via preprocessor statements in the source code. This means bld*.hrh and productvariant.hrh should not be used.

CSRule.Foff=_FOFF allows access to data in classes that were not intended for public access. This may cause problems, especially when the location of the data changes.

CSRule.Forbiddenwords=Use of forbidden words in header files, especially those destined for external release. Some words may be forbidden for legal reasons or for platform consistency. Where they exist, alternative allowed words should be used.

CSRule.Forgottoputptroncleanupstack=A memory leak can occur if a variable is not put on the cleanup stack and a leaving function or ELeave is called.

CSRule.Friend=The friend directive is often misused and can indicate problems in the OO design.

CSRule.Goto=Goto should not be used if it can be avoided because it makes the program flow more difficult to follow.

CSRule.Ifassignments=An assignment was found within an If statement, if this was intentionally done separating the assignment from the conditional is still recommended. Also reported when an action statement is on the same line as a conditional check.

CSRule.Ifpreprocessor=\#if in header files should only be used before the main include guards and not around \#include statements or around functional blocks in class definitions.

CSRule.Inheritanceorder=If a C class inherits first from an M class and then a C class, a panic can occur when trying to pop a CBase pointer pointing to such a class from the cleanup stack when in fact a pointer pointing to the first predecessor, the mixin class, was popped instead.

CSRule.Intleaves=Functions that can leave and return a TInt error are problematical for the caller. Functions should do one or the other, but not both.

CSRule.Jmp=Using setjmp and/or longjmp makes code less maintainable.

CSRule.Leave=Leaving function called in non-leaving function.

CSRule.LeaveNoError=Leaving with KErrNone usually indicates a makeshift solution around a design issue rather than a true and proper fix to the architecture.

CSRule.Leavingoperators=Non-leaving functions should not call functions that can leave, like Operator functions.

CSRule.LFunctionCantLeave=A function should not be named with an 'L' if it cannot leave. The only exception is in virtual functions where the function name is defined in the base class so the L cannot be removed. For example, RunL().

CSRule.Longlines=Lines longer than about 100 characters can indicate messy or badly-structured code that is hard to maintain.

CSRule.Magicnumbers=Use of magic numbers, ie, hard-coded in the source, should be converted to named constants to make the code easier to read and maintain.

CSRule.Mclassdestructor=M classes should not contain a destructor.

CSRule.Memberlc=Objects on the cleanup stack (LC method) should not be assigned to member variables.

CSRule.Membervariablecallld=LD functions should not be called on a member variable because ownership can be unclear and may lead to double deletes.

CSRule.Missingcancel=Cancel() should always be called in active object's destructor to cancel an outstanding request if there is one. If there is no request pending then Cancel() just does nothing, but if we do not call Cancel() when having an outstanding request a panic will be raised.

CSRule.Missingcclass=All C classes should inherit from another C class to ensure that all data members are zeroed.

CSRule.Mmpsourcepath=Use of absolute paths in MMP files makes it impossible to relocate the source. Use relative paths instead.

CSRule.Multilangrsc=Using AddResourceFileL() without first using BaflUtils::NearestLanguageFile(), may cause not all language versions of resources to be picked up.

CSRule.Multipledeclarations=Multiple declarations on one line can be confusing. Separate each declaration out into its own separate line.

CSRule.Multipleinheritance=Multiple inheritance from non M-classes

CSRule.Mydocs=The 'mydocs' directory, whose location is subject to change, should not be referenced directly using hard-coded strings.

CSRule.Namespace=Namespaces are often used to work around a poor naming convention.

CSRule.Newlreferences=NewL() and NewLC() functions should return a pointer to an object created on the heap.

CSRule.Noleavetrap=TRAP contains no leaving functions.

CSRule.Nonconsthbufc=HBufC* parameters should almost always be passed as a const pointer.

CSRule.Nonconsttdesc=TDesC& parameters should be passed as a const. If it is not, it may indicate that the coder does not understand descriptors, for example, passing descriptors by value.

CSRule.Nonleavenew=Trapping the 'new(ELeave) CXxx' call is redundant and wasteful as the code to support TRAP is surprisingly large. If the instantiation process really needs not to leave, use 'new CXxx' and check for NULL.

CSRule.Nonunicodeskins=Skin definition files (SKN, SKE) must be in Unicode.

CSRule.Null=There is no need to compare pointer variables to NULL. Use If(ptr) instead.

CSRule.Open=Ignoring the return value from Open() functions (due to OOM, etc.) means that when next the resource is accessed, a panic will result.

CSRule.Pointertoarrays=In C classes, there is no need to use pointers to arrays as data members. Instead, use the arrays themselves to simplify notation, reduce indirection and heap fragmentation.

CSRule.Pragmadisable=Disabling \#pragma warnings can lead to problems because the warnings are probably there for a reason.

CSRule.Pragmamessage=Use of \#pragma messages and warnings during the build stage can interfere with the parsing of the build log.

CSRule.Pragmaother=Only use \#pragma directives on edge cases, like functions consisting of inline assembler without explicit return statements, as their usage can mask valid build warnings and error messages.

CSRule.Privateinheritance=Classes should not be inherited privately. If public or protected inheritance is not appropriate, consider using an amalgamation; that is, have an object of that type as a member variable.

CSRule.Pushaddrvar=If the variable is owned by the code pushing it, it should be stored as a pointer. If it is not owned, the variable address should not be pushed onto the cleanup stack.

CSRule.Pushmember=Data member pushed to cleanup stack can lead to double deletes or memory leakage. Even if no panic can result, it is bad practice and makes maintenance more difficult.

CSRule.Readresource=Using ReadResource() instead of ReadResourceL() can lead to an error scenario where ReadResource() effectively fails silently by buffer overflow.

CSRule.Resourcenotoncleanupstack=If a stack-based resource object is not put on the cleanup stack with CleanupResetAndDestroyPushL() or CleanupClosePushL(), and a leaving function or ELeave is called, a memory leak occurs.

CSRule.Resourcesonheap=There is rarely a real need to put Resource classes on the heap (unless they are not real Resource classes). Doing so can lead to inefficiency and cleanup stack problems.

CSRule.Returndescriptoroutofscope=Returning a TBuf descriptor that is declared locally takes it out of scope. This can cause a crash on WINSCW, although not on WINS.

CSRule.Rfs=Connecting to an RFs is a time-consuming operation (0.1 secs on some devices). Instead, when possible, use the already-connected one in EikonEnv or elsewhere.

CSRule.Rssnames=Resource files (RSS) with clashing NAME fields can cause the wrong resource file to be accessed and lead to incorrect functionality or panics.

CSRule.Stringliterals=_L() string literals should be replaced by the _LIT() macro.

CSRule.Stringsinresourcefiles=Strings should not be defined in RSS or RA files. Instead, they should be put in RLS or other localisable files.

CSRule.Struct=C-style structs should not generally be used. The correct idiom is to use a class with public members.

CSRule.Tcclasses=T classes derived from C classes may have a complex constructors and should to be handled differently. Recomment that you make the T class into a C class, which is easier to maintain.

CSRule.Tclassdestructor=T classes should not contain a destructor.

CSRule.Todocomments="To do" comments in code suggest that it is not finished.

CSRule.Trapcleanup=A TRAP was found leaving something on the cleanup stack. Doing this will cause a panic.

CSRule.Trapeleave=A TRAP is unnecessary if there are no leaving functions.

CSRule.Traprunl=The RunError() function should be used rather than the CActive derivative using its own TRAPD solution within a RunL().

CSRule.Trspassing=TRequestStatus parameters should always be passed by reference not by value. If TRequestStatus is just being used as an error code, then convert it to a TIntPassing.

CSRule.Uids=UIDs must be unique and not duplicated.

CSRule.Uncompressedaif=AIF files should be referenced as 'AIF=' rather than 'data=' or 'file=', otherwise they can bloat the ROM size and slow down application loading.

CSRule.Uncompressedbmp=Using uncompressed bitmaps can significantly bloat the size of ROM images. All occurrences of 'bitmap=' in iby/hby files should be replaced with 'auto-bitmap='. Also, avoid use of 'data=' or 'file=' for bitmaps.

CSRule.Unicodesource=Having Unicode source files (CPP, H, RLS, LOC, RSS, and RA) will break most build systems.

CSRule.Userafter=Generally, User::After() functions are used to skirt timing problems. Typically, they should be removed and the defects fixed properly, by waiting for the correct event to continue execution.

CSRule.Userfree=User::Free() should removed and replaced by explicit deletes, because all objects free their memory on deletion; their destructors are not called and further resources cannot be freed or closed.

CSRule.UserWaitForRequest=User::WaitForRequest() should not be used in UI code because the UI will not respond to redraw events while its thread is stopped.

CSRule.Variablenames=Local variable names should be of the form localVariable and not aLocalVar or iLocalVar. Badly-named variables can be misleading and cause maintenance and coding errors.

CSRule.Voidparameter=Declaring a void parameter is unnecessary. A function declared as DoSomething(void) may as well be declared as DoSomething(). Void casts are also unnecessary.

CSRule.Worryingcomments=The presence of exclamation and question marks in comments indicate something odd about the code or it's unfinished or not fully understood.