/[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 64 - (show annotations)
Fri Dec 15 00:21:51 2000 UTC (18 years, 11 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 /*
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 <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 if (!(*result = malloc(sizeof(**result))))
35 goto ERROR1;
36
37 (*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 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 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 }
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 if (!(*result = malloc(sizeof(**result))))
80 goto ERROR1;
81
82 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 (*result)->name[strlength-1] = 0;
93 (*result)->screenfont = psiconv_read_u8(buf,lev+2,off + strlength,&res);
94 if (res)
95 goto ERROR3;
96
97 if (!(str_copy = psiconv_make_printable((*result)->name)))
98 goto ERROR3;
99
100 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 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 }
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 if (!(*result = malloc(sizeof(**result)))) {
134 goto ERROR1;
135 }
136
137 psiconv_progress(lev+2,off+len,"Going to read border kind");
138 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
139 if (res)
140 goto ERROR2;
141 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 (*result)->thickness = psiconv_read_size(buf,lev+2,off+len,&leng,&res);
164 if (res)
165 goto ERROR2;
166 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 if ((psiconv_parse_color(buf,lev+2,off+len,&leng,&(*result)->color)))
178 goto ERROR2;
179 len += leng;
180
181 psiconv_progress(lev+2,off+len,"Going to read the final unknown byte "
182 "(0x01 expected)");
183 temp = psiconv_read_u8(buf,lev+2,off + len,&res);
184 if (res)
185 goto ERROR3;
186 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 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 }
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 if (!(*result = malloc(sizeof(**result))))
224 goto ERROR1;
225 (*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 bullet_length = psiconv_read_u8(buf,lev+2,off+len,&res);
230 if (res)
231 goto ERROR2;
232 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 (*result)->font_size = psiconv_read_size(buf,lev+2,off+len, &leng,&res);
237 if (res)
238 goto ERROR2;
239 len +=leng;
240
241 psiconv_progress(lev+2,off+len,"Going to read bullet character");
242 (*result)->character = psiconv_read_u8(buf,lev+2,off+len,&res);
243 if (res)
244 goto ERROR2;
245 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 if ((res = psiconv_parse_bool(buf,lev+2,off+len,&leng,&(*result)->indent)))
250 goto ERROR2;
251 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 if ((res = psiconv_parse_color(buf,lev+2,off+len,&leng,&(*result)->color)))
256 goto ERROR2;
257 len += leng;
258
259 psiconv_progress(lev+2,off+len,"Going to read bullet font");
260 if ((res = psiconv_parse_font(buf,lev+2,off+len,&leng,&(*result)->font)))
261 goto ERROR3;
262 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
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 }
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 if (!(*result = malloc(sizeof(**result))))
301 goto ERROR1;
302
303 psiconv_progress(lev+2,off,"Going to read tab location");
304 (*result)->location = psiconv_read_length(buf,lev+2,off+len,&leng,&res);
305 if (res)
306 goto ERROR2;
307 len += leng;
308
309 psiconv_progress(lev+2,off+len,"Going to read the tab kind");
310 temp = psiconv_read_u8(buf,lev+2,off+len,&res);
311 if (res)
312 goto ERROR2;
313 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 return 0;
333
334 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 }
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 psiconv_tab temp_tab;
356 psiconv_color temp_color;
357 psiconv_border temp_border;
358 psiconv_bullet temp_bullet;
359
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 list_length = psiconv_read_u32(buf,lev+2,off + len,&res);
364 if (res)
365 goto ERROR1;
366 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 id = psiconv_read_u8(buf,lev+2,off+len,&res);
374 if (res)
375 goto ERROR1;
376 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 if ((res = psiconv_parse_color(buf,lev+3,off+len,&leng,&temp_color)))
382 goto ERROR1;
383 psiconv_free_color(result->back_color);
384 result->back_color = temp_color;
385 len += leng;
386 break;
387 case 0x02:
388 psiconv_progress(lev+3,off+len ,"Going to read indent left");
389 result->indent_left = psiconv_read_length(buf,lev+3,off+len,&leng,&res);
390 if (res)
391 goto ERROR1;
392 len += leng;
393 break;
394 case 0x03:
395 psiconv_progress(lev+3,off+len,"Going to read indent right");
396 result->indent_right = psiconv_read_length(buf,lev+2,off+len,&leng,
397 &res);
398 if (res)
399 goto ERROR1;
400 len += leng;
401 break;
402 case 0x04:
403 psiconv_progress(lev+3,off+len,"Going to read indent left first line");
404 result->indent_first = psiconv_read_length(buf,lev+2,off+len, &leng,
405 &res);
406 if (res)
407 goto ERROR1;
408 len += leng;
409 break;
410 case 0x05:
411 psiconv_progress(lev+3,off+len,"Going to read horizontal justify");
412 temp = psiconv_read_u8(buf,lev+3,off+len,&res);
413 if (res)
414 goto ERROR1;
415 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 result->justify_hor = psiconv_justify_left;
427 }
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 temp = psiconv_read_u8(buf,lev+3,off+len,&res);
434 if (res)
435 goto ERROR1;
436 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 result->justify_ver = psiconv_justify_bottom;
446 }
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 result->interline = psiconv_read_size(buf,lev+3,off+len,&leng,&res);
452 if (res)
453 goto ERROR1;
454 len += leng;
455 break;
456 case 0x08:
457 psiconv_progress(lev+3,off+len,"Going to read interline exact");
458 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,
459 &result->interline_exact)))
460 goto ERROR1;
461 len += leng;
462 break;
463 case 0x09:
464 psiconv_progress(lev+3,off+len,"Going to read top space");
465 result->top_space = psiconv_read_size(buf,lev+3,off+len,&leng,&res);
466 if (res)
467 goto ERROR1;
468 len += leng;
469 break;
470 case 0x0a:
471 psiconv_progress(lev+3,off+len,"Going to read bottom space");
472 result->bottom_space = psiconv_read_size(buf,lev+3,off+len,&leng,&res);
473 if (res)
474 goto ERROR1;
475 len += leng;
476 break;
477 case 0x0b:
478 psiconv_progress(lev+3,off+len,"Going to read on one page");
479 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,
480 &result->on_one_page)))
481 goto ERROR1;
482 len += leng;
483 break;
484 case 0x0c:
485 psiconv_progress(lev+3,off+len,"Going to read together with");
486 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,
487 &result->together_with)))
488 goto ERROR1;
489 len += leng;
490 break;
491 case 0x0d:
492 psiconv_progress(lev+3,off+len,"Going to read on next page");
493 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,
494 &result->on_next_page)))
495 goto ERROR1;
496 len += leng;
497 break;
498 case 0x0e:
499 psiconv_progress(lev+3,off+len,"Going to read no widow protection");
500 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,
501 &result->no_widow_protection)))
502 goto ERROR1;
503 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 off+len,&leng,&res);
509 if (res)
510 goto ERROR1;
511 len += leng;
512 break;
513 case 0x11:
514 psiconv_progress(lev+3,off+len,"Going to read top border");
515 if ((res = psiconv_parse_border(buf,lev+3,off+len,&leng,&temp_border)))
516 goto ERROR1;
517 psiconv_free_border(result->top_border);
518 result->top_border = temp_border;
519 len += leng;
520 break;
521 case 0x12:
522 psiconv_progress(lev+3,off+len,"Going to read bottom border");
523 if ((res = psiconv_parse_border(buf,lev+3,off+len,&leng,&temp_border)))
524 goto ERROR1;
525 psiconv_free_border(result->bottom_border);
526 result->bottom_border = temp_border;
527 len += leng;
528 break;
529 case 0x13:
530 psiconv_progress(lev+3,off+len,"Going to read left border");
531 if ((res = psiconv_parse_border(buf,lev+3,off+len,&leng,&temp_border)))
532 goto ERROR1;
533 psiconv_free_border(result->left_border);
534 result->left_border = temp_border;
535 len += leng;
536 break;
537 case 0x14:
538 psiconv_progress(lev+3,off+len,"Going to read right border");
539 if ((res = psiconv_parse_border(buf,lev+3,off+len,&leng,&temp_border)))
540 goto ERROR1;
541 psiconv_free_border(result->right_border);
542 result->right_border = temp_border;
543 len += leng;
544 break;
545 case 0x15:
546 psiconv_progress(lev+3,off+len,"Going to read bullet");
547 if ((res = psiconv_parse_bullet(buf,lev+3,off+len,&leng,&temp_bullet)));
548 goto ERROR1;
549 psiconv_free_bullet(result->bullet);
550 result->bullet = temp_bullet;
551 len += leng;
552 break;
553 case 0x16:
554 psiconv_progress(lev+3,off+len,"Going to read standard tabs");
555 result->tabs->normal = psiconv_read_length(buf,lev+3,off+len,&leng,
556 &res);
557 if (res)
558 goto ERROR1;
559 len += leng;
560 break;
561 case 0x17:
562 psiconv_progress(lev+3,off+len,"Going to read extra tab");
563 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 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 res = PSICONV_E_PARSE;
588 goto ERROR1;
589 }
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 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 }
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 psiconv_color temp_color;
620 psiconv_font temp_font;
621
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 list_length = psiconv_read_u32(buf,lev+2,off + len,&res);
626 if (res)
627 goto ERROR1;
628 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 id = psiconv_read_u8(buf,lev+2,off+len,&res);
636 if (res)
637 goto ERROR1;
638 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 if ((res = psiconv_parse_color(buf,lev+3,off+len, &leng,&temp_color)))
644 goto ERROR1;
645 psiconv_free_color(result->color);
646 result->color = temp_color;
647 len += leng;
648 break;
649 case 0x1a:
650 psiconv_progress(lev+3,off+len,"Going to read background color (?)");
651 if ((res = psiconv_parse_color(buf,lev+2,off+len, &leng,&temp_color)))
652 goto ERROR1;
653 psiconv_free_color(result->back_color);
654 result->back_color = temp_color;
655 len += leng;
656 break;
657 case 0x1c:
658 psiconv_progress(lev+3,off+len,"Going to read font size");
659 result->font_size = psiconv_read_size(buf,lev+3,off+len,&leng,&res);
660 if (res)
661 goto ERROR1;
662 len += leng;
663 break;
664 case 0x1d:
665 psiconv_progress(lev+3,off+len,"Going to read italic");
666 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,&result->italic)))
667 goto ERROR1;
668 len += leng;
669 break;
670 case 0x1e:
671 psiconv_progress(lev+3,off+len,"Going to read bold");
672 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,&result->bold)))
673 goto ERROR1;
674 len += leng;
675 break;
676 case 0x1f:
677 psiconv_progress(lev+3,off+len,"Going to read super_sub");
678 temp = psiconv_read_u8(buf,lev+3,off+len,&res);
679 if (res)
680 goto ERROR1;
681 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 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,
697 &result->underline)))
698 goto ERROR1;
699 len += leng;
700 break;
701 case 0x21:
702 psiconv_progress(lev+3,off+len,"Going to read strike_out");
703 if ((res = psiconv_parse_bool(buf,lev+3,off+len,&leng,
704 &result->strike_out)))
705 goto ERROR1;
706 len += leng;
707 break;
708 case 0x22:
709 psiconv_progress(lev+3,off+len,"Going to read font");
710 if ((res = psiconv_parse_font(buf,lev+3,off+len, &leng, &temp_font)))
711 goto ERROR1;
712 psiconv_free_font(result->font);
713 result->font = temp_font;
714 len += leng;
715 break;
716 case 0x24:
717 psiconv_progress(lev+3,off+len,
718 "Going to read unknown code 0x24 (%02x expected)", 0);
719 temp = psiconv_read_u8(buf,lev+3,off+len,&res);
720 if (res)
721 goto ERROR1;
722 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 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 res = PSICONV_E_PARSE;
744 goto ERROR1;
745 }
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
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@frodo.looijaard.name
ViewVC Help
Powered by ViewVC 1.1.26