Changeset 18610 for lang/c/msgpack

Show
Ignore:
Timestamp:
09/02/08 06:15:02 (6 years ago)
Author:
frsyuki
Message:

lang/c/msgpack: added C++ binding msgpack::pack

Location:
lang/c/msgpack/trunk
Files:
1 added
7 modified

Legend:

Unmodified
Added
Removed
  • lang/c/msgpack/trunk/c/pack_inline.h

    r17708 r18610  
    88static inline void msgpack_pack_append_buffer(msgpack_pack_t* x, const unsigned char* b, unsigned int l); 
    99 
     10#include <string.h> 
     11#include <arpa/inet.h>  /* __BYTE_ORDER */ 
    1012#include "msgpack/pack/inline_impl.h" 
    11  
    1213 
    1314#endif /* pack_inline.h */ 
  • lang/c/msgpack/trunk/cpp/Makefile

    r18608 r18610  
    1010        erb $< > $@ 
    1111 
    12 test: $(NEED_PREPROCESS) unpack.o unpack_inline.o object.o zone.o test.o object.hpp unpack.hpp 
     12test: $(NEED_PREPROCESS) unpack.o unpack_inline.o object.o zone.o test.o object.hpp unpack.hpp pack.hpp 
    1313        $(CXX) $(LDFLAGS) unpack.o unpack_inline.o zone.o object.o test.o -o $@ 
    1414 
  • lang/c/msgpack/trunk/cpp/object.cpp

    r18608 r18610  
    11#include "msgpack/object.hpp" 
     2#include "msgpack/pack.hpp" 
    23 
    34namespace msgpack { 
     
    133134        { s << (int16_t)v; } 
    134135 
     136template <typename V> 
     137inline void numeric_pack(dynamic_packer& p, V v); 
     138 
     139template <> 
     140inline void numeric_pack<uint8_t>(dynamic_packer& p, uint8_t v) 
     141        { p.pack_unsigned_int_8(v); } 
     142 
     143template <> 
     144inline void numeric_pack<uint16_t>(dynamic_packer& p, uint16_t v) 
     145        { p.pack_unsigned_int_16(v); } 
     146 
     147template <> 
     148inline void numeric_pack<uint32_t>(dynamic_packer& p, uint32_t v) 
     149        { p.pack_unsigned_int_32(v); } 
     150 
     151template <> 
     152inline void numeric_pack<uint64_t>(dynamic_packer& p, uint64_t v) 
     153        { p.pack_unsigned_int_64(v); } 
     154 
     155template <> 
     156inline void numeric_pack<int8_t>(dynamic_packer& p, int8_t v) 
     157        { p.pack_unsigned_int_8(v); } 
     158 
     159template <> 
     160inline void numeric_pack<int16_t>(dynamic_packer& p, int16_t v) 
     161        { p.pack_unsigned_int_16(v); } 
     162 
     163template <> 
     164inline void numeric_pack<int32_t>(dynamic_packer& p, int32_t v) 
     165        { p.pack_unsigned_int_32(v); } 
     166 
     167template <> 
     168inline void numeric_pack<int64_t>(dynamic_packer& p, int64_t v) 
     169        { p.pack_unsigned_int_64(v); } 
     170 
     171template <> 
     172inline void numeric_pack<float>(dynamic_packer& p, float v) 
     173        { p.pack_float(v); } 
     174 
     175template <> 
     176inline void numeric_pack<double>(dynamic_packer& p, double v) 
     177        { p.pack_double(v); } 
     178 
    135179}  // noname namespace 
    136180 
     
    139183bool object_nil::operator== (const object_class* x) const 
    140184        { return typeid(*this) == typeid(*x); } 
     185void object_nil::pack(dynamic_packer& p) const 
     186        { p.pack_nil(); } 
    141187const object_class* object_nil::inspect(std::ostream& s) const 
    142188        { s << "nil"; return this; } 
     
    145191bool object_true::operator== (const object_class* x) const 
    146192        { return typeid(*this) == typeid(*x); } 
     193void object_true::pack(dynamic_packer& p) const 
     194        { p.pack_true(); } 
    147195const object_class* object_true::inspect(std::ostream& s) const 
    148196        { s << "true"; return this; } 
     
    151199bool object_false::operator== (const object_class* x) const 
    152200        { return typeid(*this) == typeid(*x); } 
     201void object_false::pack(dynamic_packer& p) const 
     202        { p.pack_false(); } 
    153203const object_class* object_false::inspect(std::ostream& s) const 
    154204        { s << "false"; return this; } 
     
    177227        catch (negative_overflow_error&) { return true; }                                                       \ 
    178228        catch (overflow_error&) { return false; }                                                                       \ 
     229void object_##NAME::pack(dynamic_packer& p) const                                                               \ 
     230        { numeric_pack(p, val); }                                                                                                       \ 
    179231const object_class* object_##NAME::inspect(std::ostream& s) const                               \ 
    180232        { numeric_inspect(val, s); return this; }                                                                       \ 
     
    237289                }                                                                                                                                               \ 
    238290        } }                                                                                                                                                     \ 
    239 const object_class* object_##NAME::inspect(std::ostream& s) const                                                               \ 
     291void object_##NAME::pack(dynamic_packer& p) const                                                               \ 
     292        { numeric_pack(p, val); }                                                                                                       \ 
     293const object_class* object_##NAME::inspect(std::ostream& s) const                               \ 
    240294        { s << val; return this; }                                                                                                      \ 
    241295 
     
    261315        if(len == xr.len) { return ptr != xr.ptr && memcmp(ptr, xr.ptr, len) > 0; }     \ 
    262316        else { return len > xr.len; } }                                                                                         \ 
     317void object_##NAME::pack(dynamic_packer& p) const                                                               \ 
     318        { p.pack_raw(ptr, len); }                                                                                                       \ 
    263319const object_class* object_##NAME::inspect(std::ostream& s) const                               \ 
    264320        { (s << '"').write((const char*)ptr, len) << '"'; return this; }  // FIXME escape 
     
    304360        return this; 
    305361} 
     362void object_array::pack(dynamic_packer& p) const 
     363{ 
     364        p.pack_array(val.size()); 
     365        for(std::vector<object>::const_iterator it(val.begin()), it_end(val.end()); 
     366                        it != it_end; 
     367                        ++it) { 
     368                it->pack(p); 
     369        } 
     370} 
    306371 
    307372 
     
    335400        return this; 
    336401} 
     402void object_map::pack(dynamic_packer& p) const 
     403{ 
     404        p.pack_map(val.size()); 
     405        for(std::map<object, object>::const_iterator it(val.begin()), it_end(val.end()); 
     406                        it != it_end; 
     407                        ++it) { 
     408                it->first.pack(p); 
     409                it->second.pack(p); 
     410        } 
     411} 
    337412 
    338413 
  • lang/c/msgpack/trunk/cpp/object.hpp

    r18608 r18610  
    11#ifndef MSGPACK_OBJECT_HPP__ 
    22#define MSGPACK_OBJECT_HPP__ 
    3 #include <iostream> 
    43 
    54#include <cstddef> 
     
    4746typedef std::map<object, object> map; 
    4847typedef std::vector<object> array; 
     48 
     49class dynamic_packer; 
    4950 
    5051 
     
    7374        virtual bool operator<  (const object_class* x) const { throw cast_error(); } 
    7475        virtual bool operator>  (const object_class* x) const { throw cast_error(); } 
     76        virtual void pack(dynamic_packer& p) const = 0; 
    7577        operator     bool() const { return   xbool(); } // FIXME !isnil(); 
    7678        operator  uint8_t() const { return     xu8(); } 
     
    129131        bool operator<  (object x) const { return val->operator<  (x.val); } 
    130132        bool operator>  (object x) const { return val->operator>  (x.val); } 
     133        void pack(dynamic_packer& p) const { val->pack(p); } 
    131134        operator     bool() const { return val->operator bool();     } 
    132135        operator  uint8_t() const { return val->operator uint8_t();  } 
     
    161164        bool isnil() const; 
    162165        bool operator== (const object_class* x) const; 
     166        void pack(dynamic_packer& p) const; 
    163167        const object_class* inspect(std::ostream& s) const; 
    164168}; 
     
    167171        bool xbool() const; 
    168172        bool operator== (const object_class* x) const; 
     173        void pack(dynamic_packer& p) const; 
    169174        const object_class* inspect(std::ostream& s) const; 
    170175}; 
     
    173178        bool xbool() const; 
    174179        bool operator== (const object_class* x) const; 
     180        void pack(dynamic_packer& p) const; 
    175181        const object_class* inspect(std::ostream& s) const; 
    176182}; 
     
    192198        bool operator<  (const object_class* x) const;                  \ 
    193199        bool operator>  (const object_class* x) const;                  \ 
     200        void pack(dynamic_packer& p) const;                                             \ 
    194201        const object_class* inspect(std::ostream& s) const;             \ 
    195202private:                                                                                                        \ 
     
    210217 
    211218#define FLOAT_CLASS(TYPE, NAME) \ 
    212 struct object_##NAME : object_class {                                                   \ 
    213         object_##NAME(TYPE v) : val(v) {}                                                       \ 
    214         uint8_t  xu8    () const;                                                                       \ 
    215         uint16_t xu16   () const;                                                                       \ 
    216         uint32_t xu32   () const;                                                                       \ 
    217         uint64_t xu64   () const;                                                                       \ 
    218         int8_t   xi8    () const;                                                                       \ 
    219         int16_t  xi16   () const;                                                                       \ 
    220         int32_t  xi32   () const;                                                                       \ 
    221         int64_t  xi64   () const;                                                                       \ 
    222         float    xfloat () const;                                                                       \ 
    223         double   xdouble() const;                                                                       \ 
    224         bool operator== (const object_class* x) const;                          \ 
    225         bool operator<  (const object_class* x) const;                          \ 
    226         bool operator>  (const object_class* x) const;                          \ 
    227         const object_class* inspect(std::ostream& s) const;                     \ 
    228 private:                                                                                                                \ 
    229         TYPE val;                                                                                                       \ 
     219struct object_##NAME : object_class {                                           \ 
     220        object_##NAME(TYPE v) : val(v) {}                                               \ 
     221        uint8_t  xu8    () const;                                                               \ 
     222        uint16_t xu16   () const;                                                               \ 
     223        uint32_t xu32   () const;                                                               \ 
     224        uint64_t xu64   () const;                                                               \ 
     225        int8_t   xi8    () const;                                                               \ 
     226        int16_t  xi16   () const;                                                               \ 
     227        int32_t  xi32   () const;                                                               \ 
     228        int64_t  xi64   () const;                                                               \ 
     229        float    xfloat () const;                                                               \ 
     230        double   xdouble() const;                                                               \ 
     231        bool operator== (const object_class* x) const;                  \ 
     232        bool operator<  (const object_class* x) const;                  \ 
     233        bool operator>  (const object_class* x) const;                  \ 
     234        void pack(dynamic_packer& p) const;                                             \ 
     235        const object_class* inspect(std::ostream& s) const;             \ 
     236private:                                                                                                        \ 
     237        TYPE val;                                                                                               \ 
    230238}; 
    231239 
     
    243251        bool operator<  (const object_class* x) const;                                          \ 
    244252        bool operator>  (const object_class* x) const;                                          \ 
     253        void pack(dynamic_packer& p) const;                                                                     \ 
    245254        const object_class* inspect(std::ostream& s) const;                                     \ 
    246255private:                                                                                                                                \ 
     
    262271        bool operator== (const object_class* x) const; 
    263272        // FIXME operator<, operator> 
     273        void pack(dynamic_packer& p) const; 
    264274        const object_class* inspect(std::ostream& s) const; 
    265275public: 
     
    277287        bool operator== (const object_class* x) const; 
    278288        // FIXME operator<, operator> 
     289        void pack(dynamic_packer& p) const; 
    279290        const object_class* inspect(std::ostream& s) const; 
    280291public: 
  • lang/c/msgpack/trunk/cpp/test.cpp

    r18599 r18610  
    11#include <iostream> 
     2#include <string> 
    23#include <msgpack/unpack.hpp> 
     4#include <msgpack/pack.hpp> 
    35 
    46class checker { 
    57public: 
    68        void check(const char* d, size_t len, msgpack::object should) { 
     9                using msgpack::object; 
    710                try { 
    811                        std::cout << "----" << std::endl; 
    9                         msgpack::object o; 
     12 
     13                        object o; 
    1014                        try { 
    1115                                o = msgpack::unpack(d, len, m_zone); 
     
    1519                                return; 
    1620                        } 
     21 
    1722                        std::cout << o << std::endl; 
    1823                        if(o != should) { 
    1924                                std::cout << "** TEST FAILED **" << std::endl; 
    2025                        } 
     26 
     27                        try { 
     28                                std::string s; 
     29                                msgpack::pack(s, o); 
     30                                object ro = msgpack::unpack(s.data(), s.size(), m_zone); 
     31                                if(ro != o) { throw std::runtime_error("NOT MATCH"); } 
     32                        } catch (std::runtime_error& e) { 
     33                                std::cout << "** REUNPACK FAILED **" << std::endl; 
     34                                std::cout << e.what() << std::endl; 
     35                        } catch (...) { 
     36                                std::cout << "** REUNPACK FAILED **" << std::endl; 
     37                                std::cout << "unknown error" << std::endl; 
     38                        } 
     39 
    2140                } catch (...) { m_zone.clear(); throw; } 
    2241                m_zone.clear(); 
     
    2847int main(void) 
    2948{ 
     49        checker c; 
    3050 
    31 checker c; 
     51        {  // SimpleValue 
     52                msgpack::zone z; 
     53                const char d[] = { 
     54                        0x93, 0xc0, 0xc2, 0xc3, 
     55                }; 
     56                c.check(d, sizeof(d), 
     57                        z.narray( 
     58                                z.nnil(), z.nfalse(), z.ntrue() 
     59                        ) 
     60                ); 
     61        } 
    3262 
    33 {  // SimpleValue 
    34         msgpack::zone z; 
    35         const char d[] = { 
    36                 0x93, 0xc0, 0xc2, 0xc3, 
    37         }; 
    38         c.check(d, sizeof(d), 
    39                 z.narray( 
    40                         z.nnil(), z.nfalse(), z.ntrue() 
    41                 ) 
    42         ); 
     63        {  // Fixnum 
     64                msgpack::zone z; 
     65                const char d[] = { 
     66                        0x92, 
     67                                0x93, 0x00, 0x40, 0x7f, 
     68                                0x93, 0xe0, 0xf0, 0xff, 
     69                }; 
     70                c.check(d, sizeof(d), 
     71                        z.narray( 
     72                                z.narray( 
     73                                        z.nu8(0), 
     74                                        z.nu8(64), 
     75                                        z.nu8(127) 
     76                                ), 
     77                                z.narray( 
     78                                        z.ni8(-32), 
     79                                        z.ni8(-16), 
     80                                        z.ni8(-1) 
     81                                ) 
     82                        ) 
     83                ); 
     84        } 
     85 
     86        {  // FixArray 
     87                msgpack::zone z; 
     88                const char d[] = { 
     89                        0x92, 
     90                                0x90, 
     91                                0x91, 
     92                                        0x91, 0xc0, 
     93                }; 
     94                c.check(d, sizeof(d), 
     95                        z.narray( 
     96                                z.narray(), 
     97                                z.narray( 
     98                                        z.narray( 
     99                                                z.nnil() 
     100                                        ) 
     101                                ) 
     102                        ) 
     103                ); 
     104        } 
     105 
     106        {  // FixRaw 
     107                msgpack::zone z; 
     108                const char d[] = { 
     109                        0x94, 
     110                                0xa0, 
     111                                0xa1, 'a', 
     112                                0xa2, 'b', 'c', 
     113                                0xa3, 'd', 'e', 'f', 
     114                }; 
     115                c.check(d, sizeof(d), 
     116                        z.narray( 
     117                                z.nraw("", 0), 
     118                                z.nraw("a", 1), 
     119                                z.nraw("bc", 2), 
     120                                z.nraw("def", 3) 
     121                        ) 
     122                ); 
     123        } 
     124 
     125        return 0; 
    43126} 
    44127 
    45 {  // Fixnum 
    46         msgpack::zone z; 
    47         const char d[] = { 
    48                 0x92, 
    49                         0x93, 0x00, 0x40, 0x7f, 
    50                         0x93, 0xe0, 0xf0, 0xff, 
    51         }; 
    52         c.check(d, sizeof(d), 
    53                 z.narray( 
    54                         z.narray( 
    55                                 z.nu8(0), 
    56                                 z.nu8(64), 
    57                                 z.nu8(127) 
    58                         ), 
    59                         z.narray( 
    60                                 z.ni8(-32), 
    61                                 z.ni8(-16), 
    62                                 z.ni8(-1) 
    63                         ) 
    64                 ) 
    65         ); 
    66 } 
    67  
    68 {  // FixArray 
    69         msgpack::zone z; 
    70         const char d[] = { 
    71                 0x92, 
    72                         0x90, 
    73                         0x91, 
    74                                 0x91, 0xc0, 
    75         }; 
    76         c.check(d, sizeof(d), 
    77                 z.narray( 
    78                         z.narray(), 
    79                         z.narray( 
    80                                 z.narray( 
    81                                         z.nnil() 
    82                                 ) 
    83                         ) 
    84                 ) 
    85         ); 
    86 } 
    87  
    88 {  // FixRaw 
    89         msgpack::zone z; 
    90         const char d[] = { 
    91                 0x94, 
    92                         0xa0, 
    93                         0xa1, 'a', 
    94                         0xa2, 'b', 'c', 
    95                         0xa3, 'd', 'e', 'f', 
    96         }; 
    97         c.check(d, sizeof(d), 
    98                 z.narray( 
    99                         z.nraw("", 0), 
    100                         z.nraw("a", 1), 
    101                         z.nraw("bc", 2), 
    102                         z.nraw("def", 3) 
    103                 ) 
    104         ); 
    105 } 
    106  
    107  
    108 return 0; 
    109 } 
    110  
  • lang/c/msgpack/trunk/msgpack/pack/inline_impl.h

    r18599 r18610  
    1919#define MSGPACK_PACK_INLINE_IMPL_H__ 
    2020 
    21 #include <string.h> 
    22 #include <arpa/inet.h> 
     21#if !defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__) 
     22#if __BYTE_ORDER == __LITTLE_ENDIAN 
     23#define __LITTLE_ENDIAN__ 
     24#elif __BYTE_ORDER == __BIG_ENDIAN 
     25#define __BIG_ENDIAN__ 
     26#endif 
     27#endif 
    2328 
    2429#ifdef __LITTLE_ENDIAN__ 
     
    4853#endif 
    4954 
     55#ifndef msgpack_pack_inline_func(name) 
     56#define msgpack_pack_inline_func(name) \ 
     57        inline void msgpack_pack_##name 
     58#endif 
    5059 
    5160/* 
     
    5463 
    5564// wrapper 
    56 inline void msgpack_pack_int(msgpack_pack_context x, int d) 
     65msgpack_pack_inline_func(int)(msgpack_pack_context x, int d) 
    5766{ 
    5867        if(d < -32) { 
     
    8796 
    8897// wrapper 
    89 inline void msgpack_pack_unsigned_int(msgpack_pack_context x, unsigned int d) 
     98msgpack_pack_inline_func(unsigned_int)(msgpack_pack_context x, unsigned int d) 
    9099{ 
    91100        if(d < 128) { 
    92101                // fixnum 
    93                 msgpack_pack_append_buffer(x, (uint8_t*)&d, 1); 
     102                msgpack_pack_append_buffer(x, (unsigned char*)&d, 1); 
    94103        } else if(d < 256) { 
    95104                // unsigned 8 
     
    107116} 
    108117 
    109 inline void msgpack_pack_unsigned_int_8(msgpack_pack_context x, uint8_t d) 
     118msgpack_pack_inline_func(unsigned_int_8)(msgpack_pack_context x, uint8_t d) 
    110119{ 
    111120        if(d < 128) { 
     
    117126} 
    118127 
    119 inline void msgpack_pack_unsigned_int_16(msgpack_pack_context x, uint16_t d) 
     128msgpack_pack_inline_func(unsigned_int_16)(msgpack_pack_context x, uint16_t d) 
    120129{ 
    121130        const unsigned char buf[3] = {0xcd, STORE_BE16(d)}; 
     
    123132} 
    124133 
    125 inline void msgpack_pack_unsigned_int_32(msgpack_pack_context x, uint32_t d) 
     134msgpack_pack_inline_func(unsigned_int_32)(msgpack_pack_context x, uint32_t d) 
    126135{ 
    127136        const unsigned char buf[5] = {0xce, STORE_BE32(d)}; 
     
    129138} 
    130139 
    131 inline void msgpack_pack_unsigned_int_64(msgpack_pack_context x, uint64_t d) 
     140msgpack_pack_inline_func(unsigned_int_64)(msgpack_pack_context x, uint64_t d) 
    132141{ 
    133142        // FIXME optimization 
     
    136145} 
    137146 
    138 inline void msgpack_pack_signed_int_8(msgpack_pack_context x, int8_t d) 
     147msgpack_pack_inline_func(signed_int_8)(msgpack_pack_context x, int8_t d) 
    139148{ 
    140149        if(d > 0) { 
     
    148157} 
    149158 
    150 inline void msgpack_pack_signed_int_16(msgpack_pack_context x, int16_t d) 
     159msgpack_pack_inline_func(signed_int_16)(msgpack_pack_context x, int16_t d) 
    151160{ 
    152161        const unsigned char buf[3] = {0xd1, STORE_BE16(d)}; 
     
    154163} 
    155164 
    156 inline void msgpack_pack_signed_int_32(msgpack_pack_context x, int32_t d) 
     165msgpack_pack_inline_func(signed_int_32)(msgpack_pack_context x, int32_t d) 
    157166{ 
    158167        const unsigned char buf[5] = {0xd2, STORE_BE32(d)}; 
     
    160169} 
    161170 
    162 inline void msgpack_pack_signed_int_64(msgpack_pack_context x, int64_t d) 
     171msgpack_pack_inline_func(signed_int_64)(msgpack_pack_context x, int64_t d) 
    163172{ 
    164173        // FIXME optimization 
     
    172181 */ 
    173182 
    174 inline void msgpack_pack_float(msgpack_pack_context x, float d) 
     183msgpack_pack_inline_func(float)(msgpack_pack_context x, float d) 
    175184{ 
    176185        uint32_t n = *((uint32_t*)&d);  // FIXME 
     
    179188} 
    180189 
    181 inline void msgpack_pack_double(msgpack_pack_context x, double d) 
     190msgpack_pack_inline_func(double)(msgpack_pack_context x, double d) 
    182191{ 
    183192        uint64_t n = *((uint64_t*)&d);  // FIXME 
     
    191200 */ 
    192201 
    193 inline void msgpack_pack_nil(msgpack_pack_context x) 
     202msgpack_pack_inline_func(nil)(msgpack_pack_context x) 
    194203{ 
    195204        static const unsigned char d = 0xc0; 
     
    202211 */ 
    203212 
    204 inline void msgpack_pack_true(msgpack_pack_context x) 
     213msgpack_pack_inline_func(true)(msgpack_pack_context x) 
    205214{ 
    206215        static const unsigned char d = 0xc3; 
     
    208217} 
    209218 
    210 inline void msgpack_pack_false(msgpack_pack_context x) 
     219msgpack_pack_inline_func(false)(msgpack_pack_context x) 
    211220{ 
    212221        static const unsigned char d = 0xc2; 
     
    219228 */ 
    220229 
    221 inline void msgpack_pack_array(msgpack_pack_context x, unsigned int n) 
     230msgpack_pack_inline_func(array)(msgpack_pack_context x, unsigned int n) 
    222231{ 
    223232        if(n < 16) { 
     
    240249 */ 
    241250 
    242 inline void msgpack_pack_map(msgpack_pack_context x, unsigned int n) 
     251msgpack_pack_inline_func(map)(msgpack_pack_context x, unsigned int n) 
    243252{ 
    244253        if(n < 16) { 
     
    261270 */ 
    262271 
    263 inline void msgpack_pack_string(msgpack_pack_context x, const char* b) 
     272msgpack_pack_inline_func(string)(msgpack_pack_context x, const char* b) 
    264273{ 
    265274        uint32_t l = strlen(b); 
     
    267276} 
    268277 
    269 inline void msgpack_pack_raw(msgpack_pack_context x, const void* b, size_t l) 
     278msgpack_pack_inline_func(raw)(msgpack_pack_context x, const void* b, size_t l) 
    270279{ 
    271280        if(l < 32) { 
     
    281290                msgpack_pack_append_buffer(x, buf, 5); 
    282291        } 
    283         msgpack_pack_append_buffer(x, b, l); 
    284 } 
    285  
     292        msgpack_pack_append_buffer(x, (const unsigned char*)b, l); 
     293} 
     294 
     295 
     296#undef msgpack_pack_inline_func(name) 
    286297 
    287298#undef STORE_BE16(d) 
     
    289300#undef STORE_BE64(d) 
    290301 
    291  
    292302#endif /* msgpack/pack/inline_impl.h */ 
    293303 
  • lang/c/msgpack/trunk/ruby/pack_inline.h

    r17708 r18610  
    2828} 
    2929 
     30#include <string.h> 
     31#include <arpa/inet.h>  /* __BYTE_ORDER */ 
    3032#include "msgpack/pack/inline_impl.h" 
    3133