Changeset 1205

Timestamp:

07/03/09 09:29:50 (14 months ago)

Author:

artem

Message:

+ move byte order depended I/O to global.hpp

this should fix shape.input PPC issues

Location:

trunk

Files:

• include/mapnik/global.hpp (modified) (3 diffs)
• plugins/input/shape/shapefile.hpp (modified) (2 diffs)
• src/wkb.cpp (modified) (8 diffs)

trunk/include/mapnik/global.hpp

@@ -26 +26 @@
 #define GLOBAL_HPP
 
+// boost
 #include <boost/cstdint.hpp>
-
+#include <boost/detail/endian.hpp>
+// stl
+#include <cstring>
 
 namespace mapnik
@@ -35 +38 @@
                                (((boost::uint16_t) ((boost::uint8_t) (A)[0])) << 8))
 
-#define int4net(A)  (int32_t) (((boost::uint32_t) ((boost::uint8_t) (A)[3]))      | \
+#define int4net(A)  (int32_t)  (((boost::uint32_t) ((boost::uint8_t) (A)[3]))        | \
                                (((boost::uint32_t) ((boost::uint8_t) (A)[2])) << 8)  | \
                                (((boost::uint32_t) ((boost::uint8_t) (A)[1])) << 16) | \
@@ -58 +61 @@
     ((byte*) &def_temp)[3]=(M)[0];              \
     (V)=def_temp; } while(0)
+
+    
+    // read int NDR (little endian)
+    inline int& read_int_ndr(const char* data, int & val)
+    {
+#ifndef BOOST_BIG_ENDIAN
+        memcpy(&val,data,4);
+#else
+        val = (data[3]&0xff)     | 
+            ((data[2]&0xff)<<8)  | 
+            ((data[1]&0xff)<<16) | 
+            ((data[0]&0xff)<<24);
+#endif
+        return val;
+    }
+    
+    // read double NDR (little endian)
+    inline double& read_double_ndr(const char* data, double & val)
+    {
+#ifndef BOOST_BIG_ENDIAN
+        std::memcpy(&val,&data[0],8);
+#else
+        boost::int64_t bits = ((boost::int64_t)data[0] & 0xff) | 
+            ((boost::int64_t)data[1] & 0xff) << 8   |
+            ((boost::int64_t)data[2] & 0xff) << 16  |
+            ((boost::int64_t)data[3] & 0xff) << 24  |
+            ((boost::int64_t)data[4] & 0xff) << 32  |
+            ((boost::int64_t)data[5] & 0xff) << 40  |
+            ((boost::int64_t)data[6] & 0xff) << 48  |
+            ((boost::int64_t)data[7] & 0xff) << 56  ;
+        std::memcpy(&val,&bits,8);
+#endif
+        return val;
+    } 
+    
+    // read int XDR (big endian)
+    inline int& read_int_xdr(const char* data, int & val)
+    {
+#ifndef BOOST_BIG_ENDIAN
+        val = (data[3]&0xff) | ((data[2]&0xff)<<8) | ((data[1]&0xff)<<16) | ((data[0]&0xff)<<24);
+#else
+        memcpy(&val,data,4);
+#endif
+        return val;
+    }
+    
+    // read double XDR (big endian)
+    inline double& read_double_xdr(const char* data, double & val)
+    {
+#ifndef BOOST_BIG_ENDIAN
+        boost::int64_t bits = ((boost::int64_t)data[0] & 0xff) | 
+            ((boost::int64_t)data[1] & 0xff) << 8   |
+            ((boost::int64_t)data[2] & 0xff) << 16  |
+            ((boost::int64_t)data[3] & 0xff) << 24  |
+            ((boost::int64_t)data[4] & 0xff) << 32  |
+            ((boost::int64_t)data[5] & 0xff) << 40  |
+            ((boost::int64_t)data[6] & 0xff) << 48  |
+            ((boost::int64_t)data[7] & 0xff) << 56  ;
+        std::memcpy(&val,&bits,8);
+#else
+        std::memcpy(&val,&data[0],8);
+#endif
+        return val;
+    }
 }
 

trunk/plugins/input/shape/shapefile.hpp

@@ -26 +26 @@
 #define SHAPEFILE_HPP
 
+#include <mapnik/global.hpp>
 #include <mapnik/envelope.hpp>
 // boost
 #include <boost/utility.hpp>
-#include <boost/detail/endian.hpp>
+#include <boost/cstdint.hpp>
 #include <boost/iostreams/stream.hpp>
+
 #include <boost/iostreams/device/file.hpp>
 #include <boost/iostreams/device/mapped_file.hpp>
+//#include <boost/iostreams/device/file_descriptor.hpp>
 
 #include <cstring>
 
 using mapnik::Envelope;
+using mapnik::read_int_ndr;
+using mapnik::read_int_xdr;
+using mapnik::read_double_ndr;
+using mapnik::read_double_xdr;
 
 struct shape_record
 {
-      const char* data;
-      size_t size;
-      mutable size_t pos;
-      explicit shape_record(size_t size)
-         : size(size),
-           pos(0) {} 
+    const char* data;
+    size_t size;
+    mutable size_t pos;
+    explicit shape_record(size_t size)
+        : //data(static_cast<char*>(::operator new(sizeof(char)*size))),
+        size(size),
+        pos(0) {} 
       
-      void set_data(const char * data_)
-      {
-         data = data_;
-      }
+    void set_data(const char * data_)
+    {
+        data = data_;
+    }
+  
+    void skip(unsigned n)
+    {
+        pos+=n;
+    }
       
-      void skip(unsigned n)
-      {
-         pos+=n;
-      }
+    int read_ndr_integer()
+    {
+        int val;
+        read_int_ndr(&data[pos],val);
+        pos+=4;
+        return val;
+    }
       
-      int read_ndr_integer()
-      {
-         int val=(data[pos] & 0xff)     | 
-            (data[pos+1] & 0xff) << 8  |
-            (data[pos+2] & 0xff) << 16 |
-            (data[pos+3] & 0xff) << 24;
-         pos+=4;
-         return val;
-      }
+    int read_xdr_integer()
+    {
+        int val;
+        read_int_xdr(&data[pos],val);
+        pos+=4;
+        return val;
+    }
       
-      int read_xdr_integer()
-      {
-         int val=(data[pos] & 0xff) << 24 | 
-            (data[pos+1] & 0xff)   << 16   |
-            (data[pos+2] & 0xff)   << 8    |
-            (data[pos+3] & 0xff);
-         pos+=4;
-         return val;
-      }
-      
-      double read_double()
-      {
-         double val;            
-#ifndef BOOST_BIG_ENDIAN
-         std::memcpy(&val,&data[pos],8);        
-#else
-         long long bits = ((long long)data[pos] & 0xff) | 
-            ((long long)data[pos+1] & 0xff) << 8   |
-            ((long long)data[pos+2] & 0xff) << 16  |
-            ((long long)data[pos+3] & 0xff) << 24  |
-            ((long long)data[pos+4] & 0xff) << 32  |
-            ((long long)data[pos+5] & 0xff) << 40  |
-            ((long long)data[pos+6] & 0xff) << 48  |
-            ((long long)data[pos+7] & 0xff) << 56  ;
-         std::memcpy(&val,&bits,8);
-#endif 
-         pos+=8;
-         return val;
-      }
-      long remains() 
-      {
-         return (size-pos);
-      }
-      ~shape_record() {}
+    double read_double()
+    {
+        double val;             
+        read_double_ndr(&data[pos],val);
+        pos+=8;
+        return val;
+    }
+    long remains() 
+    {
+        return (size-pos);
+    }
+  
+    ~shape_record() 
+    {
+        //::operator delete(data);
+    }
  
 };
@@ -108 +104 @@
 class shape_file : boost::noncopyable
 {  
-      stream<mapped_file_source> file_;
-   public:
-      shape_file();
-      shape_file(const std::string& file_name);
-      ~shape_file();
-      bool is_open();
-      void close();
+    stream<mapped_file_source> file_;
+    //stream<file_source> file_;
+public:
+    shape_file();
+    shape_file(std::string const& file_name);
+    ~shape_file();
+    bool is_open();
+    void close();
       
-      inline void read_record(shape_record& rec)
-      {
-         rec.set_data(file_->data() + file_.tellg());
-         file_.seekg(rec.size,std::ios::cur);
-      }
+    inline void read_record(shape_record& rec)
+    {
+        rec.set_data(file_->data() + file_.tellg());
+        file_.seekg(rec.size,std::ios::cur);
+    }
+    
+    inline int read_xdr_integer()
+    {
+        char b[4];
+        file_.read(b, 4);
+        int val;
+        read_int_xdr(b,val);
+        return val;
+    }
       
-      inline int read_xdr_integer()
-      {
-         char b[4];
-         file_.read(b, 4);
-         return (b[3] & 0xffu) | ((b[2] & 0xffu) << 8) |
-            ((b[1] & 0xffu) << 16) | ((b[0] & 0xffu) << 24);
-      }
+    inline int read_ndr_integer()
+    {
+        char b[4];
+        file_.read(b,4);
+        int val;
+        read_int_ndr(b,val);
+        return val;
+    }
       
-      inline int read_ndr_integer()
-      {
-         char b[4];
-         file_.read(b,4);
-         return (b[0]&0xffu) | ((b[1]&0xffu) << 8) | 
-            ((b[2]&0xffu) << 16) | ((b[3]&0xffu) << 24);
-      }
+    inline double read_double()
+    {
+        double val;
+#ifndef WORDS_BIGENDIAN
+        file_.read(reinterpret_cast<char*>(&val),8);
+#else
+        char b[8];
+        file_.read(b,8);
+        read_double_ndr(b,val);
+#endif
+        return val;
+    }
+    
+    inline void read_envelope(Envelope<double>& envelope)
+    {
+#ifndef WORDS_BIGENDIAN
+        file_.read(reinterpret_cast<char*>(&envelope),sizeof(envelope));
+#else
+        char data[4*8];
+        file_.read(data,4*8);
+        double minx,miny,maxx,maxy;
+        read_double_ndr(data,minx);
+        read_double_ndr(data,miny);
+        read_double_ndr(data,maxx);
+        read_double_ndr(data,maxy);
+        envelope.init(minx,miny,maxx,maxy);
+#endif  
+    }
       
-      inline double read_double()
-      {
-         double val;
-#ifndef WORDS_BIGENDIAN
-         file_.read(reinterpret_cast<char*>(&val),8);
-#else
-         char b[8];
-         file_.read(b,8);
-         long long bits = ((long long)b[0] & 0xff) | 
-            ((long long)b[1] & 0xff) << 8   |
-            ((long long)b[2] & 0xff) << 16  |
-            ((long long)b[3] & 0xff) << 24  |
-            ((long long)b[4] & 0xff) << 32  |
-            ((long long)b[5] & 0xff) << 40  |
-            ((long long)b[6] & 0xff) << 48  |
-            ((long long)b[7] & 0xff) << 56  ;
-         memcpy(&val,&bits,8);
-#endif
-         return val;
-      }
+    inline void skip(std::streampos bytes)
+    {
+        file_.seekg(bytes,std::ios::cur);
+    }
       
-      inline void read_envelope(Envelope<double>& envelope)
-      {
-#ifndef WORDS_BIGENDIAN
-         file_.read(reinterpret_cast<char*>(&envelope),sizeof(envelope));
-#else
-         double minx=read_double();
-         double miny=read_double();
-         double maxx=read_double();
-         double maxy=read_double();
-         envelope.init(minx,miny,maxx,maxy);
-#endif  
-      }
+    inline void rewind()
+    {
+        seek(100);
+    }
       
-      inline void skip(std::streampos bytes)
-      {
-         file_.seekg(bytes,std::ios::cur);
-      }
+    inline void seek(std::streampos pos)
+    {
+        file_.seekg(pos,std::ios::beg);
+    }
       
-      inline void rewind()
-      {
-         seek(100);
-      }
+    inline std::streampos pos()
+    {
+        return file_.tellg();
+    }
       
-      inline void seek(std::streampos pos)
-      {
-         file_.seekg(pos,std::ios::beg);
-      }
-      
-      inline std::streampos pos()
-      {
-         return file_.tellg();
-      }
-      
-      inline bool is_eof()
-      {
-         return file_.eof();
-      }
+    inline bool is_eof()
+    {
+        return file_.eof();
+    }
 };
 

trunk/src/wkb.cpp

@@ -23 +23 @@
 //$Id: wkb.cpp 19 2005-03-22 13:53:27Z pavlenko $
 
+#include <mapnik/global.hpp>
 #include <mapnik/wkb.hpp>
 #include <mapnik/geom_util.hpp>
 #include <mapnik/feature.hpp>
+
 // boost
-#include <boost/cstdint.hpp>
+#include <boost/utility.hpp>
 #include <boost/detail/endian.hpp>
 
 namespace mapnik
 {
-   struct wkb_reader
-   {
-      private:
-         enum wkbByteOrder {
+    struct wkb_reader : boost::noncopyable
+    {
+    private:
+        enum wkbByteOrder {
             wkbXDR=0,
             wkbNDR=1
-         };
-         const char* wkb_;
-         unsigned size_;
-         unsigned pos_;
-         wkbByteOrder byteOrder_;
-         bool needSwap_;
-         wkbFormat format_;
-
-      public:
-        
-         enum wkbGeometryType {
+        };
+        const char* wkb_;
+        unsigned size_;
+        unsigned pos_;
+        wkbByteOrder byteOrder_;
+        bool needSwap_;
+        wkbFormat format_;
+
+    public:
+        
+        enum wkbGeometryType {
             wkbPoint=1,
             wkbLineString=2,
@@ -56 +58 @@
             wkbMultiPolygon=6,
             wkbGeometryCollection=7
-         };
-        
-         wkb_reader(const char* wkb,unsigned size,wkbFormat format)
+        };
+        
+        wkb_reader(const char* wkb,unsigned size,wkbFormat format)
             : wkb_(wkb),
               size_(size),
               pos_(0),
               format_(format)
-         {
+        {
             switch (format_)
             {
-               case wkbSpatiaLite:
-                  byteOrder_ = (wkbByteOrder) wkb_[1];
-                  pos_ = 39;
-                  break;
-
-               case wkbGeneric:
-               default:
-                  byteOrder_ = (wkbByteOrder) wkb_[0];
-                  pos_ = 1;
-                  break;
+            case wkbSpatiaLite:
+                byteOrder_ = (wkbByteOrder) wkb_[1];
+                pos_ = 39;
+                break;
+
+            case wkbGeneric:
+            default:
+                byteOrder_ = (wkbByteOrder) wkb_[0];
+                pos_ = 1;
+                break;
             }
 
@@ -83 +85 @@
             needSwap_=byteOrder_?wkbNDR:wkbXDR; 
 #endif      
-         }
-
-         ~wkb_reader() {}
-
-         void read_multi(Feature & feature) 
-         {
+        }
+
+        ~wkb_reader() {}
+
+        void read_multi(Feature & feature) 
+        {
             int type=read_integer();
             switch (type)
             {
-               case wkbPoint:
-                  read_point(feature);
-                  break;
-               case wkbLineString:
-                  read_linestring(feature);
-                  break;
-               case wkbPolygon:
-                  read_polygon(feature);
-                  break;
-               case wkbMultiPoint:
-                  read_multipoint(feature);
-                  break;
-               case wkbMultiLineString:
-                  read_multilinestring(feature);
-                  break;
-               case wkbMultiPolygon:
-                  read_multipolygon(feature);
-                  break;
-               case wkbGeometryCollection:
-                  break;
-               default:
-                  break;
-            }
-         }
-         
-         void read(Feature & feature) 
-         {
+            case wkbPoint:
+                read_point(feature);
+                break;
+            case wkbLineString:
+                read_linestring(feature);
+                break;
+            case wkbPolygon:
+                read_polygon(feature);
+                break;
+            case wkbMultiPoint:
+                read_multipoint(feature);
+                break;
+            case wkbMultiLineString:
+                read_multilinestring(feature);
+                break;
+            case wkbMultiPolygon:
+                read_multipolygon(feature);
+                break;
+            case wkbGeometryCollection:
+                break;
+            default:
+                break;
+            }
+        }
+         
+        void read(Feature & feature) 
+        {
             int type=read_integer();
             switch (type)
             {
-               case wkbPoint:
-                  read_point(feature);
-                  break;
-               case wkbLineString:
-                  read_linestring(feature);
-                  break;
-               case wkbPolygon:
-                  read_polygon(feature);
-                  break;
-               case wkbMultiPoint:
-                  read_multipoint_2(feature);
-                  break;
-               case wkbMultiLineString:
-                  read_multilinestring_2(feature);
-                  break;
-               case wkbMultiPolygon:
-                  read_multipolygon_2(feature);
-                  break;
-               case wkbGeometryCollection:
-                  break;
-               default:
-                  break;
-            }
-         }
+            case wkbPoint:
+                read_point(feature);
+                break;
+            case wkbLineString:
+                read_linestring(feature);
+                break;
+            case wkbPolygon:
+                read_polygon(feature);
+                break;
+            case wkbMultiPoint:
+                read_multipoint_2(feature);
+                break;
+            case wkbMultiLineString:
+                read_multilinestring_2(feature);
+                break;
+            case wkbMultiPolygon:
+                read_multipolygon_2(feature);
+                break;
+            case wkbGeometryCollection:
+                break;
+            default:
+                break;
+            }
+        }
           
-      private:
-         wkb_reader(const wkb_reader&);
-         wkb_reader& operator=(const wkb_reader&);
-        
-         int read_integer() 
-         {
+    private:
+        
+        int read_integer() 
+        {
             int n;
-
-            if (!needSwap_)
-            {
-               memcpy(&n,wkb_+pos_,4);
+            if (needSwap_)
+            {
+                read_int_xdr(wkb_+pos_,n);
             } 
             else 
             {
-               const char* b=wkb_+pos_;
-               n = (b[3]&0xff) | ((b[2]&0xff)<<8) | ((b[1]&0xff)<<16) | ((b[0]&0xff)<<24);
+                read_int_ndr(wkb_+pos_,n);
             }
             pos_+=4;
-
+            
             return n;
-         }
-        
-         double read_double()
-         {
+        }
+        
+        double read_double()
+        {
             double d;
-
-            if (!needSwap_)
-            {
-               memcpy(&d,wkb_+pos_,8);
+            if (needSwap_)
+            {
+                read_double_xdr(wkb_ + pos_, d);
             }
             else 
             {
-               const char* b= wkb_+pos_;
-               boost::int64_t n = ((boost::int64_t)b[7]&0xff) | 
-                             (((boost::int64_t)b[6]&0xff)<<8) | 
-                             (((boost::int64_t)b[5]&0xff)<<16) | 
-                             (((boost::int64_t)b[4]&0xff)<<24) |
-                             (((boost::int64_t)b[3]&0xff)<<32) |
-                             (((boost::int64_t)b[2]&0xff)<<40) |
-                             (((boost::int64_t)b[1]&0xff)<<48) |
-                             (((boost::int64_t)b[0]&0xff)<<56);
-               memcpy(&d,&n,8);
+                read_double_ndr(wkb_ + pos_, d);
             }
             pos_+=8;
-
+            
             return d;
-         }
-        
-         void read_coords(CoordinateArray& ar)
-         {
+        }
+        
+        void read_coords(CoordinateArray& ar)
+        {
             int size=sizeof(coord<double,2>)*ar.size();
             if (!needSwap_)
             {
-               std::memcpy(&ar[0],wkb_+pos_,size);
-                
+                std::memcpy(&ar[0],wkb_+pos_,size);
+                pos_+=size;
             }
             else 
             {
-               for (unsigned i=0;i<ar.size();++i)
-               {
-                  ar[i].x=read_double();
-                  ar[i].y=read_double();
-               }
-            }
-            pos_+=size;
-         }
-        
-         void read_point(Feature & feature)
-         {
+                for (unsigned i=0;i<ar.size();++i)
+                {
+                    read_double_ndr(wkb_ + pos_,ar[i].x);
+                    read_double_ndr(wkb_ + pos_ + 8,ar[i].y);
+                    pos_ += 16;
+                }
+            }
+            
+        }
+        
+        void read_point(Feature & feature)
+        {
             geometry2d * pt = new point<vertex2d>;
             double x = read_double();
@@ -221 +210 @@
             pt->move_to(x,y);
             feature.add_geometry(pt);
-         }
-         
-         void read_multipoint(Feature & feature)
-         {
+        }
+         
+        void read_multipoint(Feature & feature)
+        {
             int num_points = read_integer();
             for (int i=0;i<num_points;++i) 
             {
-               pos_+=5;
-               read_point(feature);
-            }
-         }
-         
-         void read_multipoint_2(Feature & feature)
-         {
+                pos_+=5;
+                read_point(feature);
+            }
+        }
+         
+        void read_multipoint_2(Feature & feature)
+        {
             geometry2d * pt = new point<vertex2d>;
             int num_points = read_integer(); 
             for (int i=0;i<num_points;++i) 
             {
-               pos_+=5;
-               double x = read_double();
-               double y = read_double();
-               pt->move_to(x,y);
+                pos_+=5;
+                double x = read_double();
+                double y = read_double();
+                pt->move_to(x,y);
             }
             feature.add_geometry(pt);
-         }
-         
-         void read_linestring(Feature & feature)
-         {
+        }
+         
+        void read_linestring(Feature & feature)
+        {
             geometry2d * line = new line_string<vertex2d>;
             int num_points=read_integer();
@@ -257 +246 @@
             for (int i=1;i<num_points;++i)
             {
-               line->line_to(ar[i].x,ar[i].y);
+                line->line_to(ar[i].x,ar[i].y);
             }
             feature.add_geometry(line);
-         }
-         
-         void read_multilinestring(Feature & feature)
-         {
+        }
+         
+        void read_multilinestring(Feature & feature)
+        {
             int num_lines=read_integer();
             for (int i=0;i<num_lines;++i)
             {
-               pos_+=5;
-               read_linestring(feature);
-            }
-         }
-
-         void read_multilinestring_2(Feature & feature)
-         {
+                pos_+=5;
+                read_linestring(feature);
+            }
+        }
+
+        void read_multilinestring_2(Feature & feature)
+        {
             geometry2d * line = new line_string<vertex2d>;
             int num_lines=read_integer();
@@ -279 +268 @@
             for (int i=0;i<num_lines;++i)
             {
-               pos_+=5;
-               int num_points=read_integer();
-               capacity+=num_points;
-               CoordinateArray ar(num_points); 
-               read_coords(ar);
-               line->set_capacity(capacity);
-               line->move_to(ar[0].x,ar[0].y); 
-               for (int i=1;i<num_points;++i) 
-               { 
-                  line->line_to(ar[i].x,ar[i].y); 
-               } 
+                pos_+=5;
+                int num_points=read_integer();
+                capacity+=num_points;
+                CoordinateArray ar(num_points); 
+                read_coords(ar);
+                line->set_capacity(capacity);
+                line->move_to(ar[0].x,ar[0].y); 
+                for (int i=1;i<num_points;++i) 
+                { 
+                    line->line_to(ar[i].x,ar[i].y); 
+                } 
             }
             feature.add_geometry(line);
-         }
-         
-         void read_polygon(Feature & feature) 
-         {
+        }
+         
+        void read_polygon(Feature & feature) 
+        {
             geometry2d * poly = new polygon<vertex2d>;
             int num_rings=read_integer();
@@ -301 +290 @@
             for (int i=0;i<num_rings;++i)
             {
-               int num_points=read_integer();
-               capacity+=num_points;
-               CoordinateArray ar(num_points);
-               read_coords(ar);
-               poly->set_capacity(capacity);
-               poly->move_to(ar[0].x,ar[0].y);
-               for (int j=1;j<num_points;++j)
-               {
-                  poly->line_to(ar[j].x,ar[j].y);
-               }
+                int num_points=read_integer();
+                capacity+=num_points;
+                CoordinateArray ar(num_points);
+                read_coords(ar);
+                poly->set_capacity(capacity);
+                poly->move_to(ar[0].x,ar[0].y);
+                for (int j=1;j<num_points;++j)
+                {
+                    poly->line_to(ar[j].x,ar[j].y);
+                }
             }
             feature.add_geometry(poly);
-         }
-        
-         void read_multipolygon(Feature & feature)
-         {
+        }
+        
+        void read_multipolygon(Feature & feature)
+        {
             int num_polys=read_integer();
             for (int i=0;i<num_polys;++i)
             {
-               pos_+=5;
-               read_polygon(feature);
-            }
-         }
-
-         void read_multipolygon_2(Feature & feature)
-         {
+                pos_+=5;
+                read_polygon(feature);
+            }
+        }
+
+        void read_multipolygon_2(Feature & feature)
+        {
             geometry2d * poly = new polygon<vertex2d>;
             int num_polys=read_integer();
@@ -332 +321 @@
             for (int i=0;i<num_polys;++i)
             {
-               pos_+=5;
-               int num_rings=read_integer();
-               for (int i=0;i<num_rings;++i)
-               {
-                  int num_points=read_integer();
-                  capacity += num_points;
-                  CoordinateArray ar(num_points);
-                  read_coords(ar);
-                  poly->set_capacity(capacity);
-                  poly->move_to(ar[0].x,ar[0].y);
+                pos_+=5;
+                int num_rings=read_integer();
+                for (int i=0;i<num_rings;++i)
+                {
+                    int num_points=read_integer();
+                    capacity += num_points;
+                    CoordinateArray ar(num_points);
+                    read_coords(ar);
+                    poly->set_capacity(capacity);
+                    poly->move_to(ar[0].x,ar[0].y);
                   
-                  for (int j=1;j<num_points;++j)
-                  {
-                     poly->line_to(ar[j].x,ar[j].y);
-                  }
-                  poly->line_to(ar[0].x,ar[0].y);
-               }
+                    for (int j=1;j<num_points;++j)
+                    {
+                        poly->line_to(ar[j].x,ar[j].y);
+                    }
+                    poly->line_to(ar[0].x,ar[0].y);
+                }
             }
             feature.add_geometry(poly);
-         }
-   };
-   
-   void geometry_utils::from_wkb (Feature & feature,
+        }
+    };
+    
+    void geometry_utils::from_wkb (Feature & feature,
                                    const char* wkb,
                                    unsigned size,
                                    bool multiple_geometries,
                                    wkbFormat format) 
-   {
-      wkb_reader reader(wkb,size,format);
-      if (multiple_geometries)
-         return reader.read_multi(feature);
-      else
-         return reader.read(feature);
-   }    
+    {
+        wkb_reader reader(wkb,size,format);
+        if (multiple_geometries)
+            return reader.read_multi(feature);
+        else
+            return reader.read(feature);
+    }    
 }