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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 168 - (hide annotations)
Tue Nov 25 17:57:05 2003 UTC (20 years, 4 months ago) by frodo
File MIME type: text/plain
File size: 45389 byte(s)
(Frodo) config stuff and image generation stuff

* All parse and generate functions have a new config parameter
* New files configuration.[ch] in the psiconv lib
* Some image generation stuff (not ready, but won't do any harm)

1 frodo 2 /*
2     parse_common.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 20 #include "compat.h"
22 frodo 2 #include <stdlib.h>
23     #include <string.h>
24    
25     #include "parse_routines.h"
26 frodo 71 #include "error.h"
27 frodo 2
28 frodo 142 #ifdef DMALLOC
29     #include <dmalloc.h>
30     #endif
31    
32    
33 frodo 168 static int psiconv_parse_layout_section(const psiconv_config config,
34     const psiconv_buffer buf,
35 frodo 2 int lev,psiconv_u32 off,
36     int *length,
37     psiconv_text_and_layout result,
38     psiconv_word_styles_section styles,
39     int with_styles);
40 frodo 162 static psiconv_file_type_t psiconv_determine_embedded_object_type
41 frodo 168 (const psiconv_config config,
42     const psiconv_buffer buf,int lev,
43 frodo 162 int *status);
44 frodo 2
45 frodo 168 int psiconv_parse_header_section(const psiconv_config config,
46     const psiconv_buffer buf,int lev,
47 frodo 2 psiconv_u32 off, int *length,
48     psiconv_header_section *result)
49     {
50     int res=0;
51     int len=0;
52     psiconv_u32 temp;
53    
54 frodo 168 psiconv_progress(config,lev+1,off+len,"Going to read the header section");
55 frodo 64 if (!((*result) = malloc(sizeof(**result))))
56     goto ERROR1;
57 frodo 2
58 frodo 168 psiconv_progress(config,lev+2,off+len,"Going to read UID1 to UID3");
59     (*result)->uid1 = psiconv_read_u32(config,buf,lev+2,off+len,&res);
60 frodo 65 if (res)
61 frodo 64 goto ERROR2;
62 frodo 168 psiconv_debug(config,lev+2,off+len,"UID1: %08x",(*result)->uid1);
63 frodo 41 if ((*result)->uid1 == PSICONV_ID_CLIPART) {
64     /* That's all folks... */
65     (*result)->file = psiconv_clipart_file;
66     (*result)->uid2 = 0;
67     (*result)->uid3 = 0;
68     (*result)->checksum = 0;
69     len += 4;
70 frodo 168 psiconv_debug(config,lev+2,off+len,"File is a Clipart file");
71 frodo 41 goto DONE;
72     }
73 frodo 2 if ((*result)->uid1 != PSICONV_ID_PSION5) {
74 frodo 168 psiconv_warn(config,lev+2,off+len,
75     "UID1 has unknown value. This is probably "
76 frodo 2 "not a (parsable) Psion 5 file");
77 frodo 64 res = -PSICONV_E_PARSE;
78     goto ERROR2;
79 frodo 2 }
80     len += 4;
81 frodo 168 (*result)->uid2 = psiconv_read_u32(config,buf,lev+2,off+len,&res);
82 frodo 64 if (res)
83     goto ERROR2;
84 frodo 168 psiconv_debug(config,lev+2,off+len,"UID2: %08x",(*result)->uid2);
85 frodo 2 len += 4;
86 frodo 168 (*result)->uid3 = psiconv_read_u32(config,buf,lev+2,off+len,&res);
87 frodo 64 if (res)
88     goto ERROR2;
89 frodo 168 psiconv_debug(config,lev+2,off+len,"UID3: %08x",(*result)->uid3);
90 frodo 2 len += 4;
91    
92     (*result)->file = psiconv_unknown_file;
93     if ((*result)->uid1 == PSICONV_ID_PSION5) {
94     if ((*result)->uid2 == PSICONV_ID_DATA_FILE) {
95     if ((*result)->uid3 == PSICONV_ID_WORD) {
96     (*result)->file = psiconv_word_file;
97 frodo 168 psiconv_debug(config,lev+2,off+len,"File is a Word file");
98 frodo 2 } else if ((*result)->uid3 == PSICONV_ID_TEXTED) {
99     (*result)->file = psiconv_texted_file;
100 frodo 168 psiconv_debug(config,lev+2,off+len,"File is a TextEd file");
101 frodo 24 } else if ((*result)->uid3 == PSICONV_ID_SKETCH) {
102     (*result)->file = psiconv_sketch_file;
103 frodo 168 psiconv_debug(config,lev+2,off+len,"File is a Sketch file");
104 frodo 94 } else if ((*result)->uid3 == PSICONV_ID_SHEET) {
105     (*result)->file = psiconv_sheet_file;
106 frodo 168 psiconv_debug(config,lev+2,off+len,"File is a Sheet file");
107 frodo 94 }
108 frodo 12 } else if ((*result)->uid2 == PSICONV_ID_MBM_FILE) {
109     (*result)->file = psiconv_mbm_file;
110     if ((*result)->uid3 != 0x00)
111 frodo 168 psiconv_warn(config,lev+2,off+len,"UID3 set in MBM file?!?");
112     psiconv_debug(config,lev+2,off+len,"File is a MBM file");
113 frodo 12 }
114 frodo 2 }
115     if ((*result)->file == psiconv_unknown_file) {
116 frodo 168 psiconv_warn(config,lev+2,off+len,"Unknown file type");
117 frodo 2 (*result)->file = psiconv_unknown_file;
118     }
119    
120 frodo 168 psiconv_progress(config,lev+2,off+len,"Checking UID4");
121     temp = psiconv_read_u32(config,buf,lev+2,off+len,&res);
122 frodo 64 if (res)
123     goto ERROR2;
124 frodo 2 if (temp == psiconv_checkuid((*result)->uid1,(*result)->uid2,
125     (*result)->uid3))
126 frodo 168 psiconv_debug(config,lev+2,off+len,"Checksum %08x is correct",temp);
127 frodo 2 else {
128 frodo 168 psiconv_warn(config,lev+2,off+len,"Checksum failed, file corrupted!");
129     psiconv_debug(config,lev+2,off+len,"Expected checksum %08x, found %08x",
130 frodo 2 psiconv_checkuid((*result)->uid1,(*result)->uid2,
131     (*result)->uid3),temp);
132 frodo 64 res = -PSICONV_E_PARSE;
133     goto ERROR2;
134 frodo 2 }
135     len += 4;
136 frodo 41
137     DONE:
138 frodo 2 if (length)
139     *length = len;
140    
141 frodo 168 psiconv_progress(config,lev+1,off+len-1,
142 frodo 2 "End of Header Section (total length: %08x)",len);
143    
144     return res;
145 frodo 64
146     ERROR2:
147     free(*result);
148     ERROR1:
149 frodo 168 psiconv_warn(config,lev+1,off,"Reading of Header Section failed");
150 frodo 64 if (length)
151     *length = 0;
152     if (res == 0)
153     return -PSICONV_E_NOMEM;
154     else
155     return res;
156 frodo 2 }
157    
158 frodo 168 int psiconv_parse_section_table_section(const psiconv_config config,
159     const psiconv_buffer buf, int lev,
160 frodo 2 psiconv_u32 off, int *length,
161     psiconv_section_table_section *result)
162     {
163     int res=0;
164     int len=0;
165     psiconv_section_table_entry entry;
166    
167     int i;
168     psiconv_u8 nr;
169    
170 frodo 168 psiconv_progress(config,lev+1,off+len,"Going to read the section table section");
171 frodo 64 if (!(*result = psiconv_list_new(sizeof(*entry))))
172     goto ERROR1;
173 frodo 2
174 frodo 168 psiconv_progress(config,lev+2,off+len,"Going to read the section table length");
175     nr = psiconv_read_u8(config,buf,lev+2,off+len,&res);
176 frodo 64 if (res)
177     goto ERROR2;
178 frodo 168 psiconv_debug(config,lev+2,off+len,"Length: %08x",nr);
179 frodo 2 if (nr & 0x01) {
180 frodo 168 psiconv_warn(config,lev+2,off+len,
181 frodo 2 "Section table length odd - ignoring last entry");
182     }
183     len ++;
184    
185 frodo 168 psiconv_progress(config,lev+2,off+len,"Going to read the section table entries");
186 frodo 2 entry = malloc(sizeof(*entry));
187     for (i = 0; i < nr / 2; i++) {
188 frodo 168 entry->id = psiconv_read_u32(config,buf,lev+2,off + len,&res);
189 frodo 64 if (res)
190     goto ERROR3;
191 frodo 168 psiconv_debug(config,lev+2,off + len,"Entry %d: ID = %08x",i,entry->id);
192 frodo 2 len += 0x04;
193 frodo 168 entry->offset = psiconv_read_u32(config,buf,lev+2,off + len,&res);
194 frodo 64 if (res)
195     goto ERROR3;
196 frodo 168 psiconv_debug(config,lev+2,off +len,"Entry %d: Offset = %08x",i,entry->offset);
197 frodo 2 len += 0x04;
198 frodo 64 if ((res=psiconv_list_add(*result,entry)))
199     goto ERROR3;
200 frodo 2 }
201    
202     free(entry);
203    
204     if (length)
205     *length = len;
206    
207 frodo 168 psiconv_progress(config,lev+1,off+len-1,"End of section table section "
208 frodo 25 "(total length: %08x)", len);
209 frodo 2
210 frodo 64 return 0;
211     ERROR3:
212     free(entry);
213     ERROR2:
214     psiconv_list_free(*result);
215     ERROR1:
216 frodo 168 psiconv_warn(config,lev+1,off,"Reading of Section Table Section failed");
217 frodo 64 if (length)
218     *length = 0;
219     if (res == 0)
220     return -PSICONV_E_NOMEM;
221     else
222     return res;
223 frodo 2 }
224    
225 frodo 168 int psiconv_parse_application_id_section(const psiconv_config config,
226     const psiconv_buffer buf, int lev,
227 frodo 2 psiconv_u32 off, int *length,
228     psiconv_application_id_section *result)
229     {
230     int res=0;
231     int len=0;
232     int leng;
233    
234 frodo 168 psiconv_progress(config,lev+1,off,"Going to read the application id section");
235 frodo 64 if (!(*result = malloc(sizeof(**result))))
236     goto ERROR1;
237 frodo 2
238 frodo 168 psiconv_progress(config,lev+2,off+len,"Going to read the type identifier");
239     (*result)->id = psiconv_read_u32(config,buf,lev+2,off+len,&res);
240 frodo 64 if (res)
241     goto ERROR2;
242 frodo 168 psiconv_debug(config,lev+2,off+len,"Identifier: %08x",(*result)->id);
243 frodo 2 len += 4;
244    
245 frodo 168 psiconv_progress(config,lev+2,off+len,"Going to read the application id string");
246     (*result)->name = psiconv_read_string(config,buf,lev+2,off+len,&leng,&res);
247 frodo 64 if (res)
248     goto ERROR2;
249 frodo 2 len += leng;
250    
251     if (length)
252     *length = len;
253    
254 frodo 168 psiconv_progress(config,lev+1,off+len-1,"End of application id section "
255 frodo 2 "(total length: %08x", len);
256    
257     return res;
258 frodo 64 ERROR2:
259     free(*result);
260     ERROR1:
261 frodo 168 psiconv_warn(config,lev+1,off,"Reading of Application ID Section failed");
262 frodo 64 if (length)
263     *length = 0;
264     if (res == 0)
265     return -PSICONV_E_NOMEM;
266     else
267     return res;
268 frodo 2 }
269    
270 frodo 168 int psiconv_parse_text_section(const psiconv_config config,
271     const psiconv_buffer buf,int lev,psiconv_u32 off,
272 frodo 2 int *length,psiconv_text_and_layout *result)
273     {
274    
275     int res = 0;
276     int len=0;
277    
278     psiconv_u32 text_len;
279     psiconv_paragraph para;
280    
281     int nr;
282 frodo 64 int i,j,start,leng,temp;
283 frodo 2 char *str_copy;
284    
285 frodo 168 psiconv_progress(config,lev+1,off,"Going to parse the text section");
286     psiconv_progress(config,lev+2,off,"Reading the text length");
287 frodo 64
288     if(!(*result = psiconv_list_new(sizeof(*para))))
289     goto ERROR1;
290     if (!(para = malloc(sizeof(*para))))
291     goto ERROR2;
292    
293 frodo 168 text_len = psiconv_read_X(config,buf,lev+2,off,&leng,&res);
294 frodo 65 if (res)
295 frodo 64 goto ERROR3;
296 frodo 168 psiconv_debug(config,lev+2,off,"Length: %08x",text_len);
297 frodo 2 len += leng;
298    
299 frodo 168 psiconv_progress(config,lev+2,off+len,"Going to read all paragraph text");
300 frodo 2 nr = 0;
301     start = 0;
302 frodo 64 for (i = 0; i < text_len; i++) {
303 frodo 168 temp = psiconv_read_u8(config,buf,lev+2,off+len+i,&res);
304 frodo 64 if (res)
305     goto ERROR3;
306     if (temp == 0x06) {
307     if (!(para->text = malloc(i - start + 1)))
308     goto ERROR3;
309     for (j = 0; j < i - start; j++) {
310 frodo 168 temp = psiconv_read_u8(config,buf,lev+1,off + len + start + j,&res);
311 frodo 64 if (res)
312     goto ERROR4;
313     para->text[j] = temp;
314     }
315 frodo 2 para->text[j] = 0;
316    
317 frodo 64 if ((res = psiconv_list_add(*result,para)))
318     goto ERROR4;
319 frodo 2
320 frodo 64 if (!(str_copy = psiconv_make_printable(para->text)))
321     goto ERROR3;
322 frodo 168 psiconv_debug(config,lev+2,off+i+len,"Line %d: %d characters",nr,
323 frodo 2 strlen(str_copy) +1);
324 frodo 168 psiconv_debug(config,lev+2,off+i+len,"Line %d: `%s'",nr,str_copy);
325 frodo 2 free(str_copy);
326    
327     start = i + 1;
328     nr ++;
329     }
330 frodo 64 }
331 frodo 2
332     if (start != text_len) {
333 frodo 168 psiconv_warn(config,lev+2,off+start+len,
334 frodo 2 "Last line does not end on EOL (%d characters left)", len - start);
335 frodo 64 if (!(para->text = malloc(text_len - start + 1)))
336     goto ERROR3;
337     for (j = 0; j < text_len - start; j++) {
338 frodo 168 temp = psiconv_read_u8(config,buf,lev+2,off + start + j + len, &res);
339 frodo 64 if (res)
340     goto ERROR4;
341     para->text[j] = temp;
342     }
343 frodo 2 para->text[text_len - start] = 0;
344 frodo 64 if ((res = psiconv_list_add(*result,para)))
345     goto ERROR4;
346     if (!(str_copy = psiconv_make_printable(para->text)))
347     goto ERROR3;
348 frodo 168 psiconv_debug(config,lev+2,off+start+len,"Last line: %d characters",nr,
349 frodo 2 strlen(str_copy)+1);
350 frodo 168 psiconv_debug(config,lev+2,off+start+len,"Last line: `%s'",str_copy);
351 frodo 2 free(str_copy);
352     }
353    
354     free(para);
355    
356     /* Initialize the remaining parts of each paragraph */
357     for (i = 0; i < psiconv_list_length(*result); i ++) {
358 frodo 64 if (!(para = psiconv_list_get(*result,i))) {
359 frodo 168 psiconv_warn(config,lev+2,off+len,"Massive memory corruption");
360 frodo 64 goto ERROR2_0;
361     }
362     if (!(para->in_lines = psiconv_list_new(sizeof(
363     struct psiconv_in_line_layout_s))))
364     goto ERROR2_0;
365     if (!(para->replacements = psiconv_list_new(sizeof(
366     struct psiconv_replacement_s))))
367     goto ERROR2_1;
368     if (!(para->base_character = psiconv_basic_character_layout()))
369     goto ERROR2_2;
370     if (!(para->base_paragraph = psiconv_basic_paragraph_layout()))
371     goto ERROR2_3;
372 frodo 2 para->base_style = 0;
373     }
374    
375    
376     len += text_len;
377    
378     if (length)
379     *length = len;
380    
381 frodo 168 psiconv_progress(config,lev+1,off+len-1,"End of text section (total length: %08x",
382 frodo 2 len);
383    
384     return res;
385 frodo 64
386     ERROR2_3:
387     psiconv_free_character_layout(para->base_character);
388     ERROR2_2:
389     psiconv_list_free(para->replacements);
390     ERROR2_1:
391     psiconv_list_free(para->in_lines);
392     ERROR2_0:
393     for (j = 0; j < i; j++) {
394     if (!(para = psiconv_list_get(*result,j))) {
395 frodo 168 psiconv_warn(config,lev+1,off,"Massive memory corruption...");
396 frodo 64 break;
397     }
398     psiconv_list_free(para->in_lines);
399     psiconv_list_free(para->replacements);
400     psiconv_free_character_layout(para->base_character);
401     psiconv_free_paragraph_layout(para->base_paragraph);
402     }
403     goto ERROR2;
404    
405     ERROR4:
406     free(para->text);
407     ERROR3:
408     free(para);
409     ERROR2:
410     for (i = 0; i < psiconv_list_length(*result);i++) {
411     if (!(para = psiconv_list_get(*result,i))) {
412 frodo 168 psiconv_warn(config,lev+1,off,"Massive memory corruption...");
413 frodo 64 break;
414     }
415     free(para->text);
416     }
417     psiconv_list_free(*result);
418     ERROR1:
419 frodo 168 psiconv_warn(config,lev+1,off,"Reading of Text Section failed");
420 frodo 64 if (length)
421     *length = 0;
422     if (!res)
423     return -PSICONV_E_NOMEM;
424     else
425     return res;
426 frodo 2 }
427    
428     /* First do a parse_text_section, or you will get into trouble here */
429 frodo 168 int psiconv_parse_layout_section(const psiconv_config config,
430     const psiconv_buffer buf,
431 frodo 2 int lev,psiconv_u32 off,
432     int *length,
433     psiconv_text_and_layout result,
434     psiconv_word_styles_section styles,
435     int with_styles)
436     {
437     int res = 0;
438     int len = 0;
439     psiconv_u32 temp;
440     int parse_styles,nr,i,j,total,leng,line_length;
441    
442 frodo 56 typedef struct anon_style_s
443 frodo 2 {
444     int nr;
445     psiconv_s16 base_style;
446     psiconv_character_layout character;
447     psiconv_paragraph_layout paragraph;
448     } *anon_style;
449    
450     typedef psiconv_list anon_style_list; /* of struct anon_style */
451    
452     anon_style_list anon_styles;
453 frodo 56 struct anon_style_s anon;
454 frodo 2 anon_style anon_ptr=NULL;
455    
456 frodo 64 psiconv_character_layout temp_char;
457     psiconv_paragraph_layout temp_para;
458     psiconv_word_style temp_style;
459 frodo 2 psiconv_paragraph para;
460 frodo 56 struct psiconv_in_line_layout_s in_line;
461 frodo 2
462     int *inline_count;
463    
464    
465 frodo 168 psiconv_progress(config,lev+1,off,"Going to read the layout section");
466 frodo 2
467 frodo 168 psiconv_progress(config,lev+2,off,"Going to read the section type");
468     temp = psiconv_read_u16(config,buf,lev+2,off+len,&res);
469 frodo 64 if (res)
470     goto ERROR1;
471 frodo 168 psiconv_debug(config,lev+2,off+len,"Type: %02x",temp);
472 frodo 2 parse_styles = with_styles;
473     if ((temp == 0x0001) && !with_styles) {
474 frodo 168 psiconv_warn(config,lev+2,off+len,"Styleless layout section expected, "
475 frodo 2 "but styled section found!");
476     parse_styles = 1;
477     } else if ((temp == 0x0000) && (with_styles)) {
478 frodo 168 psiconv_warn(config,lev+2,off+len,"Styled layout section expected, "
479 frodo 2 "but styleless section found!");
480     parse_styles = 0;
481     } else if ((temp != 0x0000) && (temp != 0x0001)) {
482 frodo 168 psiconv_warn(config,lev+2,off+len,
483 frodo 2 "Layout section type indicator has unknown value!");
484     }
485     len += 0x02;
486    
487 frodo 168 psiconv_progress(config,lev+2,off+len,"Going to read paragraph type list");
488 frodo 64 if (!(anon_styles = psiconv_list_new(sizeof(anon))))
489     goto ERROR1;
490 frodo 168 psiconv_progress(config,lev+3,off+len,"Going to read paragraph type list length");
491     nr = psiconv_read_u8(config,buf,lev+3,off+len,&res);
492 frodo 64 if (res)
493     goto ERROR2;
494 frodo 168 psiconv_debug(config,lev+3,off+len,"Length: %02x",nr);
495 frodo 2 len ++;
496    
497 frodo 168 psiconv_progress(config,lev+3,off+len,
498 frodo 2 "Going to read the paragraph type list elements");
499     for (i = 0; i < nr; i ++) {
500 frodo 168 psiconv_progress(config,lev+3,off+len,"Element %d",i);
501     anon.nr = psiconv_read_u32(config,buf,lev+4,off+len,&res);
502 frodo 64 if (res)
503     goto ERROR3;
504 frodo 168 psiconv_debug(config,lev+4,off+len,"Number: %08x",anon.nr);
505 frodo 2 len += 0x04;
506    
507 frodo 168 psiconv_progress(config,lev+4,off,"Going to determine the base style");
508 frodo 2 if (parse_styles) {
509 frodo 168 temp = psiconv_read_u32(config,buf,lev+4, off+len,&res);
510 frodo 64 if (res)
511     goto ERROR3;
512 frodo 168 anon.base_style = psiconv_read_u8(config,buf,lev+3, off+len+4+temp,&res);
513 frodo 64 if (res)
514     goto ERROR3;
515 frodo 168 psiconv_debug(config,lev+4,off+len+temp,
516 frodo 2 "Style indicator: %02x",anon.base_style);
517     } else
518     anon.base_style = 0;
519 frodo 64 if (!(temp_style = psiconv_get_style(styles,anon.base_style))) {
520 frodo 168 psiconv_warn(config,lev+4,off,"Unknown Style referenced");
521 frodo 64 if (!(temp_style = psiconv_get_style(styles,anon.base_style))) {
522 frodo 168 psiconv_warn(config,lev+4,off,"Base style unknown");
523 frodo 64 goto ERROR3;
524     }
525     }
526     if (!(anon.paragraph = psiconv_clone_paragraph_layout
527     (temp_style->paragraph)))
528     goto ERROR3;
529     if (!(anon.character = psiconv_clone_character_layout
530     (temp_style->character)))
531     goto ERROR3_1;
532 frodo 2
533 frodo 168 psiconv_progress(config,lev+4,off+len,"Going to read the paragraph layout");
534     if ((res = psiconv_parse_paragraph_layout_list(config,buf,lev+4,off+len,&leng,
535 frodo 64 anon.paragraph)))
536     goto ERROR3_2;
537 frodo 2 len += leng;
538     if (parse_styles)
539     len ++;
540    
541 frodo 168 psiconv_progress(config,lev+4,off+len,"Going to read the character layout");
542     if ((res = psiconv_parse_character_layout_list(config,buf,lev+4,off+len,&leng,
543 frodo 64 anon.character)))
544     goto ERROR3_2;
545 frodo 2 len += leng;
546 frodo 64 if ((res = psiconv_list_add(anon_styles,&anon)))
547     goto ERROR3_2;
548 frodo 2 }
549    
550 frodo 168 psiconv_progress(config,lev+2,off+len,"Going to parse the paragraph element list");
551     psiconv_progress(config,lev+3,off+len,"Going to read the number of paragraphs");
552     nr = psiconv_read_u32(config,buf,lev+3,off+len,&res);
553 frodo 64 if (res)
554     goto ERROR3;
555 frodo 2 if (nr != psiconv_list_length(result)) {
556 frodo 168 psiconv_warn(config,lev+3,off+len,
557 frodo 2 "Number of text paragraphs and paragraph elements does not match");
558 frodo 168 psiconv_debug(config,lev+3,off+len,
559 frodo 2 "%d text paragraphs, %d paragraph elements",
560     psiconv_list_length(result),nr);
561     }
562 frodo 168 psiconv_debug(config,lev+3,off+len,"Number of paragraphs: %d",nr);
563 frodo 2 len += 4;
564 frodo 64 if (!(inline_count = malloc(nr * sizeof(*inline_count))))
565     goto ERROR3;
566 frodo 2
567 frodo 168 psiconv_progress(config,lev+3,off+len,"Going to read the paragraph elements");
568 frodo 2 for (i = 0; i < nr; i ++) {
569 frodo 168 psiconv_progress(config,lev+3,off+len,"Element %d",i);
570 frodo 2 if (i >= psiconv_list_length(result)) {
571 frodo 168 psiconv_debug(config,lev+4,off+len,"Going to allocate a new element");
572 frodo 64 if (!(para = malloc(sizeof(*para))))
573     goto ERROR4;
574     if (!(para->in_lines = psiconv_list_new(sizeof(
575     struct psiconv_in_line_layout_s))))
576     goto ERROR4_1;
577 frodo 2 para->base_style = 0;
578 frodo 64 if (!(para->base_character = psiconv_basic_character_layout()))
579     goto ERROR4_2;
580     if (!(para->base_paragraph = psiconv_basic_paragraph_layout()))
581     goto ERROR4_3;
582     if ((res = psiconv_list_add(result,para)))
583     goto ERROR4_4;
584 frodo 2 free(para);
585     }
586 frodo 64 if (!(para = psiconv_list_get(result,i)))
587     goto ERROR4;
588 frodo 2
589 frodo 168 psiconv_progress(config,lev+4,off+len,"Going to read the paragraph length");
590     temp = psiconv_read_u32(config,buf,lev+4,off+len,&res);
591 frodo 65 if (res)
592 frodo 64 goto ERROR4;
593 frodo 2 if (temp != strlen(para->text)+1) {
594 frodo 168 psiconv_warn(config,lev+4,off+len,
595 frodo 2 "Disagreement of the length of paragraph in layout section");
596 frodo 168 psiconv_debug(config,lev+4,off+len,
597 frodo 2 "Paragraph length: layout section says %d, counted %d",
598     temp,strlen(para->text)+1);
599     } else
600 frodo 168 psiconv_debug(config,lev+4,off+len,"Paragraph length: %d",temp);
601 frodo 2 len += 4;
602    
603 frodo 168 psiconv_progress(config,lev+4,off+len,"Going to read the paragraph type");
604     temp = psiconv_read_u8(config,buf,lev+4,off+len,&res);
605 frodo 65 if (res)
606 frodo 64 goto ERROR4;
607 frodo 2 if (temp != 0x00) {
608 frodo 168 psiconv_debug(config,lev+4,off+len,"Type: %02x",temp);
609 frodo 2 for (j = 0; j < psiconv_list_length(anon_styles); j++) {
610 frodo 64 if (!(anon_ptr = psiconv_list_get(anon_styles,j))) {
611 frodo 168 psiconv_warn(config,lev+4,off+len,"Massive memory curruption");
612 frodo 64 goto ERROR4;
613     }
614 frodo 2 if (temp == anon_ptr->nr)
615     break;
616     }
617     if (j == psiconv_list_length(anon_styles)) {
618 frodo 168 psiconv_warn(config,lev+4,off+len,"Layout section paragraph type unknown");
619     psiconv_debug(config,lev+4,off+len,"Unknown type - using base styles instead");
620 frodo 2 para->base_style = 0;
621 frodo 64 if (!(temp_style = psiconv_get_style(styles,0))) {
622 frodo 168 psiconv_warn(config,lev+4,off,"Base style unknown");
623 frodo 64 goto ERROR4;
624     }
625     if (!(temp_para = psiconv_clone_paragraph_layout
626     (temp_style->paragraph)))
627     goto ERROR4;
628 frodo 2 psiconv_free_paragraph_layout(para->base_paragraph);
629 frodo 64 para->base_paragraph = temp_para;
630    
631     if (!(temp_char = psiconv_clone_character_layout
632     (temp_style->character)))
633     goto ERROR4;
634 frodo 2 psiconv_free_character_layout(para->base_character);
635 frodo 64 para->base_character = temp_char;
636 frodo 2 } else {
637     para->base_style = anon_ptr->base_style;
638 frodo 64 if (!(temp_para = psiconv_clone_paragraph_layout (anon_ptr->paragraph)))
639     goto ERROR4;
640 frodo 2 psiconv_free_paragraph_layout(para->base_paragraph);
641 frodo 64 para->base_paragraph = temp_para;
642    
643     if (!(temp_char = psiconv_clone_character_layout (anon_ptr->character)))
644     goto ERROR4;
645 frodo 2 psiconv_free_character_layout(para->base_character);
646 frodo 64 para->base_character = temp_char;
647 frodo 2 }
648     inline_count[i] = 0;
649     len += 0x01;
650     } else {
651 frodo 168 psiconv_debug(config,lev+4,off+len,"Type: %02x (not based on a paragraph type)"
652 frodo 2 ,temp);
653     len += 0x01;
654     if (parse_styles) {
655 frodo 168 temp = psiconv_read_u32(config,buf,lev+4,off+len,&res);
656 frodo 64 if (res)
657     goto ERROR4;
658 frodo 168 psiconv_progress(config,lev+4,off+len+temp+4,
659 frodo 2 "Going to read the paragraph element base style");
660 frodo 168 temp = psiconv_read_u8(config,buf,lev+4, off+len+temp+4,&res);
661 frodo 64 if (res)
662     goto ERROR4;
663 frodo 168 psiconv_debug(config,lev+4,off+len+temp+4, "Style: %02x",temp);
664 frodo 2 } else
665     temp = 0x00;
666 frodo 64
667     if (!(temp_style = psiconv_get_style (styles,temp))) {
668 frodo 168 psiconv_warn(config,lev+4,off,"Unknown Style referenced");
669 frodo 64 if (!(temp_style = psiconv_get_style(styles,0))) {
670 frodo 168 psiconv_warn(config,lev+4,off,"Base style unknown");
671 frodo 64 goto ERROR4;
672     }
673     }
674    
675     if (!(temp_para = psiconv_clone_paragraph_layout(temp_style->paragraph)))
676     goto ERROR4;
677 frodo 2 psiconv_free_paragraph_layout(para->base_paragraph);
678 frodo 64 para->base_paragraph = temp_para;
679    
680     if (!(temp_char = psiconv_clone_character_layout(temp_style->character)))
681     goto ERROR4;
682 frodo 2 psiconv_free_character_layout(para->base_character);
683 frodo 64 para->base_character = temp_char;
684    
685 frodo 2 para->base_style = temp;
686 frodo 168 psiconv_progress(config,lev+4,off+len,"Going to read paragraph layout");
687     if ((res = psiconv_parse_paragraph_layout_list(config,buf,lev+4,off+len,&leng,
688 frodo 64 para->base_paragraph)))
689     goto ERROR4;
690 frodo 2 len += leng;
691     if (parse_styles)
692     len += 1;
693 frodo 168 psiconv_progress(config,lev+4,off+len,"Going to read number of in-line "
694 frodo 2 "layout elements");
695 frodo 168 inline_count[i] = psiconv_read_u32(config,buf,lev+4,off+len,&res);
696 frodo 64 if (res)
697     goto ERROR4;
698 frodo 168 psiconv_debug(config,lev+4,off+len,"Nr: %08x",inline_count[i]);
699 frodo 2 len += 4;
700     }
701     }
702    
703 frodo 168 psiconv_progress(config,lev+2,off+len,"Going to read the text layout inline list");
704 frodo 2
705 frodo 168 psiconv_progress(config,lev+3,off+len,"Going to read the number of elements");
706     nr = psiconv_read_u32(config,buf,lev+3,off+len,&res);
707 frodo 64 if (res)
708     goto ERROR4;
709 frodo 168 psiconv_debug(config,lev+3,off+len,"Elements: %08x",nr);
710 frodo 2 len += 0x04;
711    
712 frodo 168 psiconv_progress(config,lev+3,off+len,
713 frodo 2 "Going to read the text layout inline elements");
714     total = 0;
715     for (i = 0; i < psiconv_list_length(result); i++) {
716 frodo 64 if (!(para = psiconv_list_get(result,i))) {
717 frodo 168 psiconv_warn(config,lev+3,off+len,"Massive memory corruption");
718 frodo 64 goto ERROR4;
719     }
720 frodo 2 line_length = -1;
721     for (j = 0; j < inline_count[i]; j++) {
722 frodo 168 psiconv_progress(config,lev+3,off+len,"Element %d: Paragraph %d, element %d",
723 frodo 2 total,i,j);
724     if (total >= nr) {
725 frodo 168 psiconv_warn(config,lev+3,off+len,
726 frodo 2 "Layout section inlines: not enough element");
727 frodo 168 psiconv_debug(config,lev+3,off+len,"Can't read element!");
728 frodo 2 } else {
729     total ++;
730 frodo 159 in_line.object = NULL;
731 frodo 160 in_line.layout = NULL;
732 frodo 64 if (!(in_line.layout = psiconv_clone_character_layout
733     (para->base_character)))
734     goto ERROR4;
735 frodo 168 psiconv_progress(config,lev+4,off+len,"Going to read the element type");
736     temp = psiconv_read_u8(config,buf,lev+4,len+off,&res);
737 frodo 64 if (res)
738 frodo 160 goto ERROR5;
739 frodo 2 len += 1;
740 frodo 168 psiconv_debug(config,lev+4,off+len,"Type: %02x",temp);
741     psiconv_progress(config,lev+4,off+len,
742 frodo 64 "Going to read the number of characters it applies to");
743 frodo 168 in_line.length = psiconv_read_u32(config,buf,lev+4,len+off,&res);
744 frodo 64 if (res)
745 frodo 160 goto ERROR5;
746 frodo 168 psiconv_debug(config,lev+4,off+len,"Length: %02x",in_line.length);
747 frodo 2 len += 4;
748 frodo 168 psiconv_progress(config,lev+4,off+len,"Going to read the character layout");
749     if ((res = psiconv_parse_character_layout_list(config,buf,lev+4,off+len,&leng,
750 frodo 64 in_line.layout)))
751 frodo 160 goto ERROR5;
752 frodo 2 len += leng;
753    
754     if (temp == 0x01) {
755 frodo 168 psiconv_debug(config,lev+4,off+len,"Found an embedded object");
756     psiconv_progress(config,lev+4,off+len,"Going to read the object marker "
757 frodo 160 "(0x%08x expected)",PSICONV_ID_OBJECT);
758 frodo 168 temp = psiconv_read_u32(config,buf,lev+4,off+len,&res);
759 frodo 160 if (res)
760     goto ERROR5;
761     if (temp != PSICONV_ID_OBJECT) {
762 frodo 168 psiconv_warn(config,lev+4,off+len,"Unknown id marks embedded object");
763     psiconv_debug(config,lev+4,off+len,"Marker: read %08x, expected %08x",
764 frodo 160 temp,PSICONV_ID_OBJECT);
765     }
766     len += 4;
767 frodo 168 psiconv_progress(config,lev+4,off+len,
768 frodo 160 "Going to read the Embedded Object Section offset");
769 frodo 168 temp = psiconv_read_u32(config,buf,lev+4,off+len,&res);
770 frodo 160 if (res)
771     goto ERROR5;
772 frodo 168 psiconv_debug(config,lev+4,off+len, "Offset: %08x",temp);
773 frodo 160 len += 4;
774 frodo 168 psiconv_progress(config,lev+4,off+len,
775 frodo 167 "Going to parse the Embedded Object Section");
776 frodo 168 if ((res = psiconv_parse_embedded_object_section(config,buf,lev+4,temp,
777 frodo 160 NULL,&(in_line.object))))
778     goto ERROR5;
779 frodo 168 psiconv_progress(config,lev+4,off+len,
780 frodo 160 "Going to read the object width");
781 frodo 168 in_line.object_width = psiconv_read_length(config,buf,lev+4,off+len,
782 frodo 160 &leng,&res);
783     if (res)
784     goto ERROR5;
785 frodo 168 psiconv_debug(config,lev+4,off+len,"Object width: %f cm",
786 frodo 160 in_line.object_width);
787     len += leng;
788 frodo 168 psiconv_progress(config,lev+4,off+len,
789 frodo 160 "Going to read the object height");
790 frodo 168 in_line.object_height = psiconv_read_length(config,buf,lev+4,off+len,&leng,
791 frodo 160 &res);
792     if (res)
793     goto ERROR5;
794 frodo 168 psiconv_debug(config,lev+4,off+len,"Object height: %f cm",
795 frodo 160 in_line.object_height);
796     len += leng;
797 frodo 2 } else if (temp != 0x00) {
798 frodo 168 psiconv_warn(config,lev+4,off+len,"Layout section unknown inline type");
799 frodo 2 }
800     if (line_length + in_line.length > strlen(para->text)) {
801 frodo 168 psiconv_warn(config,lev+4,off+len,
802 frodo 2 "Layout section inlines: line length mismatch");
803     res = -1;
804     in_line.length = strlen(para->text) - line_length;
805     }
806     line_length += in_line.length;
807 frodo 64 if ((res = psiconv_list_add(para->in_lines,&in_line)))
808 frodo 160 goto ERROR5;
809 frodo 2 }
810     }
811     }
812    
813     if (total != nr) {
814 frodo 168 psiconv_warn(config,lev+4,off+len,
815 frodo 2 "Layout section too many inlines, skipping remaining");
816     }
817    
818     free(inline_count);
819    
820     for (i = 0 ; i < psiconv_list_length(anon_styles); i ++) {
821 frodo 64 if (!(anon_ptr = psiconv_list_get(anon_styles,i))) {
822 frodo 168 psiconv_warn(config,lev+4,off+len,"Massive memory corruption");
823 frodo 64 goto ERROR2;
824     }
825 frodo 2 psiconv_free_character_layout(anon_ptr->character);
826     psiconv_free_paragraph_layout(anon_ptr->paragraph);
827     }
828     psiconv_list_free(anon_styles);
829    
830     if (length)
831     *length = len;
832    
833 frodo 168 psiconv_progress(config,lev+1,off+len-1,"End of layout section (total length: %08x)",
834 frodo 2 len);
835    
836 frodo 64 return 0;
837    
838     ERROR4_4:
839     psiconv_free_paragraph_layout(para->base_paragraph);
840     ERROR4_3:
841     psiconv_free_character_layout(para->base_character);
842     ERROR4_2:
843     psiconv_list_free(para->in_lines);
844     ERROR4_1:
845     free(para);
846     goto ERROR4;
847    
848     ERROR3_2:
849     psiconv_free_character_layout(anon.character);
850     ERROR3_1:
851     psiconv_free_paragraph_layout(anon.paragraph);
852     goto ERROR3;
853    
854 frodo 160 ERROR5:
855     if (in_line.layout)
856     psiconv_free_character_layout(in_line.layout);
857     if (in_line.object)
858 frodo 167 psiconv_free_embedded_object_section(in_line.object);
859 frodo 64 ERROR4:
860     free(inline_count);
861     ERROR3:
862     for (i = 0; i < psiconv_list_length(anon_styles); i++) {
863     if (!(anon_ptr = psiconv_list_get(anon_styles,i))) {
864 frodo 168 psiconv_warn(config,lev+1,off,"Massive memory corruption");
865 frodo 64 break;
866     }
867     psiconv_free_paragraph_layout(anon_ptr->paragraph);
868     psiconv_free_character_layout(anon_ptr->character);
869     }
870    
871     ERROR2:
872     psiconv_list_free(anon_styles);
873     ERROR1:
874 frodo 168 psiconv_warn(config,lev+1,off,"Reading of Layout Section failed");
875 frodo 64 if (length)
876     *length = 0;
877     if (!res)
878     return -PSICONV_E_NOMEM;
879     else
880     return res;
881 frodo 2 }
882    
883 frodo 168 int psiconv_parse_styled_layout_section(const psiconv_config config,
884     const psiconv_buffer buf,
885 frodo 2 int lev,psiconv_u32 off,
886     int *length,
887     psiconv_text_and_layout result,
888     psiconv_word_styles_section styles)
889     {
890 frodo 168 return psiconv_parse_layout_section(config,buf,lev,off,length,result,styles,1);
891 frodo 2 }
892    
893 frodo 168 int psiconv_parse_styleless_layout_section(const psiconv_config config,
894     const psiconv_buffer buf,
895 frodo 79 int lev,psiconv_u32 off,
896     int *length,
897     psiconv_text_and_layout result,
898     const psiconv_character_layout base_char,
899     const psiconv_paragraph_layout base_para)
900 frodo 2 {
901 frodo 64 int res = 0;
902 frodo 2 psiconv_word_styles_section styles_section;
903    
904 frodo 64 if (!(styles_section = malloc(sizeof(*styles_section))))
905     goto ERROR1;
906     if (!(styles_section->normal = malloc(sizeof(*styles_section->normal))))
907     goto ERROR2;
908     if (!(styles_section->normal->character =
909     psiconv_clone_character_layout(base_char)))
910     goto ERROR3;
911     if (!(styles_section->normal->paragraph =
912     psiconv_clone_paragraph_layout(base_para)))
913     goto ERROR4;
914 frodo 2 styles_section->normal->hotkey = 0;
915 frodo 64 if (!(styles_section->normal->name = strdup("")))
916     goto ERROR5;
917     if (!(styles_section->styles = psiconv_list_new(sizeof(
918     struct psiconv_word_style_s))))
919     goto ERROR6;
920 frodo 2
921 frodo 168 res = psiconv_parse_layout_section(config,buf,lev,off,length,result,
922 frodo 2 styles_section,0);
923    
924     psiconv_free_word_styles_section(styles_section);
925     return res;
926 frodo 64
927     ERROR6:
928     free(styles_section->normal->name);
929     ERROR5:
930     psiconv_free_paragraph_layout(styles_section->normal->paragraph);
931     ERROR4:
932     psiconv_free_character_layout(styles_section->normal->character);
933     ERROR3:
934     free(styles_section->normal);
935     ERROR2:
936     free(styles_section);
937     ERROR1:
938 frodo 168 psiconv_warn(config,lev+1,off,"Reading of Styleless Layout Section failed");
939 frodo 64 if (length)
940     *length = 0;
941     if (!res)
942     return -PSICONV_E_NOMEM;
943     else
944     return res;
945 frodo 2 }
946    
947 frodo 168 int psiconv_parse_embedded_object_section(const psiconv_config config,
948     const psiconv_buffer buf, int lev,
949 frodo 160 psiconv_u32 off, int *length,
950 frodo 167 psiconv_embedded_object_section *result)
951 frodo 160 {
952     int res=0;
953     int len=0;
954     int leng,i;
955     psiconv_section_table_section table;
956     psiconv_section_table_entry entry;
957 frodo 161 psiconv_u32 icon_sec=0,display_sec=0,table_sec=0;
958 frodo 162 psiconv_buffer subbuf;
959 frodo 160
960 frodo 168 psiconv_progress(config,lev+1,off+len,"Going to read an Embedded Object");
961 frodo 160 if (!(*result = malloc(sizeof(**result))))
962     goto ERROR1;
963    
964 frodo 168 psiconv_progress(config,lev+2,off+len,"Going to read the Embedded Object Section");
965     psiconv_parse_section_table_section(config,buf,lev+2,off+len,&leng,&table);
966 frodo 160 len += leng;
967    
968     for (i = 0; i < psiconv_list_length(table); i++) {
969 frodo 168 psiconv_progress(config,lev+2,off+len,"Going to read entry %d",i);
970 frodo 160 if (!(entry = psiconv_list_get(table,i)))
971     goto ERROR2;
972     if (entry->id == PSICONV_ID_OBJECT_DISPLAY_SECTION) {
973     display_sec = entry->offset;
974 frodo 168 psiconv_debug(config,lev+3,off+len,"Found the Object Display Section at %08x",
975 frodo 160 display_sec);
976     } else if (entry->id == PSICONV_ID_OBJECT_ICON_SECTION) {
977     icon_sec = entry->offset;
978 frodo 168 psiconv_debug(config,lev+3,off+len,"Found the Object Icon Section at %08x",
979 frodo 160 icon_sec);
980     } else if (entry->id == PSICONV_ID_OBJECT_SECTION_TABLE_SECTION) {
981     table_sec = entry->offset;
982 frodo 168 psiconv_debug(config,lev+3,off+len,"Found the Object Section Table Section at %08x",
983 frodo 160 table_sec);
984     } else {
985 frodo 168 psiconv_warn(config,lev+3,off+len,
986 frodo 160 "Found unknown section in the Object Display Section "
987     "(ignoring)");
988 frodo 168 psiconv_debug(config,lev+3,off+len,"Section ID %08x, offset %08x",
989 frodo 160 entry->id, entry->offset);
990     }
991     }
992    
993 frodo 168 psiconv_progress(config,lev+2,off+len,"Looking for the Object Display Section");
994 frodo 161 if (!icon_sec) {
995 frodo 168 psiconv_warn(config,lev+2,off+len,"Object Display Section not found");
996 frodo 161 (*result)->display = NULL;
997     } else {
998 frodo 168 psiconv_debug(config,lev+2,off+len,"Object Display Section at offset %08x",
999 frodo 161 display_sec);
1000 frodo 168 if ((res = psiconv_parse_object_display_section(config,buf,lev+2,display_sec,NULL,
1001 frodo 161 &(*result)->display)))
1002     goto ERROR2;
1003     }
1004    
1005 frodo 168 psiconv_progress(config,lev+2,off+len,"Looking for the Object Icon Section");
1006 frodo 161 if (!icon_sec) {
1007 frodo 168 psiconv_warn(config,lev+2,off+len,"Object Icon Section not found");
1008 frodo 161 (*result)->icon = NULL;
1009     } else {
1010 frodo 168 psiconv_debug(config,lev+2,off+len,"Object Icon Section at offset %08x",icon_sec);
1011     if ((res = psiconv_parse_object_icon_section(config,buf,lev+2,icon_sec,NULL,
1012 frodo 161 &(*result)->icon)))
1013 frodo 162 goto ERROR3;
1014 frodo 161 }
1015    
1016 frodo 168 psiconv_progress(config,lev+2,off+len,
1017 frodo 162 "Looking for the Section Table Offset Section");
1018     if (!table_sec) {
1019 frodo 168 psiconv_warn(config,lev+2,off+len,
1020 frodo 162 "Embedded Section Table Offset Section not found");
1021     (*result)->object = NULL;
1022     } else {
1023 frodo 168 psiconv_progress(config,lev+2,off+len,
1024 frodo 162 "Extracting object: add %08x to all following offsets",
1025     table_sec);
1026     /* We can't determine the length of the object, so we just take it all */
1027     if ((res = psiconv_buffer_subbuffer(&subbuf,buf,table_sec,
1028     psiconv_buffer_length(buf)-table_sec)))
1029     goto ERROR4;
1030    
1031     if (!((*result)->object = malloc(sizeof(*(*result)->object))))
1032     goto ERROR5;
1033    
1034     /* We need to find the file type, but we don't have a normal header */
1035     /* So we try to find the Application ID Section and hope for the best */
1036 frodo 168 psiconv_progress(config,lev+3,0,"Trying to determine the file type");
1037 frodo 162 (*result)->object->type = psiconv_determine_embedded_object_type
1038 frodo 168 (config,subbuf,lev+3,&res);
1039 frodo 162 switch ((*result)->object->type) {
1040     case psiconv_word_file:
1041 frodo 168 if ((res = psiconv_parse_word_file(config,subbuf,lev+3,0,
1042 frodo 162 ((psiconv_word_f *) &(*result)->object->file))))
1043     goto ERROR6;
1044     break;
1045     case psiconv_texted_file:
1046 frodo 168 if ((res = psiconv_parse_texted_file(config,subbuf,lev+3,0,
1047 frodo 162 ((psiconv_texted_f *) &(*result)->object->file))))
1048     goto ERROR6;
1049     break;
1050     case psiconv_sheet_file:
1051 frodo 168 if ((res = psiconv_parse_sheet_file(config,subbuf,lev+3,0,
1052 frodo 162 ((psiconv_sheet_f *) &(*result)->object->file))))
1053     goto ERROR6;
1054     break;
1055     case psiconv_sketch_file:
1056 frodo 168 if ((res = psiconv_parse_sketch_file(config,subbuf,lev+3,0,
1057 frodo 162 ((psiconv_sketch_f *) &(*result)->object->file))))
1058     goto ERROR6;
1059     break;
1060     default:
1061 frodo 168 psiconv_warn(config,lev+3,0,"Can't parse embedded object (still continuing)");
1062 frodo 162 (*result)->object->file = NULL;
1063     }
1064     }
1065    
1066 frodo 161 if (length)
1067     *length = len;
1068    
1069 frodo 168 psiconv_progress(config,lev+1,off+len-1,"End of Embedded Object Section "
1070 frodo 160 "(total length: %08x)",len);
1071 frodo 161
1072 frodo 160 return res;
1073    
1074 frodo 162
1075     ERROR6:
1076     free((*result)->object);
1077     ERROR5:
1078     psiconv_buffer_free(subbuf);
1079     ERROR4:
1080     psiconv_free_object_icon_section((*result)->icon);
1081     ERROR3:
1082     psiconv_free_object_display_section((*result)->display);
1083 frodo 160 ERROR2:
1084     psiconv_free_section_table_section(table);
1085     ERROR1:
1086 frodo 168 psiconv_warn(config,lev+1,off,"Reading Embedded Object failed");
1087 frodo 161
1088 frodo 160 if (length)
1089     *length = 0;
1090 frodo 161
1091 frodo 160 if (res == 0)
1092     return -PSICONV_E_NOMEM;
1093     else
1094     return res;
1095     }
1096 frodo 161
1097 frodo 162 psiconv_file_type_t psiconv_determine_embedded_object_type
1098 frodo 168 (const psiconv_config config,
1099     const psiconv_buffer buf,int lev,
1100 frodo 162 int *status)
1101     {
1102     psiconv_u32 off;
1103     psiconv_section_table_section table;
1104     int res,i;
1105     psiconv_file_type_t file_type = psiconv_unknown_file;
1106     psiconv_section_table_entry entry;
1107     psiconv_application_id_section applid;
1108    
1109 frodo 168 psiconv_progress(config,lev+1,0,"Going to determine embedded object file type");
1110     psiconv_progress(config,lev+2,0,"Going to read the Section Table Offset Section");
1111     off = psiconv_read_u32(config,buf,lev,0,&res);
1112 frodo 162 if (res)
1113     goto ERROR1;
1114 frodo 168 psiconv_debug(config,lev+2,0,"Offset: %08x",off);
1115 frodo 162
1116 frodo 168 psiconv_progress(config,lev+2,off,"Going to read the Section Table Section");
1117     if ((res = psiconv_parse_section_table_section(config,buf,lev+2,off,NULL,&table)))
1118 frodo 162 goto ERROR1;
1119    
1120 frodo 168 psiconv_progress(config,lev+2,off,"Going to search the Section Table Section "
1121 frodo 162 "for the Application ID Section");
1122     for (i=0; i < psiconv_list_length(table); i++) {
1123 frodo 168 psiconv_progress(config,lev+3,off,"Going to read entry %d",i);
1124 frodo 162 if (!(entry = psiconv_list_get(table,i)))
1125     goto ERROR2;
1126     if (entry->id == PSICONV_ID_APPL_ID_SECTION) {
1127 frodo 168 psiconv_progress(config,lev+3,off,
1128 frodo 162 "Found the Application ID Section at offset %08x",
1129     entry->offset);
1130     off = entry->offset;
1131     break;
1132     }
1133     }
1134     if (i == psiconv_list_length(table)) {
1135 frodo 168 psiconv_warn(config,lev+2,off,"No Application ID Section found");
1136 frodo 162 res = PSICONV_E_PARSE;
1137     goto ERROR2;
1138     }
1139    
1140 frodo 168 psiconv_progress(config,lev+2,off,"Going to read the Application ID Section");
1141     if ((res = psiconv_parse_application_id_section(config,buf,lev+2,off,NULL,&applid)))
1142 frodo 162 goto ERROR2;
1143    
1144     switch (applid->id) {
1145     case PSICONV_ID_WORD: file_type = psiconv_word_file;
1146 frodo 168 psiconv_debug(config,lev+2,off,"Found a Word file");
1147 frodo 162 break;
1148     case PSICONV_ID_TEXTED: file_type = psiconv_texted_file;
1149 frodo 168 psiconv_debug(config,lev+2,off,"Found a TextEd file");
1150 frodo 162 break;
1151     case PSICONV_ID_SKETCH: file_type = psiconv_sketch_file;
1152 frodo 168 psiconv_debug(config,lev+2,off,"Found a Sketch file");
1153 frodo 162 break;
1154     case PSICONV_ID_SHEET: file_type = psiconv_sheet_file;
1155 frodo 168 psiconv_debug(config,lev+2,off,"Found a Sheet file");
1156 frodo 162 break;
1157 frodo 168 default: psiconv_warn(config,lev+2,off,"Found an unknown file type");
1158     psiconv_debug(config,lev+2,off,"Found ID %08x",applid->id);
1159 frodo 162 }
1160    
1161     ERROR2:
1162     psiconv_free_application_id_section(applid);
1163     ERROR1:
1164     psiconv_free_section_table_section(table);
1165     if (status)
1166     *status = res;
1167     return file_type;
1168    
1169     }
1170    
1171 frodo 168 int psiconv_parse_object_display_section(const psiconv_config config,
1172     const psiconv_buffer buf,int lev,
1173 frodo 161 psiconv_u32 off, int *length,
1174     psiconv_object_display_section *result)
1175     {
1176     int res = 0;
1177     int len = 0;
1178     int leng;
1179     psiconv_u32 temp;
1180    
1181 frodo 168 psiconv_progress(config,lev+1,off,"Going to read the Object Display Section");
1182 frodo 161 if (!(*result = malloc(sizeof(**result))))
1183     goto ERROR1;
1184    
1185 frodo 168 psiconv_progress(config,lev+2,off+len,"Going to read the display as icon flag "
1186 frodo 161 "(expecting 0x00 or 0x01)");
1187 frodo 168 temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1188 frodo 161 if (res)
1189     goto ERROR2;
1190     if (temp == 0x00) {
1191     (*result)->show_icon = psiconv_bool_true;
1192 frodo 168 psiconv_debug(config,lev+2,off+len,"Displayed as icon");
1193 frodo 161 } else if (temp == 0x01) {
1194     (*result)->show_icon = psiconv_bool_false;
1195 frodo 168 psiconv_debug(config,lev+2,off+len,"Displayed as full document");
1196 frodo 161 } else {
1197 frodo 168 psiconv_warn(config,lev+2,off+len,"Unknown Object Display Section Icon Flag");
1198     psiconv_debug(config,lev+2,off+len,"Icon flag found: %02x",temp);
1199 frodo 161 /* Improvise */
1200     (*result)->show_icon = (temp & 0x01?psiconv_bool_false:psiconv_bool_true);
1201     }
1202     len ++;
1203    
1204 frodo 168 psiconv_progress(config,lev+2,off+len,"Going to read the display width");
1205     (*result)->width = psiconv_read_length(config,buf,lev+2,off+len,&leng,&res);
1206 frodo 161 if (res)
1207     goto ERROR2;
1208 frodo 168 psiconv_debug(config,lev+2,off+len,"Display width: %f cm",(*result)->width);
1209 frodo 161 len += leng;
1210    
1211 frodo 168 psiconv_progress(config,lev+2,off+len,"Going to read the display height");
1212     (*result)->height = psiconv_read_length(config,buf,lev+2,off+len,&leng,&res);
1213 frodo 161 if (res)
1214     goto ERROR2;
1215 frodo 168 psiconv_debug(config,lev+2,off+len,"Display length: %f cm",(*result)->height);
1216 frodo 161 len += leng;
1217    
1218 frodo 168 psiconv_progress(config,lev+2,off+len,"Going to read unknown long (%08x expected)",
1219 frodo 161 0);
1220 frodo 168 temp = psiconv_read_u32(config,buf,lev+2,off+len,&res);
1221 frodo 161 if (temp != 0) {
1222 frodo 168 psiconv_warn(config,lev+2,off+len,"Unknown Object Display Section final long");
1223     psiconv_debug(config,lev+2,off+len,"Long read: %08x",temp);
1224 frodo 161 }
1225     len += 4;
1226    
1227     if (length)
1228     *length = len;
1229    
1230 frodo 168 psiconv_progress(config,lev+1,off+len-1,"End of Object Display Section "
1231 frodo 161 "(total length: %08x",len);
1232     return res;
1233    
1234     ERROR2:
1235     free(*result);
1236     ERROR1:
1237 frodo 168 psiconv_warn(config,lev+1,off+len,"Reading of Object Display Section failed");
1238 frodo 161 if (length)
1239     *length=0;
1240     if (!res)
1241     return -PSICONV_E_NOMEM;
1242     else
1243     return res;
1244     }
1245    
1246 frodo 168 int psiconv_parse_object_icon_section(const psiconv_config config,
1247     const psiconv_buffer buf,int lev,
1248 frodo 161 psiconv_u32 off, int *length,
1249     psiconv_object_icon_section *result)
1250     {
1251     int res = 0;
1252     int len = 0;
1253     int leng;
1254    
1255 frodo 168 psiconv_progress(config,lev+1,off,"Going to read the Object Icon Section");
1256 frodo 161 if (!(*result = malloc(sizeof(**result))))
1257     goto ERROR1;
1258    
1259 frodo 168 psiconv_progress(config,lev+2,off+len,"Going to read the icon name");
1260     (*result)->icon_name = psiconv_read_string(config,buf,lev+2,off+len,&leng,&res);
1261 frodo 161 if (res)
1262     goto ERROR2;
1263 frodo 168 psiconv_debug(config,lev+2,off+len,"Icon name: %s",(*result)->icon_name);
1264 frodo 161 len += leng;
1265    
1266 frodo 168 psiconv_progress(config,lev+2,off+len,"Going to read the icon width");
1267     (*result)->icon_width = psiconv_read_length(config,buf,lev+2,off+len,&leng,&res);
1268 frodo 161 if (res)
1269     goto ERROR3;
1270 frodo 168 psiconv_debug(config,lev+2,off+len,"Icon width: %f cm",(*result)->icon_width);
1271 frodo 161 len += leng;
1272    
1273 frodo 168 psiconv_progress(config,lev+2,off+len,"Going to read the icon height");
1274     (*result)->icon_height = psiconv_read_length(config,buf,lev+2,off+len,&leng,&res);
1275 frodo 161 if (res)
1276     goto ERROR3;
1277 frodo 168 psiconv_debug(config,lev+2,off+len,"Icon length: %f cm",(*result)->icon_height);
1278 frodo 161 len += leng;
1279    
1280     if (length)
1281     *length = len;
1282    
1283 frodo 168 psiconv_progress(config,lev+1,off+len-1,"End of Object Icon Section"
1284 frodo 161 "(total length: %08x",len);
1285     return res;
1286    
1287     ERROR3:
1288     free((*result)->icon_name);
1289     ERROR2:
1290     free(*result);
1291     ERROR1:
1292 frodo 168 psiconv_warn(config,lev+1,off+len,"Reading of Object Icon Section failed");
1293 frodo 161 if (length)
1294     *length=0;
1295     if (!res)
1296     return -PSICONV_E_NOMEM;
1297     else
1298     return res;
1299     }

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