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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 142 - (show annotations)
Tue Jan 29 18:38:38 2002 UTC (22 years, 2 months ago) by frodo
File MIME type: text/plain
File size: 24870 byte(s)
(Frodo) DMALLOC support

1 /*
2 parse_layout.c - Part of psiconv, a PSION 5 file formats converter
3 Copyright (c) 1999, 2000 Frodo Looijaard <frodol@dds.nl>
4
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 "compat.h"
22
23 #include <stdlib.h>
24 #include <math.h>
25
26 #include "parse_routines.h"
27 #include "error.h"
28
29 #ifdef DMALLOC
30 #include <dmalloc.h>
31 #endif
32
33
34 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 if (!(*result = malloc(sizeof(**result))))
42 goto ERROR1;
43
44 (*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 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 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 }
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 if (!(*result = malloc(sizeof(**result))))
87 goto ERROR1;
88
89 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 (*result)->name[strlength-1] = 0;
100 (*result)->screenfont = psiconv_read_u8(buf,lev+2,off + strlength,&res);
101 if (res)
102 goto ERROR3;
103
104 if (!(str_copy = psiconv_make_printable((*result)->name)))
105 goto ERROR3;
106
107 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 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 }
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 if (!(*result = malloc(sizeof(**result)))) {
141 goto ERROR1;
142 }
143
144 psiconv_progress(lev+2,off+len,"Going to read border kind");
145 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
146 if (res)
147 goto ERROR2;
148 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 (*result)->kind = psiconv_border_dashed;
158 else if (temp == 0x05)
159 (*result)->kind = psiconv_border_dotdashed;
160 else if (temp == 0x06)
161 (*result)->kind = psiconv_border_dotdotdashed;
162 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 (*result)->thickness = psiconv_read_size(buf,lev+2,off+len,&leng,&res);
171 if (res)
172 goto ERROR2;
173 #if 0
174 /* This seems no longer necessary to test? */
175 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 #endif
183 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 if ((psiconv_parse_color(buf,lev+2,off+len,&leng,&(*result)->color)))
188 goto ERROR2;
189 len += leng;
190
191 psiconv_progress(lev+2,off+len,"Going to read the final unknown byte "
192 "(0x00 or 0x01 expected)");
193 temp = psiconv_read_u8(buf,lev+2,off + len,&res);
194 if (res)
195 goto ERROR3;
196 if ((temp != 0x01) && (temp != 0x00)) {
197 psiconv_warn(lev+2,off,"Unknown last byte in border specification");
198 psiconv_debug(lev+2,off+len, "Last byte: read %02x, expected %02x or %02x",
199 temp,0x00,0x01);
200 }
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 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 }
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 if (!(*result = malloc(sizeof(**result))))
234 goto ERROR1;
235 (*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 bullet_length = psiconv_read_u8(buf,lev+2,off+len,&res);
240 if (res)
241 goto ERROR2;
242 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 (*result)->font_size = psiconv_read_size(buf,lev+2,off+len, &leng,&res);
247 if (res)
248 goto ERROR2;
249 len +=leng;
250
251 psiconv_progress(lev+2,off+len,"Going to read bullet character");
252 (*result)->character = psiconv_read_u8(buf,lev+2,off+len,&res);
253 if (res)
254 goto ERROR2;
255 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 if ((res = psiconv_parse_bool(buf,lev+2,off+len,&leng,&(*result)->indent)))
260 goto ERROR2;
261 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 if ((res = psiconv_parse_color(buf,lev+2,off+len,&leng,&(*result)->color)))
266 goto ERROR2;
267 len += leng;
268
269 psiconv_progress(lev+2,off+len,"Going to read bullet font");
270 if ((res = psiconv_parse_font(buf,lev+2,off+len,&leng,&(*result)->font)))
271 goto ERROR3;
272 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 return 0;
286
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 }
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 if (!(*result = malloc(sizeof(**result))))
311 goto ERROR1;
312
313 psiconv_progress(lev+2,off,"Going to read tab location");
314 (*result)->location = psiconv_read_length(buf,lev+2,off+len,&leng,&res);
315 if (res)
316 goto ERROR2;
317 len += leng;
318
319 psiconv_progress(lev+2,off+len,"Going to read the tab kind");
320 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
321 if (res)
322 goto ERROR2;
323 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 return 0;
343
344 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 }
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 psiconv_tab temp_tab;
366 psiconv_color temp_color;
367 psiconv_border temp_border;
368 psiconv_bullet temp_bullet;
369
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 list_length = psiconv_read_u32(buf,lev+2,off + len,&res);
374 if (res)
375 goto ERROR1;
376 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 id = psiconv_read_u8(buf,lev+2,off+len,&res);
384 if (res)
385 goto ERROR1;
386 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 if ((res = psiconv_parse_color(buf,lev+3,off+len,&leng,&temp_color)))
392 goto ERROR1;
393 psiconv_free_color(result->back_color);
394 result->back_color = temp_color;
395 len += leng;
396 break;
397 case 0x02:
398 psiconv_progress(lev+3,off+len ,"Going to read indent left");
399 result->indent_left = psiconv_read_length(buf,lev+3,off+len,&leng,&res);
400 if (res)
401 goto ERROR1;
402 len += leng;
403 break;
404 case 0x03:
405 psiconv_progress(lev+3,off+len,"Going to read indent right");
406 result->indent_right = psiconv_read_length(buf,lev+2,off+len,&leng,
407 &res);
408 if (res)
409 goto ERROR1;
410 len += leng;
411 break;
412 case 0x04:
413 psiconv_progress(lev+3,off+len,"Going to read indent left first line");
414 result->indent_first = psiconv_read_length(buf,lev+2,off+len, &leng,
415 &res);
416 if (res)
417 goto ERROR1;
418 len += leng;
419 break;
420 case 0x05:
421 psiconv_progress(lev+3,off+len,"Going to read horizontal justify");
422 temp = psiconv_read_u8(buf,lev+3,off+len,&res);
423 if (res)
424 goto ERROR1;
425 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 result->justify_hor = psiconv_justify_left;
437 }
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 temp = psiconv_read_u8(buf,lev+3,off+len,&res);
444 if (res)
445 goto ERROR1;
446 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 result->justify_ver = psiconv_justify_bottom;
456 }
457 psiconv_debug(lev+3,off+len,"Justify: %02x",temp);
458 len ++;
459 break;
460 case 0x07:
461 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 if (res)
464 goto ERROR1;
465 len += leng;
466 break;
467 case 0x08:
468 psiconv_progress(lev+3,off+len,"Going to read linespacing exact");
469 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,
470 &result->linespacing_exact)))
471 goto ERROR1;
472 len += leng;
473 break;
474 case 0x09:
475 psiconv_progress(lev+3,off+len,"Going to read top space");
476 result->space_above = psiconv_read_size(buf,lev+3,off+len,&leng,&res);
477 if (res)
478 goto ERROR1;
479 len += leng;
480 break;
481 case 0x0a:
482 psiconv_progress(lev+3,off+len,"Going to read bottom space");
483 result->space_below = psiconv_read_size(buf,lev+3,off+len,&leng,&res);
484 if (res)
485 goto ERROR1;
486 len += leng;
487 break;
488 case 0x0b:
489 psiconv_progress(lev+3,off+len,"Going to read on one page");
490 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,
491 &result->keep_together)))
492 goto ERROR1;
493 len += leng;
494 break;
495 case 0x0c:
496 psiconv_progress(lev+3,off+len,"Going to read together with");
497 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,
498 &result->keep_with_next)))
499 goto ERROR1;
500 len += leng;
501 break;
502 case 0x0d:
503 psiconv_progress(lev+3,off+len,"Going to read on next page");
504 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,
505 &result->on_next_page)))
506 goto ERROR1;
507 len += leng;
508 break;
509 case 0x0e:
510 psiconv_progress(lev+3,off+len,"Going to read no widow protection");
511 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,
512 &result->no_widow_protection)))
513 goto ERROR1;
514 len += leng;
515 break;
516 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 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 off+len,&leng,&res);
527 if (res)
528 goto ERROR1;
529 len += leng;
530 break;
531 case 0x11:
532 psiconv_progress(lev+3,off+len,"Going to read top border");
533 if ((res = psiconv_parse_border(buf,lev+3,off+len,&leng,&temp_border)))
534 goto ERROR1;
535 psiconv_free_border(result->top_border);
536 result->top_border = temp_border;
537 len += leng;
538 break;
539 case 0x12:
540 psiconv_progress(lev+3,off+len,"Going to read bottom border");
541 if ((res = psiconv_parse_border(buf,lev+3,off+len,&leng,&temp_border)))
542 goto ERROR1;
543 psiconv_free_border(result->bottom_border);
544 result->bottom_border = temp_border;
545 len += leng;
546 break;
547 case 0x13:
548 psiconv_progress(lev+3,off+len,"Going to read left border");
549 if ((res = psiconv_parse_border(buf,lev+3,off+len,&leng,&temp_border)))
550 goto ERROR1;
551 psiconv_free_border(result->left_border);
552 result->left_border = temp_border;
553 len += leng;
554 break;
555 case 0x14:
556 psiconv_progress(lev+3,off+len,"Going to read right border");
557 if ((res = psiconv_parse_border(buf,lev+3,off+len,&leng,&temp_border)))
558 goto ERROR1;
559 psiconv_free_border(result->right_border);
560 result->right_border = temp_border;
561 len += leng;
562 break;
563 case 0x15:
564 psiconv_progress(lev+3,off+len,"Going to read bullet");
565 if ((res = psiconv_parse_bullet(buf,lev+3,off+len,&leng,&temp_bullet)))
566 goto ERROR1;
567 psiconv_free_bullet(result->bullet);
568 result->bullet = temp_bullet;
569 len += leng;
570 break;
571 case 0x16:
572 psiconv_progress(lev+3,off+len,"Going to read standard tabs");
573 result->tabs->normal = psiconv_read_length(buf,lev+3,off+len,&leng,
574 &res);
575 if (res)
576 goto ERROR1;
577 len += leng;
578 break;
579 case 0x17:
580 psiconv_progress(lev+3,off+len,"Going to read extra tab");
581 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 len += leng;
588 break;
589 default:
590 psiconv_warn(lev+3,off+len,
591 "Unknown code in paragraph layout codes list");
592 psiconv_debug(lev+3,off+len,"Code: %02x",id);
593 len ++;
594 break;
595 }
596 nr ++;
597 }
598
599 if (len - 4 != list_length) {
600 psiconv_warn(lev+2,off+len,
601 "Read past end of paragraph layout codes list. I probably lost track"
602 "somewhere!");
603 psiconv_debug(lev+2,off+len,"Read %d characters instead of %d",
604 len-4,list_length);
605 res = PSICONV_E_PARSE;
606 goto ERROR1;
607 }
608
609 len = list_length + 4;
610
611 psiconv_progress(lev+1,off+len,
612 "End of paragraph layout list (total length: %08x)",len);
613
614 if (length)
615 *length = len;
616 return 0;
617
618 ERROR1:
619 psiconv_warn(lev+1,off,"Reading of paragraph_layout_list failed");
620 if (length)
621 *length = 0;
622 if (!res)
623 return -PSICONV_E_NOMEM;
624 else
625 return res;
626 }
627
628 int psiconv_parse_character_layout_list(const psiconv_buffer buf, int lev,
629 psiconv_u32 off, int *length,
630 psiconv_character_layout result)
631 {
632 int res=0;
633 int len=0;
634 int list_length,leng,nr;
635 psiconv_u8 id;
636 psiconv_u32 temp;
637 psiconv_color temp_color;
638 psiconv_font temp_font;
639
640 psiconv_progress(lev+1,off,"Going to read character layout codes");
641
642 psiconv_progress(lev+2,off,"Going to read the list length");
643 list_length = psiconv_read_u32(buf,lev+2,off + len,&res);
644 if (res)
645 goto ERROR1;
646 psiconv_debug(lev+2,off,"Length in bytes: %08x",list_length);
647 len += 4;
648
649 nr = 0;
650 while(len-4 < list_length) {
651 psiconv_progress(lev+2,off+len,"Going to read element %d",nr);
652 psiconv_progress(lev+3,off+len,"Going to read the element id");
653 id = psiconv_read_u8(buf,lev+2,off+len,&res);
654 if (res)
655 goto ERROR1;
656 psiconv_debug(lev+3,off+len,"Id: %02x",id);
657 len ++;
658 switch(id) {
659 case 0x18:
660 psiconv_progress(lev+3,off+len,"Going to skip an unknown setting");
661 len ++;
662 break;
663 case 0x19:
664 psiconv_progress(lev+3,off+len,"Going to read text color");
665 if ((res = psiconv_parse_color(buf,lev+3,off+len, &leng,&temp_color)))
666 goto ERROR1;
667 psiconv_free_color(result->color);
668 result->color = temp_color;
669 len += leng;
670 break;
671 case 0x1a:
672 psiconv_progress(lev+3,off+len,"Going to read background color (?)");
673 if ((res = psiconv_parse_color(buf,lev+2,off+len, &leng,&temp_color)))
674 goto ERROR1;
675 psiconv_free_color(result->back_color);
676 result->back_color = temp_color;
677 len += leng;
678 break;
679 case 0x1b:
680 psiconv_progress(lev+3,off+len,"Going to skip an unknown setting");
681 len ++;
682 break;
683 case 0x1c:
684 psiconv_progress(lev+3,off+len,"Going to read font size");
685 result->font_size = psiconv_read_size(buf,lev+3,off+len,&leng,&res);
686 if (res)
687 goto ERROR1;
688 len += leng;
689 break;
690 case 0x1d:
691 psiconv_progress(lev+3,off+len,"Going to read italic");
692 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,&result->italic)))
693 goto ERROR1;
694 len += leng;
695 break;
696 case 0x1e:
697 psiconv_progress(lev+3,off+len,"Going to read bold");
698 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,&result->bold)))
699 goto ERROR1;
700 len += leng;
701 break;
702 case 0x1f:
703 psiconv_progress(lev+3,off+len,"Going to read super_sub");
704 temp = psiconv_read_u8(buf,lev+3,off+len,&res);
705 if (res)
706 goto ERROR1;
707 if (temp == 0x00)
708 result->super_sub = psiconv_normalscript;
709 else if (temp == 0x01)
710 result->super_sub = psiconv_superscript;
711 else if (temp == 0x02)
712 result->super_sub = psiconv_subscript;
713 else {
714 psiconv_warn(lev+3,off+len,
715 "Unknown super_sub argument in character layout codes list");
716 }
717 psiconv_debug(lev+3,off+len,"Super_sub: %02x",temp);
718 len ++;
719 break;
720 case 0x20:
721 psiconv_progress(lev+3,off+len,"Going to read underline");
722 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,
723 &result->underline)))
724 goto ERROR1;
725 len += leng;
726 break;
727 case 0x21:
728 psiconv_progress(lev+3,off+len,"Going to read strikethrough");
729 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,
730 &result->strikethrough)))
731 goto ERROR1;
732 len += leng;
733 break;
734 case 0x22:
735 psiconv_progress(lev+3,off+len,"Going to read font");
736 if ((res = psiconv_parse_font(buf,lev+3,off+len, &leng, &temp_font)))
737 goto ERROR1;
738 psiconv_free_font(result->font);
739 result->font = temp_font;
740 len += leng;
741 break;
742 case 0x23:
743 psiconv_progress(lev+3,off+len,"Going to skip an unknown setting");
744 len ++;
745 break;
746 case 0x24:
747 psiconv_progress(lev+3,off+len,
748 "Going to read unknown code 0x24 (%02x expected)", 0);
749 temp = psiconv_read_u8(buf,lev+3,off+len,&res);
750 if (res)
751 goto ERROR1;
752 if (temp != 0) {
753 psiconv_warn(lev+3,off+len,
754 "Unknown code 0x24 value != 0x0 (0x%02x)", temp);
755 }
756 len ++;
757 break;
758 default:
759 psiconv_warn(lev+3,off+len,"Unknown code in character layout list");
760 psiconv_debug(lev+3,off+len,"Code: %02x",id);
761 len ++;
762 break;
763 }
764 nr ++;
765 }
766
767 if (len - 4 != list_length) {
768 psiconv_warn(lev+2,off+len,
769 "Read past end of character layout codes list. I probably lost track"
770 "somewhere!");
771 psiconv_debug(lev+2,off+len,"Read %d characters instead of %d",
772 len-4,list_length);
773 res = PSICONV_E_PARSE;
774 goto ERROR1;
775 }
776
777 len = list_length + 4;
778
779 psiconv_progress(lev+1,off+len,
780 "End of character layout list (total length: %08x)",len);
781
782 if (length)
783 *length = len;
784 return res;
785
786 ERROR1:
787 psiconv_warn(lev+1,off,"Reading of character_layout_list failed");
788 if (length)
789 *length = 0;
790 if (!res)
791 return -PSICONV_E_NOMEM;
792 else
793 return res;
794 }

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