Uncrustify: where do the Spaces options work

# Uncrustify: Where do the options work?

## Spaces

You want to "add/ force/ ignore/ remove" a

- space for assign
- space for byref
- space for case
- space for cast
- space for class
- space for comma
- space for D
- space for enum
- space for for loop
- space for new/ delete
- space for operator
- space for parenthesis
- space for preprocessor
- space for template
- options_Java
- options_Objectiv-C
- options_C#
- options_CLI .NET
- options_ASM

at some places.

Some more options...

    // Comments
      █
    int a;            /* emb cmt */ int b;            // trailing cmt
          █..........█                    █..........█

        union {
            uint maxChars;
            uint maxBytes;
        } mLength;
        union { int m_size; int m_any; };
               █                      █
        return { -1, -1, -1 };
                █          █

    class Parser :: ParserPrivate { };
                █  █               █
    template <typename T> class to { };
                                    █
    my $all = { };
               █
    enum FocusEffect { };
                      █
    struct error { };
                  █
    };

    #define LOG_FMT (sev, args ...) \
                   █          █
       do { if (log_sev_on(sev)) { log_fmt(sev, ## args); } } while (0)
                                               █  █
    #endif
    #define FS_NOCOW_FL 0x00800000
                       █
    #define STRHACK(x) HACKSTR(x)
                 █
    #define wakeUpCaller(cond) \
                              █
        if (cond) { \
                   █
            cond->release(); \
                            █
         }
    typedef struct { int val; int sel; } DiceInfo;
                                        █
    void * bar()
        █ █
    {
        int a = 5;
             █ █
             █ █
        int * const i;
             █
        c = a + b;
             █ █
        a = ~ b;
             █
        x = - 5;
             █
        y = + 7;
             █
        (-- a);
           █
        i ++;
         █
        b = ( a == d ) ? 55 : 88;
                      █ █  █ █
                      █ █  █ █
        b = ( a == d ) ? : 88;
                        █
        if( ( a || b ) && c ) x = 1;
               █  █   █  █
             █      █      █
           █
        c = a > b;
             █ █
        int * i;
           █ █
           █
        int * * j;
             █
        throw (x);
             █
        try {
           █
        } catch (const Exception &e) { }
         █     █
        } catch (...) { }
         █     █
        } catch { }
         █     █
        auto x1 = decltype(x) {0};
                             █
        Foo() noexcept () {}
                      █
        void operator ++ ( );
                     █  █ █
        int a0[][] = { { 1 } };
                      █ █ █ █
        char m_array [256];
                    █
        return { {crypt(_Nums, inSeed)} };
                █                      █
        do {
          █
            xxx = _error;
        } while(0)
         █
        bool CompareGenomeByFeatureResults::clickOnLink(std::string const& inLink) {
            auto const [sequence, type, firstPosition, lastPosition] = parseLink(inLink);
                      █
        decltype (x)  y;
                █
        using x_t = decltype (x);
                            █
        foo( ABC );
            █   █
        foo( ( ABC ) )
            █       █
        typedef void timer_cb (struct timer_node *n);
                             █
        if (n) ;
              █
        a( , 1);
          █
        foo() noexcept;
             █
        return {x};
              █
        void funcName() const;
                       █
        void ncName() override;
                     █
    template  <  int  ...  X  > int bar2()
    {
            auto s = sizeof ... (  X  );
                           █   █
            chomp(  X  ) ...;
                        █
            return X  +  ...;
    }
        if (data)   go = new ClassA();
                  █
        else        go = new ClassB();
                  █

    int main(int argc , char *argv [])
                     █ █          █
    {
    	int a [2];
    	     █
    	a[ n ] = 3;
    	  █ █
    	const char *names [] =
    	                 █
    	{
    		"{ False , True }",
    		        █ █
    		"{ Ignore, Add, Remove, Force }",

    	return (-1);
    	      █

        int a ( );
             █ █
        int a (int b) {};
             █       █
        int foo () {};
               █
    void ( int a ) ( int b );
          █     █ █ █     █
    static void sockaddr_unmapped(
        struct sockaddr *sa __attribute__ ((unused)),
                                         █
        socklen_t *len __attribute__ ((unused)))
                                    █

    void (^ weak_recurseTreeNodes)(int a);
           █
    template< >
    struct Bar< false > : Foo { };
                       █

    template < typename T > inline static bool remove(T column)
            █ █          █
            █              █
    int & a(int & b);
       █ █     █ █
    int c(int &)
       █     █
    {
    	d = aa (& y,& d) ;
    	      █  █   █  █
            e = ee ();
                  █
    	if ( a == 5 ) ...
    	  █
                █      █
                █      █
                ...
            if (b) ;
                  █
    	if ( a == 6 ) b = 66;
                         █
    	if ( a == 7 ) { b = 77; }
                         █
            if (! a) {
                 █
                b = 4;
            } else {
             █    █
                b = 5;
            }
            for(a = 1 ; a < b ; a++) {
                     █       █
               ...
    	for( ; ; ) {
                █ █ █
               ...
    	switch (whatIsToDo) ...
    	      █
    	while (start < end) ...
    	     █

    namespace Server {
                    █
    class Cache : public QObject
               █ █
    Cache::StorageDebugger ()
                          █
        : mFile(0)
       █ █
    {
            new service;
               █
            delete service;
                  █
            delete[] buffer;
                    █
            if (this == & other) return * this;
                         █               █
            switch (a) {
            case 1 :
                  █
                    b= 1;
                    break;
            case 2 : {
                    b = 2;
                    break;
            }
            default :
                    break;
            }
            bool operator () (Entity::Id lhs, Entity::Id rhs) const
            ...          █  █

            a = ( int ) 5.6;
                 █   █ █
            cpp = int (7);
                     █
            len = sizeof (int);
                        █
            SomeStruct a = SomeStruct {1, 2, 3};
                                     █
    	someFuncCall(SomeStruct {4, 5, 6});
    	                       █
            log . foo . bar = 5;
               █ █   █ █
    	other -> foo -> bar = 123;
    	     █  █   █  █
    }
    /// doxygen sequence
       █
    ///< doxygen sequence
        █
    //! doxygen sequence
       █
    //!< doxygen sequence
        █
    #if A
    #else /* Comment A */
         █
    #endif /* Comment B */
          █

    void Initialize( BYTE nDelay = 100 );
                                █ █
    void f1()
    {
          auto a = [ = ] (int *a, Something & b)
                    █ █ █

          list[idx] (param);
                   █

    double foo()
    {
    	return( foo(n) );
    	       █      █

    Vector2<double> ()
                   █

    {
            List<byte> bob = new List<byte> ();
                      █
            QVector<QPair<Condition, QString> > mWhenThen;
                                             █

    template<int i, int ... Indexes, typename IdxHolder, typename ... Elements>
                       █                                         █
    struct index_holder_impl<i, index_holder<Indexes ...>, IdxHolder, Elements ...>
                                                    █                         █
    {
    	typedef typename index_holder_impl<i + 1, index_holder<Indexes ... i>,	Elements ...>::type type;
    	                                                              █                 █

Java Sources
        for (Type var : expr)
                       █