/[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 64 - (hide annotations)
Fri Dec 15 00:21:51 2000 UTC (19 years, 3 months ago) by frodo
File MIME type: text/plain
File size: 24019 byte(s)
(Frodo) Massive update: theoretically, all return codes are now checked.
        Untested - may have many typos.

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

frodo@frodo.looijaard.name
ViewVC Help
Powered by ViewVC 1.1.26