Ticket #322: endianness.2

File endianness.2, 25.3 KB (added by pini, 12 years ago)

New patch tested on Debian sparc with MG maps.

Line 
1Handle endianness while reading data from mmapped mg files.
2Index: navit-0.1.1.0+dfsg.1/navit/data.h
3===================================================================
4--- navit-0.1.1.0+dfsg.1.orig/navit/data.h      2009-06-28 20:08:53.000000000 +0200
5+++ navit-0.1.1.0+dfsg.1/navit/data.h   2009-06-28 20:08:55.000000000 +0200
6@@ -20,6 +20,12 @@
7 #ifndef NAVIT_DATA_H
8 #define NAVIT_DATA_H
9 
10+#include "config.h"
11+
12+#ifdef WORDS_BIGENDIAN
13+#include <byteswap.h>
14+#endif
15+
16 static inline unsigned char
17 get_u8(unsigned char **p)
18 {
19@@ -31,7 +37,11 @@
20        unsigned short ret;
21        ret=*((unsigned short *)*p);
22        *p+=sizeof(unsigned short);
23+#ifdef WORDS_BIGENDIAN
24+       return __bswap_16(ret);
25+#else
26        return ret;
27+#endif
28 }
29 
30 static inline unsigned short
31@@ -66,7 +76,11 @@
32        unsigned long ret;
33        ret=*((unsigned int *)*p);
34        *p+=sizeof(unsigned int);
35+#ifdef WORDS_BIGENDIAN
36+       return __bswap_32(ret);
37+#else
38        return ret;
39+#endif
40 }
41 
42 static inline unsigned int
43Index: navit-0.1.1.0+dfsg.1/navit/map/mg/block.c
44===================================================================
45--- navit-0.1.1.0+dfsg.1.orig/navit/map/mg/block.c      2009-06-28 20:08:53.000000000 +0200
46+++ navit-0.1.1.0+dfsg.1/navit/map/mg/block.c   2009-06-28 20:08:55.000000000 +0200
47@@ -26,16 +26,24 @@
48 int block_lin_count,block_idx_count,block_active_count,block_mem,block_active_mem;
49 
50 struct block_index_item {
51-       unsigned int blocknum;
52-       unsigned int blocks;
53+       /*unsigned int blocknum;
54+       unsigned int blocks;*/
55+       unsigned char p[8];
56 };
57+static inline unsigned int block_index_item_get_blocknum(struct block_index_item * blk) { unsigned char *p = blk->p; return get_u32(&p); }
58+static inline unsigned int block_index_item_get_blocks(struct block_index_item * blk) { unsigned char *p = blk->p+4; return get_u32(&p); }
59 
60 struct block_index {
61-       unsigned int blocks;
62+/*     unsigned int blocks;
63         unsigned int size;
64         unsigned int next;     
65-       struct block_index_item list[0];
66+       struct block_index_item list[0];*/
67+       unsigned char p[12];
68 };
69+static inline unsigned int block_index_get_blocks(struct block_index * blk) { unsigned char *p = blk->p; return get_u32(&p); }
70+static inline unsigned int block_index_get_size(struct block_index * blk) { unsigned char *p = blk->p+4; return get_u32(&p); }
71+static inline unsigned int block_index_get_next(struct block_index * blk) { unsigned char *p = blk->p+8; return get_u32(&p); }
72+static inline struct block_index_item * block_index_get_list(struct block_index * blk) { return (struct block_index_item *)(blk->p+12); }
73 
74 static struct block *
75 block_get(unsigned char **p)
76@@ -54,13 +62,13 @@
77 
78 
79        blk_idx=(struct block_index *)(file->begin+0x1000);
80-       max=(blk_idx->size-sizeof(struct block_index))/sizeof(struct block_index_item);
81+       max=(block_index_get_size(blk_idx)-sizeof(struct block_index))/sizeof(struct block_index_item);
82        block_mem+=24;
83        while (id >= max) {
84-               blk_idx=(struct block_index *)(file->begin+blk_idx->next*512);
85+               blk_idx=(struct block_index *)(file->begin+block_index_get_next(blk_idx)*512);
86                id-=max;
87        }
88-       blk_num=blk_idx->list[id].blocknum;
89+       blk_num=block_index_item_get_blocknum(&block_index_get_list(blk_idx)[id]);
90 
91        *p_ret=file->begin+blk_num*512;
92        return block_get(p_ret);
93@@ -73,7 +81,7 @@
94        blk->b=block_get_byid(file, idx, &blk->p);
95        blk->block_start=(unsigned char *)(blk->b);
96        blk->p_start=blk->p;
97-       blk->end=blk->block_start+blk->b->size;
98+       blk->end=blk->block_start+block_get_size(blk->b);
99 
100        return 1;
101 }
102@@ -159,6 +167,7 @@
103 int
104 block_next_lin(struct map_rect_priv *mr)
105 {
106+       struct coord_rect r;
107        for (;;) {
108                block_lin_count++;
109                block_mem+=sizeof(struct block *);
110@@ -166,7 +175,7 @@
111                if (! mr->b.block_num)
112                        mr->b.p=mr->file->begin+0x2000;
113                else
114-                       mr->b.p=mr->b.block_start+mr->b.b->blocks*512;
115+                       mr->b.p=mr->b.block_start+block_get_blocks(mr->b.b)*512;
116                if (mr->b.p >= mr->file->end) {
117                        dbg(1,"end of blocks %p vs %p\n", mr->b.p, mr->file->end);
118                        return 0;
119@@ -174,14 +183,15 @@
120                mr->b.block_start=mr->b.p;
121                mr->b.b=block_get(&mr->b.p);
122                mr->b.p_start=mr->b.p;
123-               mr->b.end=mr->b.block_start+mr->b.b->size;
124-               if (mr->b.b->count == -1) {
125+               mr->b.end=mr->b.block_start+block_get_size(mr->b.b);
126+               if (block_get_count(mr->b.b) == -1) {
127                        dbg(1,"empty blocks\n");
128                        return 0;
129                }
130-               if (!mr->cur_sel || coord_rect_overlap(&mr->cur_sel->u.c_rect, &mr->b.b->r)) {
131+               block_get_r(mr->b.b, &r);
132+               if (!mr->cur_sel || coord_rect_overlap(&mr->cur_sel->u.c_rect, &r)) {
133                        block_active_count++;
134-                       block_active_mem+=mr->b.b->blocks*512-sizeof(struct block *);
135+                       block_active_mem+=block_get_blocks(mr->b.b)*512-sizeof(struct block *);
136                        dbg(1,"block ok\n");
137                        return 1;
138                }
139@@ -194,6 +204,7 @@
140 {
141        int blk_num,coord,r_h,r_w;
142        struct block_bt_priv *bt=&mr->b.bt;
143+       struct coord_rect r;
144 
145        if (!mr->b.binarytree || ! mr->cur_sel)
146                return block_next_lin(mr);
147@@ -203,10 +214,10 @@
148                        if (bt->next == -1)
149                                return 0;
150                        bt->b=block_get_byid(mr->file, bt->next, &bt->p);
151-                       bt->end=(unsigned char *)mr->b.bt.b+mr->b.bt.b->size;
152-                       bt->next=bt->b->next;
153+                       bt->end=(unsigned char *)mr->b.bt.b+block_get_size(mr->b.bt.b);
154+                       bt->next=block_get_next(bt->b);
155                        bt->order=0;
156-                       dbg(1,"size 0x%x next 0x%x\n", bt->b->size, bt->b->next);
157+                       dbg(1,"size 0x%x next 0x%x\n", block_get_size(bt->b), block_get_next(bt->b));
158                        if (! mr->b.bt.block_count) {
159 #if 0
160                                if (debug) {
161@@ -214,7 +225,7 @@
162                                        block_rect_print(&mr->b.bt.b->r);
163                                }
164 #endif
165-                               bt->r=bt->b->r;
166+                               block_get_r(bt->b, &bt->r);
167                                bt->r_curr=bt->r;
168                                coord=get_u32(&mr->b.bt.p);
169                        } else {
170@@ -248,8 +259,9 @@
171                                        dbg_assert(mr->b.b != NULL);
172                                        mr->b.block_start=(unsigned char *)(mr->b.b);
173                                        mr->b.p_start=mr->b.p;
174-                                       mr->b.end=mr->b.block_start+mr->b.b->size;
175-                                       block_rect_same(&mr->b.b->r, &bt->r_curr);
176+                                       mr->b.end=mr->b.block_start+block_get_size(mr->b.b);
177+                                       block_get_r(mr->b.b, &r);
178+                                       block_rect_same(&r, &bt->r_curr);
179                                }
180                        }
181                        if (coord != -1) {
182@@ -276,7 +288,7 @@
183                        }
184                        if (mr->b.b) {
185                                block_active_count++;
186-                               block_active_mem+=mr->b.b->blocks*512;
187+                               block_active_mem+=block_get_blocks(mr->b.b)*512;
188                                return 1;
189                        }
190                }
191Index: navit-0.1.1.0+dfsg.1/navit/map/mg/mg.h
192===================================================================
193--- navit-0.1.1.0+dfsg.1.orig/navit/map/mg/mg.h 2009-06-28 20:08:53.000000000 +0200
194+++ navit-0.1.1.0+dfsg.1/navit/map/mg/mg.h      2009-06-28 21:47:37.000000000 +0200
195@@ -31,12 +31,18 @@
196 };
197 
198 struct block {
199-       int blocks;
200+/*     int blocks;
201        int size;
202        int next;
203        struct coord_rect r;
204-       int count;
205+       int count;*/
206+       unsigned char p[32];
207 };
208+static inline int block_get_blocks(struct block * blk) { unsigned char *p = blk->p; return get_u32(&p); }
209+static inline int block_get_size(struct block * blk) { unsigned char *p = blk->p+4; return get_u32(&p); }
210+static inline int block_get_next(struct block * blk) { unsigned char *p = blk->p+8; return get_u32(&p); }
211+static inline int block_get_count(struct block * blk) { unsigned char *p = blk->p+28; return get_u32(&p); }
212+static inline void block_get_r(struct block * blk, struct coord_rect * r) { unsigned char *p = blk->p+12; r ->lu.x = get_u32(&p); r ->lu.y = get_u32(&p); r ->rl.x = get_u32(&p); r ->rl.y = get_u32(&p); }
213 
214 struct item_priv {
215        int cidx;
216@@ -93,14 +99,20 @@
217 };
218 
219 struct street_header {
220-        unsigned char order;
221-        int count;
222+        /*unsigned char order;
223+        int count;*/
224+       unsigned char p[5];
225 } __attribute__((packed));
226+static inline unsigned char street_header_get_order(struct street_header * str) { return *str->p; }
227+static inline int street_header_get_count(struct street_header * str) { unsigned char *p = str->p+1; return get_u32_unal(&p); }
228 
229 struct street_type {
230-        unsigned char order;
231-        unsigned short country;
232+        /*unsigned char order;
233+        unsigned short country;*/
234+       unsigned char p[3];
235 } __attribute__((packed));
236+static inline unsigned char street_type_get_order(struct street_type * str) { return *str->p; }
237+static inline unsigned short street_type_get_country(struct street_type * str) { unsigned char *p = str->p+1; return get_u16_unal(&p); }
238 
239 struct street_header_type {
240        struct street_header *header;
241@@ -109,13 +121,20 @@
242 };
243 
244 struct street_str {
245-        int segid;
246-        unsigned char limit;            /* 0x03,0x30=One Way,0x33=No Passing */
247-        unsigned char unknown2;
248+        /*int segid;
249+        unsigned char limit;*/            /* 0x03,0x30=One Way,0x33=No Passing */
250+        /*unsigned char unknown2;
251         unsigned char unknown3;
252         unsigned char type;
253-        unsigned int nameid;
254+        unsigned int nameid;*/
255+       unsigned char p[12];
256 };
257+static inline int street_str_get_segid(struct street_str * str) { unsigned char *p = str->p; return get_u32_unal(&p); }
258+static inline unsigned char street_str_get_limit(struct street_str * str) { return str->p[4]; }
259+static inline unsigned char street_str_get_unknown2(struct street_str * str) { return str->p[5]; }
260+static inline unsigned char street_str_get_unknown3(struct street_str * str) { return str->p[6]; }
261+static inline unsigned char street_str_get_type(struct street_str * str) { return str->p[7]; }
262+static inline unsigned int street_str_get_nameid(struct street_str * str) { unsigned char *p = str->p+8; return get_u32_unal(&p); }
263 
264 struct street_name_segment {
265        int segid;
266@@ -187,7 +206,7 @@
267        unsigned char *next;
268        int status;
269        int status_rewind;
270-       struct coord *ref;
271+       struct coord_rect ref;
272        int bytes;
273        int more;
274        int flags;
275Index: navit-0.1.1.0+dfsg.1/configure.in
276===================================================================
277--- navit-0.1.1.0+dfsg.1.orig/configure.in      2009-06-28 20:08:55.000000000 +0200
278+++ navit-0.1.1.0+dfsg.1/configure.in   2009-06-28 21:46:24.000000000 +0200
279@@ -87,6 +87,10 @@
280 AC_SUBST(CC_FOR_BUILD)
281 AC_SUBST(CCLD_FOR_BUILD)
282 
283+# Endianness
284+# defines WORDS_BIGENDIAN for big-endian systems
285+AC_C_BIGENDIAN
286+
287 AC_ARG_ENABLE(variant, [  --enable-variant=something          set variant], NAVIT_VARIANT=$enableval)
288 AC_SUBST(NAVIT_VARIANT)
289 
290Index: navit-0.1.1.0+dfsg.1/navit/map/mg/poly.c
291===================================================================
292--- navit-0.1.1.0+dfsg.1.orig/navit/map/mg/poly.c       2009-06-28 20:08:53.000000000 +0200
293+++ navit-0.1.1.0+dfsg.1/navit/map/mg/poly.c    2009-06-28 20:08:55.000000000 +0200
294@@ -122,7 +122,7 @@
295                        poly->poly_next=mr->b.p;
296                        item->meth=&poly_meth;
297                }
298-               if (poly->poly_num >= mr->b.b->count)
299+               if (poly->poly_num >= block_get_count(mr->b.b))
300                        return 0;
301                if (!poly->subpoly_num) {
302                        mr->b.p=poly->poly_next;
303Index: navit-0.1.1.0+dfsg.1/navit/map/mg/street.c
304===================================================================
305--- navit-0.1.1.0+dfsg.1.orig/navit/map/mg/street.c     2009-06-28 20:08:53.000000000 +0200
306+++ navit-0.1.1.0+dfsg.1/navit/map/mg/street.c  2009-06-28 20:08:55.000000000 +0200
307@@ -198,7 +198,7 @@
308        return bytes;
309 }
310 
311-static int street_get_coord(unsigned char **pos, int bytes, struct coord *ref, struct coord *f)
312+static int street_get_coord(unsigned char **pos, int bytes, struct coord_rect *ref, struct coord *f)
313 {
314        unsigned char *p;
315        int x,y,flags=0;
316@@ -235,9 +235,9 @@
317                y|=(*p++) << 24;
318        }
319        if (f) {
320-               f->x=ref[0].x+x;
321-               f->y=ref[1].y+y;
322-               dbg(1,"0x%x,0x%x + 0x%x,0x%x = 0x%x,0x%x\n", x, y, ref[0].x, ref[1].y, f->x, f->y);
323+               f->x=ref->lu.x+x;
324+               f->y=ref->rl.y+y;
325+               dbg(1,"0x%x,0x%x + 0x%x,0x%x = 0x%x,0x%x\n", x, y, ref->lu.x, ref->rl.y, f->x, f->y);
326        }
327        *pos=p;
328        return flags;
329@@ -249,7 +249,7 @@
330        struct street_str *str;
331 
332        str=(struct street_str *)(*p);
333-       while (L(str->segid)) {
334+       while (street_str_get_segid(str)) {
335                str++;
336        }
337        (*p)=(unsigned char *)str;
338@@ -275,7 +275,7 @@
339        if (street->status >= 4)
340                return 0;
341        n=street->p;
342-       if (street_get_coord(&street->p, street->bytes, street->ref, c)) {
343+       if (street_get_coord(&street->p, street->bytes, &street->ref, c)) {
344                if (street->status)
345                        street->next=n;
346                street->status+=2;
347@@ -298,14 +298,14 @@
348                street->p=street->coord_begin;
349                scount=street->str-street->str_start;
350                for (i = 0 ; i < scount ; i++) {
351-                       street->status=L(street->str[i+1].segid) >= 0 ? 0:1;
352+                       street->status=street_str_get_segid(&street->str[i+1]) >= 0 ? 0:1;
353                        while (street_coord_get_helper(street, c));
354                        street->p=street->next;
355                }
356-               street->status_rewind=street->status=L(street->str[1].segid) >= 0 ? 0:1;
357+               street->status_rewind=street->status=street_str_get_segid(&street->str[1]) >= 0 ? 0:1;
358        }
359 #ifdef DEBUG_COORD_GET
360-       segid=street->str[0].segid;
361+       segid=street_str_get_segid(&street->str[0]);
362        if (segid < 0)
363                segid=-segid;
364        if (segid == 0x15)
365@@ -345,7 +345,7 @@
366        struct street_priv *street=priv_data;
367        int nameid;
368 
369-       dbg(1,"segid 0x%x\n", L(street->str->segid));
370+       dbg(1,"segid 0x%x\n", street_str_get_segid(street->str));
371        attr->type=attr_type;
372        switch (attr_type) {
373        case attr_any:
374@@ -356,7 +356,7 @@
375                return 0;
376        case attr_label:
377                street->attr_next=attr_street_name;
378-               nameid=L(street->str->nameid);
379+               nameid=street_str_get_nameid(street->str);
380                if (! nameid)
381                        return 0;
382                if (! street->name.len)
383@@ -370,7 +370,7 @@
384                return 0;
385        case attr_street_name:
386                street->attr_next=attr_street_name_systematic;
387-               nameid=L(street->str->nameid);
388+               nameid=street_str_get_nameid(street->str);
389                if (! nameid)
390                        return 0;
391                if (! street->name.len)
392@@ -379,7 +379,7 @@
393                return ((attr->u.str && attr->u.str[0]) ? 1:0);
394        case attr_street_name_systematic:
395                street->attr_next=attr_flags;
396-               nameid=L(street->str->nameid);
397+               nameid=street_str_get_nameid(street->str);
398                if (! nameid)
399                        return 0;
400                if (! street->name.len)
401@@ -392,7 +392,7 @@
402                return 1;
403        case attr_country_id:
404                street->attr_next=attr_debug;
405-               nameid=L(street->str->nameid);
406+               nameid=street_str_get_nameid(street->str);
407                if (! nameid)
408                        return 0;
409                if (! street->name.len)
410@@ -403,7 +403,7 @@
411                street->attr_next=attr_none;
412                {
413                struct street_str *str=street->str;
414-               sprintf(street->debug,"order:0x%x\nsegid:0x%x\nlimit:0x%x\nunknown2:0x%x\nunknown3:0x%x\ntype:0x%x\nnameid:0x%x\ntownassoc:0x%x",street->header->order,str->segid,str->limit,str->unknown2,str->unknown3,str->type,str->nameid, street->name.len ? street->name.townassoc : 0);
415+               sprintf(street->debug,"order:0x%x\nsegid:0x%x\nlimit:0x%x\nunknown2:0x%x\nunknown3:0x%x\ntype:0x%x\nnameid:0x%x\ntownassoc:0x%x",street_header_get_order(street->header),street_str_get_segid(str),street_str_get_limit(str),street_str_get_unknown2(str),street_str_get_unknown3(str),street_str_get_type(str),street_str_get_nameid(str), street->name.len ? street->name.townassoc : 0);
416                attr->u.str=street->debug;
417                }
418                return 1;
419@@ -425,7 +425,7 @@
420 {
421        street->header=(struct street_header *)(*p);
422        (*p)+=sizeof(struct street_header);
423-       street->type_count=street->header->count;
424+       street->type_count=street_header_get_count(street->header);
425        street->type=(struct street_type *)(*p);       
426        (*p)+=street->type_count*sizeof(struct street_type);
427 }
428@@ -570,7 +570,7 @@
429                                                continue;
430 #endif
431                                        }
432-                                       if (street->str->type & 0x40) {
433+                                       if (street_str_get_type(street->str) & 0x40) {
434                                                dir=-dir;
435                                                dlr=-dlr;
436                                        }
437@@ -596,7 +596,7 @@
438 street_get_housenumber(struct map_rect_priv *mr, struct street_priv *street, struct item *item)
439 {
440        int nameid;
441-       nameid=L(street->str->nameid);
442+       nameid=street_str_get_nameid(street->str);
443        if (! nameid)
444                return 0;
445        if (! street->name.len)
446@@ -622,6 +622,7 @@
447 street_get(struct map_rect_priv *mr, struct street_priv *street, struct item *item)
448 {     
449        int *flags;
450+       struct coord_rect r;
451        for (;;) {
452                while (street->more) {
453                        struct coord c;
454@@ -637,11 +638,12 @@
455                if (mr->b.p == mr->b.p_start) {
456                        street_get_data(street, &mr->b.p);
457                        street->name_file=mr->m->file[file_strname_stn];
458-                       if (mr->cur_sel && street->header->order > limit[mr->cur_sel->order])
459+                       if (mr->cur_sel && street_header_get_order(street->header) > limit[mr->cur_sel->order])
460                                return 0;
461                        street->end=mr->b.end;
462-                       street->ref=&mr->b.b->r.lu;
463-                       street->bytes=street_get_bytes(&mr->b.b->r);
464+                       block_get_r(mr->b.b, &r);
465+                       street->ref=r;
466+                       street->bytes=street_get_bytes(&r);
467                        street->str_start=street->str=(struct street_str *)mr->b.p;
468                        street->coord_begin=mr->b.p;
469                        street_coord_get_begin(&street->coord_begin);
470@@ -653,25 +655,25 @@
471                        street->str++;
472                        street->p=street->next;
473                }
474-               if (! L(street->str->segid))
475+               if (! street_str_get_segid(street->str))
476                        return 0;
477-               if (L(street->str->segid) < 0)
478+               if (street_str_get_segid(street->str) < 0)
479                        street->type++;
480 #if 0
481                dbg_assert(street->p != NULL);
482 #endif
483                street->next=NULL;
484-               street->status_rewind=street->status=L(street->str[1].segid) >= 0 ? 0:1;
485+               street->status_rewind=street->status=street_str_get_segid(&street->str[1]) >= 0 ? 0:1;
486 #if 0
487                if (street->type->country != 0x31) {
488                        printf("country=0x%x\n", street->type->country);
489                }
490 #endif
491-               item->id_hi=street->type->country | (mr->current_file << 16);
492-               item->id_lo=L(street->str->segid) > 0 ? L(street->str->segid) : -L(street->str->segid);
493-               switch(street->str->type & 0x1f) {
494+               item->id_hi=street_type_get_country(street->type) | (mr->current_file << 16);
495+               item->id_lo=street_str_get_segid(street->str) > 0 ? street_str_get_segid(street->str) : -street_str_get_segid(street->str);
496+               switch(street_str_get_type(street->str) & 0x1f) {
497                case 0xf: /* very small street */
498-                       if (street->str->limit == 0x33)
499+                       if (street_str_get_limit(street->str) == 0x33)
500                                item->type=type_street_nopass;
501                        else
502                                item->type=type_street_0;
503@@ -686,15 +688,15 @@
504                        item->type=type_street_2_city;
505                        break;
506                case 0xa:
507-                       if ((street->str->limit == 0x03 || street->str->limit == 0x30) && street->header->order < 4)
508+                       if ((street_str_get_limit(street->str) == 0x03 || street_str_get_limit(street->str) == 0x30) && street_header_get_order(street->header) < 4)
509                                item->type=type_street_4_city;
510                        else   
511                                item->type=type_street_3_city;
512                        break;
513                case 0x9:
514-                       if (street->header->order < 5)
515+                       if (street_header_get_order(street->header) < 5)
516                                item->type=type_street_4_city;
517-                       else if (street->header->order < 7)
518+                       else if (street_header_get_order(street->header) < 7)
519                                item->type=type_street_2_city;
520                        else
521                                item->type=type_street_1_city;
522@@ -703,7 +705,7 @@
523                        item->type=type_street_2_land;
524                        break;
525                case 0x7:
526-                       if ((street->str->limit == 0x03 || street->str->limit == 0x30) && street->header->order < 4)
527+                       if ((street_str_get_limit(street->str) == 0x03 || street_str_get_limit(street->str) == 0x30) && street_header_get_order(street->header) < 4)
528                                item->type=type_street_4_city;
529                        else
530                                item->type=type_street_3_land;
531@@ -728,19 +730,19 @@
532                        break;
533                default:
534                        item->type=type_street_unkn;
535-                       dbg(0,"unknown type 0x%x\n",street->str->type);
536+                       dbg(0,"unknown type 0x%x\n",street_str_get_type(street->str));
537                }
538                flags=item_get_default_flags(item->type);
539                if (flags)
540                        street->flags=*flags;
541                else
542                        street->flags=0;
543-               if (street->str->type & 0x40) {
544-                       street->flags|=(street->str->limit & 0x30) ? AF_ONEWAYREV:0;
545-                       street->flags|=(street->str->limit & 0x03) ? AF_ONEWAY:0;
546+               if (street_str_get_type(street->str) & 0x40) {
547+                       street->flags|=(street_str_get_limit(street->str) & 0x30) ? AF_ONEWAYREV:0;
548+                       street->flags|=(street_str_get_limit(street->str) & 0x03) ? AF_ONEWAY:0;
549                } else {
550-                       street->flags|=(street->str->limit & 0x30) ? AF_ONEWAY:0;
551-                       street->flags|=(street->str->limit & 0x03) ? AF_ONEWAYREV:0;
552+                       street->flags|=(street_str_get_limit(street->str) & 0x30) ? AF_ONEWAY:0;
553+                       street->flags|=(street_str_get_limit(street->str) & 0x03) ? AF_ONEWAYREV:0;
554                }
555 #if 0
556                coord_debug=(street->str->unknown2 != 0x40 || street->str->unknown3 != 0x40);
557@@ -768,6 +770,7 @@
558 {
559         int country=id_hi & 0xffff;
560         int res;
561+       struct coord_rect r;
562        dbg(1,"enter(%p,%p,0x%x,0x%x,%p)\n", mr, street, id_hi, id_lo, item);
563        if (! country)
564                return 0;
565@@ -777,8 +780,9 @@
566        street_get_data(street, &mr->b.p);
567        street->name_file=mr->m->file[file_strname_stn];
568        street->end=mr->b.end;
569-       street->ref=&mr->b.b->r.lu;
570-       street->bytes=street_get_bytes(&mr->b.b->r);
571+       block_get_r(mr->b.b, &r);
572+       street->ref=r;
573+       street->bytes=street_get_bytes(&r);
574        street->str_start=street->str=(struct street_str *)mr->b.p;
575        street->coord_begin=mr->b.p;
576        street_coord_get_begin(&street->coord_begin);
577@@ -787,7 +791,7 @@
578        item->meth=&street_meth;
579        item->priv_data=street;
580        street->str+=(res & 0xfff)-1;
581-       dbg(1,"segid 0x%x\n", L(street->str[1].segid));
582+       dbg(1,"segid 0x%x\n", street_str_get_segid(&street->str[1]));
583        return street_get(mr, street, item);
584 #if 0
585         mr->b.p=mr->b.block_start+(res & 0xffff);
586Index: navit-0.1.1.0+dfsg.1/navit/map/mg/tree.c
587===================================================================
588--- navit-0.1.1.0+dfsg.1.orig/navit/map/mg/tree.c       2009-06-28 20:08:53.000000000 +0200
589+++ navit-0.1.1.0+dfsg.1/navit/map/mg/tree.c    2009-06-28 20:08:55.000000000 +0200
590@@ -23,34 +23,52 @@
591 #include "mg.h"
592 
593 struct tree_hdr {
594-       unsigned int addr;
595+       /*unsigned int addr;
596        unsigned int size;
597-       unsigned int low;
598+       unsigned int low;*/
599+       unsigned char p[12];
600 };
601+static inline unsigned int tree_hdr_get_addr(struct tree_hdr * tree) { unsigned char *p = tree->p; return get_u32(&p); }
602+static inline unsigned int tree_hdr_get_size(struct tree_hdr * tree) { unsigned char *p = tree->p+4; return get_u32(&p); }
603+static inline unsigned int tree_hdr_get_low(struct tree_hdr * tree) { unsigned char *p = tree->p+8; return get_u32(&p); }
604 
605 struct tree_hdr_h {
606-       unsigned int addr;
607-       unsigned int size;
608+/*     unsigned int addr;
609+       unsigned int size;*/
610+       unsigned char p[8];
611 };
612+static inline unsigned int tree_hdr_h_get_addr(struct tree_hdr_h * tree) { unsigned char *p = tree->p; return get_u32(&p); }
613+static inline unsigned int tree_hdr_h_get_size(struct tree_hdr_h * tree) { unsigned char *p = tree->p+4; return get_u32(&p); }
614 
615 struct tree_leaf_h {
616-       unsigned int lower;
617+/*     unsigned int lower;
618        unsigned int higher;
619        unsigned int match;
620-       unsigned int value;
621+       unsigned int value;*/
622+       unsigned char p[16];
623 };
624+static inline unsigned int tree_leaf_h_get_lower(struct tree_leaf_h * tree) { unsigned char *p = tree->p; return get_u32(&p); }
625+static inline unsigned int tree_leaf_h_get_higher(struct tree_leaf_h * tree) { unsigned char *p = tree->p+4; return get_u32(&p); }
626+static inline unsigned int tree_leaf_h_get_match(struct tree_leaf_h * tree) { unsigned char *p = tree->p+8; return get_u32(&p); }
627+static inline unsigned int tree_leaf_h_get_value(struct tree_leaf_h * tree) { unsigned char *p = tree->p+12; return get_u32(&p); }
628 
629 
630 struct tree_hdr_v {
631-       unsigned int count;
632+       /*unsigned int count;
633        unsigned int next;
634-       unsigned int unknown;
635+       unsigned int unknown;*/
636+       unsigned char p[12];
637 };
638+static inline unsigned int tree_hdr_v_get_count(struct tree_hdr_v * tree) { unsigned char *p = tree->p; return get_u32_unal(&p); }
639+static inline unsigned int tree_hdr_v_get_next(struct tree_hdr_v * tree) { unsigned char *p = tree->p+4; return get_u32_unal(&p); }
640+static inline unsigned int tree_hdr_v_get_unknown(struct tree_hdr_v * tree) { unsigned char *p = tree->p+8; return get_u32_unal(&p); }
641 
642 struct tree_leaf_v {
643        unsigned char key;
644-       int value;
645+       /*int value;*/
646+       unsigned char p[4];
647 } __attribute__((packed));
648+static inline int tree_leaf_v_get_value(struct tree_leaf_v * tree) { unsigned char *p = tree->p; return get_u32_unal(&p); }
649 
650 static int
651 tree_search_h(struct file *file, unsigned int search)
652@@ -64,24 +82,24 @@
653        while (i++ < 1000) {
654                thdr=(struct tree_hdr_h *)p;
655                p+=sizeof(*thdr);
656-               end=p+thdr->size;
657+               end=p+tree_hdr_h_get_size(thdr);
658                dbg(1,"@0x%x\n", p-file->begin);
659                last=0;
660                while (p < end) {
661                        tleaf=(struct tree_leaf_h *)p;
662                        p+=sizeof(*tleaf);
663-                       dbg(1,"low:0x%x high:0x%x match:0x%x val:0x%x search:0x%x\n", tleaf->lower, tleaf->higher, tleaf->match, tleaf->value, search);
664-                       value=tleaf->value;
665+                       dbg(1,"low:0x%x high:0x%x match:0x%x val:0x%x search:0x%x\n", tree_leaf_h_get_lower(tleaf), tree_leaf_h_get_higher(tleaf), tree_leaf_h_get_match(tleaf), tree_leaf_h_get_value(tleaf), search);
666+                       value=tree_leaf_h_get_value(tleaf);
667                        if (value == search)
668-                               return tleaf->match;
669+                               return tree_leaf_h_get_match(tleaf);
670                        if (value > search) {
671                                dbg(1,"lower\n");
672-                               lower=tleaf->lower;
673+                               lower=tree_leaf_h_get_lower(tleaf);
674                                if (lower)
675                                        last=lower;
676                                break;
677                        }
678-                       last=tleaf->higher;
679+                       last=tree_leaf_h_get_higher(tleaf);
680                }
681                if (! last || last == -1)
682                        return 0;
683@@ -100,16 +118,16 @@
684        while (i++ < 1000) {
685                thdr=(struct tree_hdr_v *)p;
686                p+=sizeof(*thdr);
687-               count=L(thdr->count);
688+               count=tree_hdr_v_get_count(thdr);
689                dbg(1,"offset=0x%x count=0x%x\n", p-file->begin, count);
690                while (count--) {
691                        tleaf=(struct tree_leaf_v *)p;
692                        p+=sizeof(*tleaf);
693                        dbg(1,"0x%x 0x%x\n", tleaf->key, search);
694                        if (tleaf->key == search)
695-                               return L(tleaf->value);
696+                               return tree_leaf_v_get_value(tleaf);
697                }
698-               next=L(thdr->next);
699+               next=tree_hdr_v_get_next(thdr);
700                if (! next)
701                        break;
702                p=file->begin+next;
703@@ -164,10 +182,10 @@
704        tsn->hdr=(struct tree_hdr *)p;
705        tsn->p=p+sizeof(struct tree_hdr);
706        tsn->last=tsn->p;
707-       tsn->end=p+tsn->hdr->size;
708-       tsn->low=tsn->hdr->low;
709-       tsn->high=tsn->hdr->low;
710-       dbg(1,"pos 0x%x addr 0x%x size 0x%x low 0x%x end 0x%x\n", p-ts->f->begin, tsn->hdr->addr, tsn->hdr->size, tsn->hdr->low, tsn->end-ts->f->begin);
711+       tsn->end=p+tree_hdr_get_size(tsn->hdr);
712+       tsn->low=tree_hdr_get_low(tsn->hdr);
713+       tsn->high=tree_hdr_get_low(tsn->hdr);
714+       dbg(1,"pos 0x%x addr 0x%x size 0x%x low 0x%x end 0x%x\n", p-ts->f->begin, tree_hdr_get_addr(tsn->hdr), tree_hdr_get_size(tsn->hdr), tree_hdr_get_low(tsn->hdr), tsn->end-ts->f->begin);
715        return tsn;
716 }
717