/[public]/psiconv/trunk/lib/psiconv/parse_layout.c
ViewVC logotype

Annotation of /psiconv/trunk/lib/psiconv/parse_layout.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 143 - (hide annotations)
Tue Jan 29 18:47:26 2002 UTC (22 years, 2 months ago) by frodo
File MIME type: text/plain
File size: 24906 byte(s) 
(Frodo) Two memory-leaks fixed
1 frodo 2 /*
2     parse_layout.c - Part of psiconv, a PSION 5 file formats converter
3 frodo 63 Copyright (c) 1999, 2000 Frodo Looijaard <frodol@dds.nl>
4 frodo 2
5     This program is free software; you can redistribute it and/or modify
6     it under the terms of the GNU General Public License as published by
7     the Free Software Foundation; either version 2 of the License, or
8     (at your option) any later version.
9    
10     This program is distributed in the hope that it will be useful,
11     but WITHOUT ANY WARRANTY; without even the implied warranty of
12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13     GNU General Public License for more details.
14    
15     You should have received a copy of the GNU General Public License
16     along with this program; if not, write to the Free Software
17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18     */
19    
20     #include "config.h"
21 frodo 71 #include "compat.h"
22    
23 frodo 2 #include <stdlib.h>
24     #include <math.h>
25    
26     #include "parse_routines.h"
27 frodo 71 #include "error.h"
28 frodo 2
29 frodo 142 #ifdef DMALLOC
30     #include <dmalloc.h>
31     #endif
32    
33    
34 frodo 2 int psiconv_parse_color(const psiconv_buffer buf, int lev, psiconv_u32 off,
35     int *length, psiconv_color *result)
36     {
37     int res = 0;
38     int len = 0;
39    
40     psiconv_progress(lev+1,off,"Going to parse color");
41 frodo 64 if (!(*result = malloc(sizeof(**result))))
42     goto ERROR1;
43 frodo 2
44 frodo 64 (*result)->red = psiconv_read_u8(buf,lev+2,off+len,&res);
45     if (res)
46     goto ERROR2;
47     (*result)->green = psiconv_read_u8(buf,lev+2,off+len+1,&res);
48     if (res)
49     goto ERROR2;
50     (*result)->blue = psiconv_read_u8(buf,lev+2,off+len+2,&res);
51     if (res)
52     goto ERROR2;
53 frodo 2 len += 3;
54    
55     psiconv_debug(lev+2,off,"Color: red %02x, green %02x, blue %02x",
56     (*result)->red, (*result)->green, (*result)->blue);
57     if (length)
58     *length = len;
59    
60     psiconv_progress(lev+1,off+len-1,"End of color (total length: %08x)",len);
61 frodo 64 return 0;
62    
63     ERROR2:
64     free(*result);
65     ERROR1:
66     psiconv_warn(lev+1,off,"Reading of Color failed");
67     if (length)
68     *length = 0;
69     if (res == 0)
70     return -PSICONV_E_NOMEM;
71     else
72     return res;
73 frodo 2 }
74    
75    
76    
77     int psiconv_parse_font(const psiconv_buffer buf, int lev, psiconv_u32 off,
78     int *length, psiconv_font *result)
79     {
80     int res = 0;
81     int strlength,i;
82     char *str_copy;
83     int len;
84    
85     psiconv_progress(lev+1,off,"Going to parse font");
86 frodo 64 if (!(*result = malloc(sizeof(**result))))
87     goto ERROR1;
88 frodo 2
89 frodo 64 strlength = psiconv_read_u8(buf,lev+2,off,&res);
90     if (res)
91     goto ERROR2;
92     if (!((*result)->name = malloc(strlength))) {
93     goto ERROR2;
94     }
95     for (i = 0; (i < strlength-1) && !res; i++)
96     (*result)->name[i] = psiconv_read_u8(buf,lev+2,off + 1 + i,&res);
97     if (res)
98     goto ERROR3;
99 frodo 2 (*result)->name[strlength-1] = 0;
100 frodo 64 (*result)->screenfont = psiconv_read_u8(buf,lev+2,off + strlength,&res);
101     if (res)
102     goto ERROR3;
103 frodo 2
104 frodo 64 if (!(str_copy = psiconv_make_printable((*result)->name)))
105     goto ERROR3;
106    
107 frodo 2 psiconv_debug(lev+2,off+1,"Found font `%s', displayed with screen font %02x",
108     str_copy,(*result)->screenfont);
109     free(str_copy);
110     len = strlength + 1;
111     if (length)
112     *length = len;
113    
114     psiconv_progress(lev+1,off + len - 1,"End of font (total length: %08x)",len);
115 frodo 64 return 0;
116    
117     ERROR3:
118     free ((*result)->name);
119     ERROR2:
120     free (*result);
121     ERROR1:
122     psiconv_warn(lev+1,off,"Reading of Font failed");
123     if (length)
124     *length = 0;
125     if (!res)
126     return -PSICONV_E_NOMEM;
127     else
128     return res;
129 frodo 2 }
130    
131     int psiconv_parse_border(const psiconv_buffer buf,int lev,psiconv_u32 off,
132     int *length, psiconv_border *result)
133     {
134     int res = 0;
135     int len = 0;
136     psiconv_u32 temp;
137     int leng;
138    
139     psiconv_progress(lev+1,off,"Going to parse border data");
140 frodo 64 if (!(*result = malloc(sizeof(**result)))) {
141     goto ERROR1;
142     }
143 frodo 2
144     psiconv_progress(lev+2,off+len,"Going to read border kind");
145 frodo 64 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
146     if (res)
147     goto ERROR2;
148 frodo 2 if (temp == 0x00)
149     (*result)->kind = psiconv_border_none;
150     else if (temp == 0x01)
151     (*result)->kind = psiconv_border_solid;
152     else if (temp == 0x02)
153     (*result)->kind = psiconv_border_double;
154     else if (temp == 0x03)
155     (*result)->kind = psiconv_border_dotted;
156     else if (temp == 0x04)
157 frodo 67 (*result)->kind = psiconv_border_dashed;
158 frodo 2 else if (temp == 0x05)
159 frodo 67 (*result)->kind = psiconv_border_dotdashed;
160 frodo 2 else if (temp == 0x06)
161 frodo 67 (*result)->kind = psiconv_border_dotdotdashed;
162 frodo 2 else {
163     psiconv_warn(lev+2,off,"Unknown border kind (defaults to `none')");
164     (*result)->kind = psiconv_border_none;
165     }
166     psiconv_debug(lev+2,off+len,"Kind: %02x",temp);
167     len ++;
168    
169     psiconv_progress(lev+2,off+len,"Going to read border thickness");
170 frodo 64 (*result)->thickness = psiconv_read_size(buf,lev+2,off+len,&leng,&res);
171     if (res)
172     goto ERROR2;
173 frodo 84 #if 0
174     /* This seems no longer necessary to test? */
175 frodo 2 if (((*result)->kind != psiconv_border_solid) &&
176     ((*result)->kind != psiconv_border_double) &&
177     ((*result)->thickness != 0.0) &&
178     (fabs((*result)->thickness - 1/20) >= 1/1000)) {
179     psiconv_warn(lev+2,off,
180     "Border thickness specified for unlikely border type");
181     }
182 frodo 84 #endif
183 frodo 2 psiconv_debug(lev+2,off+len,"Thickness: %f",(*result)->thickness);
184     len += leng;
185    
186     psiconv_progress(lev+2,off+len,"Going to read the border color");
187 frodo 64 if ((psiconv_parse_color(buf,lev+2,off+len,&leng,&(*result)->color)))
188     goto ERROR2;
189 frodo 2 len += leng;
190    
191     psiconv_progress(lev+2,off+len,"Going to read the final unknown byte "
192 frodo 84 "(0x00 or 0x01 expected)");
193 frodo 64 temp = psiconv_read_u8(buf,lev+2,off + len,&res);
194     if (res)
195     goto ERROR3;
196 frodo 84 if ((temp != 0x01) && (temp != 0x00)) {
197 frodo 2 psiconv_warn(lev+2,off,"Unknown last byte in border specification");
198 frodo 84 psiconv_debug(lev+2,off+len, "Last byte: read %02x, expected %02x or %02x",
199     temp,0x00,0x01);
200 frodo 2 }
201     len ++;
202    
203     if (length)
204     *length = len;
205    
206     psiconv_progress(lev+1,off + len - 1,
207     "End of border (total length: %08x)",len);
208    
209 frodo 64 return 0;
210    
211     ERROR3:
212     psiconv_free_color((*result)->color);
213     ERROR2:
214     free (result);
215     ERROR1:
216     psiconv_warn(lev+1,off,"Reading of Border failed");
217     if (length)
218     *length = 0;
219     if (!res)
220     return -PSICONV_E_NOMEM;
221     else
222     return res;
223 frodo 2 }
224    
225     int psiconv_parse_bullet(const psiconv_buffer buf,int lev,psiconv_u32 off,
226     int *length, psiconv_bullet *result)
227     {
228     int res = 0;
229     int len = 0;
230     int leng;
231     int bullet_length;
232    
233 frodo 64 if (!(*result = malloc(sizeof(**result))))
234     goto ERROR1;
235 frodo 2 (*result)->on = psiconv_bool_true;
236    
237     psiconv_progress(lev+1,off,"Going to parse bullet data");
238     psiconv_progress(lev+2,off+len,"Going to read bullet length");
239 frodo 64 bullet_length = psiconv_read_u8(buf,lev+2,off+len,&res);
240     if (res)
241     goto ERROR2;
242 frodo 2 psiconv_debug(lev+2,off+len,"Length: %02x",bullet_length);
243     len ++;
244    
245     psiconv_progress(lev+2,off+len,"Going to read bullet font size");
246 frodo 64 (*result)->font_size = psiconv_read_size(buf,lev+2,off+len, &leng,&res);
247     if (res)
248     goto ERROR2;
249 frodo 2 len +=leng;
250    
251     psiconv_progress(lev+2,off+len,"Going to read bullet character");
252 frodo 64 (*result)->character = psiconv_read_u8(buf,lev+2,off+len,&res);
253     if (res)
254     goto ERROR2;
255 frodo 2 psiconv_debug(lev+2,off+len,"Character: %02x",(*result)->character);
256     len ++;
257    
258     psiconv_progress(lev+2,off+len,"Going to read indent on/off");
259 frodo 64 if ((res = psiconv_parse_bool(buf,lev+2,off+len,&leng,&(*result)->indent)))
260     goto ERROR2;
261 frodo 2 psiconv_debug(lev+2,off+len,"Indent on: %02x",(*result)->indent);
262     len += leng;
263    
264     psiconv_progress(lev+2,off+len,"Going to read bullet color");
265 frodo 64 if ((res = psiconv_parse_color(buf,lev+2,off+len,&leng,&(*result)->color)))
266     goto ERROR2;
267 frodo 2 len += leng;
268    
269     psiconv_progress(lev+2,off+len,"Going to read bullet font");
270 frodo 64 if ((res = psiconv_parse_font(buf,lev+2,off+len,&leng,&(*result)->font)))
271     goto ERROR3;
272 frodo 2 len += leng;
273    
274     if (len != bullet_length + 1) {
275     psiconv_warn(lev+2,off,"Bullet data structure length mismatch");
276     psiconv_debug(lev+2,off,"Length: specified %02x, found %02x",
277     bullet_length,len-1);
278     }
279    
280     psiconv_progress(lev+1,off + len - 1,
281     "End of bullet data (total length: %08x)",len);
282    
283     if (length)
284     *length = len;
285 frodo 65 return 0;
286 frodo 64
287     ERROR3:
288     psiconv_free_color((*result)->color);
289     ERROR2:
290     free (result);
291     ERROR1:
292     psiconv_warn(lev+1,off,"Reading of Bullet failed");
293     if (length)
294     *length = 0;
295     if (!res)
296     return -PSICONV_E_NOMEM;
297     else
298     return res;
299 frodo 2 }
300    
301     int psiconv_parse_tab(const psiconv_buffer buf, int lev, psiconv_u32 off,
302     int *length, psiconv_tab *result)
303     {
304     int res = 0;
305     int len = 0;
306     int leng;
307     psiconv_u8 temp;
308    
309     psiconv_progress(lev+1,off,"Going to parse tab");
310 frodo 64 if (!(*result = malloc(sizeof(**result))))
311     goto ERROR1;
312 frodo 2
313     psiconv_progress(lev+2,off,"Going to read tab location");
314 frodo 64 (*result)->location = psiconv_read_length(buf,lev+2,off+len,&leng,&res);
315     if (res)
316     goto ERROR2;
317 frodo 2 len += leng;
318    
319     psiconv_progress(lev+2,off+len,"Going to read the tab kind");
320 frodo 64 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
321     if (res)
322     goto ERROR2;
323 frodo 2 if (temp == 1)
324     (*result)->kind = psiconv_tab_left;
325     else if (temp == 2)
326     (*result)->kind = psiconv_tab_centre;
327     else if (temp == 3)
328     (*result)->kind = psiconv_tab_right;
329     else {
330     psiconv_warn(lev+2,off+len,"Unknown tab kind argument");
331     psiconv_debug(lev+2,off+len,"Kind found: %02x (defaulted to left tab)",
332     temp);
333     (*result)->kind = psiconv_tab_left;
334     }
335     psiconv_debug(lev+2,off+len,"Kind: %02x",temp);
336     len ++;
337    
338     if (length)
339     *length = len;
340    
341     psiconv_progress(lev+1,off+len-1,"End of tab (total length: %08x)",len);
342 frodo 64 return 0;
343 frodo 2
344 frodo 64 ERROR2:
345     free (result);
346     ERROR1:
347     psiconv_warn(lev+1,off,"Reading of Tab failed");
348     if (length)
349     *length = 0;
350     if (!res)
351     return -PSICONV_E_NOMEM;
352     else
353     return res;
354 frodo 2 }
355    
356     int psiconv_parse_paragraph_layout_list(const psiconv_buffer buf, int lev,
357     psiconv_u32 off, int *length,
358     psiconv_paragraph_layout result)
359     {
360     int res=0;
361     int len=0;
362     int list_length,leng,nr;
363     psiconv_u8 id;
364     psiconv_u32 temp;
365 frodo 64 psiconv_tab temp_tab;
366     psiconv_color temp_color;
367     psiconv_border temp_border;
368     psiconv_bullet temp_bullet;
369 frodo 2
370     psiconv_progress(lev+1,off,"Going to read paragraph layout list");
371    
372     psiconv_progress(lev+2,off,"Going to read the list length");
373 frodo 64 list_length = psiconv_read_u32(buf,lev+2,off + len,&res);
374     if (res)
375     goto ERROR1;
376 frodo 2 psiconv_debug(lev+2,off,"Length in bytes: %08x",list_length);
377     len += 4;
378    
379     nr = 0;
380     while(len - 4 < list_length) {
381     psiconv_progress(lev+2,off+len,"Going to read element %d",nr);
382     psiconv_progress(lev+3,off+len,"Going to read the element id");
383 frodo 64 id = psiconv_read_u8(buf,lev+2,off+len,&res);
384     if (res)
385     goto ERROR1;
386 frodo 2 psiconv_debug(lev+3,off+len,"Id: %02x",id);
387     len ++;
388     switch(id) {
389     case 0x01:
390     psiconv_progress(lev+3,off+len,"Going to read background color");
391 frodo 64 if ((res = psiconv_parse_color(buf,lev+3,off+len,&leng,&temp_color)))
392     goto ERROR1;
393 frodo 2 psiconv_free_color(result->back_color);
394 frodo 64 result->back_color = temp_color;
395 frodo 2 len += leng;
396     break;
397     case 0x02:
398     psiconv_progress(lev+3,off+len ,"Going to read indent left");
399 frodo 64 result->indent_left = psiconv_read_length(buf,lev+3,off+len,&leng,&res);
400     if (res)
401     goto ERROR1;
402 frodo 2 len += leng;
403     break;
404     case 0x03:
405     psiconv_progress(lev+3,off+len,"Going to read indent right");
406 frodo 64 result->indent_right = psiconv_read_length(buf,lev+2,off+len,&leng,
407     &res);
408     if (res)
409     goto ERROR1;
410 frodo 2 len += leng;
411     break;
412     case 0x04:
413     psiconv_progress(lev+3,off+len,"Going to read indent left first line");
414 frodo 64 result->indent_first = psiconv_read_length(buf,lev+2,off+len, &leng,
415     &res);
416     if (res)
417     goto ERROR1;
418 frodo 2 len += leng;
419     break;
420     case 0x05:
421     psiconv_progress(lev+3,off+len,"Going to read horizontal justify");
422 frodo 64 temp = psiconv_read_u8(buf,lev+3,off+len,&res);
423     if (res)
424     goto ERROR1;
425 frodo 2 if (temp == 0x00)
426     result->justify_hor = psiconv_justify_left;
427     else if (temp == 0x01)
428     result->justify_hor = psiconv_justify_centre;
429     else if (temp == 0x02)
430     result->justify_hor = psiconv_justify_right;
431     else if (temp == 0x03)
432     result->justify_hor = psiconv_justify_full;
433     else {
434     psiconv_warn(lev+3,off+len, "Unknown horizontal justify argument "
435     "in paragraph layout codes list");
436 frodo 64 result->justify_hor = psiconv_justify_left;
437 frodo 2 }
438     psiconv_debug(lev+3,off+len,"Justify: %02x",temp);
439     len ++;
440     break;
441     case 0x06:
442     psiconv_progress(lev+3,off+len,"Going to read vertical justify");
443 frodo 64 temp = psiconv_read_u8(buf,lev+3,off+len,&res);
444     if (res)
445     goto ERROR1;
446 frodo 2 if (temp == 0x00)
447     result->justify_ver = psiconv_justify_top;
448     else if (temp == 0x01)
449     result->justify_ver = psiconv_justify_middle;
450     else if (temp == 0x02)
451     result->justify_ver = psiconv_justify_bottom;
452     else {
453     psiconv_warn(lev+3,off+len, "Unknown vertical justify argument "
454     "in paragraph layout codes list");
455 frodo 64 result->justify_ver = psiconv_justify_bottom;
456 frodo 2 }
457     psiconv_debug(lev+3,off+len,"Justify: %02x",temp);
458     len ++;
459 frodo 110 break;
460 frodo 2 case 0x07:
461 frodo 67 psiconv_progress(lev+3,off+len,"Going to read linespacing distance");
462     result->linespacing = psiconv_read_size(buf,lev+3,off+len,&leng,&res);
463 frodo 64 if (res)
464     goto ERROR1;
465 frodo 2 len += leng;
466     break;
467     case 0x08:
468 frodo 67 psiconv_progress(lev+3,off+len,"Going to read linespacing exact");
469 frodo 64 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,
470 frodo 67 &result->linespacing_exact)))
471 frodo 64 goto ERROR1;
472 frodo 2 len += leng;
473     break;
474     case 0x09:
475     psiconv_progress(lev+3,off+len,"Going to read top space");
476 frodo 67 result->space_above = psiconv_read_size(buf,lev+3,off+len,&leng,&res);
477 frodo 64 if (res)
478     goto ERROR1;
479 frodo 2 len += leng;
480     break;
481     case 0x0a:
482     psiconv_progress(lev+3,off+len,"Going to read bottom space");
483 frodo 67 result->space_below = psiconv_read_size(buf,lev+3,off+len,&leng,&res);
484 frodo 64 if (res)
485     goto ERROR1;
486 frodo 2 len += leng;
487     break;
488     case 0x0b:
489     psiconv_progress(lev+3,off+len,"Going to read on one page");
490 frodo 64 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,
491 frodo 67 &result->keep_together)))
492 frodo 64 goto ERROR1;
493 frodo 2 len += leng;
494     break;
495     case 0x0c:
496     psiconv_progress(lev+3,off+len,"Going to read together with");
497 frodo 64 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,
498 frodo 67 &result->keep_with_next)))
499 frodo 64 goto ERROR1;
500 frodo 2 len += leng;
501     break;
502     case 0x0d:
503     psiconv_progress(lev+3,off+len,"Going to read on next page");
504 frodo 64 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,
505     &result->on_next_page)))
506     goto ERROR1;
507 frodo 2 len += leng;
508     break;
509     case 0x0e:
510     psiconv_progress(lev+3,off+len,"Going to read no widow protection");
511 frodo 64 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,
512     &result->no_widow_protection)))
513     goto ERROR1;
514 frodo 2 len += leng;
515     break;
516 frodo 104 case 0x0f:
517     psiconv_progress(lev+3,off+len,"Going to read wrap to fit cell limits");
518     if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,
519     &result->wrap_to_fit_cell)))
520     goto ERROR1;
521     len += leng;
522     break;
523 frodo 2 case 0x10:
524     psiconv_progress(lev+3,off+len,"Going to read border distance to text");
525     result->border_distance = psiconv_read_length(buf,lev+3,
526 frodo 64 off+len,&leng,&res);
527     if (res)
528     goto ERROR1;
529 frodo 2 len += leng;
530     break;
531     case 0x11:
532     psiconv_progress(lev+3,off+len,"Going to read top border");
533 frodo 64 if ((res = psiconv_parse_border(buf,lev+3,off+len,&leng,&temp_border)))
534     goto ERROR1;
535 frodo 2 psiconv_free_border(result->top_border);
536 frodo 64 result->top_border = temp_border;
537 frodo 2 len += leng;
538     break;
539     case 0x12:
540     psiconv_progress(lev+3,off+len,"Going to read bottom border");
541 frodo 64 if ((res = psiconv_parse_border(buf,lev+3,off+len,&leng,&temp_border)))
542     goto ERROR1;
543 frodo 2 psiconv_free_border(result->bottom_border);
544 frodo 64 result->bottom_border = temp_border;
545 frodo 2 len += leng;
546     break;
547     case 0x13:
548     psiconv_progress(lev+3,off+len,"Going to read left border");
549 frodo 64 if ((res = psiconv_parse_border(buf,lev+3,off+len,&leng,&temp_border)))
550     goto ERROR1;
551 frodo 2 psiconv_free_border(result->left_border);
552 frodo 64 result->left_border = temp_border;
553 frodo 2 len += leng;
554     break;
555     case 0x14:
556     psiconv_progress(lev+3,off+len,"Going to read right border");
557 frodo 64 if ((res = psiconv_parse_border(buf,lev+3,off+len,&leng,&temp_border)))
558     goto ERROR1;
559 frodo 2 psiconv_free_border(result->right_border);
560 frodo 64 result->right_border = temp_border;
561 frodo 2 len += leng;
562     break;
563     case 0x15:
564     psiconv_progress(lev+3,off+len,"Going to read bullet");
565 frodo 65 if ((res = psiconv_parse_bullet(buf,lev+3,off+len,&leng,&temp_bullet)))
566 frodo 64 goto ERROR1;
567 frodo 2 psiconv_free_bullet(result->bullet);
568 frodo 64 result->bullet = temp_bullet;
569 frodo 2 len += leng;
570     break;
571     case 0x16:
572     psiconv_progress(lev+3,off+len,"Going to read standard tabs");
573 frodo 64 result->tabs->normal = psiconv_read_length(buf,lev+3,off+len,&leng,
574     &res);
575     if (res)
576     goto ERROR1;
577 frodo 2 len += leng;
578     break;
579     case 0x17:
580     psiconv_progress(lev+3,off+len,"Going to read extra tab");
581 frodo 64 if ((res = psiconv_parse_tab(buf,lev+3,off+len,&leng,&temp_tab)))
582     goto ERROR1;
583     if ((res = psiconv_list_add(result->tabs->extras,temp_tab))) {
584     psiconv_free_tab(temp_tab);
585     goto ERROR1;
586     }
587 frodo 143 psiconv_free_tab(temp_tab);
588 frodo 2 len += leng;
589     break;
590     default:
591     psiconv_warn(lev+3,off+len,
592     "Unknown code in paragraph layout codes list");
593     psiconv_debug(lev+3,off+len,"Code: %02x",id);
594     len ++;
595     break;
596     }
597     nr ++;
598     }
599    
600     if (len - 4 != list_length) {
601     psiconv_warn(lev+2,off+len,
602     "Read past end of paragraph layout codes list. I probably lost track"
603     "somewhere!");
604     psiconv_debug(lev+2,off+len,"Read %d characters instead of %d",
605     len-4,list_length);
606 frodo 64 res = PSICONV_E_PARSE;
607     goto ERROR1;
608 frodo 2 }
609    
610     len = list_length + 4;
611    
612     psiconv_progress(lev+1,off+len,
613     "End of paragraph layout list (total length: %08x)",len);
614    
615     if (length)
616     *length = len;
617 frodo 64 return 0;
618    
619     ERROR1:
620     psiconv_warn(lev+1,off,"Reading of paragraph_layout_list failed");
621     if (length)
622     *length = 0;
623     if (!res)
624     return -PSICONV_E_NOMEM;
625     else
626     return res;
627 frodo 2 }
628    
629     int psiconv_parse_character_layout_list(const psiconv_buffer buf, int lev,
630     psiconv_u32 off, int *length,
631     psiconv_character_layout result)
632     {
633     int res=0;
634     int len=0;
635     int list_length,leng,nr;
636     psiconv_u8 id;
637     psiconv_u32 temp;
638 frodo 64 psiconv_color temp_color;
639     psiconv_font temp_font;
640 frodo 2
641     psiconv_progress(lev+1,off,"Going to read character layout codes");
642    
643     psiconv_progress(lev+2,off,"Going to read the list length");
644 frodo 64 list_length = psiconv_read_u32(buf,lev+2,off + len,&res);
645     if (res)
646     goto ERROR1;
647 frodo 2 psiconv_debug(lev+2,off,"Length in bytes: %08x",list_length);
648     len += 4;
649    
650     nr = 0;
651     while(len-4 < list_length) {
652     psiconv_progress(lev+2,off+len,"Going to read element %d",nr);
653     psiconv_progress(lev+3,off+len,"Going to read the element id");
654 frodo 64 id = psiconv_read_u8(buf,lev+2,off+len,&res);
655     if (res)
656     goto ERROR1;
657 frodo 2 psiconv_debug(lev+3,off+len,"Id: %02x",id);
658     len ++;
659     switch(id) {
660 frodo 86 case 0x18:
661     psiconv_progress(lev+3,off+len,"Going to skip an unknown setting");
662     len ++;
663     break;
664 frodo 2 case 0x19:
665     psiconv_progress(lev+3,off+len,"Going to read text color");
666 frodo 64 if ((res = psiconv_parse_color(buf,lev+3,off+len, &leng,&temp_color)))
667     goto ERROR1;
668 frodo 2 psiconv_free_color(result->color);
669 frodo 64 result->color = temp_color;
670 frodo 2 len += leng;
671     break;
672     case 0x1a:
673     psiconv_progress(lev+3,off+len,"Going to read background color (?)");
674 frodo 64 if ((res = psiconv_parse_color(buf,lev+2,off+len, &leng,&temp_color)))
675     goto ERROR1;
676 frodo 2 psiconv_free_color(result->back_color);
677 frodo 64 result->back_color = temp_color;
678 frodo 2 len += leng;
679     break;
680 frodo 86 case 0x1b:
681     psiconv_progress(lev+3,off+len,"Going to skip an unknown setting");
682     len ++;
683     break;
684 frodo 2 case 0x1c:
685     psiconv_progress(lev+3,off+len,"Going to read font size");
686 frodo 64 result->font_size = psiconv_read_size(buf,lev+3,off+len,&leng,&res);
687     if (res)
688     goto ERROR1;
689 frodo 2 len += leng;
690     break;
691     case 0x1d:
692     psiconv_progress(lev+3,off+len,"Going to read italic");
693 frodo 64 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,&result->italic)))
694     goto ERROR1;
695 frodo 2 len += leng;
696     break;
697     case 0x1e:
698     psiconv_progress(lev+3,off+len,"Going to read bold");
699 frodo 64 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,&result->bold)))
700     goto ERROR1;
701 frodo 2 len += leng;
702     break;
703     case 0x1f:
704     psiconv_progress(lev+3,off+len,"Going to read super_sub");
705 frodo 64 temp = psiconv_read_u8(buf,lev+3,off+len,&res);
706     if (res)
707     goto ERROR1;
708 frodo 2 if (temp == 0x00)
709     result->super_sub = psiconv_normalscript;
710     else if (temp == 0x01)
711     result->super_sub = psiconv_superscript;
712     else if (temp == 0x02)
713     result->super_sub = psiconv_subscript;
714     else {
715     psiconv_warn(lev+3,off+len,
716     "Unknown super_sub argument in character layout codes list");
717     }
718     psiconv_debug(lev+3,off+len,"Super_sub: %02x",temp);
719     len ++;
720     break;
721     case 0x20:
722     psiconv_progress(lev+3,off+len,"Going to read underline");
723 frodo 64 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,
724     &result->underline)))
725     goto ERROR1;
726 frodo 2 len += leng;
727     break;
728     case 0x21:
729 frodo 67 psiconv_progress(lev+3,off+len,"Going to read strikethrough");
730 frodo 64 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,
731 frodo 67 &result->strikethrough)))
732 frodo 64 goto ERROR1;
733 frodo 2 len += leng;
734     break;
735     case 0x22:
736     psiconv_progress(lev+3,off+len,"Going to read font");
737 frodo 64 if ((res = psiconv_parse_font(buf,lev+3,off+len, &leng, &temp_font)))
738     goto ERROR1;
739 frodo 2 psiconv_free_font(result->font);
740 frodo 64 result->font = temp_font;
741 frodo 2 len += leng;
742     break;
743 frodo 86 case 0x23:
744     psiconv_progress(lev+3,off+len,"Going to skip an unknown setting");
745     len ++;
746     break;
747 frodo 27 case 0x24:
748     psiconv_progress(lev+3,off+len,
749     "Going to read unknown code 0x24 (%02x expected)", 0);
750 frodo 64 temp = psiconv_read_u8(buf,lev+3,off+len,&res);
751     if (res)
752     goto ERROR1;
753 frodo 27 if (temp != 0) {
754     psiconv_warn(lev+3,off+len,
755     "Unknown code 0x24 value != 0x0 (0x%02x)", temp);
756     }
757     len ++;
758     break;
759 frodo 2 default:
760     psiconv_warn(lev+3,off+len,"Unknown code in character layout list");
761     psiconv_debug(lev+3,off+len,"Code: %02x",id);
762     len ++;
763     break;
764     }
765     nr ++;
766     }
767    
768     if (len - 4 != list_length) {
769     psiconv_warn(lev+2,off+len,
770     "Read past end of character layout codes list. I probably lost track"
771     "somewhere!");
772     psiconv_debug(lev+2,off+len,"Read %d characters instead of %d",
773     len-4,list_length);
774 frodo 64 res = PSICONV_E_PARSE;
775     goto ERROR1;
776 frodo 2 }
777    
778     len = list_length + 4;
779    
780     psiconv_progress(lev+1,off+len,
781     "End of character layout list (total length: %08x)",len);
782    
783     if (length)
784     *length = len;
785     return res;
786 frodo 64
787     ERROR1:
788     psiconv_warn(lev+1,off,"Reading of character_layout_list failed");
789     if (length)
790     *length = 0;
791     if (!res)
792     return -PSICONV_E_NOMEM;
793     else
794     return res;
795 frodo 2 }
frodo@frodo.looijaard.name
 ViewVC Help
Powered by ViewVC 1.1.26