[clang-tidy] Add new check 'concurrency-thread-canceltype-asynchronous' and alias 'cert-pos47-c'.

[Eugene.Zelenko]

clang-tools-extra/docs/ReleaseNotes.rst

70–85

Please add subsections for new checks and aliases. Looks like they were removed after release branch creation.

clang-tools-extra/docs/clang-tidy/checks/bugprone-thread-canceltype-asynchronous.rst

6 ↗

(On Diff #323780)

Please remove unnecessary indentation and synchronize first statement with Release Notes.

15 ↗

(On Diff #323780)

Please fix excessive indentation.

[balazske]

Fixed problems with documentation and improved test.

[aaron.ballman]

clang-tools-extra/clang-tidy/bugprone/BugproneTidyModule.cpp

169 ↗

(On Diff #323896)

I think this check is likely better surfaced in the concurrency module. WDYT?

clang-tools-extra/clang-tidy/bugprone/ThreadCanceltypeAsynchronousCheck.cpp

29 ↗

(On Diff #323896)

Any particular reason to use a global variable here rather than making it a member of ThreadCanceltypeAsynchronousCheck?

34 ↗

(On Diff #323896)

We don't use top-level const on local value types (here and elsewhere in the patch).

38 ↗

(On Diff #323896)

Do we know that POSIX implementations always use a simple integer here, or do we have to worry about code like:

#define PTHREAD_CANCEL_ASYNCHRONOUS (1 << 0)

or

#define PTHREAD_CANCEL_ASYNCHRONOUS SOME_OTHER_MACRO

68 ↗

(On Diff #323896)

How about: the cancel type for a pthread should not be 'PTHREAD_CANCEL_ASYNCHRONOUS'?

clang-tools-extra/docs/clang-tidy/checks/bugprone-thread-canceltype-asynchronous.rst

9 ↗

(On Diff #323896)

[balazske]

Adding missed alias to CERT module.

[balazske]

clang-tools-extra/clang-tidy/bugprone/BugproneTidyModule.cpp

169 ↗

(On Diff #323896)

It is really better in `concurrency`, I was not aware of that module (it contains only one check).

clang-tools-extra/clang-tidy/bugprone/ThreadCanceltypeAsynchronousCheck.cpp

29 ↗

(On Diff #323896)

Member is better, I just copied the code from another file (that was added not long ago) and assumed that it is correct even if it looks not good.

38 ↗

(On Diff #323896)

Theoretically it is possible that the macro is defined not as a simple number (at this page see "Symbolic Constant"). But I am not sure if it is possible to get the value from the preprocessor for any constant expression.

There is a similar function tryExpandAsInteger already in clang (CheckerHelpers.cpp) that can be reused here, probably it retrieves the macro definition better. The function could be put into one of the "utils" files, maybe LexerUtils.h, it is already needed at 2 places (bad-signal-to-kill-thread and here).

[balazske]

Moving to module concurrency from bugprone.

[aaron.ballman]

clang-tools-extra/clang-tidy/bugprone/ThreadCanceltypeAsynchronousCheck.cpp

38 ↗

(On Diff #323896)

Having a single place to get this information would be an improvement, but not necessary for this patch. If you don't know of a POSIX implementation that uses something other than a positive integer literal for the expansion, I think the current code is fine.

[aaron.ballman]

clang-tools-extra/clang-tidy/cert/CERTTidyModule.cpp

114

80-col issue?

clang-tools-extra/clang-tidy/concurrency/ThreadCanceltypeAsynchronousCheck.cpp

35

Drop the top-level const unless it's a pointer/reference to a const object (here and elsewhere in the patch).

clang-tools-extra/docs/clang-tidy/checks/list.rst

98

It looks like this file needs to be updated from the rename.

[balazske]

clang-tools-extra/clang-tidy/bugprone/ThreadCanceltypeAsynchronousCheck.cpp

38 ↗

(On Diff #323896)

I found that it is good to rely on isExpandedFromMacro AST matcher instead of this whole tryExpandAsInteger function. The current solution can find only cases where the macro is defined as an integer literal. If isExpandedFromMacro is used it will work at least in all cases regardless of the value of the macro. It will not work if a variable is used to pass the value, but this does not work in the current code either.

[aaron.ballman]

clang-tools-extra/clang-tidy/bugprone/ThreadCanceltypeAsynchronousCheck.cpp

38 ↗

(On Diff #323896)

That's a good point! I don't think it's important to handle the case where a variable or an integer literal is used as the function call argument; we can tackle those cases if they crop up in practice and there's a need.

[balazske]

• Fixed remaining formatting and rename problems.
• Removed tryExpandAsInteger, use matcher instead.
• Improved test.

[aaron.ballman]

Wow, that really simplified the implementation of the check nicely. LGTM!

[njames93]

Before landing this, can you update the title of this to reflect its in the concurrency module, the title is typically used for the commit message.

clang-tools-extra/clang-tidy/cert/CERTTidyModule.cpp

 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
 #include "../bugprone/BadSignalToKillThreadCheck.h"
 #include "../bugprone/ReservedIdentifierCheck.h"
 #include "../bugprone/SignalHandlerCheck.h"
 #include "../bugprone/SignedCharMisuseCheck.h"
 #include "../bugprone/SpuriouslyWakeUpFunctionsCheck.h"
 #include "../bugprone/UnhandledSelfAssignmentCheck.h"
+#include "../concurrency/ThreadCanceltypeAsynchronousCheck.h"
 #include "../google/UnnamedNamespaceInHeaderCheck.h"
 #include "../misc/NewDeleteOverloadsCheck.h"
 #include "../misc/NonCopyableObjects.h"
 #include "../misc/StaticAssertCheck.h"
 #include "../misc/ThrowByValueCatchByReferenceCheck.h"
 #include "../performance/MoveConstructorInitCheck.h"
 #include "../readability/UppercaseLiteralSuffixCheck.h"
 #include "CommandProcessorCheck.h"
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<StrToNumCheck>("cert-err34-c");
     // MSC
     CheckFactories.registerCheck<LimitedRandomnessCheck>("cert-msc30-c");
     CheckFactories.registerCheck<ProperlySeededRandomGeneratorCheck>(
         "cert-msc32-c");
     // POS
     CheckFactories.registerCheck<bugprone::BadSignalToKillThreadCheck>(
         "cert-pos44-c");
+    CheckFactories
+        .registerCheck<concurrency::ThreadCanceltypeAsynchronousCheck>(
+            "cert-pos47-c");
     // SIG
     CheckFactories.registerCheck<bugprone::SignalHandlerCheck>("cert-sig30-c");
     // STR
     CheckFactories.registerCheck<bugprone::SignedCharMisuseCheck>(
         "cert-str34-c");
   }
 
   ClangTidyOptions getModuleOptions() override {

clang-tools-extra/clang-tidy/cert/CMakeLists.txt

add_clang_library(clangTidyCERTModule
   StaticObjectExceptionCheck.cpp
   StrToNumCheck.cpp
   ThrownExceptionTypeCheck.cpp
   VariadicFunctionDefCheck.cpp
 
   LINK_LIBS
   clangTidy
   clangTidyBugproneModule
+  clangTidyConcurrencyModule
   clangTidyGoogleModule
   clangTidyMiscModule
   clangTidyPerformanceModule
   clangTidyReadabilityModule
   clangTidyUtils
 
   DEPENDS
   omp_gen

clang-tools-extra/clang-tidy/concurrency/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   FrontendOpenMP
   Support
   )
 
 add_clang_library(clangTidyConcurrencyModule
   ConcurrencyTidyModule.cpp
   MtUnsafeCheck.cpp
+  ThreadCanceltypeAsynchronousCheck.cpp
 
   LINK_LIBS
   clangTidy
   clangTidyUtils
   )
 
 clang_target_link_libraries(clangTidyConcurrencyModule
   PRIVATE
   clangAnalysis
   clangAST
   clangASTMatchers
   clangBasic
   clangLex
   clangSerialization
   clangTooling
   )

clang-tools-extra/clang-tidy/concurrency/ConcurrencyTidyModule.cpp

 //===--- ConcurrencyTidyModule.cpp - clang-tidy ---------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "../ClangTidy.h"
 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
 #include "MtUnsafeCheck.h"
+#include "ThreadCanceltypeAsynchronousCheck.h"
 
 namespace clang {
 namespace tidy {
 namespace concurrency {
 
 class ConcurrencyModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<concurrency::MtUnsafeCheck>(
         "concurrency-mt-unsafe");
+    CheckFactories.registerCheck<ThreadCanceltypeAsynchronousCheck>(
+        "concurrency-thread-canceltype-asynchronous");
   }
 };
 
 } // namespace concurrency
 
 // Register the ConcurrencyTidyModule using this statically initialized variable.
 static ClangTidyModuleRegistry::Add<concurrency::ConcurrencyModule>
     X("concurrency-module", "Adds concurrency checks.");
 
 // This anchor is used to force the linker to link in the generated object file
 // and thus register the ConcurrencyModule.
 volatile int ConcurrencyModuleAnchorSource = 0;
 
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/concurrency/ThreadCanceltypeAsynchronousCheck.h

+//===--- ThreadCanceltypeAsynchronousCheck.h - clang-tidy -------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CONCURRENCY_THREADCANCELTYPEASYNCHRONOUSCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CONCURRENCY_THREADCANCELTYPEASYNCHRONOUSCHECK_H
+
+#include "../ClangTidyCheck.h"
+
+namespace clang {
+namespace tidy {
+namespace concurrency {
+
+/// Finds ``pthread_setcanceltype`` function calls where a thread's
+/// cancellation type is set to asynchronous.
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/concurrency-thread-canceltype-asynchronous.html
+class ThreadCanceltypeAsynchronousCheck : public ClangTidyCheck {
+public:
+  ThreadCanceltypeAsynchronousCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+};
+
+} // namespace concurrency
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CONCURRENCY_THREADCANCELTYPEASYNCHRONOUSCHECK_H

clang-tools-extra/clang-tidy/concurrency/ThreadCanceltypeAsynchronousCheck.cpp

+//===--- ThreadCanceltypeAsynchronousCheck.cpp - clang-tidy ---------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "ThreadCanceltypeAsynchronousCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Lex/Preprocessor.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace concurrency {
+
+void ThreadCanceltypeAsynchronousCheck::registerMatchers(MatchFinder *Finder) {
+  Finder->addMatcher(
+      callExpr(
+          allOf(callee(functionDecl(hasName("::pthread_setcanceltype"))),
+                argumentCountIs(2)),
+          hasArgument(0, isExpandedFromMacro("PTHREAD_CANCEL_ASYNCHRONOUS")))
+          .bind("setcanceltype"),
+      this);
+}
+
+void ThreadCanceltypeAsynchronousCheck::check(
+    const MatchFinder::MatchResult &Result) {
+  const auto *MatchedExpr = Result.Nodes.getNodeAs<Expr>("setcanceltype");
+  diag(MatchedExpr->getBeginLoc(), "the cancel type for a pthread should not "
+                                   "be 'PTHREAD_CANCEL_ASYNCHRONOUS'");
+}
+
+} // namespace concurrency
+} // namespace tidy
+} // namespace clang

clang-tools-extra/docs/ReleaseNotes.rst

 Improvements to clang-rename
 ----------------------------
 
 The improvements are...
 
 Improvements to clang-tidy
 --------------------------
 
-The improvements are...
+New checks
+^^^^^^^^^^
+
+- New :doc:`concurrency-thread-canceltype-asynchronous
+  <clang-tidy/checks/concurrency-thread-canceltype-asynchronous>` check.
+
+  Finds ``pthread_setcanceltype`` function calls where a thread's cancellation
+  type is set to asynchronous.
+
+New check aliases
+^^^^^^^^^^^^^^^^^
+
+- New alias :doc:`cert-pos47-c
+  <clang-tidy/checks/cert-pos47-c>` to
+  :doc:`concurrency-thread-canceltype-asynchronous
+  <clang-tidy/checks/concurrency-thread-canceltype-asynchronous>` was added.
 
 Improvements to include-fixer
 -----------------------------
 
 The improvements are...
 
 Improvements to clang-include-fixer
 -----------------------------------

clang-tools-extra/docs/clang-tidy/checks/cert-pos47-c.rst

+.. title:: clang-tidy - cert-pos47-c
+.. meta::
+   :http-equiv=refresh: 5;URL=concurrency-thread-canceltype-asynchronous.html
+
+cert-pos47-c
+============
+
+The cert-pos47-c check is an alias, please see
+`concurrency-thread-canceltype-asynchronous <concurrency-thread-canceltype-asynchronous.html>`_ for more information.

clang-tools-extra/docs/clang-tidy/checks/concurrency-thread-canceltype-asynchronous.rst

+.. title:: clang-tidy - concurrency-thread-canceltype-asynchronous
+
+concurrency-thread-canceltype-asynchronous
+==========================================
+
+Finds ``pthread_setcanceltype`` function calls where a thread's cancellation
+type is set to asynchronous. Asynchronous cancellation type
+(``PTHREAD_CANCEL_ASYNCHRONOUS``) is generally unsafe, use type
+``PTHREAD_CANCEL_DEFERRED`` instead which is the default. Even with deferred
+cancellation, a cancellation point in an asynchronous signal handler may still
+be acted upon and the effect is as if it was an asynchronous cancellation.
+
+.. code-block: c++
+
+  pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &oldtype);
+
+This check corresponds to the CERT C Coding Standard rule
+`POS47-C. Do not use threads that can be canceled asynchronously
+<https://wiki.sei.cmu.edu/confluence/display/c/POS47-C.+Do+not+use+threads+that+can+be+canceled+asynchronously>`_.

clang-tools-extra/docs/clang-tidy/checks/list.rst

.. csv-table::
    `bugprone-suspicious-enum-usage <bugprone-suspicious-enum-usage.html>`_,
    `bugprone-suspicious-include <bugprone-suspicious-include.html>`_,
    `bugprone-suspicious-memset-usage <bugprone-suspicious-memset-usage.html>`_, "Yes"
    `bugprone-suspicious-missing-comma <bugprone-suspicious-missing-comma.html>`_,
    `bugprone-suspicious-semicolon <bugprone-suspicious-semicolon.html>`_, "Yes"
    `bugprone-suspicious-string-compare <bugprone-suspicious-string-compare.html>`_, "Yes"
    `bugprone-swapped-arguments <bugprone-swapped-arguments.html>`_, "Yes"
    `bugprone-terminating-continue <bugprone-terminating-continue.html>`_, "Yes"
    `bugprone-throw-keyword-missing <bugprone-throw-keyword-missing.html>`_,
    `bugprone-too-small-loop-variable <bugprone-too-small-loop-variable.html>`_,
    `bugprone-undefined-memory-manipulation <bugprone-undefined-memory-manipulation.html>`_,
    `bugprone-undelegated-constructor <bugprone-undelegated-constructor.html>`_,
    `bugprone-unhandled-self-assignment <bugprone-unhandled-self-assignment.html>`_,
    `bugprone-unused-raii <bugprone-unused-raii.html>`_, "Yes"
    `bugprone-unused-return-value <bugprone-unused-return-value.html>`_,
    `bugprone-use-after-move <bugprone-use-after-move.html>`_,
    `bugprone-virtual-near-miss <bugprone-virtual-near-miss.html>`_, "Yes"
.. csv-table::
    `clang-analyzer-osx.cocoa.Loops <clang-analyzer-osx.cocoa.Loops.html>`_,
    `clang-analyzer-osx.cocoa.MissingSuperCall <clang-analyzer-osx.cocoa.MissingSuperCall.html>`_,
    `clang-analyzer-osx.cocoa.NonNilReturnValue <clang-analyzer-osx.cocoa.NonNilReturnValue.html>`_,
    `clang-analyzer-osx.cocoa.RunLoopAutoreleaseLeak <clang-analyzer-osx.cocoa.RunLoopAutoreleaseLeak.html>`_,
    `clang-analyzer-valist.CopyToSelf <clang-analyzer-valist.CopyToSelf.html>`_,
    `clang-analyzer-valist.Uninitialized <clang-analyzer-valist.Uninitialized.html>`_,
    `clang-analyzer-valist.Unterminated <clang-analyzer-valist.Unterminated.html>`_,
    `concurrency-mt-unsafe <concurrency-mt-unsafe.html>`_,
+   `concurrency-thread-canceltype-asynchronous <concurrency-thread-canceltype-asynchronous.html>`_,
    `cppcoreguidelines-avoid-goto <cppcoreguidelines-avoid-goto.html>`_,
    `cppcoreguidelines-avoid-non-const-global-variables <cppcoreguidelines-avoid-non-const-global-variables.html>`_,
    `cppcoreguidelines-init-variables <cppcoreguidelines-init-variables.html>`_, "Yes"
    `cppcoreguidelines-interfaces-global-init <cppcoreguidelines-interfaces-global-init.html>`_,
    `cppcoreguidelines-macro-usage <cppcoreguidelines-macro-usage.html>`_,
    `cppcoreguidelines-narrowing-conversions <cppcoreguidelines-narrowing-conversions.html>`_,
    `cppcoreguidelines-no-malloc <cppcoreguidelines-no-malloc.html>`_,
    `cppcoreguidelines-owning-memory <cppcoreguidelines-owning-memory.html>`_,
.. csv-table:: Aliases..
    `cert-err09-cpp <cert-err09-cpp.html>`_, `misc-throw-by-value-catch-by-reference <misc-throw-by-value-catch-by-reference.html>`_,
    `cert-err61-cpp <cert-err61-cpp.html>`_, `misc-throw-by-value-catch-by-reference <misc-throw-by-value-catch-by-reference.html>`_,
    `cert-fio38-c <cert-fio38-c.html>`_, `misc-non-copyable-objects <misc-non-copyable-objects.html>`_,
    `cert-msc30-c <cert-msc30-c.html>`_, `cert-msc50-cpp <cert-msc50-cpp.html>`_,
    `cert-msc32-c <cert-msc32-c.html>`_, `cert-msc51-cpp <cert-msc51-cpp.html>`_,
    `cert-oop11-cpp <cert-oop11-cpp.html>`_, `performance-move-constructor-init <performance-move-constructor-init.html>`_, "Yes"
    `cert-oop54-cpp <cert-oop54-cpp.html>`_, `bugprone-unhandled-self-assignment <bugprone-unhandled-self-assignment.html>`_,
    `cert-pos44-c <cert-pos44-c.html>`_, `bugprone-bad-signal-to-kill-thread <bugprone-bad-signal-to-kill-thread.html>`_,
+   `cert-pos47-c <cert-pos47-c.html>`_, `concurrency-thread-canceltype-asynchronous <concurrency-thread-canceltype-asynchronous.html>`_,
    `cert-str34-c <cert-str34-c.html>`_, `bugprone-signed-char-misuse <bugprone-signed-char-misuse.html>`_,
    `clang-analyzer-core.CallAndMessage <clang-analyzer-core.CallAndMessage.html>`_, `Clang Static Analyzer <https://clang.llvm.org/docs/analyzer/checkers.html>`_,
    `clang-analyzer-core.DivideZero <clang-analyzer-core.DivideZero.html>`_, `Clang Static Analyzer <https://clang.llvm.org/docs/analyzer/checkers.html>`_,
    `clang-analyzer-core.NonNullParamChecker <clang-analyzer-core.NonNullParamChecker.html>`_, `Clang Static Analyzer <https://clang.llvm.org/docs/analyzer/checkers.html>`_,
    `clang-analyzer-core.NullDereference <clang-analyzer-core.NullDereference.html>`_, `Clang Static Analyzer <https://clang.llvm.org/docs/analyzer/checkers.html>`_,
    `clang-analyzer-core.StackAddressEscape <clang-analyzer-core.StackAddressEscape.html>`_, `Clang Static Analyzer <https://clang.llvm.org/docs/analyzer/checkers.html>`_,
    `clang-analyzer-core.UndefinedBinaryOperatorResult <clang-analyzer-core.UndefinedBinaryOperatorResult.html>`_, `Clang Static Analyzer <https://clang.llvm.org/docs/analyzer/checkers.html>`_,
    `clang-analyzer-core.VLASize <clang-analyzer-core.VLASize.html>`_, `Clang Static Analyzer <https://clang.llvm.org/docs/analyzer/checkers.html>`_,

clang-tools-extra/test/clang-tidy/checkers/concurrency-thread-canceltype-asynchronous.cpp

+// RUN: %check_clang_tidy %s concurrency-thread-canceltype-asynchronous %t
+
+#define ONE (1 << 0)
+
+#define PTHREAD_CANCEL_DEFERRED 0
+// define the macro intentionally complex
+#define PTHREAD_CANCEL_ASYNCHRONOUS ONE
+
+#define ASYNCHR PTHREAD_CANCEL_ASYNCHRONOUS
+
+int pthread_setcanceltype(int type, int *oldtype);
+
+int main() {
+  int result, oldtype;
+
+  if ((result = pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &oldtype)) != 0) {
+    // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: the cancel type for a pthread should not be 'PTHREAD_CANCEL_ASYNCHRONOUS' [concurrency-thread-canceltype-asynchronous]
+    return 1;
+  }
+
+  if ((result = pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, &oldtype)) != 0) {
+    return 1;
+  }
+
+  return 0;
+}
+
+int f1() {
+  int result, oldtype;
+
+  if ((result = pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &oldtype)) != 0) {
+    // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: the cancel type for a pthread should not be 'PTHREAD_CANCEL_ASYNCHRONOUS' [concurrency-thread-canceltype-asynchronous]
+    return 1;
+  }
+
+  if ((result = pthread_setcanceltype(ASYNCHR, &oldtype)) != 0) {
+    // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: the cancel type for a pthread should not be 'PTHREAD_CANCEL_ASYNCHRONOUS' [concurrency-thread-canceltype-asynchronous]
+    return 1;
+  }
+
+  return 0;
+}
+
+int f2(int type) {
+  int result, oldtype;
+
+  if ((result = pthread_setcanceltype(type, &oldtype)) != 0) {
+    return 1;
+  }
+
+  return 0;
+}