BOOST_BINARY मैक्रो पार्स रिक्त स्थान कैसे करता है?

Question

नीचे दिए गए कोड पर विचार करें।

int value1 = BOOST_BINARY(100 111000 01 1 110); 

क्या कोई यह समझा सकता है कि BOOST_BINARY int मूल्य की गणना कैसे करता है?

Answer 1

यह बहुत जटिल है। यह बूस्ट पुस्तकालय अन्य मैक्रोज़ द्वारा निर्मित मैक्रोज़ का उपयोग करता है।

मैं तुम्हें पूर्वप्रक्रमक प्रोग्रामिंग के कुछ सरल उदाहरण पेश करने के लिए जा रहा हूँ:

सरलीकृत प्रश्न:

कैसे मैक्रो 0 या 1 जोड़ने बाकी की शुरुआत में बनाने के लिए - इस उदाहरण में की तरह:

CAT (0 1) --> 01 
CAT (1 100) --> 1100 

तो - किसी भी तरह , अनुक्रम में दोनों तर्कों के बीच रखा जाना चाहिए।

// start point - this is our desired format 
#define CATS(a,b) a##b 
// helper macro to invoke preprocessor on result of a 
#define CALLP(a) a 
// some helper symbols to build CATS() 
#define CATB (
#define CATE) 
#define CATSN CATS 
// I use that only 0 or 1 is expected at the beginning: 
// CATS (0, 
#define CAT_B0 CATSN CATB 0, 
// CATS (1, 
#define CAT_B1 CATSN CATB 1, 

// the final macro: 
// Example: 
// CAT(0 XXX) --> CALLP(CAT_B ## 0 XXX )) 
// --> CALLP(CAT_B0 XXX) --> CALLP(CATSN (0, XXX)) 
// --> CALLP(CATS(0, XXX)) --> CATS(0,XXX) --> 0##XXX -> 0XXX 
#define CAT(tt) CALLP (CAT_B ## tt CATE) 

यह वास्तव में (कम से कम जीसीसी में) काम करता है:: http://ideone.com/EKlTGt

अब कल्पना कैसे जटिल अपने पुस्तकालय में बूस्ट लोगों द्वारा किए गए कार्य कर रहा है अच्छी तरह से मैं इस किया था? हां, यह बहुत जटिल है - लेकिन मैंने प्रस्तुत की गई प्रीप्रोसेसर चाल का उपयोग किया, और शायद कई अन्य - मैंने पहली बार इस पुस्तक पुस्तकालय http://www.boost.org/doc/libs/1_46_1/boost/utility/binary.hpp के स्रोत को देखा (विश्वास या नहीं)।

Answer 2

स्रोत का प्रयोग करें, ल्यूक!

The following code works by converting the input bit pattern into a 
Boost.Preprocessor sequence, then converting groupings of 3 bits each into 
the corresponding octal digit, and finally concatenating all of the digits 
together along with a leading zero. This yields a standard octal literal 
with the desired value as specified in bits. 

और यह बहुत आसान है। हमें बस कुछ मैक्रोज़ को परिभाषित करने की आवश्यकता है। कस के पकड।

#define BOOST_BINARY(bit_groupings)           \ 
    BOOST_BINARY_LITERAL_D(BOOST_PP_DEDUCE_D(), bit_groupings) 

// ... 

#define BOOST_BINARY_LITERAL_D(d, bit_groupings)        \ 
    BOOST_PP_SEQ_CAT                \ 
    ((0) BOOST_DETAIL_CREATE_BINARY_LITERAL_OCTAL_SEQUENCE(d, bit_groupings) \ 
) 

#define BOOST_DETAIL_CREATE_BINARY_LITERAL_OCTAL_SEQUENCE(d, bit_groupings) \ 
    BOOST_PP_SEQ_TRANSFORM              \ 
    (BOOST_DETAIL_TRIPLE_TO_OCTAL_OPERATION          \ 
    , BOOST_PP_NIL                \ 
    , BOOST_PP_IDENTITY(BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_TRIPLE_SEQUENCE)()\ 
    (BOOST_DETAIL_COMPLETE_TRIPLE_SEQUENCE         \ 
     (                  \ 
     d                  \ 
     , BOOST_DETAIL_CREATE_BINARY_LITERAL_BIT_SEQUENCE(d, bit_groupings) \ 
    )                  \ 
    )                   \ 
) 

#define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_TRIPLE_SEQUENCE(bit_sequence) \ 
    BOOST_PP_CAT                 \ 
    (BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_1 bit_sequence  \ 
    , END_BIT                 \ 
) 

#define BOOST_DETAIL_BITS_PER_OCTIT 3 

#define BOOST_DETAIL_COMPLETE_TRIPLE_SEQUENCE(d, incomplete_nibble_sequence) \ 
    BOOST_PP_CAT                 \ 
    (BOOST_DETAIL_CREATE_TRIPLE_COMPLETION_SEQUENCE_       \ 
    , BOOST_PP_MOD_D(d               \ 
        , BOOST_PP_SEQ_SIZE(incomplete_nibble_sequence)   \ 
        , BOOST_DETAIL_BITS_PER_OCTIT        \ 
       )               \ 
)                   \ 
    incomplete_nibble_sequence 

#define BOOST_DETAIL_FIXED_COMPL(bit)          \ 
    BOOST_PP_CAT(BOOST_DETAIL_FIXED_COMPL_, bit) 

#define BOOST_DETAIL_FIXED_COMPL_0 1 

#define BOOST_DETAIL_FIXED_COMPL_1 0 

#define BOOST_DETAIL_CREATE_BINARY_LITERAL_BIT_SEQUENCE(d, bit_groupings) \ 
    BOOST_PP_EMPTY                \ 
    BOOST_PP_CAT(BOOST_PP_WHILE_, d)           \ 
    (BOOST_DETAIL_BINARY_LITERAL_PREDICATE          \ 
    , BOOST_DETAIL_BINARY_LITERAL_OPERATION          \ 
    , bit_groupings()               \ 
) 

#define BOOST_DETAIL_BINARY_LITERAL_PREDICATE(d, state)      \ 
    BOOST_DETAIL_FIXED_COMPL(BOOST_DETAIL_IS_NULLARY_ARGS(state)) 

#define BOOST_DETAIL_BINARY_LITERAL_OPERATION(d, state)      \ 
    BOOST_DETAIL_SPLIT_AND_SWAP             \ 
    (BOOST_PP_CAT(BOOST_DETAIL_BINARY_LITERAL_ELEMENT_, state)) 

#define BOOST_DETAIL_TRIPLE_TO_OCTAL_OPERATION(s, dummy_param, tuple)  \ 
    BOOST_DETAIL_TERNARY_TRIPLE_TO_OCTAL tuple 

#define BOOST_DETAIL_TERNARY_TRIPLE_TO_OCTAL(bit2, bit1, bit0)    \ 
    BOOST_DETAIL_TRIPLE_TO_OCTAL_ ## bit2 ## bit1 ## bit0 

#define BOOST_DETAIL_CREATE_TRIPLE_COMPLETION_SEQUENCE_1 (0)(0) 
#define BOOST_DETAIL_CREATE_TRIPLE_COMPLETION_SEQUENCE_2 (0) 
#define BOOST_DETAIL_CREATE_TRIPLE_COMPLETION_SEQUENCE_0 

#define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_1END_BIT 

#define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_1(bit)  \ 
    ((bit, BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_2 

#define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_2(bit)  \ 
    bit, BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_3 

#define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_3(bit)  \ 
    bit)) BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_1 

#define BOOST_DETAIL_SPLIT_AND_SWAP(params)         \ 
    BOOST_PP_IDENTITY(BOOST_DETAIL_SPLIT_AND_SWAP_PARAMS)()(params) 

#define BOOST_DETAIL_SPLIT_AND_SWAP_PARAMS(first_param, second_param)  \ 
    second_param first_param 

#define BOOST_DETAIL_LEFT_OF_COMMA(params)         \ 
    BOOST_PP_IDENTITY(BOOST_DETAIL_FIRST_MACRO_PARAM)()(params) 

#define BOOST_DETAIL_FIRST_MACRO_PARAM(first_param, second_param)   \ 
    first_param 

/* Begin derived concepts from Chaos by Paul Mensonides */ 

#define BOOST_DETAIL_IS_NULLARY_ARGS(param)         \ 
    BOOST_DETAIL_LEFT_OF_COMMA             \ 
    (BOOST_PP_CAT(BOOST_DETAIL_IS_NULLARY_ARGS_R_        \ 
       , BOOST_DETAIL_IS_NULLARY_ARGS_C param       \ 
       )                \ 
) 

#define BOOST_DETAIL_IS_NULLARY_ARGS_C()          \ 
    1 

#define BOOST_DETAIL_IS_NULLARY_ARGS_R_1          \ 
    1, BOOST_PP_NIL 

#define BOOST_DETAIL_IS_NULLARY_ARGS_R_BOOST_DETAIL_IS_NULLARY_ARGS_C   \ 
    0, BOOST_PP_NIL 

/* End derived concepts from Chaos by Paul Mensonides */ 

#define BOOST_DETAIL_TRIPLE_TO_OCTAL_000 0 
#define BOOST_DETAIL_TRIPLE_TO_OCTAL_001 1 
#define BOOST_DETAIL_TRIPLE_TO_OCTAL_010 2 
#define BOOST_DETAIL_TRIPLE_TO_OCTAL_011 3 
#define BOOST_DETAIL_TRIPLE_TO_OCTAL_100 4 
#define BOOST_DETAIL_TRIPLE_TO_OCTAL_101 5 
#define BOOST_DETAIL_TRIPLE_TO_OCTAL_110 6 
#define BOOST_DETAIL_TRIPLE_TO_OCTAL_111 7 

#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0 (0), 
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1 (1), 

#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00 (0)(0), 
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01 (0)(1), 
// ... and so on, until ... 
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111110 (1)(1)(1)(1)(1)(1)(1)(0), 
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111111 (1)(1)(1)(1)(1)(1)(1)(1), 

यह boost/preprocessor/ में मैक्रो का गहन उपयोग करता है, लेकिन मैं उन्हें यहां दोहराना नहीं होगा। यह कोड के हजारों लाइनों को एक साथ मिला है।

मुझे पता है कि यह बहुत उपयोगी, गहन उत्तर नहीं है, लेकिन मैं इसे किसी भी तरह से पोस्ट करने जा रहा हूं क्योंकि यह कुछ भी नहीं है। उम्मीद है कि किसी के पास इस से छुटकारा पाने और कुछ और अंतर्दृष्टि प्रदान करने का साहस होगा!