commit 51e7c28ae779b819ce7ecb888292eb6b1b0a9ca2
Author: vaydheesh <lokendras1998@gmail.com>
Date:   Sat Jul 13 22:19:11 2019 +0530

    tagger.h compatible with swig 3.0.12
    
    Removed: const qualifier from Apertium::basic_Tagger::Flags and derived classes

diff --git a/apertium/basic_stream_tagger.cc b/apertium/basic_stream_tagger.cc
index 1d3d947..5055e4a 100644
--- a/apertium/basic_stream_tagger.cc
+++ b/apertium/basic_stream_tagger.cc
@@ -35,7 +35,7 @@
 namespace Apertium {
 basic_StreamTagger::~basic_StreamTagger() {}
 
-void basic_StreamTagger::tag(Stream &Input, std::wostream &Output) const {
+void basic_StreamTagger::tag(Stream &Input, std::wostream &Output) {
   while (true) {
     StreamedType StreamedType_ = Input.get();
     Output << StreamedType_.TheString;
@@ -62,7 +62,7 @@ void basic_StreamTagger::tag(Stream &Input, std::wostream &Output) const {
 }
 
 void basic_StreamTagger::tag(const LexicalUnit &LexicalUnit_,
-                             std::wostream &Output) const {
+                             std::wostream &Output) {
 #if ENABLE_DEBUG
 
   for (std::vector<Analysis>::const_iterator Analysis_ =
diff --git a/apertium/basic_stream_tagger.h b/apertium/basic_stream_tagger.h
index 898dea4..fb105f9 100644
--- a/apertium/basic_stream_tagger.h
+++ b/apertium/basic_stream_tagger.h
@@ -37,7 +37,7 @@ class basic_StreamTagger : public StreamTagger {
 public:
   virtual ~basic_StreamTagger();
   virtual void deserialise(std::istream &Serialised_basic_Tagger) = 0;
-  virtual void tag(Stream &Input, std::wostream &Output) const;
+  virtual void tag(Stream &Input, std::wostream &Output);
 protected:
   virtual long double score(const Analysis &Analysis_) const = 0;
 
@@ -48,7 +48,7 @@ protected:
 #endif // ENABLE_DEBUG
 
 private:
-  void tag(const LexicalUnit &LexicalUnit_, std::wostream &Output) const;
+  void tag(const LexicalUnit &LexicalUnit_, std::wostream &Output);
 };
 }
 
diff --git a/apertium/basic_tagger.cc b/apertium/basic_tagger.cc
index 980bd98..4af7619 100644
--- a/apertium/basic_tagger.cc
+++ b/apertium/basic_tagger.cc
@@ -20,33 +20,33 @@ basic_Tagger::Flags::Flags()
     : Debug(false), First(false), Mark(false), ShowSuperficial(false),
       NullFlush(false) {}
 
-bool basic_Tagger::Flags::getDebug() const { return Debug; }
+bool basic_Tagger::Flags::getDebug() { return Debug; }
 
 void basic_Tagger::Flags::setDebug(const bool &Debug_) { Debug = Debug_; }
 
-bool basic_Tagger::Flags::getSentSeg() const { return SentSeg; }
+bool basic_Tagger::Flags::getSentSeg() { return SentSeg; }
 
 void basic_Tagger::Flags::setSentSeg(const bool &SentSeg_) { SentSeg = SentSeg_; }
 
-bool basic_Tagger::Flags::getSkipErrors() const { return SkipErrors; }
+bool basic_Tagger::Flags::getSkipErrors() { return SkipErrors; }
 
 void basic_Tagger::Flags::setSkipErrors(const bool &SkipErrors_) { SkipErrors = SkipErrors_; }
 
-bool basic_Tagger::Flags::getFirst() const { return First; }
+bool basic_Tagger::Flags::getFirst() { return First; }
 
 void basic_Tagger::Flags::setFirst(const bool &First_) { First = First_; }
 
-bool basic_Tagger::Flags::getMark() const { return Mark; }
+bool basic_Tagger::Flags::getMark() { return Mark; }
 
 void basic_Tagger::Flags::setMark(const bool &Mark_) { Mark = Mark_; }
 
-bool basic_Tagger::Flags::getShowSuperficial() const { return ShowSuperficial; }
+bool basic_Tagger::Flags::getShowSuperficial() { return ShowSuperficial; }
 
 void basic_Tagger::Flags::setShowSuperficial(const bool &ShowSuperficial_) {
   ShowSuperficial = ShowSuperficial_;
 }
 
-bool basic_Tagger::Flags::getNullFlush() const { return NullFlush; }
+bool basic_Tagger::Flags::getNullFlush() { return NullFlush; }
 
 void basic_Tagger::Flags::setNullFlush(const bool &NullFlush_) {
   NullFlush = NullFlush_;
@@ -54,5 +54,5 @@ void basic_Tagger::Flags::setNullFlush(const bool &NullFlush_) {
 
 basic_Tagger::basic_Tagger() : TheFlags() {}
 
-basic_Tagger::basic_Tagger(const Flags &Flags_) : TheFlags(Flags_) {}
+basic_Tagger::basic_Tagger(Flags &Flags_) : TheFlags(Flags_) {}
 }
diff --git a/apertium/basic_tagger.h b/apertium/basic_tagger.h
index c2f3f62..14a796b 100644
--- a/apertium/basic_tagger.h
+++ b/apertium/basic_tagger.h
@@ -22,19 +22,19 @@ public:
   class Flags {
   public:
     Flags();
-    bool getDebug() const;
+    bool getDebug();
     void setDebug(const bool &Debug_);
-    bool getSentSeg() const;
-    void setSentSeg(const bool &SentSeg);
-    bool getSkipErrors() const;
+    bool getSentSeg();
+    void setSentSeg(const bool &SentSeg_);
+    bool getSkipErrors();
     void setSkipErrors(const bool &SkipErrors_);
-    bool getFirst() const;
+    bool getFirst();
     void setFirst(const bool &First_);
-    bool getMark() const;
+    bool getMark();
     void setMark(const bool &Mark_);
-    bool getShowSuperficial() const;
+    bool getShowSuperficial();
     void setShowSuperficial(const bool &ShowSuperficial_);
-    bool getNullFlush() const;
+    bool getNullFlush();
     void setNullFlush(const bool &NullFlush_);
     static bool (Flags::*GetDebug)() const;
     static void (Flags::*SetDebug)(const bool &);
@@ -59,7 +59,7 @@ public:
 
 protected:
   basic_Tagger();
-  basic_Tagger(const Flags &Flags_);
+  basic_Tagger(Flags &Flags_);
   Flags TheFlags;
 };
 }
diff --git a/apertium/perceptron_tagger.cc b/apertium/perceptron_tagger.cc
index 066d0f7..395fc0e 100644
--- a/apertium/perceptron_tagger.cc
+++ b/apertium/perceptron_tagger.cc
@@ -12,7 +12,7 @@ PerceptronTagger::PerceptronTagger(basic_Tagger::Flags flags) : basic_Tagger(fla
 
 PerceptronTagger::~PerceptronTagger() {};
 
-void PerceptronTagger::tag(Stream &in, std::wostream &out) const {
+void PerceptronTagger::tag(Stream &in, std::wostream &out) {
   SentenceStream::SentenceTagger::tag(in, out, TheFlags.getSentSeg());
 }
 
@@ -30,7 +30,7 @@ operator<<(std::wostream &out, PerceptronTagger const &pt) {
 }
 
 TaggedSentence
-PerceptronTagger::tagSentence(const Sentence &untagged_sent) const {
+PerceptronTagger::tagSentence(const Sentence &untagged_sent) {
   const size_t sent_len = untagged_sent.size();
 
   std::vector<AgendaItem> agenda;
@@ -100,7 +100,7 @@ PerceptronTagger::tagSentence(const Sentence &untagged_sent) const {
 
 void PerceptronTagger::outputLexicalUnit(
     const LexicalUnit &lexical_unit, const Optional<Analysis> analysis,
-    std::wostream &output) const {
+    std::wostream &output) {
   StreamTagger::outputLexicalUnit(lexical_unit, analysis, output);
 }
 
diff --git a/apertium/perceptron_tagger.h b/apertium/perceptron_tagger.h
index 344663c..919af2e 100644
--- a/apertium/perceptron_tagger.h
+++ b/apertium/perceptron_tagger.h
@@ -22,16 +22,16 @@ public:
   virtual void train(Stream &tagged, Stream &untagged, int iterations);
   // tagger
   virtual void deserialise(std::istream &serialised);
-  virtual void tag(Stream &input, std::wostream &output) const;
+  virtual void tag(Stream &input, std::wostream &output);
 
   void read_spec(const std::string &filename);
 
   friend std::wostream& operator<<(std::wostream &out, PerceptronTagger const &pt);
 protected:
-  virtual TaggedSentence tagSentence(const Sentence &untagged) const;
+  virtual TaggedSentence tagSentence(const Sentence &untagged);
   virtual void outputLexicalUnit(
     const LexicalUnit &lexical_unit, const Optional<Analysis> analysis,
-    std::wostream &output) const;
+    std::wostream &output);
 private:
   bool trainSentence(
     const TrainingSentence &sentence,
diff --git a/apertium/sentence_stream.cc b/apertium/sentence_stream.cc
index cfcb7a4..39630ff 100644
--- a/apertium/sentence_stream.cc
+++ b/apertium/sentence_stream.cc
@@ -38,7 +38,7 @@ bool isSentenceEnd(StreamedType tok, Stream &in, bool sent_seg) {
 
 SentenceTagger::SentenceTagger() {}
 
-void SentenceTagger::tag(Stream &in, std::wostream &out, bool sent_seg) const {
+void SentenceTagger::tag(Stream &in, std::wostream &out, bool sent_seg) {
   clearBuffers();
 
   while (true) {
@@ -68,7 +68,7 @@ void SentenceTagger::clearBuffers() const {
   flushes.clear();
 }
 
-void SentenceTagger::tagAndPutSentence(std::wostream &out) const {
+void SentenceTagger::tagAndPutSentence(std::wostream &out) {
   TaggedSentence tagged_sent = tagSentence(lexical_sent);
   TaggedSentence::const_iterator ts_it = tagged_sent.begin();
 
diff --git a/apertium/sentence_stream.h b/apertium/sentence_stream.h
index c317c67..aea298e 100644
--- a/apertium/sentence_stream.h
+++ b/apertium/sentence_stream.h
@@ -20,16 +20,16 @@ namespace SentenceStream {
   bool isSentenceEnd(Stream &in, bool sent_seg = false);
   class SentenceTagger {
   public:
-    void tag(Stream &in, std::wostream &out, bool sent_seg) const;
+    void tag(Stream &in, std::wostream &out, bool sent_seg);
     SentenceTagger();
   protected:
-    virtual TaggedSentence tagSentence(const Sentence &untagged) const = 0;
+    virtual TaggedSentence tagSentence(const Sentence &untagged) = 0;
     virtual void outputLexicalUnit(
       const LexicalUnit &lexical_unit, const Optional<Analysis> analysis,
-      std::wostream &output) const = 0;
+      std::wostream &output) = 0;
   private:
     void clearBuffers() const;
-    void tagAndPutSentence(std::wostream &out) const;
+    void tagAndPutSentence(std::wostream &out);
     void putTaggedSent(
       std::wostream &out, TaggedSentence &tagged_sent, Sentence &full_sent,
       std::vector<bool> &flushes) const;
diff --git a/apertium/stream.cc b/apertium/stream.cc
index 3426513..ab14f23 100644
--- a/apertium/stream.cc
+++ b/apertium/stream.cc
@@ -30,23 +30,23 @@
 #include <string>
 
 namespace Apertium {
-Stream::Stream(const basic_Tagger::Flags &Flags_)
+Stream::Stream(basic_Tagger::Flags &Flags_)
     : TheCharacterStream(std::wcin), TheFilename(), TheLineNumber(1), TheLine(),
       TheFlags(Flags_), private_flush_(false), ThePreviousCase() {}
 
-Stream::Stream(const basic_Tagger::Flags &Flags_,
+Stream::Stream(basic_Tagger::Flags &Flags_,
                std::wifstream &CharacterStream_, const char *const Filename_)
     : TheCharacterStream(CharacterStream_), TheFilename(Filename_),
       TheLineNumber(1), TheLine(), TheFlags(Flags_), private_flush_(false),
       ThePreviousCase() {}
 
-Stream::Stream(const basic_Tagger::Flags &Flags_,
+Stream::Stream(basic_Tagger::Flags &Flags_,
                std::wifstream &CharacterStream_, const std::string &Filename_)
     : TheCharacterStream(CharacterStream_), TheFilename(Filename_),
       TheLineNumber(1), TheLine(), TheFlags(Flags_), private_flush_(false),
       ThePreviousCase() {}
 
-Stream::Stream(const basic_Tagger::Flags &Flags_,
+Stream::Stream(basic_Tagger::Flags &Flags_,
                std::wifstream &CharacterStream_,
                const std::stringstream &Filename_)
     : TheCharacterStream(CharacterStream_), TheFilename(Filename_.str()),
@@ -652,7 +652,7 @@ bool Stream::flush_() const { return private_flush_; }
 
 void Stream::outputLexicalUnit(
     const LexicalUnit &lexical_unit, const Optional<Analysis> analysis,
-    std::wostream &output, const basic_Tagger::Flags &flags) {
+    std::wostream &output, basic_Tagger::Flags &flags) {
   using namespace std::rel_ops;
   output << L"^";
 
diff --git a/apertium/stream.h b/apertium/stream.h
index bb3b104..18aa83a 100644
--- a/apertium/stream.h
+++ b/apertium/stream.h
@@ -28,12 +28,12 @@
 namespace Apertium {
 class Stream {
 public:
-  Stream(const basic_Tagger::Flags &Flags_);
-  Stream(const basic_Tagger::Flags &Flags_, std::wifstream &CharacterStream_,
+  Stream(basic_Tagger::Flags &Flags_);
+  Stream(basic_Tagger::Flags &Flags_, std::wifstream &CharacterStream_,
          const char *const Filename_);
-  Stream(const basic_Tagger::Flags &Flags_, std::wifstream &CharacterStream_,
+  Stream(basic_Tagger::Flags &Flags_, std::wifstream &CharacterStream_,
          const std::string &Filename_);
-  Stream(const basic_Tagger::Flags &Flags_, std::wifstream &CharacterStream_,
+  Stream(basic_Tagger::Flags &Flags_, std::wifstream &CharacterStream_,
          const std::stringstream &Filename_);
   StreamedType get();
   StreamedType peek();
@@ -42,7 +42,7 @@ public:
 
   static void outputLexicalUnit(
     const LexicalUnit &lexical_unit, const Optional<Analysis> analysis,
-    std::wostream &output, const basic_Tagger::Flags &flags);
+    std::wostream &output, basic_Tagger::Flags &flags);
 
   std::size_t TheLineNumber;
 private:
@@ -66,7 +66,7 @@ private:
   std::wistream &TheCharacterStream;
   Optional<std::string> TheFilename;
   std::wstring TheLine;
-  const basic_Tagger::Flags &TheFlags;
+  basic_Tagger::Flags &TheFlags;
   bool private_flush_ : 1;
   Optional<PreviousCaseType> ThePreviousCase;
 };
diff --git a/apertium/stream_5_3_1_tagger.cc b/apertium/stream_5_3_1_tagger.cc
index 7268800..34c2809 100644
--- a/apertium/stream_5_3_1_tagger.cc
+++ b/apertium/stream_5_3_1_tagger.cc
@@ -36,7 +36,7 @@
 #endif // ENABLE_DEBUG
 
 namespace Apertium {
-Stream_5_3_1_Tagger::Stream_5_3_1_Tagger(const Flags &Flags_)
+Stream_5_3_1_Tagger::Stream_5_3_1_Tagger(Flags &Flags_)
     : basic_Tagger(Flags_), basic_5_3_1_Tagger() {}
 
 void Stream_5_3_1_Tagger::deserialise(std::istream &Serialised_basic_Tagger) {
diff --git a/apertium/stream_5_3_1_tagger.h b/apertium/stream_5_3_1_tagger.h
index aab04c8..66563b7 100644
--- a/apertium/stream_5_3_1_tagger.h
+++ b/apertium/stream_5_3_1_tagger.h
@@ -34,7 +34,7 @@ namespace Apertium {
 class Stream_5_3_1_Tagger : private basic_5_3_1_Tagger,
                             public basic_StreamTagger {
 public:
-  Stream_5_3_1_Tagger(const Flags &Flags_);
+  Stream_5_3_1_Tagger(Flags &Flags_);
   void deserialise(std::istream &Serialised_basic_Tagger);
 
 private:
diff --git a/apertium/stream_5_3_1_tagger_trainer.cc b/apertium/stream_5_3_1_tagger_trainer.cc
index 615b22f..d14b4ba 100644
--- a/apertium/stream_5_3_1_tagger_trainer.cc
+++ b/apertium/stream_5_3_1_tagger_trainer.cc
@@ -26,7 +26,7 @@
 
 namespace Apertium {
 Stream_5_3_1_TaggerTrainer::Stream_5_3_1_TaggerTrainer(
-    const basic_Tagger::Flags &Flags_)
+    basic_Tagger::Flags &Flags_)
     : basic_Tagger(Flags_), basic_5_3_1_Tagger() {}
 
 void Stream_5_3_1_TaggerTrainer::serialise(
diff --git a/apertium/stream_5_3_1_tagger_trainer.h b/apertium/stream_5_3_1_tagger_trainer.h
index 486f7be..a3d00fc 100644
--- a/apertium/stream_5_3_1_tagger_trainer.h
+++ b/apertium/stream_5_3_1_tagger_trainer.h
@@ -28,7 +28,7 @@ namespace Apertium {
 class Stream_5_3_1_TaggerTrainer : private basic_5_3_1_Tagger,
                                    public basic_StreamTaggerTrainer {
 public:
-  Stream_5_3_1_TaggerTrainer(const Flags &Flags_);
+  Stream_5_3_1_TaggerTrainer(Flags &Flags_);
   void serialise(std::ostream &Serialised_basic_Tagger) const;
 
 private:
diff --git a/apertium/stream_5_3_2_tagger.cc b/apertium/stream_5_3_2_tagger.cc
index 1060711..8ec5293 100644
--- a/apertium/stream_5_3_2_tagger.cc
+++ b/apertium/stream_5_3_2_tagger.cc
@@ -34,7 +34,7 @@
 #endif // ENABLE_DEBUG
 
 namespace Apertium {
-Stream_5_3_2_Tagger::Stream_5_3_2_Tagger(const Flags &Flags_)
+Stream_5_3_2_Tagger::Stream_5_3_2_Tagger(Flags &Flags_)
     : basic_Tagger(Flags_), basic_5_3_2_Tagger() {}
 
 void Stream_5_3_2_Tagger::deserialise(std::istream &Serialised_basic_Tagger) {
diff --git a/apertium/stream_5_3_2_tagger.h b/apertium/stream_5_3_2_tagger.h
index 397d729..4b7c992 100644
--- a/apertium/stream_5_3_2_tagger.h
+++ b/apertium/stream_5_3_2_tagger.h
@@ -34,7 +34,7 @@ namespace Apertium {
 class Stream_5_3_2_Tagger : private basic_5_3_2_Tagger,
                             public basic_StreamTagger {
 public:
-  Stream_5_3_2_Tagger(const Flags &Flags_);
+  Stream_5_3_2_Tagger(Flags &Flags_);
   void deserialise(std::istream &Serialised_basic_Tagger);
 
 private:
diff --git a/apertium/stream_5_3_2_tagger_trainer.cc b/apertium/stream_5_3_2_tagger_trainer.cc
index f7f54d3..3051ed7 100644
--- a/apertium/stream_5_3_2_tagger_trainer.cc
+++ b/apertium/stream_5_3_2_tagger_trainer.cc
@@ -25,7 +25,7 @@
 #include <utility>
 
 namespace Apertium {
-Stream_5_3_2_TaggerTrainer::Stream_5_3_2_TaggerTrainer(const Flags &Flags_)
+Stream_5_3_2_TaggerTrainer::Stream_5_3_2_TaggerTrainer(Flags &Flags_)
     : basic_Tagger(Flags_) {}
 
 void Stream_5_3_2_TaggerTrainer::serialise(
diff --git a/apertium/stream_5_3_2_tagger_trainer.h b/apertium/stream_5_3_2_tagger_trainer.h
index 04c2a07..39b4959 100644
--- a/apertium/stream_5_3_2_tagger_trainer.h
+++ b/apertium/stream_5_3_2_tagger_trainer.h
@@ -25,7 +25,7 @@ namespace Apertium {
 class Stream_5_3_2_TaggerTrainer : private basic_5_3_2_Tagger,
                                    public basic_StreamTaggerTrainer {
 public:
-  Stream_5_3_2_TaggerTrainer(const Flags &Flags_);
+  Stream_5_3_2_TaggerTrainer(Flags &Flags_);
   void serialise(std::ostream &Serialised_basic_Tagger) const;
 
 private:
diff --git a/apertium/stream_5_3_3_tagger.cc b/apertium/stream_5_3_3_tagger.cc
index 9eefc59..d28193f 100644
--- a/apertium/stream_5_3_3_tagger.cc
+++ b/apertium/stream_5_3_3_tagger.cc
@@ -33,7 +33,7 @@
 #endif // ENABLE_DEBUG
 
 namespace Apertium {
-Stream_5_3_3_Tagger::Stream_5_3_3_Tagger(const Flags &Flags_)
+Stream_5_3_3_Tagger::Stream_5_3_3_Tagger(Flags &Flags_)
     : basic_Tagger(Flags_) {}
 
 void Stream_5_3_3_Tagger::deserialise(std::istream &Serialised_basic_Tagger) {
diff --git a/apertium/stream_5_3_3_tagger.h b/apertium/stream_5_3_3_tagger.h
index 9b7c5ca..a101fa8 100644
--- a/apertium/stream_5_3_3_tagger.h
+++ b/apertium/stream_5_3_3_tagger.h
@@ -36,7 +36,7 @@ namespace Apertium {
 class Stream_5_3_3_Tagger : private basic_5_3_3_Tagger,
                             public basic_StreamTagger {
 public:
-  Stream_5_3_3_Tagger(const Flags &Flags_);
+  Stream_5_3_3_Tagger(Flags &Flags_);
   void deserialise(std::istream &Serialised_basic_Tagger);
 
 private:
diff --git a/apertium/stream_5_3_3_tagger_trainer.cc b/apertium/stream_5_3_3_tagger_trainer.cc
index bd6c47c..56f1e55 100644
--- a/apertium/stream_5_3_3_tagger_trainer.cc
+++ b/apertium/stream_5_3_3_tagger_trainer.cc
@@ -26,7 +26,7 @@
 #include <vector>
 
 namespace Apertium {
-Stream_5_3_3_TaggerTrainer::Stream_5_3_3_TaggerTrainer(const Flags &Flags_)
+Stream_5_3_3_TaggerTrainer::Stream_5_3_3_TaggerTrainer(Flags &Flags_)
     : basic_Tagger(Flags_) {}
 
 void Stream_5_3_3_TaggerTrainer::serialise(
diff --git a/apertium/stream_5_3_3_tagger_trainer.h b/apertium/stream_5_3_3_tagger_trainer.h
index 7e2e5d6..ca6108c 100644
--- a/apertium/stream_5_3_3_tagger_trainer.h
+++ b/apertium/stream_5_3_3_tagger_trainer.h
@@ -26,7 +26,7 @@ namespace Apertium {
 class Stream_5_3_3_TaggerTrainer : private basic_5_3_3_Tagger,
                                    public basic_StreamTaggerTrainer {
 public:
-  Stream_5_3_3_TaggerTrainer(const Flags &Flags_);
+  Stream_5_3_3_TaggerTrainer(Flags &Flags_);
   void serialise(std::ostream &Serialised_basic_Tagger) const;
 
 private:
diff --git a/apertium/stream_tagger.cc b/apertium/stream_tagger.cc
index 7311399..dc6576f 100644
--- a/apertium/stream_tagger.cc
+++ b/apertium/stream_tagger.cc
@@ -7,7 +7,7 @@ StreamTagger::~StreamTagger() {}
 
 void StreamTagger::outputLexicalUnit(
     const LexicalUnit &lexical_unit, const Optional<Analysis> analysis,
-    std::wostream &output) const {
+    std::wostream &output) {
   Stream::outputLexicalUnit(lexical_unit, analysis, output, TheFlags);
 }
 }
diff --git a/apertium/stream_tagger.h b/apertium/stream_tagger.h
index 94b5a14..1b4e38f 100644
--- a/apertium/stream_tagger.h
+++ b/apertium/stream_tagger.h
@@ -11,10 +11,10 @@ class StreamTagger : protected virtual basic_Tagger {
 public:
   virtual ~StreamTagger();
   virtual void deserialise(std::istream &Serialised_basic_Tagger) = 0;
-  virtual void tag(Stream &Input, std::wostream &Output) const = 0;
+  virtual void tag(Stream &Input, std::wostream &Output) = 0;
   void outputLexicalUnit(
     const LexicalUnit &lexical_unit, const Optional<Analysis> analysis,
-    std::wostream &output) const;
+    std::wostream &output);
 };
 }
 
diff --git a/apertium/tagger.cc b/apertium/tagger.cc
index bdeca4f..6693778 100644
--- a/apertium/tagger.cc
+++ b/apertium/tagger.cc
@@ -424,7 +424,7 @@ void apertium_tagger::set_indexptr() {
 }
 
 void apertium_tagger::flagOptionCase(
-    bool (basic_Tagger::Flags::*GetFlag)() const,
+    bool (basic_Tagger::Flags::*GetFlag)(),
     void (basic_Tagger::Flags::*SetFlag)(const bool &)) {
   if ((TheFlags.*GetFlag)()) {
     std::stringstream what_;
diff --git a/apertium/tagger.h b/apertium/tagger.h
index e0f1598..86063e4 100644
--- a/apertium/tagger.h
+++ b/apertium/tagger.h
@@ -46,7 +46,7 @@ private:
   static std::string option_string(const struct option &option_);
   static void locale_global_();
   void set_indexptr();
-  void flagOptionCase(bool (basic_Tagger::Flags::*GetFlag)() const,
+  void flagOptionCase(bool (basic_Tagger::Flags::*GetFlag)(),
                       void (basic_Tagger::Flags::*SetFlag)(const bool &));
   std::string option_string();
   void functionTypeTypeOptionCase(const FunctionTypeType &FunctionTypeType_);