C++ runtime changes for high warning levels

contributors.txt

@@ -148,3 +148,4 @@ YYYY/MM/DD, github id, Full name, email
 2017/05/11, jimallman, Jim Allman, [email protected]
 2017/05/26, waf, Will Fuqua, [email protected]
 2017/05/29, kosak, Corey Kosak, [email protected]
+2017/06/10, jm-mikkelsen, Jan Martin Mikkelsen, [email protected]

runtime/Cpp/runtime/src/ANTLRErrorListener.cpp

@@ -0,0 +1,5 @@
+#include "ANTLRErrorListener.h"
+
+antlr4::ANTLRErrorListener::~ANTLRErrorListener()
+{
+}

runtime/Cpp/runtime/src/ANTLRErrorListener.h

@@ -16,7 +16,7 @@ namespace antlr4 {
   /// How to emit recognition errors (an interface in Java).
   class ANTLR4CPP_PUBLIC ANTLRErrorListener {
   public:
-    virtual ~ANTLRErrorListener() {};
+    virtual ~ANTLRErrorListener();
 
     /// <summary>
     /// Upon syntax error, notify any interested parties. This is not how to

runtime/Cpp/runtime/src/ANTLRErrorStrategy.cpp

@@ -0,0 +1,5 @@
+#include "ANTLRErrorStrategy.h"
+
+antlr4::ANTLRErrorStrategy::~ANTLRErrorStrategy()
+{
+}

runtime/Cpp/runtime/src/ANTLRErrorStrategy.h

@@ -32,7 +32,7 @@ namespace antlr4 {
     /// <summary>
     /// Reset the error handler state for the specified {@code recognizer}. </summary>
     /// <param name="recognizer"> the parser instance </param>
-    virtual ~ANTLRErrorStrategy() {};
+    virtual ~ANTLRErrorStrategy();
 
     virtual void reset(Parser *recognizer) = 0;
 

runtime/Cpp/runtime/src/ANTLRInputStream.cpp

@@ -71,19 +71,19 @@ size_t ANTLRInputStream::LA(ssize_t i) {
     return 0; // undefined
   }
 
-  ssize_t position = (ssize_t)p;
+  ssize_t position = static_cast<ssize_t>(p);
   if (i < 0) {
     i++; // e.g., translate LA(-1) to use offset i=0; then _data[p+0-1]
     if ((position + i - 1) < 0) {
       return IntStream::EOF; // invalid; no char before first char
     }
   }
 
-  if ((position + i - 1) >= (ssize_t)_data.size()) {
+  if ((position + i - 1) >= static_cast<ssize_t>(_data.size())) {
     return IntStream::EOF;
   }
 
-  return _data[(size_t)(position + i - 1)];
+  return _data[static_cast<size_t>((position + i - 1))];
 }
 
 size_t ANTLRInputStream::LT(ssize_t i) {
@@ -123,8 +123,8 @@ std::string ANTLRInputStream::getText(const Interval &interval) {
     return "";
   }
 
-  size_t start = interval.a;
-  size_t stop = interval.b;
+  size_t start = static_cast<size_t>(interval.a);
+  size_t stop = static_cast<size_t>(interval.b);
 
 
   if (stop >= _data.size()) {

runtime/Cpp/runtime/src/BailErrorStrategy.cpp

@@ -18,7 +18,7 @@ void BailErrorStrategy::recover(Parser *recognizer, std::exception_ptr e) {
     context->exception = e;
     if (context->parent == nullptr)
       break;
-    context = (ParserRuleContext *)context->parent;
+    context = static_cast<ParserRuleContext *>(context->parent);
   } while (true);
 
   try {
@@ -42,7 +42,7 @@ Token* BailErrorStrategy::recoverInline(Parser *recognizer)  {
     context->exception = exception;
     if (context->parent == nullptr)
       break;
-    context = (ParserRuleContext *)context->parent;
+    context = static_cast<ParserRuleContext *>(context->parent);
   } while (true);
 
   try {

runtime/Cpp/runtime/src/BufferedTokenStream.cpp

@@ -96,7 +96,7 @@ size_t BufferedTokenStream::fetch(size_t n) {
     std::unique_ptr<Token> t(_tokenSource->nextToken());
 
     if (is<WritableToken *>(t.get())) {
-      (static_cast<WritableToken *>(t.get()))->setTokenIndex((int)_tokens.size());
+      (static_cast<WritableToken *>(t.get()))->setTokenIndex(_tokens.size());
     }
 
     _tokens.push_back(std::move(t));
@@ -272,7 +272,7 @@ ssize_t BufferedTokenStream::previousTokenOnChannel(size_t i, size_t channel) {
     }
 
     if (i == 0)
-      return i;
+      break;
     i--;
   }
   return i;
@@ -289,7 +289,7 @@ std::vector<Token *> BufferedTokenStream::getHiddenTokensToRight(size_t tokenInd
   size_t from = tokenIndex + 1;
   // if none onchannel to right, nextOnChannel=-1 so set to = last token
   if (nextOnChannel == -1) {
-    to = (ssize_t)size() - 1;
+    to = static_cast<ssize_t>(size() - 1);
   } else {
     to = nextOnChannel;
   }
@@ -313,11 +313,11 @@ std::vector<Token *> BufferedTokenStream::getHiddenTokensToLeft(size_t tokenInde
   }
 
   ssize_t prevOnChannel = previousTokenOnChannel(tokenIndex - 1, Lexer::DEFAULT_TOKEN_CHANNEL);
-  if (prevOnChannel == (ssize_t)tokenIndex - 1) {
+  if (prevOnChannel == static_cast<ssize_t>(tokenIndex - 1)) {
     return { };
   }
   // if none onchannel to left, prevOnChannel=-1 then from=0
-  size_t from = (size_t)(prevOnChannel + 1);
+  size_t from = static_cast<size_t>(prevOnChannel + 1);
   size_t to = tokenIndex - 1;
 
   return filterForChannel(from, to, channel);
@@ -336,7 +336,7 @@ std::vector<Token *> BufferedTokenStream::filterForChannel(size_t from, size_t t
         hidden.push_back(t);
       }
     } else {
-      if (t->getChannel() == (size_t)channel) {
+      if (t->getChannel() == static_cast<size_t>(channel)) {
         hidden.push_back(t);
       }
     }

runtime/Cpp/runtime/src/CharStream.h

@@ -13,7 +13,7 @@ namespace antlr4 {
   /// A source of characters for an ANTLR lexer.
   class ANTLR4CPP_PUBLIC CharStream : public IntStream {
   public:
-    virtual ~CharStream() = 0;
+    virtual ~CharStream();
 
     /// This method returns the text for a range of characters within this input
     /// stream. This method is guaranteed to not throw an exception if the

runtime/Cpp/runtime/src/CommonToken.cpp

@@ -35,7 +35,7 @@ CommonToken::CommonToken(std::pair<TokenSource*, CharStream*> source, size_t typ
   _start = start;
   _stop = stop;
   if (_source.first != nullptr) {
-    _line = (int)source.first->getLine();
+    _line = static_cast<int>(source.first->getLine());
     _charPositionInLine = source.first->getCharPositionInLine();
   }
 }

runtime/Cpp/runtime/src/CommonTokenFactory.cpp

@@ -13,7 +13,7 @@ using namespace antlr4;
 
 const Ref<TokenFactory<CommonToken>> CommonTokenFactory::DEFAULT = std::make_shared<CommonTokenFactory>();
 
-CommonTokenFactory::CommonTokenFactory(bool copyText) : copyText(copyText) {
+CommonTokenFactory::CommonTokenFactory(bool copyText_) : copyText(copyText_) {
 }
 
 CommonTokenFactory::CommonTokenFactory() : CommonTokenFactory(false) {

runtime/Cpp/runtime/src/CommonTokenStream.cpp

@@ -12,8 +12,8 @@ using namespace antlr4;
 CommonTokenStream::CommonTokenStream(TokenSource *tokenSource) : CommonTokenStream(tokenSource, Token::DEFAULT_CHANNEL) {
 }
 
-CommonTokenStream::CommonTokenStream(TokenSource *tokenSource, size_t channel)
-: BufferedTokenStream(tokenSource), channel(channel) {
+CommonTokenStream::CommonTokenStream(TokenSource *tokenSource, size_t channel_)
+: BufferedTokenStream(tokenSource), channel(channel_) {
 }
 
 ssize_t CommonTokenStream::adjustSeekIndex(size_t i) {
@@ -25,7 +25,7 @@ Token* CommonTokenStream::LB(size_t k) {
     return nullptr;
   }
 
-  ssize_t i = (ssize_t)_p;
+  ssize_t i = static_cast<ssize_t>(_p);
   size_t n = 1;
   // find k good tokens looking backwards
   while (n <= k) {
@@ -46,7 +46,7 @@ Token* CommonTokenStream::LT(ssize_t k) {
     return nullptr;
   }
   if (k < 0) {
-    return LB((size_t)-k);
+    return LB(static_cast<size_t>(-k));
   }
   size_t i = _p;
   ssize_t n = 1; // we know tokens[p] is a good one

runtime/Cpp/runtime/src/DefaultErrorStrategy.cpp

@@ -62,18 +62,18 @@ void DefaultErrorStrategy::reportError(Parser *recognizer, const RecognitionExce
 
   beginErrorCondition(recognizer);
   if (is<const NoViableAltException *>(&e)) {
-    reportNoViableAlternative(recognizer, (const NoViableAltException &)e);
+    reportNoViableAlternative(recognizer, static_cast<const NoViableAltException &>(e));
   } else if (is<const InputMismatchException *>(&e)) {
-    reportInputMismatch(recognizer, (const InputMismatchException &)e);
+    reportInputMismatch(recognizer, static_cast<const InputMismatchException &>(e));
   } else if (is<const FailedPredicateException *>(&e)) {
-    reportFailedPredicate(recognizer, (const FailedPredicateException &)e);
+    reportFailedPredicate(recognizer, static_cast<const FailedPredicateException &>(e));
   } else if (is<const RecognitionException *>(&e)) {
     recognizer->notifyErrorListeners(e.getOffendingToken(), e.what(), std::current_exception());
   }
 }
 
 void DefaultErrorStrategy::recover(Parser *recognizer, std::exception_ptr /*e*/) {
-  if (lastErrorIndex == (int)recognizer->getInputStream()->index() &&
+  if (lastErrorIndex == static_cast<int>(recognizer->getInputStream()->index()) &&
       lastErrorStates.contains(recognizer->getState())) {
 
     // uh oh, another error at same token index and previously-visited
@@ -82,7 +82,7 @@ void DefaultErrorStrategy::recover(Parser *recognizer, std::exception_ptr /*e*/)
     // at least to prevent an infinite loop; this is a failsafe.
     recognizer->consume();
   }
-  lastErrorIndex = (int)recognizer->getInputStream()->index();
+  lastErrorIndex = static_cast<int>(recognizer->getInputStream()->index());
   lastErrorStates.add(recognizer->getState());
   misc::IntervalSet followSet = getErrorRecoverySet(recognizer);
   consumeUntil(recognizer, followSet);
@@ -312,7 +312,7 @@ misc::IntervalSet DefaultErrorStrategy::getErrorRecoverySet(Parser *recognizer)
 
     if (ctx->parent == nullptr)
       break;
-    ctx = (RuleContext *)ctx->parent;
+    ctx = static_cast<RuleContext *>(ctx->parent);
   }
   recoverSet.remove(Token::EPSILON);
 

runtime/Cpp/runtime/src/DiagnosticErrorListener.cpp

@@ -17,7 +17,7 @@ using namespace antlr4;
 DiagnosticErrorListener::DiagnosticErrorListener() : DiagnosticErrorListener(true) {
 }
 
-DiagnosticErrorListener::DiagnosticErrorListener(bool exactOnly) : exactOnly(exactOnly) {
+DiagnosticErrorListener::DiagnosticErrorListener(bool exactOnly_) : exactOnly(exactOnly_) {
 }
 
 void DiagnosticErrorListener::reportAmbiguity(Parser *recognizer, const dfa::DFA &dfa, size_t startIndex, size_t stopIndex,
@@ -53,7 +53,7 @@ void DiagnosticErrorListener::reportContextSensitivity(Parser *recognizer, const
 
 std::string DiagnosticErrorListener::getDecisionDescription(Parser *recognizer, const dfa::DFA &dfa) {
   size_t decision = dfa.decision;
-  size_t ruleIndex = ((atn::ATNState*)dfa.atnStartState)->ruleIndex;
+  size_t ruleIndex = (reinterpret_cast<atn::ATNState*>(dfa.atnStartState))->ruleIndex;
 
   const std::vector<std::string>& ruleNames = recognizer->getRuleNames();
   if (ruleIndex == INVALID_INDEX || ruleIndex >= ruleNames.size()) {

runtime/Cpp/runtime/src/Exceptions.cpp

@@ -22,3 +22,43 @@ IOException::IOException(const std::string &msg) : std::exception(), _message(ms
 const char* IOException::what() const NOEXCEPT {
   return _message.c_str();
 }
+
+//------------------ IllegalStateException -----------------------------------------------------------------------------
+
+IllegalStateException::~IllegalStateException() {
+}
+
+//------------------ IllegalArgumentException --------------------------------------------------------------------------
+
+IllegalArgumentException::~IllegalArgumentException() {
+}
+
+//------------------ NullPointerException ------------------------------------------------------------------------------
+
+NullPointerException::~NullPointerException() {
+}
+
+//------------------ IndexOutOfBoundsException -------------------------------------------------------------------------
+
+IndexOutOfBoundsException::~IndexOutOfBoundsException() {
+}
+
+//------------------ UnsupportedOperationException ---------------------------------------------------------------------
+
+UnsupportedOperationException::~UnsupportedOperationException() {
+}
+
+//------------------ EmptyStackException -------------------------------------------------------------------------------
+
+EmptyStackException::~EmptyStackException() {
+}
+
+//------------------ CancellationException -----------------------------------------------------------------------------
+
+CancellationException::~CancellationException() {
+}
+
+//------------------ ParseCancellationException ------------------------------------------------------------------------
+
+ParseCancellationException::~ParseCancellationException() {
+}

runtime/Cpp/runtime/src/Exceptions.h

@@ -21,32 +21,51 @@ namespace antlr4 {
 
   class ANTLR4CPP_PUBLIC IllegalStateException : public RuntimeException {
   public:
-    IllegalStateException(const std::string &msg = "") : RuntimeException(msg) {};
+    IllegalStateException(const std::string &msg = "") : RuntimeException(msg) {}
+    IllegalStateException(IllegalStateException const&) = default;
+    ~IllegalStateException();
+    IllegalStateException& operator=(IllegalStateException const&) = default;
   };
 
   class ANTLR4CPP_PUBLIC IllegalArgumentException : public RuntimeException {
   public:
-    IllegalArgumentException(const std::string &msg = "") : RuntimeException(msg) {};
+    IllegalArgumentException(IllegalArgumentException const&) = default;
+    IllegalArgumentException(const std::string &msg = "") : RuntimeException(msg) {}
+    ~IllegalArgumentException();
+    IllegalArgumentException& operator=(IllegalArgumentException const&) = default;
   };
 
   class ANTLR4CPP_PUBLIC NullPointerException : public RuntimeException {
   public:
-    NullPointerException(const std::string &msg = "") : RuntimeException(msg) {};
+    NullPointerException(const std::string &msg = "") : RuntimeException(msg) {}
+    NullPointerException(NullPointerException const&) = default;
+    ~NullPointerException();
+    NullPointerException& operator=(NullPointerException const&) = default;
   };
 
   class ANTLR4CPP_PUBLIC IndexOutOfBoundsException : public RuntimeException {
   public:
-    IndexOutOfBoundsException(const std::string &msg = "") : RuntimeException(msg) {};
+    IndexOutOfBoundsException(const std::string &msg = "") : RuntimeException(msg) {}
+    IndexOutOfBoundsException(IndexOutOfBoundsException const&) = default;
+    ~IndexOutOfBoundsException();
+    IndexOutOfBoundsException& operator=(IndexOutOfBoundsException const&) = default;
   };
 
   class ANTLR4CPP_PUBLIC UnsupportedOperationException : public RuntimeException {
   public:
-    UnsupportedOperationException(const std::string &msg = "") : RuntimeException(msg) {};
+    UnsupportedOperationException(const std::string &msg = "") : RuntimeException(msg) {}
+    UnsupportedOperationException(UnsupportedOperationException const&) = default;
+    ~UnsupportedOperationException();
+    UnsupportedOperationException& operator=(UnsupportedOperationException const&) = default;
+
   };
 
   class ANTLR4CPP_PUBLIC EmptyStackException : public RuntimeException {
   public:
-    EmptyStackException(const std::string &msg = "") : RuntimeException(msg) {};
+    EmptyStackException(const std::string &msg = "") : RuntimeException(msg) {}
+    EmptyStackException(EmptyStackException const&) = default;
+    ~EmptyStackException();
+    EmptyStackException& operator=(EmptyStackException const&) = default;
   };
 
   // IOException is not a runtime exception (in the java hierarchy).
@@ -63,12 +82,18 @@ namespace antlr4 {
 
   class ANTLR4CPP_PUBLIC CancellationException : public IllegalStateException {
   public:
-    CancellationException(const std::string &msg = "") : IllegalStateException(msg) {};
+    CancellationException(const std::string &msg = "") : IllegalStateException(msg) {}
+    CancellationException(CancellationException const&) = default;
+    ~CancellationException();
+    CancellationException& operator=(CancellationException const&) = default;
   };
 
   class ANTLR4CPP_PUBLIC ParseCancellationException : public CancellationException {
   public:
-    ParseCancellationException(const std::string &msg = "") : CancellationException(msg) {};
+    ParseCancellationException(const std::string &msg = "") : CancellationException(msg) {}
+    ParseCancellationException(ParseCancellationException const&) = default;
+    ~ParseCancellationException();
+    ParseCancellationException& operator=(ParseCancellationException const&) = default;
   };
 
 } // namespace antlr4

runtime/Cpp/runtime/src/FailedPredicateException.cpp

@@ -28,8 +28,8 @@ FailedPredicateException::FailedPredicateException(Parser *recognizer, const std
   atn::ATNState *s = recognizer->getInterpreter<atn::ATNSimulator>()->atn.states[recognizer->getState()];
   atn::Transition *transition = s->transitions[0];
   if (is<atn::PredicateTransition*>(transition)) {
-    _ruleIndex = ((atn::PredicateTransition *)transition)->ruleIndex;
-    _predicateIndex = ((atn::PredicateTransition *)transition)->predIndex;
+    _ruleIndex = static_cast<atn::PredicateTransition *>(transition)->ruleIndex;
+    _predicateIndex = static_cast<atn::PredicateTransition *>(transition)->predIndex;
   } else {
     _ruleIndex = 0;
     _predicateIndex = 0;

runtime/Cpp/runtime/src/InputMismatchException.cpp

@@ -13,3 +13,6 @@ InputMismatchException::InputMismatchException(Parser *recognizer)
   : RecognitionException(recognizer, recognizer->getInputStream(), recognizer->getContext(),
                          recognizer->getCurrentToken()) {
 }
+
+InputMismatchException::~InputMismatchException() {
+}