diff options
Diffstat (limited to 'debian/uncrustify-trinity/uncrustify-trinity-0.78.1/scripts/pclint')
8 files changed, 1089 insertions, 0 deletions
diff --git a/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/scripts/pclint/au-sm123.lnt b/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/scripts/pclint/au-sm123.lnt new file mode 100644 index 00000000..6eaf9a6b --- /dev/null +++ b/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/scripts/pclint/au-sm123.lnt @@ -0,0 +1,237 @@ +/* Date Stamp */ -d"_lint_au_sm123_lnt=au-sm123.lnt modified 5-Jan-2006" +/* To document usage use: -message( "Using " _lint_au_sm123_lnt ) */ +// --------------------------------------------------------------------- +// This file is provided by Gimpel Software (www.gimpel.com) for use with +// its products PC-lint and FlexeLint. +// +// Redistribution and use of this file, with or without modification, is +// permitted provided that any such redistribution retains this notice. +// --------------------------------------------------------------------- +// au-sm123.lnt -- Author options - Scott Meyers + +/* + This options file can be used to explicitly activate those + checks advocated in the publications: + + [12] Meyers, Scott, Effective C++, Addison-Wesley, Reading Mass., 1992 + [23] Meyers, Scott, More Effective C++, Addison-Wesley, 1996 + [30] Meyers, Scott, Effective C++ Third Edition, Addison-Wesley, 2005 + + You can use this file directly when linting your programs as in: + + lin au-sm123 files + + Most of the Scott Meyers checks are on by default. The + Elective Notes (19??), however, are not and so this file + is necessary to get the full impact of the Scott Meyers + multi-volume set of recommendations. + + Also, this file explicitly activates those Warnings and + Informationals advocated by Scott Meyers just in case they were + suppressed previously. For example, + + lin -w2 au-sm123 files + + has the effect of removing all Informational messages + other than those reactivated in this file. + + If you do not want code to adhere to all of the Scott Meyers' + checks we recommend that, rather than editing this file, you + include it within a file of your own. For example: let + my-sm.lnt contain + + au-sm123.lnt + -e1932 // allow concrete base classes + + In this way you inherit the checks specified in this file + except for the ones that you wish to specifically exclude. + + Then you can use my-sm.lnt in place of au-sm123.lnt + + You might consider placing this file (au-sm123.lnt) or your own + derivation of it (as shown above) in your global options + file. + + */ + ++e424 // Inappropriate deallocation -- [12, Item 5], [30, Item 16] +-append(424, -- Effective C++ #5 & Eff. C++ 3rd Ed. item 16) ++e530 // Symbol not initialized -- [30, Item 4] +-append( 530, --- Eff. C++ 3rd Ed. item 4 ) ++e603 // Symbol not initialized -- [30, Item 4] +-append( 603, --- Eff. C++ 3rd Ed. item 4 ) ++e605 // Increase in pointer capability -- [12, Item 29] +-append(605, -- Effective C++ #29 ) ++e644 // Variable may not have been initialized -- [30, Item 4] +-append( 644, --- Eff. C++ 3rd Ed. item 4 ) ++e645 // Symbol may not have been initialized -- [30, Item 4] +-append( 645, --- Eff. C++ 3rd Ed. item 4 ) ++e673 // Possibly inappropriate deallocation (Name1) for 'Name2' data. -- [30, Item 16] +-append( 673, --- Eff. C++ 3rd Ed. item 16 ) ++e727 // Symbol not explicitly initialized -- [30, Item 4] +-append( 727, --- Eff. C++ 3rd Ed. item 4 ) ++e728 // Symbol not explicitly initialized -- [30, Item 4] +-append( 728, --- Eff. C++ 3rd Ed. item 4 ) ++e729 // Symbol not explicitly initialized -- [30, Item 4] +-append( 729, --- Eff. C++ 3rd Ed. item 4 ) ++e738 // Symbol not explicitly initialized -- [30, Item 4] +-append( 738, --- Eff. C++ 3rd Ed. item 4 ) ++e771 // Symbol conceivably not initialized -- [30, Item 4] +-append( 771, --- Eff. C++ 3rd Ed. item 4 ) ++e772 // Symbol conceivably not initialized -- [30, Item 4] +-append( 772, --- Eff. C++ 3rd Ed. item 4 ) ++e794 // Conceivable use of null pointer -- [12, Item 7] +-append(794, -- Effective C++ #7 ) ++e802 // Conceivably passing a null pointer to function -- [12, Item 7] +-append(802, -- Effective C++ #7 ) ++e818 // Pointer parameter could be declared ptr to const -- [30, Item 3] +-append( 818, --- Eff. C++ 3rd Ed. item 3 ) ++e952 // Parameter could be declared const -- [30, Item 3] +-append( 952, --- Eff. C++ 3rd Ed. item 3 ) ++e953 // Variable could be declared as const -- [30, Item 3] +-append( 953, --- Eff. C++ 3rd Ed. item 3 ) ++e954 // Pointer variable could be declared as pointing to a const -- [30, Item 3] +-append( 954, --- Eff. C++ 3rd Ed. item 3 ) ++e1072 // Reference variable must be initialized -- [30, Item 4] +-append( 1072, --- Eff. C++ 3rd Ed. item 4 ) ++e1401 // member symbol not initialized by constructor -- [30, Item 4], [30, Item 13] +-append( 1401, --- Eff. C++ 3rd Ed. item 4 & Eff. C++ 3rd Ed. item 13) ++e1402 // member not initialized -- [30, Item 4] +-append( 1402, --- Eff. C++ 3rd Ed. item 4 ) ++e1403 // member not initialized -- [30, Item 4] +-append( 1403, --- Eff. C++ 3rd Ed. item 4 ) ++e1411 // Member with different signature hides virtual member -- [30, Item 33] +-append( 1411, --- Eff. C++ 3rd Ed. item 33 ) ++e1412 // Reference member is not initialized -- [30, Item 4] +-append( 1412, --- Eff. C++ 3rd Ed. item 4 ) ++e1413 // function is returning a temporary via a reference -- [30, Item 21] +-append( 1413, --- Eff. C++ 3rd Ed. item 21 ) ++e1506 // Call to virtual function within a constructor or destructor -- [30, Item 9] +-append( 1506, --- Eff. C++ 3rd Ed. item 9 ) ++e1509 // base class destructor for class is not virtual -- [12, Item 14], [30, Item 7] +-append(1509, -- Effective C++ #14 & Eff. C++ 3rd Ed. item 7) ++e1510 // base class has no destructor -- [12, Item 14] +-append(1510, -- Effective C++ #14 ) ++e1511 // Member hides non-virtual member -- [12, Item 37], [30, Item 33], [30, Item 36] +-append(1511, -- Effective C++ #37 & Eff. C++ 3rd Ed. item 33& Eff. C++ 3rd Ed. item 36) ++e1516 // Data member hides inherited member -- [30, Item 33] +-append( 1516, --- Eff. C++ 3rd Ed. item 33 ) ++e1529 // not first checking for assignment to this -- [12, Item 17], [30, Item 11] +-append(1529, -- Effective C++ #17 & Eff. C++ 3rd Ed. item 11) ++e1531 // Symbol should have compared argument against sizeof(class) -- [30, Item 51] +-append( 1531, --- Eff. C++ 3rd Ed. item 51 ) ++e1534 // static variable found within inline function -- [23, Item 26], [30, Item 30] +-append(1534, -- More Effective C++ #26 & Eff. C++ 3rd Ed. item 30) ++e1536 // Exposing low access member -- [12, Item 30] +-append(1536, -- Effective C++ #30 ) ++e1537 // const function returns pointer data member -- [12, Item 29 ], [30, Item 28] +-append(1537, -- Effective C++ #29 & Eff. C++ 3rd Ed. item 28) ++e1539 // member not assigned by assignment operator -- [12, Item 16], [30, Item 12] +-append(1539, -- Effective C++ #16 & Eff. C++ 3rd Ed. item 12) ++e1540 // pointer member freed nor zero'ed by destructor -- [12, Item 6] +-append(1540, -- Effective C++ #6 ) ++e1541 // member possibly not initialized by constructor -- [30, Item 4], [30, Item 13] +-append( 1541, --- Eff. C++ 3rd Ed. item 4 & Eff. C++ 3rd Ed. item 13) ++e1542 // member possibly not initialized -- [30, Item 4] +-append( 1542, --- Eff. C++ 3rd Ed. item 4 ) ++e1543 // member possibly not initialized -- [30, Item 4] +-append( 1543, --- Eff. C++ 3rd Ed. item 4 ) ++e1544 // value indeterminate (order of initialization) -- [12, Item 47] +-append(1544, -- Effective C++ #47 ) ++e1546 // throw() called within destuctor -- [23, Item 11], [30, Item 8] +-append(1546, -- Effective C++ #11 & Eff. C++ 3rd Ed. item 8) ++e1547 // Assignment of array to pointer to base -- [23, Item 3] +-append(1547, -- More Effective C++ #3 ) ++e1549 // Exception thrown for function not declared to throw -- [23, Item 11] +-append(1549, -- More Effective C++ #11 ) ++e1551 // function may throw an exception in destructor -- [23, Item 11], [30, Item 8] +-append(1551, -- More Effective C++ #11 & Eff. C++ 3rd Ed. item 8) ++e1557 // const member is not initialized -- [30, Item 4] +-append( 1557, --- Eff. C++ 3rd Ed. item 4 ) ++e1559 // Uncaught exception 'Name' may be thrown in destructor -- [30, Item 8] +-append( 1559, --- Eff. C++ 3rd Ed. item 8 ) ++e1722 // assignment operator does not return a reference -- [12, Item 15], [30, Item 10] +-append(1722, -- Effective C++ #15 & Eff. C++ 3rd Ed. item 10) ++e1724 // Argument to copy constructor for class should be a const reference -- [30, Item 3], [30, Item 20] +-append( 1724, --- Eff. C++ 3rd Ed. item 3 & Eff. C++ 3rd Ed. item 20) ++e1727 // inline not previously defined inline at -- [30, Item 30] +-append( 1727, --- Eff. C++ 3rd Ed. item 30 ) ++e1729 // Initializer inversion detected for member -- [12, Item 13] +-append(1729, -- Effective C++ #13 ) ++e1732 // new in constructor for class which has no assignment operator -- [12, Item 11] +-append(1732, -- Effective C++ #11 ) ++e1733 // new in constructor for class which has no copy constructor -- [12, Item 11] +-append(1733, -- Effective C++ #11 ) ++e1735 // Virtual function has default parameter -- [12, Item 38] +-append(1735, -- Effective C++ #38 ) ++e1737 // 'Symbol' hides global operator new -- [12, Item 9] +-append(1737, -- Effective C++ #9 ) ++e1739 // Binary operator should be non-member function -- [12, Item 19], [30, Item 24] +-append(1739, -- Effective C++ #19 & Eff. C++ 3rd Ed. item 24) ++e1740 // pointer member not directly freed or zero'ed by destructor -- [12, Item 6] +-append(1740, -- Effective C++ #6 ) ++e1741 // member conceivably not initialized by constructor -- [30, Item 4], [30, Item 13] +-append( 1741, --- Eff. C++ 3rd Ed. item 4 & Eff. C++ 3rd Ed. item 13) ++e1742 // member conceivably not initialized -- [30, Item 4] +-append( 1742, --- Eff. C++ 3rd Ed. item 4 ) ++e1743 // member conceivably not initialized -- [30, Item 4] +-append( 1743, --- Eff. C++ 3rd Ed. item 4 ) ++e1744 // member possibly not initialized by private constructor -- [30, Item 4] +-append( 1744, --- Eff. C++ 3rd Ed. item 4 ) ++e1745 // member not assigned by private assignment operator -- [12, Item 16], [30, Item 12] +-append(1745, -- Effective C++ #16 & Eff. C++ 3rd Ed. item 12) ++e1746 // parameter of function could be made const ref -- [12, Item 22], [30, Item 3], [30, Item 20] +-append(1746, -- Effective C++ #22 & Eff. C++ 3rd Ed. item 3& Eff. C++ 3rd Ed. item 20) ++e1747 // binary operator returning a reference -- [12, Item 23] +-append(1747, -- Effective C++ #23 ) ++e1749 // base class of class need not be virtual -- [23, Item 24] +-append(1749, -- More Effective C++ #24 ) ++e1752 // catch parameter Integer is not a reference -- [23, Item 13] +-append(1752, -- More Effective C++ #13 ) ++e1753 // Overloading special operator -- [23, Item 7] +-append(1753, -- More Effective C++ #7 ) ++e1754 // Expected 'Symbol' to be declared for class 'Symbol' -- [23, Item 22] +-append(1754, -- More Effective C++ #22 ) ++e1757 // Discarded instance of post decrement/increment -- [23, Item 6] +-append(1757, -- More Effective C++ #6 ) ++e1758 // Prefix increment/decrement operator returns a non-reference. -- [23, Item 6] +-append(1758, -- More Effective C++ #6 ) ++e1759 // Postfix increment/decrement operator returns a reference. -- [23, Item 6] +-append(1759, -- More Effective C++ #6 ) ++e1762 // Member function could be made const -- [30, Item 3] +-append( 1762, --- Eff. C++ 3rd Ed. item 3 ) ++e1764 // Reference parameter could be declared const reference -- [30, Item 3] +-append( 1764, --- Eff. C++ 3rd Ed. item 3 ) ++e1770 // function defined without function 'String' -- [30, Item 52] +-append( 1770, --- Eff. C++ 3rd Ed. item 52 ) ++e1772 // Assignment operator is not returning *this -- [30, Item 10] +-append( 1772, --- Eff. C++ 3rd Ed. item 10 ) ++e1904 // Old-style C comment -- [12, Item 4] +-append(1904, -- Effective C++ #4 ) ++e1921 // Symbol not checking argument against sizeof(class) -- [30, Item 51] +-append( 1921, --- Eff. C++ 3rd Ed. item 51 ) ++e1923 // macro could become const variable -- [12, Item 1], [30, Item 2] +-append(1923, -- Effective C++ #1 & Eff. C++ 3rd Ed. item 2) ++e1924 // C-style cast -- [23, Item 2] +-append(1924, -- More Effective C++ #2 ) ++e1925 // public data member -- [12, Item 20], [30, Item 22] +-append(1925, -- Effective C++ #20 & Eff. C++ 3rd Ed. item 22) ++e1926 // 'Symbol's default constructor implicitly called -- [12, Item 12] +-append(1926, -- Effective C++ #12 ) ++e1927 // 'Symbol' was not initialized in the constructor init list -- [12, Item 12] +-append(1927, -- Effective C++ #12 ) ++e1928 // 'Symbol' did not appear in the ctor initializer list -- [12, Item 12] +-append(1928, -- Effective C++ #12 ) ++e1929 // function returning a reference -- [12, Item 23], [30, Item 21] +-append(1929, -- Effective C++ #23 & Eff. C++ 3rd Ed. item 21) +-esym( 1929, operator<<, operator>> ) // but these op's are OK ++e1930 // Conversion operator found -- [23, Item 5] +-append(1930, -- More Effective C++ #5 ) ++e1931 // Constructor can be used for implicit conversions -- [23, Item 5] +-append(1931, -- More Effective C++ #5 ) ++e1932 // Base class is not abstract. -- [23, Item 33] +-append(1932, -- More Effective C++ #33 ) ++e1934 // flags member functions operator<< and operator>> +-append(1934, -- Effective C++ #19 ) ++e1961 // virtual member function could be made const -- [30, Item 3] +-append( 1961, --- Eff. C++ 3rd Ed. item 3 ) diff --git a/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/scripts/pclint/co-gcc.h b/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/scripts/pclint/co-gcc.h new file mode 100644 index 00000000..e948a20f --- /dev/null +++ b/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/scripts/pclint/co-gcc.h @@ -0,0 +1,35 @@ +#ifndef CO_GCC_H_ +#define CO_GCC_H_ + +#ifdef _lint /* Make sure no compiler comes this way */ + +/* + The headers included below must be generated; For C++, generate + with: + + g++ [usual build options] -E -dM t.cpp >lint_cppmac.h + + For C, generate with: + + gcc [usual build options] -E -dM t.c >lint_cmac.h + + ...where "t.cpp" and "t.c" are empty source files. + + It's important to use the same compiler options used when compiling + project code because they can affect the existence and precise + definitions of certain predefined macros. See the preamble to + co-gcc.lnt for details and a tutorial. + */ +#if defined(__cplusplus) +//# include "lint_cppmac.h" +#else +# include "lint_cmac.h" +#endif + + +/* If the macros given by the generated macro files must be adjusted + in order for Lint to cope, then you can do so here. */ + + +#endif /* _lint */ +#endif /* CO_GCC_H_ */ diff --git a/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/scripts/pclint/co-gcc.lnt b/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/scripts/pclint/co-gcc.lnt new file mode 100644 index 00000000..f7bd38dd --- /dev/null +++ b/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/scripts/pclint/co-gcc.lnt @@ -0,0 +1,188 @@ +/* co-gcc.lnt: This is the seed file for configuring Lint for use with + GCC versions 2.95.3 and later. + + Like all compiler options files this file is intended to be used + as follows: + + lint co-gcc.lnt source-files-to-be-linted + + Some of the information that co-gcc.lnt requires needs to be + furnished with the help of the gcc system itself. + + If any of these directions are unclear, you may gain a better insight + into what is happening by checking the file gcc-readme.txt + + For C, first create an empty file named empty.c and then + run the command (options are case sensitive): + + gcc -E -dM empty.c >lint_cmac.h + + This will capture macro definitions in a file that will be included + automatically at the beginning of each module by use of the -header + option within co-gcc.lnt. The macros may change as you change + compiler options so that ultimately you may want to incorporate + this step into a make facility. + + Next we need to determine the search directories. If you run + + gcc -c -v empty.c + + you will see among other things this coveted list. For example you + might get: + + ... + #include "..." search starts here + #include <...> search starts here + /usr/local/include + /usr/lib/gcc/i686-apple-darwin8/4.0.1/include + /usr/include + /System/Library/Frameworks + /Library/Frameworks + End of search list. + ... + + For each directory shown (there are five in the list above) prefix + the directory name by a "--i" and place it in a file whose name is, + say, include.lnt. You may then begin linting programs by using the + command + + lint co-gcc.lnt include.lnt source-files + + Note: it is conventional to place both .lnt files into a single .lnt + file called std.lnt + + For C++, run the command (options are again case sensitive): + + g++ -E -dM empty.c >lint_cppmac.h + + This will capture C++ macro definitions in a file that will be + included automatically at the beginning of each C++ module + at the request of co-gcc.lnt. + + Next we need to determine C++ search directories. If you run + + g++ -c -v empty.c + + As in the case of C you should prepend a --i onto each directory + displayed and place these options into a file such as include.lnt. + Again, there is nothing sacred about the name and if you intend to + do mixed C and C++ programming it will be necessary for you to use + a differently named file. The rest proceeds as before. + + Note, some options in this file (such as the size options, i.e. -sp4 + indicating that pointers are four bytes wide) may need to be changed. + See "System Dependent Options" below. +*/ + +-cgnu // Notifies FlexeLint that gcc is being used. + +// Begin: System Dependent Options +// ------------------------------- +-a#machine(i386) // #assert's machine(i386) (SVR4 facility). ++fdi // Use the directory of the including file +-si4 // size of int +-sp4 // size of pointer + +// ----------------------------- +// End: System Dependent Options + ++cpp(.cc,.c) // extensions for C++ that are commonly used in addition + // to the default extensions of .cpp and .cxx +-header(scripts/pclint/co-gcc.h) // Includes header generated by GCC. ++libh(co-gcc.h) // Marks that header as library code. + +// ========================================================= +// +rw and -d options to cope with GNU syntax: ++ppw(ident) // Tolerate #ident keyword definitions for SCCS/RCS ++ppw(warning) + +// GCC provides alternative spellings of certain keywords: +-rw_asgn(__inline,inline) +-rw_asgn(__inline__,inline) +-rw_asgn(__signed__,signed) +-rw_asgn( __volatile__, volatile ) +-rw_asgn( __volatile, volatile ) +++d__const=const // gconv.h uses __const rather than const +++dconst=const // ensure const expands to const. + +-rw_asgn( asm, _up_to_brackets ) +-rw_asgn( __asm, _up_to_brackets ) +-rw_asgn( __asm__, _up_to_brackets ) +// This re-definition of the various spellings of the asm keyword enables +// Lint to pass gracefully over expression-statements like: +// __asm __volatile ("fsqrt" : "=t" (__result) : "0" (__x)); + +++d__attribute__()= // ignore this keyword and following parenthetical +++d__attribute()= // variant spelling of "__attribute__" + +// "__extension__" is GCC's way of allowing the use of non-standard +// constructs in a strict Standard-conforming mode. We don't currently +// have explicit support for it, but we can use local suppressions. For +// example, we can use -e(160) so that we will not see any Errors about +// GNU statement-expressions wrapped in __extension__(). +++d"__extension__=/*lint -e(160) */" + +++d__builtin_va_list=void* // used by stdarg.h +++d__builtin_stdarg_start()=_to_semi // ditto +++d__builtin_va_end()=_to_semi // ditto +++d"__builtin_va_arg(a,b)=(*( (b *) ( ((a) += sizeof(b)) - sizeof(b) )))" +++d__null=0 ++rw(_to_semi) // needed for the two macros above. ++rw(__typeof__) // activate __typeof__ keyword +-d__typeof=__typeof__ // an alternative to using __typeof__ + ++rw( __restrict ) ++rw( __restrict__ ) +-rw(__except) // This MS reserved word is used as an identifier ++rw( __complex__, __real__, __imag__ ) // reserved words that can be ignored. +++d__builtin_strchr=(char*) // permits the inline definition ... +++d__builtin_strpbrk=(char*) // of these functions to be linted ... +++d__builtin_strrchr=(char*) // without drawing a complaint +++d__builtin_strstr=(char*) // about the use of a non-standard name +++d__PRETTY_FUNCTION__=___function___ // lint defines ___function___ internally +++d__FUNCTION__=___function___ // lint defines ___function___ internally + + +// ========================================================= +// Other options supporting GNU C/C++ syntax: ++fld // enables the processing of _L_abel _D_esignators E.g.: + // union { double d; int i; } u = { d: 3.141 }; + +// +fwc // wchar_t might be builtin; if so, uncomment + // this option. + +// ========================================================= +// Generally useful suppressions: +-wlib(1) // sets the warning level within library headers to 1 + // (no warnings, just syntax errors). Comment out if you + // are actually linting library headers. +-elib(123) // 123 is really a warning, but it's in the "Error" range. +-elib(93) // allow newlines within quoted string arguments to macros +-elibsym(628) // Suppress 628 for __builtin symbols. + +-esym(528,__huge_val,__nan,__qnan,__qnanf,__snan,__snanf) + // We don't care if we don't reference some GNU functions +-esym(528,__gnu_malloc,__gnu_calloc) + +// The following functions exhibit variable return modes. +// That is, they may equally-usefully be called for a value +// as called just for their effects. Accordingly we inhibit +// Warning 534 for these functions. +// Feel free to add to or subtract from this list. + +-esym(534,close,creat,fclose,fprintf,fputc, nanosleep, time) +-esym(534,fputs,fscanf,fseek,fwrite,lseek,memcpy,memmove,memset) +-esym(534,printf,puts,scanf,sprintf,sscanf,strcat,strcpy) +-esym(534,strncat,strncpy,unlink,write, snprintf, dprintf) + +// For non-ANSI compilers we suppress messages 515 and 516 +// for functions known to have variable argument lists. +// For ANSI compilers, header files should take care of this. + +-esym(515,fprintf,printf,sprintf,fscanf,scanf,sscanf) +-esym(516,fprintf,printf,sprintf,fscanf,scanf,sscanf) +-esym(1702,*operator<<,*operator>>) +-esym(534,*operator<<,*operator>>) +-esym(1055,*__builtin*) +-esym(718,*__builtin*) // The compiler does not need these ... +-esym(746,*__builtin*) // declared and it knows their prototypes. diff --git a/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/scripts/pclint/lint_cfg.lnt b/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/scripts/pclint/lint_cfg.lnt new file mode 100644 index 00000000..72530d53 --- /dev/null +++ b/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/scripts/pclint/lint_cfg.lnt @@ -0,0 +1,55 @@ +// These settings are used to adjust the pcLint checking for +// the operating unit source code + +// show pclint where to find Header files +-i".\include" +-i".\lib" +-i".\src" + +-iC:\mingw\include +-iC:\mingw\lib\gcc\mingw32\4.8.1\include\ +-iC:\mingw\lib\gcc\mingw32\4.8.1\include\-fixed +-iC:\mingw\lib\gcc\mingw32\4.8.1\include\c++\ +-iC:\mingw\lib\gcc\mingw32\4.8.1\include\c++\mingw32 +//+libdir(D:\Programme\linaro\gcc-linaro-arm-linux-gnueabihf-4.9-2014.08\*) // define a directory as holding only headers, may be used with * or ? +//+libdir(D:\Programme\linaro\gcc-linaro-arm-linux-gnueabihf-4.9-2014.08\libc\usr\include\*) + +//+libclass(ansi) // use this if only ANSI headers are seen as unchecked libraries ++libclass(foreign) // ignore all headers comeing from a foreign directory using -i or the INCLUDE environment variable +//+libclass(angle) // ingore all headers specified with angle brackets +//+libclass(all) // ignore all header files ++libh(co-ggc.lnt) // ignore this file +//+libdir(uncrustify/scripts/*) +//-wlib(1) + +// Compiler specific configuration for Visual DSP + +// co-tiger.lnt use this file for tiger sharc as reference +scripts\pclint\co-gcc.lnt // Compiler Options for GCC + +// Configuration for checking the operating unit source code + +//-d__ARM_PCS_VFP +-d__cplusplus +-d_GNU_SOURCE +//-d__GNUC__ +-d__STDC__ +//-d__GLIBCXX__=20130531 +//-d__SIZE_TYPE__=int +//-d__PTRDIFF_TYPE__=int +//-d__CHAR_BIT__=8 +-dWIN32 +-d__i386__ +-dDEFINE_CHAR_TABLE +-dDEFINE_PCF_NAMES + +// define compiler specific keywords + +//+rw(__inline) // activate the __inline keyword +//+ppw(import) // activate #import +//-d"_exit=_up_to_brackets" +//-d"extern 'C'=gobble" +//+fkp // complain about non-KR extensions + +// To print a stack usage report pclint has to know how much space is required by some functions +// define an upper limit of stack space usage for recursion and function pointers diff --git a/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/scripts/pclint/pclint_cfg_eclipse.lnt b/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/scripts/pclint/pclint_cfg_eclipse.lnt new file mode 100644 index 00000000..d1945c5b --- /dev/null +++ b/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/scripts/pclint/pclint_cfg_eclipse.lnt @@ -0,0 +1,58 @@ +// These are generale configuration options used for pcLint +// throughout all kind of projects. +// This was adjusted to nuinno policy. +// See manual (chapter LIVING WITH LINT) for further details. +// +// Project specific settings shall be included from a separate file +// at the end of this file + +//-i"%PCLINT_HOME%" // add pclint home directory to include path + +//-p // only run preprocessor (use this for debugging pclint test) +//+source // print source code (use this for debugging pclint test) +-v // be not verbose (standard setting for normal operation) +//-voif // show the options that pclint uses (only for debugging pclint) +//+v // be verbose (use this for debugging pclint test) +//-v* // be more verbose (use this for debugging pclint) +//-vf // print included files (useful for debugging pclint test) +-summary // prints a summary of all pclint results (useful for debugging pclint test) +//-format_summary=. +//-format_template= +//-format_verbosity=. + ++fan // allow anonymous unions +++fim // use multiple include directories ++fus // automatically recognize std namespace ++fbo // activate keyword bool, true, false +-fkp // allow ANSI/ISO standard do not insist on Kernighan Richy style +-fdh // do not append a .h to header names +-ffb // do not establish a separate scope for declares within for clauses ++fsv // track static variables ++fll // enable long long types ++fqb // expect const and volatile before type ++e900 // print total number of errors/warnings + +-d__USE_GNU=1 +scripts\pclint\lint_cfg.lnt // include project specific settings +scripts\pclint\policy.lnt // pclint rules from nuinno + +-esym(123,min,max) // allows users to use min, max as variables + +// Disable unwanted warnings +//-strong(AB,bool) +//-strong(AB,boolean) +//-strong(AJX) // all typedef must match exactly + +// create output that is understood from Jenkins ++ffn // force full path names +-width(0) // don't insert line breaks (unlimited output width). +-hF1 // set message height one ++program_info(output_prefix = "tests\pclint\pclint_") + +// make error format same as GCC to display it in Eclipse +-"format=%(%f:%l:%C:%) %t %n: %m" +-frl // Enable warning 831 ++flm // make sure no foreign includes change the format +// env-xml.lnt // create output in xml format +// -"format_stack=%-20f %5a %-20t %5n %c %e" +// +stack( &file=test\pclint\pclint-stack-report.txt ) diff --git a/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/scripts/pclint/policy.lnt b/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/scripts/pclint/policy.lnt new file mode 100644 index 00000000..911e74b7 --- /dev/null +++ b/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/scripts/pclint/policy.lnt @@ -0,0 +1,396 @@ +// uncrustify policy +-passes(2) // number of analysis passes (higher values give better detection but slower) +-static_depth(2) // number of analyzed redirection for static variables +//-w2 // suppress informational messages +// -strong(AJX) // All typedefs must match exactly +-w3 // display informational messages +//-w4 // use the maximum warning level +//+fpn // warns about the use of pointer parameters without first checking for NULL +//+fsc // assumes string constants are const char* + +// all checks from 0 to 599 are enabled by +w2 +-e10 // Expecting identifier or other declarator +-e18 // symbol redefined +-e19 // useless declaration +-e14 // symbol previously defined +-e26 // expected an expression found const/return +-e30 // expected an integer constant +-e31 // redefinition of symbol +-e32 // field size should not be zero +-e36 // redefining the storage class of symbol +-e40 // undeclared identifier +-e46 // field type should be an integral or enumeration type +-e48 // bad type +-e49 // expected a typed +-e50 // attempted to take the address of a non-lvalue +-e52 // expected an lvalue +-e55 // bad type +-e56 // bad type +-e63 // expected an lvalue +-e64 // type mismatch +-e78 // typedef'd symbol used in expression +-e85 // array has dimension 0 +-e96 // unmatched left brace for linkage specification +-e114 // inconsistent +-e119 // too many arguments +-e123 // macro defined with arguments +-e129 // declaration expected +-e200 // internal error +-e438 // last value assignd to variable not used +-e451 // header without include guard +-e457 // enable for checking multithreading +-e458 // enable for checking multithreading +-e459 // enable for checking multithreading +-e506 // allow constant value booleans +-e514 // unusual use of boolean expression +-e516 // symbol has arg type conflict +-e520 // highest operation lacks side effects +-e522 // highest operation lacks side effects +-e526 // symbol not defined +-e528 // symbol not referenced +-e534 // ignoring return value of function +-e537 // do not warn about repeated inclusion +-e574 // signed / unsigned mix with relational +-e578 // Declaration of symbol hides symbol +-e585 // not a valid Trigraph sequence + ++e601 // Expected a type for symbol Symbol ++e602 // Comment within comment ++e603 // Symbol not initialized ++e604 // Returning address of auto variable ++e605 // Increase in pointer capability ++e606 // Non-ANSI escape sequence: ++e607 // Parameter of macro found within string ++e608 // Assigning to an array parameter ++e609 // Suspicious pointer conversion ++e610 // Suspicious pointer combination ++e611 // Suspicious cast ++e612 // Expected a declarator +-e613 // Possible use of null pointer ++e614 // auto aggregate initializer not constant ++e615 // auto aggregate initializer has side effects ++e616 // control flows into case/default ++e617 // String is both a module and an include file ++e618 // Storage class specified after a type ++e619 // Loss of precision (Context) (Pointer to Pointer) ++e620 // Suspicious constant (small L or one?) ++e621 // Identifier clash ++e622 // Size of argument no. Integer inconsistent with format ++e623 // redefining the storage class of symbol ++e624 // typedef redeclared ++e625 // auto symbol has unusual type modifier ++e626 // Integer inconsistent with format ++e627 // indirect object inconsistent with format +-e628 // no argument information provided for function ++e629 // static class for function is non standard ++e630 // ambiguous reference to symbol ++e631 // tag 'Symbol' defined differently at Location ++e632 // Assignment to strong type ++e633 // Assignment from a strong type ++e634 // Strong type mismatch in equality or conditional ++e635 // resetting strong parent of type ++e636 // ptr to strong type versus another type ++e637 // Expected index type for strong type ++e638 // Strong type mismatch for type in relational ++e639 // Strong type mismatch for type in binary operation ++e640 // Expected strong type 'Name' in Boolean context +-e641 // Converting enum to int ++e642 // Format char 'Char' not supported by wsprintf ++e643 // Loss of precision in pointer cast ++e644 // Variable may not have been initialized ++e645 // Symbol may not have been initialized ++e646 // case/default within Kind loop; may have been misplaced ++e647 // Suspicious truncation ++e648 // Overflow in computing constant for operation: ++e649 // Sign fill during constant shift ++e650 // Constant out of range for operator ++e651 // Potentially confusing initializer +-e652 // #define of symbol 'Symbol' declared previously ++e653 // Possible loss of fraction ++e654 // Option String obsolete; use -width(W,I) +-e655 // bit-wise operation uses (compatible) enum's ++e656 // Arithmetic operation uses (compatible) enum's ++e657 // Unusual (nonportable) anonymous struct or union ++e658 // Anonymous union assumed ++e659 // Nothing follows '}' ++e660 // Option requests removing an extent that is not on the list ++e661 // possible access of out-of-bounds pointer ++e662 // possible creation of out-of-bounds pointer ++e663 // Suspicious array to pointer conversion ++e664 // Left side of logical OR (||) or logical AND (&&) does not return ++e665 // Unparenthesized parameter Integer in macro is passed an expression ++e666 // Expression with side effects passed to repeated parameter ++e667 // Inconsistent use of qualifiers for symbol ++e668 // Possibly passing a null pointer to function ++e669 // Possible data overrun for function ++e670 // Possible access beyond array for function ++e671 // Possibly passing to function a negative value ++e672 // Possible memory leak in assignment to pointer ++e673 // Possibly inappropriate deallocation ++e674 // Returning address of auto through variable ++e675 // No prior semantics associated with symbol ++e676 // Possibly negative subscript ++e677 // sizeof used within preprocessor statement ++e678 // Member field length (Integer) too small for enum precision ++e679 // Suspicious Truncation in arithmetic expression combining with pointer ++e680 // Suspicious Truncation in arithmetic expression converted to pointer ++e681 // Loop is not entered ++e682 // sizeof applied to a parameter whose type is a sized array ++e683 // function 'Symbol' #define'd ++e684 // Passing address of auto variable into caller space ++e685 // Relational operator always evaluates to same result ++e686 // Option is suspicious ++e687 // Suspicious use of comma operator ++e688 // Cast used within preprocessor conditional statement ++e689 // Apparent end of comment ignored ++e690 // Possible access of pointer pointing Integer bytes past null character by operator ++e691 // Suspicious use of backslash ++e692 // Decimal character follows octal escape sequence ++e693 // Hexadecimal digit immediately after is suspicious in string literal. ++e694 // The type of constant (precision Integer) is dialect dependent ++e695 // Inline function defined without a storage-class specifier ('static' recommended) ++e696 // Variable has value that is out of range for operator ++e697 // Quasi-boolean values should be equality-compared only with 0 ++e698 // Casual use of realloc can create a memory leak + ++e701 // Shift left of signed int variable +-e702 // Shift right of signed int variable ++e703 // Shift left of signed long variable ++e704 // Shift right of signed long variable ++e705 // Integer nominally inconsistent with format ++e706 // indirect object inconsistent with format ++e707 // Mixing narrow and wide string literals in concatenation ++e708 // union initialization +-e712 // Loss of precision +-e713 // Loss of precision +-e714 // external variable not referenced +-e715 // Symbol not referenced +-e716 // while(1) found, allow endless loops +-e717 // do ... while(0) found ++e718 // Symbol undeclared, assumed to return int ++e719 // Too many arguments for format ++e720 // Boolean test of assignment ++e721 // Suspicious use of ; ++e722 // Suspicious use of ; ++e723 // Suspicious use of = -- A preprocessor definition began with an = sign. ++e725 // Expected positive indentation from Location +-e726 // Extraneous comma ignored ++e727 // local static variable not explicitly initialized ++e728 // global static variable not explicitly initialized ++e729 // exteral variable not explicitly initialized +-e730 // Boolean argument to function +-e731 // Boolean argument to equal/not equal +-e732 // Loss of sign ++e733 // Assigning address of auto variable to outer scope symbol ++e734 // Loss of precision int ++e735 // Loss of precision double ++e736 // Loss of precision float +-e737 // Loss of sign in promotion from Type1 to Type2 ++e738 // Symbol not explicitly initialized ++e739 // Trigraph Sequence in literal (Quiet Change) ++e740 // Unusual pointer cast (incompatible indirect types) ++e741 // Unusual pointer cast (function qualification) ++e742 // Multiple character constant ++e743 // Negative character constant ++e744 // switch statement has no default ++e745 // function has no explicit type or class, int assumed ++e746 // call to function not made in the presence of a prototype +-e747 // (noisy when using bool) Significant prototype coercion Type1 to Type2 ++e748 // Symbol is a register variable used with setjmp +-e749 // check for unused enum values +-e750 // ignore unused local macros +-e751 // check for unused local typedefs +-e752 // check for unused local declarations +-e753 // check for unused local struct, union or enum tag +-e754 // check for unused local structure member +-e755 // ignore unused global macros +-e756 // check for unused global typedefs +-e757 // check for unused global declarations +-e758 // check for unused global struct, union or enum tag +-e759 // check if symbol can be moved from header to module ++e760 // check for redundant macros +-e761 // check for redundant typedefs ++e762 // check for redundantly declared symbol ++e763 // check for redundant declaration for symbol ++e764 // check for switch statement without a case +-e765 // check for external symbols that could be made static ++e766 // check for unused headers ++e767 // check for differing macros +-e768 // check for global struct member that is never referenced +-e769 // check for global enumeration constant that is never referenced ++e770 // tag is defined identically at several locations ++e771 // check for uninitialized symbols ++e772 // check for uninitialized symbols ++e773 // Expression-like macro not parenthesized +-e774 // Boolean within 'String' always evaluates to [True/False] ++e775 // non-negative quantity cannot be less than zero ++e776 // Possible truncation of addition ++e777 // Testing float's for equality +-e778 // Constant expression evaluates to 0 ++e779 // String constant in comparison operator ++e780 // Vacuous array element ++e782 // Line exceeds Integer characters ++e783 // Line does not end with new-line ++e784 // Nul character truncated from string ++e785 // Too few initializers for aggregate ++e786 // String concatenation within initializer ++e787 // enum constant should not be used within switch +-e788 // enum constant not used within defaulted switch ++e789 // Assigning address of auto variable to static ++e790 // Suspicious truncation, integral to float ++e791 // unusual option sequence ++e792 // void cast of void expression ++e793 // ANSI/ISO limit of String 'Name' exceeded ++e794 // Conceivable use of null pointer ++e795 // Conceivable division by 0 ++e796 // Conceivable access of out-of-bounds pointer ++e797 // Conceivable creation of out-of-bounds pointer ++e798 // Redundant character ++e799 // numerical constant 'Integer' larger than unsigned long + +-e801 // Use of goto is deprecated ++e802 // Conceivably passing a null pointer to function ++e803 // Conceivable data overrun for function ++e804 // Conceivable access beyond array for function ++e805 // Expected L"..." to initialize wide char string ++e806 // Small bit field is signed rather than unsigned ++e807 // Conceivably passing to function a negative value ++e808 // No explicit type given to symbol ++e809 // Possible return of address of auto through variable ++e810 // Arithmetic modification of custodial variable ++e811 // Possible deallocation of pointer alias ++e812 // static variable 'Symbol' has size 'Integer' ++e813 // auto variable 'Symbol' in function 'Symbol' has size 'Integer' ++e814 // useless declaration ++e815 // Arithmetic modification of unsaved pointer ++e816 // Non-ANSI format specification ++e817 // Conceivably negative subscript +-e818 // Pointer parameter could be declared ptr to const ++e820 // Boolean test of a parenthesized assignment ++e821 // Right hand side of assignment not parenthesized ++e825 // control flows into case/default without -fallthrough comment ++e826 // Suspicious pointer-to-pointer conversion ++e827 // Loop not reachable ++e828 // redefinition of functions ++e829 // dangerous header was used ++e830 // print error location indicator ++e831 // print error location indicator ++e832 // Parameter 'Symbol' not explicitly declared ++e833 // Symbol is typed differently in another module +-e834 // missing parentheses between operators +-e835 // A zero has been given as [left/right] argument to operator ++e836 // Conceivable access of pointer pointing Integer bytes past nul ++e838 // Previously assigned value to variable has not been used ++e839 // Storage class of symbol 'Symbol' assumed static ++e840 // Use of null character in a string literal +-e843 // Variable 'Symbol' (Location) could be declared as const ++e844 // Pointer variable could be declared as pointing to const +-e845 // The [left/right] argument to operator is certain to be 0 ++e846 // Signedness of bit-field is implementation defined ++e847 // Thread has unprotected call to thread unsafe function ++e849 // Two enumerators have the same value +-e850 // loop index variable is modified in body of the for loop +-e864 // Expression possibly depends on order of evaluation ++e866 // Unusual use of 'String' in argument to sizeof + ++e900 // print total number of errors/warnings +-e904 // Return statement before end of function 'Symbol' ++e905 // Non-literal format specifier used (with arguments) +-e909 // Implicit conversion from Type to bool +-e910 // Implicit conversion (Context) from 0 to pointer +-e911 // (noisy) Implicit expression promotion from Type to Type +-e912 // (noisy) Implicit binary conversion from Type1 to Type2 ++e913 // Implicit adjustment of expected argument type from Type1 to Type2 ++e914 // Implicit adjustment of function return value from Type1 to Type2 +-e915 // (noisy) Implicit conversion (Context) Type1 to Type2 +-e916 // Implicit pointer assignment conversion +-e917 // (noisy) Prototype coercion Type1 to Type2 +-e918 // Prototype coercion (Context) of pointers +-e919 // (noisy) Implicit conversion (Context) Type to Type +-e920 // Cast from Type to void +-e931 // Both sides have side effects ++e932 // Passing near pointer to library function 'Symbol' ++e933 // Passing near pointer to far function (Context) ++e934 // taking address of near auto variable 'Symbol' +-e935 // (noisy) int within struct ++e936 // type is missing for function arguments ++e937 // type is missing for function arguments ++e939 // return type is missing for function ++e940 // omitted braces within an initialize ++e943 // Too few initializers for aggregate ++e945 // Undefined struct used with extern +-e946 // Relational or subtract operator applied to pointers ++e947 // Subtract operator applied to pointers +-e950 // Non-ISO/ANSI reserved word or construct: ++e951 // Pointer to incomplete type employed in operation +-e952 // Parameter could be declared const +-e953 // Variable could be declared as const +-e954 // Pointer variable could be declared as pointing to a const ++e955 // Parameter name missing from prototype for function +-e956 // (use for multithreaded SW) Non const, non volatile static or external variable ++e957 // Function defined without a prototype in scope +-e958 // (can help to save some bytes of memory) Padding of Integer byte(s) is required to align string on Integer byte boundary ++e962 // Macro defined identically at another location ++e963 // expect modifier (const, volatile) before type +-e964 // Header file not directly used in module +-e966 // Indirectly included header file 'FileName' not used in module ++e967 // Header file 'FileName' does not have a standard include guard +-e970 // (noisy) Use of modifier or type outside of a typedef +-e971 // (noisy) Use of 'char' without 'signed' or 'unsigned' ++e974 // print Worst case function for stack usage: +-e1013 // symbol is not a member of class +-e1015 // symbol not found in class +-e1025 // no function or template matches invocation +-e1039 // symbol is not a member of class +-e1040 // symbol is not a legal declaration within class +-e1042 // a least one class like operand is required with operator +-e1048 // expected a constant expression +-e1051 // symbol is both a function and a variable +-e1052 // a type was expected, class assumed +-e1054 // template variable declaration expects a type +-e1055 // symbol undeclared, assumed to return int +-e1057 // member cannot be used without an object +-e1058 // initializing a non-const reference +-e1065 // symbol not declared as "C" +-e1062 // template must be either a class or a function +-e1066 // symbol declared as "C" +-e1075 // Ambiguous reference to symbol +-e1077 // could not evaluate default template parameter +-e1086 // do not warn about compount literals +-e1087 // previous declaration is incompatible +-e1401 // member not initialized by constructor +-e1502 // object has no nonstatic data member +-e1526 // Member function not defined +-e1529 // symbol not first checking for assignment to this +-e1536 // exposing low access member +-e1540 // pointer member neither freed nor zeroed by destructor +-e1551 // function may throw exception in destructor +-e1554 // direct pointer copy of member within copy constructor +-e1561 // reference initialization causes loss of const/volatile +-e1566 // member might have been initialized by a separate function +-e1702 // operator is both an ordinary function and a member function +-e1704 // constructor has private access specification +-e1711 // function needs not to be virtual +-e1712 // default constructor not defined for class +-e1714 // Member function not referenced +-e1725 // class member is a reference +-e1732 // constructor for class has no assignment operator +-e1733 // constructor for class has no copy constructor +-e1736 // redundant access specifier +-e1740 // pointer member not directly freed or zeroed by destructor +-e1746 // parameter could be made const reference +-e1757 // discarded instance of post decrement/increment +-e1762 // member could be made const +-e1764 // reference parameter could be declared const +-e1776 // converting a string literal to char* +-e1786 // implicit conversion to bool +-e1788 // variable is referenced only by its constructor or destructor +-e1795 // Template was defined but not instantiated +-e1904 // allow old style comments +-e1923 // ignore defines that could be const variables +-e1924 // C-style cast + +//scripts/pclint/au-sm123.lnt // also check Scott Meyers rules of all three books +//scripts/pclint/au-misra3.lnt // Misra 2012 rules +//scripts/pclint/au-barr10.lnt // Top 10 Bug-Killing Rules +//scripts/pclint/au-ds.lnt // Dan Saks diff --git a/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/scripts/pclint/run-pclint-eclipse.bat b/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/scripts/pclint/run-pclint-eclipse.bat new file mode 100644 index 00000000..051813d6 --- /dev/null +++ b/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/scripts/pclint/run-pclint-eclipse.bat @@ -0,0 +1,104 @@ +rem set to on for debugging +@echo off +setlocal + +rem Run this script from the project root directory + +echo ------------------------------------------------------ +echo Start pcLint analysis to check code quality ... + +set SRC_DIR=src +set EXC_DIR=lnt +set OUT_DIR=tests\pclint +set LNT_DIR=scripts\pclint + +rem Check if pcLint program is available +set prog=lint-nt.exe +for %%i in ("%path:;=";"%") do ( +rem echo %%~i + if exist %%~i\%prog% ( + set found=%%i + echo found %prog% in %%i + ) +) +if %found%=="" goto PROG_MISSING + +if NOT EXIST tests md tests +if NOT EXIST tests\pclint md tests\pclint + +rem create list of all C source files to analyze +rem FIXME: works only if there are no spaces in the paths + +dir /s/b %EXC_DIR%\*.lnt > .\%OUT_DIR%\exceptions.lnt + +rem to check single files activate one of the lines below +rem dir /s/b %SRC_DIR%\align_stack.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\align.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\args.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\backup.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\brace_cleanup.cpp> .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\braces.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\chunk.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\ChunkStack.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\combine.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\compat_posix.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\compat_win32.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\defines.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\detect.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\indent.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\keywords.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\lang_pawn.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\logger.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\logmask.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\md5.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\newlines.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\options_for_QT.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\options.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\output.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\parens.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\parse_frame.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\punctuators.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\semicolons.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\sorting.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\space.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\tokenize_cleanup.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\tokenize.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\unc_text.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\unc_tools.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\uncrustify_emscripten.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\uncrustify.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\unicode.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\universalindentgui.cpp > .\%OUT_DIR%\files.lnt +rem dir /s/b %SRC_DIR%\width.cpp > .\%OUT_DIR%\files.lnt + +rem to check all source files use the line below +dir /s/b %SRC_DIR%\*.cpp > .\%OUT_DIR%\files.lnt + +rem use this to save the pclint errors to a file for later review +rem lint-nt .\%LNT_DIR%\pclint_cfg_eclipse.lnt .\%OUT_DIR%\exceptions.lnt .\%OUT_DIR%\files.lnt > .\%OUT_DIR%\pclint-results.xml + +rem to make eclipse parse the pclint errors it has to be output to the console +lint-nt .\%LNT_DIR%\pclint_cfg_eclipse.lnt .\%OUT_DIR%\exceptions.lnt .\%OUT_DIR%\files.lnt + +rem type %OUT_DIR%\pclint-results.xml | more +rem type %OUT_DIR%\pclint-results.xml +rem echo pcLint output placed in %OUT_DIR%\pclint-results.xml + +goto END + +:PROG_MISSING +echo. +echo ------------------------------------------------------ +echo pcLint Error: %prog% not found. +echo Verify that PCLINT is correctly installed, the +echo installation was added to the PATH and the +echo environment variable PCLINT_HOME was set to its path. +echo ------------------------------------------------------ +echo. +goto END + +:END +echo pcLint finished +echo ------------------------------------------------------ +endlocal + diff --git a/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/scripts/pclint/usage.txt b/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/scripts/pclint/usage.txt new file mode 100644 index 00000000..fff1c305 --- /dev/null +++ b/debian/uncrustify-trinity/uncrustify-trinity-0.78.1/scripts/pclint/usage.txt @@ -0,0 +1,16 @@ +"pclint" is a static source code checker. +It helps detecting programming errors during development. + +To run the check you need a license for pclint. The results can either be saved to a text file or be displayed on top of the source code when using Eclipse. +The present configuration is ment for Windows using Mingw as toolchain. To run the check with another toolchain the paths in run-pclint-eclipse.bat need to be change. To run the check under Linux another tool called "flexelint" is required. + +Run the check from the top level directory of uncrustify by calling +run-pclint-eclipse.bat + +To run the check from Eclipse create a new target and use the script +as build command like that: +${workspace_loc:/uncrustify}/scripts/pclint/run-pclint-eclipse.bat + +The file policy.lnt determines which tests are performed. +The more tests are used the longer it takes but the more +precise will be the results.
\ No newline at end of file |