Modernize XSC code

.clang-format

@@ -0,0 +1 @@
+ColumnLimit: 120

.github/workflows/linux.yml

@@ -7,6 +7,10 @@ on:
     - cron: '0 1 * * SUN'
   workflow_dispatch:
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
 permissions:
   contents: read
 
@@ -47,15 +51,14 @@ jobs:
       if: matrix.Repo != ''
     - name: Add packages
       run: |
-        sudo apt-get --yes install libxerces-c-dev libssl-dev libboost-all-dev ${{ matrix.PackageDeps }}
+        sudo apt-get --yes install libxerces-c-dev libssl-dev ${{ matrix.PackageDeps }}
     - name: create $ACE_ROOT/ace/config.h
       run: |
         '#include "ace/config-linux.h"' > ${env:ACE_ROOT}/ace/config.h
       shell: pwsh
     - name: create $ACE_ROOT/include/makeinclude/platform_macros.GNU
       run: |
-        'boost=1' > ${env:ACE_ROOT}/include/makeinclude/platform_macros.GNU
-        'xerces3=1' >> ${env:ACE_ROOT}/include/makeinclude/platform_macros.GNU
+        'xerces3=1' > ${env:ACE_ROOT}/include/makeinclude/platform_macros.GNU
         'ssl=1' >> ${env:ACE_ROOT}/include/makeinclude/platform_macros.GNU
         'xsc=1' >> ${env:ACE_ROOT}/include/makeinclude/platform_macros.GNU
       shell: pwsh
@@ -70,8 +73,7 @@ jobs:
       shell: pwsh
     - name: create $ACE_ROOT/bin/MakeProjectCreator/config/default.features
       run: |
-        'boost=1' > ${env:ACE_ROOT}/bin/MakeProjectCreator/config/default.features
-        'xerces3=1' >> ${env:ACE_ROOT}/bin/MakeProjectCreator/config/default.features
+        'xerces3=1' > ${env:ACE_ROOT}/bin/MakeProjectCreator/config/default.features
         'xsc=1' >> ${env:ACE_ROOT}/bin/MakeProjectCreator/config/default.features
       shell: pwsh
     - name: Run mwc.pl on $(XSC_ROOT)/XSC.mwc

contrib/CCF/CCF/CCF/CodeGenerationKit/IndentationBuffer.hpp → CCF/CodeGenerationKit/IndentationBuffer.hpp

@@ -4,8 +4,7 @@
 #ifndef CCF_CODE_GENERATION_KIT_INDENTATION_BUFFER_HPP
 #define CCF_CODE_GENERATION_KIT_INDENTATION_BUFFER_HPP
 
-#include "CCF/CompilerElements/ExH.hpp"
-
+#include <stdexcept>
 #include <string>
 
 namespace Indentation
@@ -15,29 +14,17 @@ namespace Indentation
   {
   public:
 
-    typedef ExH::Logic::DescriptiveException Exception;
-
-    class EndOfStream_ {};
-    typedef
-    ExH::Compound <EndOfStream_, Exception>
-    EndOfStream;
+    using EndOfStream = std::runtime_error;
 
   public:
-    virtual
-    ~Buffer () { }
+    virtual ~Buffer () = default;
 
   public:
-    typedef
-    std::char_traits<C>
-    traits_type;
+    using traits_type = std::char_traits<C>;
 
-    typedef
-    typename traits_type::char_type
-    char_type;
+    using char_type = typename traits_type::char_type;
 
-    typedef
-    typename traits_type::int_type
-    int_type;
+    using int_type = typename traits_type::int_type;
 
   public:
     virtual int_type

contrib/CCF/CCF/CCF/CodeGenerationKit/IndentationCxx.hpp → CCF/CodeGenerationKit/IndentationCxx.hpp

@@ -4,6 +4,7 @@
 #ifndef CCF_CODE_GENERATION_KIT_INDENTATION_CXX_HPP
 #define CCF_CODE_GENERATION_KIT_INDENTATION_CXX_HPP
 
+#include <cstddef>
 #include <deque>
 #include <stack>
 
@@ -21,16 +22,16 @@ namespace Indentation
   {
   public:
     /// Type definition of the traits type.
-    typedef typename Buffer <C>::traits_type traits_type;
+    using traits_type = typename Buffer<C>::traits_type;
 
     /// Type definition of the char type.
-    typedef typename Buffer <C>::char_type char_type;
+    using char_type = typename Buffer<C>::char_type;
 
     /// Type definition of the integer type
-    typedef typename Buffer <C>::int_type int_type;
+    using int_type = typename Buffer<C>::int_type;
 
     /// Type definition of the end of stream.
-    typedef typename Buffer <C>::EndOfStream EndOfStream;
+    using EndOfStream = typename Buffer<C>::EndOfStream;
 
   public:
     /**
@@ -49,16 +50,14 @@ namespace Indentation
     }
 
     /// Destructor
-    virtual ~Cxx (void)
-    {
-    }
+    ~Cxx () override = default;
 
   public:
     /**
      * Add a new character to the buffer. Based on the character, different
      * actions are taken. The newline always causes the buffer to be flushed.
      */
-    virtual int_type put (char_type c)
+    int_type put (char_type c) override
     {
       int_type result = traits_type::to_int_type (c);
 
@@ -165,7 +164,7 @@ namespace Indentation
             if (this->hold_.size () > 1 && this->hold_.back () == '\n')
             {
               bool pop_nl = false;
-              typedef typename Hold::reverse_iterator iterator;
+              using iterator = typename Hold::reverse_iterator;
 
               for (iterator i = this->hold_.rbegin (),
                    e = this->hold_.rend ();
@@ -333,7 +332,7 @@ namespace Indentation
      * Unbuffer the elements. This will remove the elements on
      * the holding queue to the target output stream.
      */
-    virtual void unbuffer (void)
+    void unbuffer () override
     {
       int_type result;
 
@@ -355,7 +354,7 @@ namespace Indentation
      * Helper method that makes sure a newline exists at the end
      * of the holding buffer.
      */
-    void ensure_new_line (void)
+    void ensure_new_line ()
     {
       if (this->hold_.empty () || hold_.back () != '\n')
       {
@@ -371,11 +370,11 @@ namespace Indentation
      * Helper method that writes the current indentation to the
      * output buffer.
      */
-    void output_indentation (void)
+    void output_indentation ()
     {
       if (!this->hold_.empty () && this->hold_.back () == '\n')
       {
-        for (unsigned long i = 0; i < this->indentation_.top (); i++)
+        for (std::size_t i {}; i < this->indentation_.top (); ++i)
           this->write (' ');
 
         this->position_ += this->indentation_.top ();
@@ -410,16 +409,16 @@ namespace Indentation
     Buffer <C> & out_;
 
     /// Current position on the line
-    unsigned long position_;
+    std::size_t position_;
 
     /// Balance the parenthesis
-    unsigned long paren_balance_;
+    std::size_t paren_balance_;
 
     /// Saved indentations based on state/scope.
-    std::stack <size_t> indentation_;
+    std::stack<std::size_t> indentation_;
 
     /// Number of space in a indentation.
-    unsigned long spaces_;
+    std::size_t spaces_;
 
     enum Construct
     {
@@ -433,7 +432,7 @@ namespace Indentation
     Construct construct_;
 
     /// Type definition of the holding queue.
-    typedef std::deque <int_type> Hold;
+    using Hold = std::deque<int_type>;
 
     /// Holding queue for elements.
     Hold hold_;

contrib/CCF/CCF/CCF/CodeGenerationKit/IndentationIDL.hpp → CCF/CodeGenerationKit/IndentationIDL.hpp

@@ -4,6 +4,7 @@
 #ifndef CCF_CODE_GENERATION_KIT_INDENTATION_IDL_HPP
 #define CCF_CODE_GENERATION_KIT_INDENTATION_IDL_HPP
 
+#include <cstddef>
 #include <deque>
 
 #include "CCF/CodeGenerationKit/IndentationBuffer.hpp"
@@ -14,37 +15,28 @@ namespace Indentation
   class IDL : public Buffer<C>
   {
   public:
-    typedef
-    typename Buffer<C>::traits_type
-    traits_type;
+    using traits_type = typename Buffer<C>::traits_type;
 
-    typedef
-    typename Buffer<C>::char_type
-    char_type;
+    using char_type = typename Buffer<C>::char_type;
 
-    typedef
-    typename Buffer<C>::int_type
-    int_type;
+    using int_type = typename Buffer<C>::int_type;
 
-    typedef
-    typename Buffer<C>::EndOfStream
-    EndOfStream;
+    using EndOfStream = typename Buffer<C>::EndOfStream;
 
   public:
     IDL (Buffer<C>& out)
         : out_ (out),
-          indentation_ (0),
+          indentation_ {},
           spaces_ (2),
           construct_ (OTHER)
     {
     }
 
-    virtual
-    ~IDL () throw () {}
+    ~IDL () noexcept override = default;
 
   public:
-    virtual int_type
-    put (char_type c)
+    int_type
+    put (char_type c) override
     {
       int_type result = traits_type::to_int_type (c);
 
@@ -185,8 +177,8 @@ namespace Indentation
       return result;
     }
 
-    virtual void
-    unbuffer ()
+    void
+    unbuffer () override
     {
       int_type result;
 
@@ -222,7 +214,7 @@ namespace Indentation
     {
       if (!hold_.empty () && hold_.back () == '\n')
       {
-        for (unsigned long i = 0; i < indentation_ * spaces_; i++)
+        for (std::size_t i {}; i < indentation_ * spaces_; ++i)
         {
           write (' ');
         }
@@ -251,8 +243,8 @@ namespace Indentation
 
   private:
     Buffer<C>& out_;
-    unsigned long indentation_;
-    unsigned long spaces_;
+    std::size_t indentation_;
+    std::size_t spaces_;
 
     enum Construct
     {
@@ -263,9 +255,7 @@ namespace Indentation
 
     Construct construct_;
 
-    typedef
-    std::deque<int_type>
-    Hold;
+    using Hold = std::deque<int_type>;
 
     Hold hold_;
   };