[Clang-tidy] readability check to convert numerical constants to std::numeric_limits

[IdrissRio]

Summary

Hello, i want to propose this check suggested by @EugeneZelenko.
I have found it in the beginner tag of llvm-bugzilla repository.

This check looks for numerical unsigned constants that are equal to -1 or ~0
and substitutes them with std::numeric_limits<type>::max().

It includes the library <limits> if is not found.

Example:

unsigned const int x = -1;

becomes

unsigned const int x = std::numeric_limits<unsigned int>::max();

If the library <limits> is not include in the TU the check will add it with this criteria:

• If a #include is found it will add #include <limits> before this include.
• if no #include directive is found it will add it at the begin of the TU.

[lebedev.ri]

The check itself isn't in the diff.

[IdrissRio]

Sorry i have forgot to add the source code.

[JonasToth]

Hi IdrissRio,

thanks for working on this! I have one question: Why are variables _not_ considered in the check but only constants? IMHO it would make sense to transform these as well.

I dont have time for long review today anymore, I will continue tomorrow.

clang-tidy/readability/NumericalCostantsToMaxIntCheck.cpp

22

Unfortunatly this is duplicated effort.
Please take a look at cppcoreguidelines/ProBoundsConstantArrayIndexCheck.cpp and
utils/IncludeInserter.{h,cpp} to add new includes from clang-tidy

90

Is failure here expected? The matcher should match both nodes simultanously, if so please use an assert instead to detect unexpected failures

docs/clang-tidy/checks/readability-numerical-costants-to-max-int.rst

16

please indent that code, otherwise its is rendered incorrect

[Eugene.Zelenko]

I think modernize is better module for this check.

clang-tidy/readability/NumericalCostantsToMaxIntCheck.cpp

58

Semicolon at end is not necessary. Please also run Clang-format.

87

Unnecessary empty line.

docs/ReleaseNotes.rst

60

Please use alphabetical order for new checks.

63

Please enclose -1 and ~0 in `.

64

Please enclose std::numeric_limits<type>::max() in ``.

docs/clang-tidy/checks/readability-numerical-costants-to-max-int.rst

7

Please synchronize with Release Notes.

[Eugene.Zelenko]

It'll be good idea to handle climits constants too.

[jfb]

Can you also catch casts such as (unsigned)-1 ?

[Eugene.Zelenko]

clang-tidy/readability/NumericalCostantsToMaxIntCheck.cpp

44

Unnecessary empty line.

[JonasToth]

@aaron.ballman I have a question for an expert: How would bitfields relate to this check? Can there be a similar pattern for them and do they need to be handled here?

clang-tidy/readability/NumericalCostantsToMaxIntCheck.cpp

62

you dont need this-> and please use the same return early pattern as in the other registering call

64

its uncommong to specify the global namespace (first ::), you can remove these

77

Please use the full name for the bind, Literal or IntLiteral (please consistent with VarDecl, so CamelCase). I feel that this is more readable (no strong opinion though if you want to leave it as is)

93

Please declar this variable later, directly before usage (locality), and add const SourceManager* SM as you don't seem to manipulate SM

95

You can use llvm::Twine here which is very efficient for concatenation.

std::string Replacement = (Twine("std::numeric_limits<") + Decl->getType().getAtomicUnqualifiedType().getAsString() + ">::max()").str();

107

I think its better to create the source-range before to deal with exceptional cases (invalid ranges, macros)

docs/clang-tidy/checks/list.rst

12

spurious change, does it still happen on master? i thought this was ordered at some point already

219

this does not follow the naming convention (hyphens and not CamelCase)

docs/clang-tidy/checks/readability-numerical-costants-to-max-int.rst

4

please make === full length.

10

This line is slightly inaccurate. The library is the standard library, s/library/header-file

37

Please remove the empty lines at the end

test/clang-tidy/readability-numerical-costants-to-max-int.cpp

9

Please add testcases for macros (literal in macro, variable declaration in macro, other possibilities you might find) and for templates.

template <typename Foo>
void f() {
    Foo f = -1;
}

template <int NonType>
void f2() {
    decltype(NonType) new_var = -1;
}

and variations. Please try to cover as many possible constructs as you can.

Another interesting case are enums, example:

enum FooEnum : unsigned {
   bar = 0,
   foobar = 1,
   maximum = -1
}

You don't need to handle this case yet, but please add a testcase to demonstrate the behaviour of the check for it. Adding a TODO: would be perfect to signal future extendability.

[Eugene.Zelenko]

clang-tidy/readability/NumericalCostantsToMaxIntCheck.cpp

62

By the word, see PR32774 for such check suggestion.

[IdrissRio]

Update with the suggestion proposed by @Eugene.Zelenko and @JonasToth

[lebedev.ri]

clang-tidy/readability/NumericalCostantsToMaxIntCheck.h

26

I feel like the name is overly vague.
This *only* handles the cases of -1 and ~0.
It does not handle cases like 255 -> std::numeric_limits<uint_8>::max().
(It might be nice to do that, but it is more complex i suspect.)

[Eugene.Zelenko]

docs/ReleaseNotes.rst

118

Wrong kind of quotes were used. Should be . std::numeric_limits<type>::max() Should be enclosed in `.

docs/clang-tidy/checks/readability-numerical-costants-to-max-int.rst

8

Please re-synchronize.

[JonasToth]

clang-tidy/readability/NumericalCostantsToMaxIntCheck.cpp

64

please assert Lit as well and add an error message in the assert, like assert(Decl && Lit && "Expect both matchers to match");

docs/clang-tidy/checks/readability-numerical-costants-to-max-int.rst

37

Please remove the empty line at the end

test/clang-tidy/readability-numerical-costants-to-max-int.cpp

73

Please add tests that use typedefs (and using = ...) to mask the underlying type. If they dont work, use hasCanonicalType in the matcher, as the canonical type looks through the typedefs.

Common typedefs are uint32_t and the like to control the bitwidth of the integer.

[aaron.ballman]

I like the thrust of this check, but we already have the readability-magic-numbers check and I think that this functionality would fit naturally there. That check finds numerical constants and recommends turning them into named constants, but for special values it seems reasonable to recommend using numeric_limits instead. What do others think of that, from an organizational perspective?

[JonasToth]

In D52892#1263324, @aaron.ballman wrote:

I like the thrust of this check, but we already have the readability-magic-numbers check and I think that this functionality would fit naturally there. That check finds numerical constants and recommends turning them into named constants, but for special values it seems reasonable to recommend using numeric_limits instead. What do others think of that, from an organizational perspective?

+1, totally forgot that one. I feel that the bugprone is more strict though, so adding an readability-mode for it that only warns for the numeric_limits constants seems desirable.

clang-tidy/readability/CMakeLists.txt

add_clang_library(clangTidyReadabilityModule
   ImplicitBoolConversionCheck.cpp
   InconsistentDeclarationParameterNameCheck.cpp
   MagicNumbersCheck.cpp
   MisleadingIndentationCheck.cpp
   MisplacedArrayIndexCheck.cpp
   NamedParameterCheck.cpp
   NamespaceCommentCheck.cpp
   NonConstParameterCheck.cpp
+  NumericalCostantsToMaxIntCheck.cpp
   ReadabilityTidyModule.cpp
   RedundantControlFlowCheck.cpp
   RedundantDeclarationCheck.cpp
   RedundantFunctionPtrDereferenceCheck.cpp
   RedundantMemberInitCheck.cpp
   RedundantSmartptrGetCheck.cpp
   RedundantStringCStrCheck.cpp
   RedundantStringInitCheck.cpp

clang-tidy/readability/NumericalCostantsToMaxIntCheck.h

+//===--- NumericalCostantsToMaxIntCheck.h - clang-tidy ----------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_NUMERICALCOSTANTSTOMAXINTCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_NUMERICALCOSTANTSTOMAXINTCHECK_H
+
+#include "../ClangTidy.h"
+
+namespace clang {
+namespace tidy {
+namespace readability {
+
+/// \brief This check looks for numerical unsigned constants that are equal to
+/// -1 or ~0 and substitutes them with std::numeric_limits<type>::max().
+///
+///  If necessary it adds the library 'limits'.
+///
+class NumericalCostantsToMaxIntCheck : public ClangTidyCheck {
+public:
+  NumericalCostantsToMaxIntCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  void registerPPCallbacks(CompilerInstance &Compiler) override;
+
+private:
+  bool InsertLimits;
+  SourceLocation IncludeLocation;
+};
+
+} // namespace readability
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_NUMERICALCOSTANTSTOMAXINTCHECK_H

clang-tidy/readability/NumericalCostantsToMaxIntCheck.cpp

+//===--- NumericalcostantstomaxintCheck.cpp - clang-tidy ------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "NumericalCostantsToMaxIntCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Frontend/CompilerInstance.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace readability {
+
+namespace {
+class NumericalConstCheckPPCallbacks : public PPCallbacks {
+public:
+  explicit NumericalConstCheckPPCallbacks(bool &IL, SourceLocation *IS);
+  void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
+                          StringRef FileName, bool IsAngled,
+                          CharSourceRange FilenameRange, const FileEntry *File,
+                          StringRef SearchPath, StringRef RelativePath,
+                          const Module *Imported,
+                          SrcMgr::CharacteristicKind FileType) override;
+
+private:
+  bool *IL;
+  bool AtLeastOneInclude;
+  SourceLocation *IS;
+};
+} // namespace
+
+void NumericalConstCheckPPCallbacks::InclusionDirective(
+    SourceLocation HashLoc, const Token &IncludeTok, StringRef FileName,
+    bool IsAngled, CharSourceRange FilenameRange, const FileEntry *File,
+    StringRef SearchPath, StringRef RelativePath, const Module *Imported,
+    SrcMgr::CharacteristicKind FileType) {
+
+  if (FileName == "limits") {
+    *IL = true;
+    return;
+  }
+  if (AtLeastOneInclude)
+    return;
+
+  *IS = HashLoc;
+  AtLeastOneInclude = true;
+}
+
+NumericalConstCheckPPCallbacks::NumericalConstCheckPPCallbacks(
+    bool &IL, SourceLocation *IS)
+    : IL(&IL), AtLeastOneInclude(false), IS(IS){};
+
+void NumericalCostantsToMaxIntCheck::registerPPCallbacks(
+    CompilerInstance &Compiler) {
+  if (this->getLangOpts().CPlusPlus) {
+    Compiler.getPreprocessor().addPPCallbacks(
+        ::llvm::make_unique<NumericalConstCheckPPCallbacks>(InsertLimits,
+                                                            &IncludeLocation));
+  }
+}
+
+void NumericalCostantsToMaxIntCheck::registerMatchers(MatchFinder *Finder) {
+  if (!getLangOpts().CPlusPlus)
+    return;
+  Finder->addMatcher(
+      varDecl(
+          hasType(qualType(allOf(isUnsignedInteger(), isConstQualified()))),
+          anyOf(hasInitializer(ignoringImpCasts(unaryOperator(
+                    hasOperatorName("-"),
+                    hasUnaryOperand(integerLiteral(equals(1)).bind("Lit"))))),
+                hasInitializer(ignoringImpCasts(unaryOperator(
+                    hasOperatorName("~"),
+                    hasUnaryOperand(integerLiteral(equals(0)).bind("Lit")))))))
+          .bind("VarDecl"),
+      this);
+}
+
+void NumericalCostantsToMaxIntCheck::check(
+    const MatchFinder::MatchResult &Result) {
+
+  const auto *Decl = Result.Nodes.getNodeAs<VarDecl>("VarDecl");
+  const auto *Lit = Result.Nodes.getNodeAs<IntegerLiteral>("Lit");
+  if (Decl == nullptr || Lit == nullptr)
+    return;
+
+  SourceManager *SM = Result.SourceManager;
+  std::string InsteadOf = "-1";
+  std::string Replacement =
+      ("std::numeric_limits<" +
+       StringRef(Decl->getType().getAtomicUnqualifiedType().getAsString()) +
+       ">::max()")
+          .str();
+
+  if (Lit->getValue() == 0)
+    InsteadOf = "~0";
+
+  diag(Lit->getLocation(), "use '%0' instead of '%1' for unsigned constant int")
+      << Replacement << InsteadOf
+      << FixItHint::CreateReplacement(
+             SourceRange(Lit->getBeginLoc().getLocWithOffset(-1),
+                         Lit->getEndLoc()),
+             Replacement);
+
+  if (InsertLimits)
+    return;
+
+  if (IncludeLocation.isInvalid())
+    IncludeLocation =
+        SM->getLocForStartOfFile(SM->getFileID(Lit->getBeginLoc()));
+
+  diag(IncludeLocation, "Add '#include<limits>' to use "
+                        "std::numeric_limits<type>::max() function")
+      << FixItHint::CreateInsertion(IncludeLocation, "#include <limits>\n");
+}
+
+} // namespace readability
+} // namespace tidy
+} // namespace clang

clang-tidy/readability/ReadabilityTidyModule.cpp

 #include "IdentifierNamingCheck.h"
 #include "ImplicitBoolConversionCheck.h"
 #include "InconsistentDeclarationParameterNameCheck.h"
 #include "MagicNumbersCheck.h"
 #include "MisleadingIndentationCheck.h"
 #include "MisplacedArrayIndexCheck.h"
 #include "NamedParameterCheck.h"
 #include "NonConstParameterCheck.h"
+#include "NumericalCostantsToMaxIntCheck.h"
 #include "RedundantControlFlowCheck.h"
 #include "RedundantDeclarationCheck.h"
 #include "RedundantFunctionPtrDereferenceCheck.h"
 #include "RedundantMemberInitCheck.h"
 #include "RedundantSmartptrGetCheck.h"
 #include "RedundantStringCStrCheck.h"
 #include "RedundantStringInitCheck.h"
 #include "SimplifyBooleanExprCheck.h"
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<InconsistentDeclarationParameterNameCheck>(
         "readability-inconsistent-declaration-parameter-name");
     CheckFactories.registerCheck<MagicNumbersCheck>(
         "readability-magic-numbers");
     CheckFactories.registerCheck<MisleadingIndentationCheck>(
         "readability-misleading-indentation");
     CheckFactories.registerCheck<MisplacedArrayIndexCheck>(
         "readability-misplaced-array-index");
+    CheckFactories.registerCheck<NumericalCostantsToMaxIntCheck>(
+        "readability-numerical-costants-to-max-int");
     CheckFactories.registerCheck<RedundantFunctionPtrDereferenceCheck>(
         "readability-redundant-function-ptr-dereference");
     CheckFactories.registerCheck<RedundantMemberInitCheck>(
         "readability-redundant-member-init");
     CheckFactories.registerCheck<SimplifySubscriptExprCheck>(
         "readability-simplify-subscript-expr");
     CheckFactories.registerCheck<StaticAccessedThroughInstanceCheck>(
         "readability-static-accessed-through-instance");

docs/ReleaseNotes.rst

 Improvements to clang-rename
 ----------------------------
 
 The improvements are...
 
 Improvements to clang-tidy
 --------------------------
 
+- New :doc:`readability-numerical-costants-to-max-int
+  <clang-tidy/checks/readability-numerical-costants-to-max-int>` check.
+
+  Checks for numerical unsigned constants that are equal to -1 or ~0
+  and substitutes them with std::numeric_limits<type>::max().
+
 - New :doc:`abseil-duration-division
   <clang-tidy/checks/abseil-duration-division>` check.
 
   Checks for uses of ``absl::Duration`` division that is done in a
   floating-point context, and recommends the use of a function that
   returns a floating-point value.
 
 - New :doc:`abseil-faster-strsplit-delimiter
- New :doc:`readability-magic-numbers
   <clang-tidy/checks/readability-magic-numbers>` check.
 
   Detects usage of magic numbers, numbers that are used as literals instead of
   introduced via constants or symbols.
 
 Improvements to include-fixer
 -----------------------------
 
 The improvements are...
 
 Improvements to modularize
 --------------------------
 
 The improvements are...

docs/clang-tidy/checks/list.rst

 .. title:: clang-tidy - Clang-Tidy Checks
 
 Clang-Tidy Checks
 =================
 
 .. toctree::
    abseil-duration-division
    abseil-faster-strsplit-delimiter
    abseil-no-internal-dependencies
    abseil-no-namespace
    abseil-redundant-strcat-calls
-   abseil-string-find-startswith
    abseil-str-cat-append
+   abseil-string-find-startswith
    android-cloexec-accept
    android-cloexec-accept4
    android-cloexec-creat
    android-cloexec-dup
    android-cloexec-epoll-create
    android-cloexec-epoll-create1
    android-cloexec-fopen
    android-cloexec-inotify-init
.. toctree::
    performance-inefficient-vector-operation
    performance-move-const-arg
    performance-move-constructor-init
    performance-noexcept-move-constructor
    performance-type-promotion-in-math-fn
    performance-unnecessary-copy-initialization
    performance-unnecessary-value-param
    portability-simd-intrinsics
+   readability-NumericalCostantsToMaxInt
    readability-avoid-const-params-in-decls
    readability-braces-around-statements
    readability-container-size-empty
    readability-delete-null-pointer
    readability-deleted-default
    readability-else-after-return
    readability-function-size
    readability-identifier-naming

docs/clang-tidy/checks/readability-numerical-costants-to-max-int.rst

+.. title:: clang-tidy - readability-numerical-costants-to-max-int
+
+readability-numerical-costants-to-max-int
+==================================
+
+
+This check looks for numerical unsigned constants that are equal to -1 or ~0
+and substitutes them with std::numeric_limits<type>::max().
+
+If necessary it adds the library 'limits'.
+
+Examples:
+
+.. code-block:: c++
+
+unsigned const long int x = -1;
+
+becomes
+
+.. code-block:: c++
+
+unsigned const long int x = std::numeric_limits<unsigned long>::max();
+
+or
+
+.. code-block:: c++
+
+unsigned const short x = ~0;
+
+
+becomes
+
+.. code-block:: c++
+
+unsigned const short x = std::numeric_limits<short>::max();
+  
 No newline at end of file

test/clang-tidy/readability-numerical-costants-to-max-int.cpp

+// RUN: %check_clang_tidy %s readability-numerical-costants-to-max-int %t
+unsigned const int Uval1 = -1;
+// CHECK-MESSAGES: :[[@LINE-2]]:1: warning: Add '#include<limits>' to use std::numeric_limits<type>::max() function [readability-numerical-costants-to-max-int]
+// CHECK-MESSAGES: :[[@LINE-2]]:29: warning: use 'std::numeric_limits<unsigned int>::max()' instead of '-1' for unsigned constant int [readability-numerical-costants-to-max-int]
+// CHECK-FIXES: #include <limits>
+// CHECK-FIXES: unsigned const int Uval1 = std::numeric_limits<unsigned int>::max();
+
+
+unsigned const long Uval2 = -1;
+// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: use 'std::numeric_limits<unsigned long>::max()' instead of '-1' for unsigned constant int [readability-numerical-costants-to-max-int]
+// CHECK-FIXES: unsigned const long Uval2 = std::numeric_limits<unsigned long>::max();
+
+unsigned const long int Uval3 = -1;
+// CHECK-MESSAGES: :[[@LINE-1]]:34: warning: use 'std::numeric_limits<unsigned long>::max()' instead of '-1' for unsigned constant int [readability-numerical-costants-to-max-int]
+// CHECK-FIXES: unsigned const long int Uval3 = std::numeric_limits<unsigned long>::max();
+
+unsigned const long long int Uval4 = -1;
+// CHECK-MESSAGES: :[[@LINE-1]]:39: warning: use 'std::numeric_limits<unsigned long long>::max()' instead of '-1' for unsigned constant int [readability-numerical-costants-to-max-int]
+// CHECK-FIXES: unsigned const long long int Uval4 = std::numeric_limits<unsigned long long>::max();
+
+unsigned const short int Uval5 = -1;
+// CHECK-MESSAGES: :[[@LINE-1]]:35: warning: use 'std::numeric_limits<unsigned short>::max()' instead of '-1' for unsigned constant int [readability-numerical-costants-to-max-int]
+// CHECK-FIXES: unsigned const short int Uval5 = std::numeric_limits<unsigned short>::max();
+
+unsigned const Uval6 = -1;
+// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: use 'std::numeric_limits<unsigned int>::max()' instead of '-1' for unsigned constant int [readability-numerical-costants-to-max-int]
+// CHECK-FIXES: unsigned const Uval6 = std::numeric_limits<unsigned int>::max();
+
+unsigned const char Uval7 = -1;
+// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: use 'std::numeric_limits<unsigned char>::max()' instead of '-1' for unsigned constant int [readability-numerical-costants-to-max-int]
+// CHECK-FIXES: unsigned const char Uval7 = std::numeric_limits<unsigned char>::max();
+
+
+//if not constants do nothing
+unsigned int Uval8 = -1;
+unsigned long Uval9 = -1;
+unsigned long int Uval10 = -1;
+unsigned long long int Uval11 = -1;
+unsigned short int Uval12 = -1;
+unsigned Uval13 = -1;
+unsigned char Uval14 = -1;
+
+
+unsigned const long Uval15 = ~0;
+// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: use 'std::numeric_limits<unsigned long>::max()' instead of '~0' for unsigned constant int [readability-numerical-costants-to-max-int]
+// CHECK-FIXES: unsigned const long Uval15 = std::numeric_limits<unsigned long>::max();
+
+unsigned const long int Uval16 = ~0;
+// CHECK-MESSAGES: :[[@LINE-1]]:35: warning: use 'std::numeric_limits<unsigned long>::max()' instead of '~0' for unsigned constant int [readability-numerical-costants-to-max-int]
+// CHECK-FIXES: unsigned const long int Uval16 = std::numeric_limits<unsigned long>::max();
+
+unsigned const long long int Uval17 = ~0;
+// CHECK-MESSAGES: :[[@LINE-1]]:40: warning: use 'std::numeric_limits<unsigned long long>::max()' instead of '~0' for unsigned constant int [readability-numerical-costants-to-max-int]
+// CHECK-FIXES: unsigned const long long int Uval17 = std::numeric_limits<unsigned long long>::max();
+
+unsigned const short int Uval18 = ~0;
+// CHECK-MESSAGES: :[[@LINE-1]]:36: warning: use 'std::numeric_limits<unsigned short>::max()' instead of '~0' for unsigned constant int [readability-numerical-costants-to-max-int]
+// CHECK-FIXES: unsigned const short int Uval18 = std::numeric_limits<unsigned short>::max();
+
+unsigned const Uval19 = ~0;
+// CHECK-MESSAGES: :[[@LINE-1]]:26: warning: use 'std::numeric_limits<unsigned int>::max()' instead of '~0' for unsigned constant int [readability-numerical-costants-to-max-int]
+// CHECK-FIXES: unsigned const Uval19 = std::numeric_limits<unsigned int>::max();
+
+unsigned const char Uval20 = ~0;
+// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: use 'std::numeric_limits<unsigned char>::max()' instead of '~0' for unsigned constant int [readability-numerical-costants-to-max-int]
+// CHECK-FIXES: unsigned const char Uval20 = std::numeric_limits<unsigned char>::max();
+
+
+//if not constants do nothing
+unsigned int Uval21 = ~0;
+unsigned long Uva22 = ~0;
+unsigned long int Uval23 = ~0;
+unsigned long long int Uval24 = ~0;
+unsigned short int Uval25 = ~0;
+unsigned Uval26 = ~0;
+unsigned char Uval27 = ~0;