снова здравствуйте!

есть такой код:

#include <boost/preprocessor.hpp>

/***************************************************************************/

#define CONSTRUCT_CONCRETE_proc(name, tuple) /* макровызов обработки последовательности для proc-типов */ \
    myproc[name: BOOST_PP_TUPLE_ENUM tuple]

#define CONSTRUCT_CONCRETE_enum(name, tuple) /* макровызов обработки последовательности для enum-типов */ \
    myenum[name: BOOST_PP_TUPLE_ENUM tuple]

#define CONSTRUCT_PROCS(unused, idx, seq) /* тут конкатинируем 'CONSTRUCT_CONCRETE_' и 'proc' или 'enum', и экспандим его */ \
    BOOST_PP_EXPAND(BOOST_PP_CAT(CONSTRUCT_CONCRETE_, BOOST_PP_SEQ_ELEM(idx, seq)))

#define CONSTRUCT(name, seq) \
    struct name { \
        BOOST_PP_REPEAT( \
             BOOST_PP_SEQ_SIZE(seq) \
            ,CONSTRUCT_PROCS \
            ,seq \
        ) \
    }; /* struct name */

/***************************************************************************/

CONSTRUCT(
    type1
    ,
    (proc(m0, (float)))
    (proc(m1, (int, long)))
    (enum(mye1, (e0, e1, e2)))
)

/***************************************************************************/

суть кода — получить возможность обрабатывать последовательности типов разными способами.

сейчас, при препроцессировании, получаю такой код:

struct type1 {
    myproc[m0: BOOST_PP_CAT(BOOST_PP_TUPLE_REM_CTOR_O_, 1)(float)]
    myproc[m1: BOOST_PP_CAT(BOOST_PP_TUPLE_REM_CTOR_O_, 2)(int, long)]
    myenum[mye1: BOOST_PP_CAT(BOOST_PP_TUPLE_REM_CTOR_O_, 3)(e0, e1, e2)]
};

этот код полностью валиден, за исключением того, что эти строки начинающиеся с 'BOOST_PP_CAT' — должны обрабатываться препроцессором, чего не происходит.
не понимаю, от чего так?

спасибо.

Здравствуйте, niXman, Вы писали:

X>#define CONSTRUCT_PROCS(unused, idx, seq) /* тут конкатинируем 'CONSTRUCT_CONCRETE_' и 'proc' или 'enum', и экспандим его */ \
X> BOOST_PP_EXPAND(BOOST_PP_CAT(CONSTRUCT_CONCRETE_, BOOST_PP_SEQ_ELEM(idx, seq)))
Может так поможет?

BOOST_PP_EXPAND(BOOST_PP_CAT)(CONSTRUCT_CONCRETE_, BOOST_PP_SEQ_ELEM(idx, seq))

Здравствуйте, Vain, Вы писали:

V>Может так поможет?
V>

V>BOOST_PP_EXPAND(BOOST_PP_CAT)(CONSTRUCT_CONCRETE_, BOOST_PP_SEQ_ELEM(idx, seq))
V>

нет, не помогло. абсолютно без изменений.

Здравствуйте, niXman, Вы писали:

X>нет, не помогло. абсолютно без изменений.
Можно ещё проверить правда ли то, что выдал препроцессор пытается компилировать компилятор. Для этого можно результат препроцессора скормить опять компилятору и сравнить номера ошибок. Они должны совпадать.

так код же не полностью препроцессирован. какой смысл его компилировать?

Здравствуйте, niXman, Вы писали:

А если так:

/***************************************************************************/
#define CONSTRUCT_CONCRETE_proc(name, tuple) /* макровызов обработки последовательности для proc-типов */ \
    (name)(tuple)

#define CONSTRUCT_CONCRETE_enum(name, tuple) /* макровызов обработки последовательности для enum-типов */ \
    (name)(tuple)


#define GET_MACRO(sub_macro) myproc[BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(0,BOOST_PP_CAT(CONSTRUCT_CONCRETE_, sub_macro)),:) BOOST_PP_TUPLE_ENUM(BOOST_PP_SEQ_ELEM(1,BOOST_PP_CAT(CONSTRUCT_CONCRETE_, sub_macro)))]

#define CONSTRUCT_PROCS(unused, idx, seq) /* тут конкатинируем 'CONSTRUCT_CONCRETE_' и 'proc' или 'enum', и экспандим его */ \
    GET_MACRO(BOOST_PP_SEQ_ELEM(idx, seq))

#define CONSTRUCT(name, seq) \
struct name { \
    BOOST_PP_REPEAT( \
    BOOST_PP_SEQ_SIZE(seq) \
    ,CONSTRUCT_PROCS \
    ,seq \
    ) \
}; /* struct name */

/***************************************************************************/

CONSTRUCT(
    type1
    ,
    (proc(m0, (float)))
    (proc(m1, (int, long)))
    (enum(mye1, (e0, e1, e2)))
    )

Aутпут:

struct type1 { myproc[m0: float] myproc[m1: int, long] myproc[mye1: e0, e1, e2] };

Думаю иде должна быть ясна. По сути, раскрываем полученный сиквенс в конкретных макросах, макросом из вне.
Если нужно, можно "специализировать" какие то еще дополнительные аргументы в сиквенсе в самих CONSTRUCT_CONCRETE_proc/CONSTRUCT_CONCRETE_enum а раскрыть их в GET_MACRO

p.s.
Вся "сложность" этих макросов, то что в голове постоянно нужен держать одно очень важное правило — препроцессор штука однопроходная.
Со временем можно легко натаскаться и писать их будет значительно проще, особенно с такой мощной либой как boost::preprocessor

поправочка

#define CONSTRUCT_CONCRETE_proc(name, tuple) /* макровызов обработки последовательности для proc-типов */ \
    (name)(tuple)(myproc)

#define CONSTRUCT_CONCRETE_enum(name, tuple) /* макровызов обработки последовательности для enum-типов */ \
    (name)(tuple)(myenum)


#define GET_MACRO(sub_macro) BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(2,BOOST_PP_CAT(CONSTRUCT_CONCRETE_, sub_macro)), \
        [BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(0,BOOST_PP_CAT(CONSTRUCT_CONCRETE_, sub_macro)),:) BOOST_PP_TUPLE_ENUM(BOOST_PP_SEQ_ELEM(1,BOOST_PP_CAT(CONSTRUCT_CONCRETE_, sub_macro)))] \
    )

спасибо за ответ!

но я, признаться, не понимаю, почему ты сделал то, что сделал. объясни плиз как-то более развернуто, плиз

зы
а твой вариант у тебя препроцессируется нормально, без ошибок?

Здравствуйте, nen777w, Вы писали:

N>важное правило — препроцессор штука однопроходная.
слышал это не единожды, но не уверен, что правильно понимаю. объясни и это, плиз

решил следующим образом:
1. формируем имя нужного макроса
2. извлекаем тьюпл с типами
3. производим макровызов подставляя тьюпл

вопрос закрыт.

решить проблему — решил. переключился на другую задачу, а сейчас не могу найти где решение записал. с утра тыркаюсь, а заново решить не получается %)

фух, получилось %)

оставлю-ка я решение тут:

#include <boost/preprocessor.hpp>

/***************************************************************************/

#define YARMI_CONSTRUCT_INVOKER_OPEN_NS_ITEM(unused, data, elem) \
    namespace elem {

#define YARMI_CONSTRUCT_INVOKER_OPEN_NS(seq) \
    BOOST_PP_SEQ_FOR_EACH( \
         YARMI_CONSTRUCT_INVOKER_OPEN_NS_ITEM \
        ,~ \
        ,seq \
    )

#define YARMI_CONSTRUCT_INVOKER_CLOSE_NS_ITEM(unused1, unused2, data) \
    data

#define YARMI_CONSTRUCT_INVOKER_CLOSE_NS(seq) \
    BOOST_PP_REPEAT( \
         BOOST_PP_SEQ_SIZE(seq) \
        ,YARMI_CONSTRUCT_INVOKER_CLOSE_NS_ITEM \
        ,} \
    )

/***************************************************************************/

#define NAME_proc(...) \
    GEN_proc
#define NAME_code(...) \
    GEN_code

#define GEN_proc(name, tuple) \
    void name(BOOST_PP_TUPLE_ENUM(tuple)) {}

#define GEN_code(...) \
    __VA_ARGS__

#define GET_PROC_NAME(str) \
    BOOST_PP_CAT(NAME_, str)

#define ARGS_proc(...) \
    __VA_ARGS__
#define ARGS_code(...) \
    __VA_ARGS__

#define GET_PROC_ARGS_NAME(str) \
    BOOST_PP_CAT(ARGS_, str)

#define EXP(idx, name, args) \
    name(args)

#define YARMI_CONSTRUCT_INVOKER_IMPL_AUX(idx, item) \
    EXP(idx, GET_PROC_NAME(item), GET_PROC_ARGS_NAME(item))

#define YARMI_CONSTRUCT_INVOKER_IMPL(unused, idx, seq) \
    YARMI_CONSTRUCT_INVOKER_IMPL_AUX(idx, BOOST_PP_SEQ_ELEM(idx, seq))

/***************************************************************************/

#define YARMI_CONSTRUCT_INVOKER(reqns, name, seq, oposeq) \
    YARMI_CONSTRUCT_INVOKER_OPEN_NS(reqns) \
    \
    struct name { \
        BOOST_PP_REPEAT( \
             BOOST_PP_SEQ_SIZE(seq) \
            ,YARMI_CONSTRUCT_INVOKER_IMPL \
            ,seq \
        ) \
    }; \
    YARMI_CONSTRUCT_INVOKER_CLOSE_NS(reqns)

/***************************************************************************/

#define YARMI_CONSTRUCT( \
     reqns \
    ,reqname \
    ,reqseq \
    ,repns \
    ,repname \
    ,repseq) \
    \
    YARMI_CONSTRUCT_INVOKER( \
         reqns \
        ,reqname \
        ,reqseq \
        ,repseq \
    )

/***************************************************************************/

YARMI_CONSTRUCT(
    (ns1)(ns2)(ns3)(ns4),
    login_request
    ,
    (code(
        private: int v;
        public: login_request(int v)
            :v(v)
        {}
        void set_v(int r) { v = r; }
        const int get_v() const { return v; }
    ))
    (proc(login, (char, int, double)))
    (code(using int_pair = std::pair<int, int>;))
    (proc(login, (char, int, double, int_pair)))
    (proc(login2, (int, double)))
    ,
    (ns4)(ns3)(ns2)(ns1),
    login_reply
    ,
    (code(void f0(){} int f1(){} std::pair<int, int> f2(){}))
    (proc(login, (char, int, double)))
)

/***************************************************************************/

результат:

namespace ns1 {
namespace ns2 {
namespace ns3 {
namespace ns4 {
struct login_request {
private:
   int v;
public:
   login_request(int v)
      :v(v)
   {}

   void set_v(int r) { v = r; }
   const int get_v() const { return v; }

   void login(char, int, double) {}
   using int_pair = std::pair<int, int>;
   void login(char, int, double, int_pair) {}
   void login2(int, double) {}
}; // struct login_request
} // ns4
} // ns3
} // ns2
} // ns1

всем спасибо!