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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 208 - (hide annotations)
Mon Feb 9 23:12:58 2004 UTC (20 years, 1 month ago) by frodo
File MIME type: text/plain
File size: 40233 byte(s)
(Frodo) Several (smallish) memory leaks resolved

1 frodo 2 /*
2     data.c - Part of psiconv, a PSION 5 file formats converter
3 frodo 196 Copyright (c) 1999-2004 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     #include "data.h"
25 frodo 87 #include "list.h"
26 frodo 184 #include "unicode.h"
27 frodo 2
28 frodo 142 #ifdef DMALLOC
29     #include <dmalloc.h>
30     #endif
31    
32 frodo 2 static psiconv_color clone_color(psiconv_color color);
33     static psiconv_font clone_font(psiconv_font font);
34     static psiconv_border clone_border(psiconv_border border);
35     static psiconv_bullet clone_bullet(psiconv_bullet bullet);
36     static psiconv_all_tabs clone_all_tabs(psiconv_all_tabs all_tabs);
37     static void psiconv_free_style_aux(void *style);
38     static void psiconv_free_in_line_layout_aux(void * layout);
39     static void psiconv_free_paragraph_aux(void * paragraph);
40 frodo 12 static void psiconv_free_paint_data_section_aux(void * section);
41 frodo 42 static void psiconv_free_clipart_section_aux(void * section);
42 frodo 99 static void psiconv_free_formula_aux(void *data);
43 frodo 111 static void psiconv_free_sheet_worksheet_aux (void *data);
44 frodo 129 static void psiconv_free_sheet_variable_aux(void * variable);
45 frodo 171 static void psiconv_free_sheet_cell_aux(void *cell);
46     static void psiconv_free_sheet_line_aux(void *line);
47     static void psiconv_free_sheet_worksheet_aux (void *data);
48 frodo 2
49 frodo 87 static psiconv_word_styles_section psiconv_empty_word_styles_section(void);
50     static psiconv_text_and_layout psiconv_empty_text_and_layout(void);
51     static psiconv_texted_section psiconv_empty_texted_section(void);
52     static psiconv_page_header psiconv_empty_page_header(void);
53     static psiconv_page_layout_section psiconv_empty_page_layout_section(void);
54     static psiconv_word_status_section psiconv_empty_word_status_section(void);
55     static psiconv_word_f psiconv_empty_word_f(void);
56 frodo 94 static psiconv_sheet_status_section psiconv_empty_sheet_status_section(void);
57 frodo 98 static psiconv_formula_list psiconv_empty_formula_list(void);
58 frodo 95 static psiconv_sheet_workbook_section
59     psiconv_empty_sheet_workbook_section(void);
60 frodo 94 static psiconv_sheet_f psiconv_empty_sheet_f(void);
61 frodo 87 static psiconv_texted_f psiconv_empty_texted_f(void);
62     static psiconv_paint_data_section psiconv_empty_paint_data_section(void);
63     static psiconv_pictures psiconv_empty_pictures(void);
64     static psiconv_mbm_f psiconv_empty_mbm_f(void);
65     static psiconv_sketch_section psiconv_empty_sketch_section(void);
66     static psiconv_sketch_f psiconv_empty_sketch_f(void);
67     static psiconv_clipart_f psiconv_empty_clipart_f(void);
68     static psiconv_cliparts psiconv_empty_cliparts(void);
69    
70    
71 frodo 69 /* Note: these defaults seem to be hard-coded somewhere outside the
72     files themself. */
73 frodo 2 psiconv_character_layout psiconv_basic_character_layout(void)
74     {
75 frodo 20 /* Make the structures static, to oblige IRIX */
76 frodo 56 static struct psiconv_color_s black =
77 frodo 2 {
78     0x00, /* red */
79     0x00, /* green */
80     0x00, /* blue */
81     };
82 frodo 56 static struct psiconv_color_s white =
83 frodo 2 {
84     0xff, /* red */
85     0xff, /* green */
86     0xff, /* blue */
87     };
88 frodo 184 static psiconv_ucs2 font_times[16] = { 'T','i','m','e','s',' ',
89     'N','e','w',' ',
90     'R','o','m','a','n',0 };
91 frodo 56 static struct psiconv_font_s font =
92 frodo 20 {
93 frodo 184 font_times, /* name */
94 frodo 20 3 /* screenfont */
95     };
96 frodo 56 struct psiconv_character_layout_s cl =
97 frodo 2 {
98     &black, /* color */
99     &white, /* back_color */
100     10.0, /* font_size */
101     psiconv_bool_false, /* italic */
102     psiconv_bool_false, /* bold */
103     psiconv_normalscript, /* super_sub */
104     psiconv_bool_false, /* underline */
105 frodo 67 psiconv_bool_false, /* strikethrough */
106 frodo 24 &font, /* font */
107 frodo 2 };
108    
109     return psiconv_clone_character_layout(&cl);
110     }
111    
112 frodo 69 /* Note: these defaults seem to be hard-coded somewhere outside the
113     files themself. */
114 frodo 2 psiconv_paragraph_layout psiconv_basic_paragraph_layout(void)
115     {
116 frodo 184 static psiconv_ucs2 font_times[16] = { 'T','i','m','e','s',' ',
117     'N','e','w',' ',
118     'R','o','m','a','n',0 };
119    
120 frodo 56 static struct psiconv_font_s font =
121 frodo 2 {
122 frodo 184 font_times, /* name */
123 frodo 2 2 /* screenfont */
124     };
125 frodo 56 static struct psiconv_color_s black =
126 frodo 2 {
127     0x00, /* red */
128     0x00, /* green */
129     0x00, /* blue */
130     };
131 frodo 56 static struct psiconv_color_s white =
132 frodo 2 {
133     0xff, /* red */
134     0xff, /* green */
135     0xff, /* blue */
136     };
137 frodo 56 static struct psiconv_border_s no_border =
138 frodo 2 {
139     psiconv_border_none, /* kind */
140     1, /* thickness */
141     &black /* color */
142     };
143 frodo 56 static struct psiconv_bullet_s bullet =
144 frodo 2 {
145     psiconv_bool_false, /* on */
146     10.0, /* font_size */
147 frodo 184 0x201d, /* character */
148 frodo 2 psiconv_bool_true, /* indent */
149     &black, /* color */
150     &font, /* font */
151     };
152 frodo 56 static struct psiconv_all_tabs_s tabs =
153 frodo 2 {
154     0.64, /* normal */
155     NULL /* kind */
156     };
157 frodo 56 struct psiconv_paragraph_layout_s pl =
158 frodo 2 {
159     &white, /* back_color */
160     0.0, /* indent_left */
161     0.0, /* indent_right */
162     0.0, /* indent_first */
163     psiconv_justify_left, /* justify_hor */
164     psiconv_justify_middle,/* justify_ver */
165 frodo 69 10.0, /* linespacing */
166 frodo 67 psiconv_bool_false, /* linespacing_exact */
167     0.0, /* space_above */
168     0.0, /* space_below */
169     psiconv_bool_false, /* keep_together */
170     psiconv_bool_false, /* keep_with_next */
171 frodo 2 psiconv_bool_false, /* on_next_page */
172     psiconv_bool_false, /* no_widow_protection */
173 frodo 104 psiconv_bool_false, /* wrap_to_fit_cell */
174 frodo 2 0.0, /* left_margin */
175     &bullet, /* bullet */
176     &no_border, /* left_border */
177     &no_border, /* right_border */
178     &no_border, /* top_border */
179     &no_border, /* bottom_border */
180     &tabs, /* tabs */
181     };
182     psiconv_paragraph_layout res;
183    
184 frodo 62 if (!(pl.tabs->extras = psiconv_list_new(sizeof(struct psiconv_tab_s))))
185     return NULL;
186 frodo 2 res = psiconv_clone_paragraph_layout(&pl);
187     psiconv_list_free(pl.tabs->extras);
188     return res;
189     }
190    
191     psiconv_color clone_color(psiconv_color color)
192     {
193     psiconv_color result;
194 frodo 62 if (!(result = malloc(sizeof(*result))))
195     return NULL;
196 frodo 2 *result = *color;
197     return result;
198     }
199    
200     psiconv_font clone_font(psiconv_font font)
201     {
202     psiconv_font result;
203 frodo 62 if(!(result = malloc(sizeof(*result))))
204     goto ERROR1;
205 frodo 2 *result = *font;
206 frodo 184 if (!(result->name = psiconv_unicode_strdup(result->name)))
207 frodo 62 goto ERROR2;
208 frodo 2 return result;
209 frodo 62 ERROR2:
210     free(result);
211     ERROR1:
212     return NULL;
213 frodo 2 }
214    
215     psiconv_border clone_border(psiconv_border border)
216     {
217     psiconv_border result;
218 frodo 62 if (!(result = malloc(sizeof(*result))))
219     goto ERROR1;
220 frodo 2 *result = *border;
221 frodo 62 if(!(result->color = clone_color(result->color)))
222     goto ERROR2;
223 frodo 2 return result;
224 frodo 62 ERROR2:
225     free(result);
226     ERROR1:
227     return NULL;
228 frodo 2 }
229    
230     psiconv_bullet clone_bullet(psiconv_bullet bullet)
231     {
232     psiconv_bullet result;
233 frodo 62 if (!(result = malloc(sizeof(*result))))
234     goto ERROR1;
235 frodo 2 *result = *bullet;
236 frodo 62 if (!(result->font = clone_font(result->font)))
237     goto ERROR2;
238     if (!(result->color = clone_color(result->color)))
239     goto ERROR3;
240 frodo 2 return result;
241 frodo 62 ERROR3:
242     psiconv_free_font(result->font);
243     ERROR2:
244     free(result);
245     ERROR1:
246     return NULL;
247 frodo 2 }
248    
249     psiconv_all_tabs clone_all_tabs(psiconv_all_tabs all_tabs)
250     {
251     psiconv_all_tabs result;
252 frodo 62 if (!(result = malloc(sizeof(*result))))
253     goto ERROR1;
254 frodo 2 *result = *all_tabs;
255 frodo 62 if (!(result->extras = psiconv_list_clone(result->extras)))
256     goto ERROR2;
257 frodo 2 return result;
258 frodo 62 ERROR2:
259     free(result);
260     ERROR1:
261     return NULL;
262 frodo 2 }
263    
264     psiconv_character_layout psiconv_clone_character_layout
265     (psiconv_character_layout ls)
266     {
267     psiconv_character_layout result;
268    
269 frodo 62 if (!(result = malloc(sizeof(*result))))
270     goto ERROR1;
271 frodo 2 *result = *ls;
272 frodo 62 if (!(result->color = clone_color(result->color)))
273     goto ERROR2;
274     if (!(result->back_color = clone_color(result->back_color)))
275     goto ERROR3;
276     if (!(result->font = clone_font(result->font)))
277     goto ERROR4;
278 frodo 2 return result;
279 frodo 62 ERROR4:
280     psiconv_free_color(result->back_color);
281     ERROR3:
282     psiconv_free_color(result->color);
283     ERROR2:
284     free(result);
285     ERROR1:
286     return NULL;
287 frodo 2 }
288    
289     psiconv_paragraph_layout psiconv_clone_paragraph_layout
290     (psiconv_paragraph_layout ls)
291     {
292     psiconv_paragraph_layout result;
293    
294 frodo 62 if (!(result = malloc(sizeof(*result))))
295     goto ERROR1;
296 frodo 2 *result = *ls;
297 frodo 62 if (!(result->back_color = clone_color(result->back_color)))
298     goto ERROR2;
299     if (!(result->bullet = clone_bullet(result->bullet)))
300     goto ERROR3;
301     if (!(result->left_border = clone_border(result->left_border)))
302     goto ERROR4;
303     if (!(result->right_border = clone_border(result->right_border)))
304     goto ERROR5;
305     if (!(result->top_border = clone_border(result->top_border)))
306     goto ERROR6;
307     if (!(result->bottom_border = clone_border(result->bottom_border)))
308     goto ERROR7;
309     if (!(result->tabs = clone_all_tabs(result->tabs)))
310     goto ERROR8;
311 frodo 2 return result;
312 frodo 62 ERROR8:
313     psiconv_free_border(result->bottom_border);
314     ERROR7:
315     psiconv_free_border(result->top_border);
316     ERROR6:
317     psiconv_free_border(result->right_border);
318     ERROR5:
319     psiconv_free_border(result->left_border);
320     ERROR4:
321     psiconv_free_bullet(result->bullet);
322     ERROR3:
323     psiconv_free_color(result->back_color);
324     ERROR2:
325     free(result);
326     ERROR1:
327     return NULL;
328 frodo 2 }
329    
330     psiconv_word_style psiconv_get_style (psiconv_word_styles_section ss, int nr)
331     {
332     if (nr == 0)
333     return ss->normal;
334     else
335     return psiconv_list_get(ss->styles,0xff - nr);
336     }
337    
338 frodo 125 psiconv_formula psiconv_get_formula (psiconv_formula_list ss, int nr)
339     {
340     return psiconv_list_get(ss,psiconv_list_length(ss)-nr-1);
341     }
342    
343 frodo 128 /* TODO: What if a cell is both in a default row and a default column?!? */
344     psiconv_sheet_cell_layout psiconv_get_default_layout
345     (psiconv_sheet_line_list row_defaults,
346     psiconv_sheet_line_list col_defaults,
347     psiconv_sheet_cell_layout cell_default,
348     int row,int col)
349     {
350     int i;
351     psiconv_sheet_line line;
352     for (i = 0;i < psiconv_list_length(row_defaults);i++) {
353     line = psiconv_list_get(row_defaults,i);
354     if (line->position == row)
355     return line->layout;
356     }
357     for (i = 0;i < psiconv_list_length(col_defaults);i++) {
358     line = psiconv_list_get(col_defaults,i);
359     if (line->position == col)
360     return line->layout;
361     }
362     return cell_default;
363     }
364 frodo 125
365 frodo 128
366 frodo 2 void psiconv_free_color (psiconv_color color)
367     {
368     if (color)
369     free(color);
370     }
371    
372     void psiconv_free_border(psiconv_border border)
373     {
374     if (border) {
375     psiconv_free_color(border->color);
376     free(border);
377     }
378     }
379    
380     void psiconv_free_font(psiconv_font font)
381     {
382     if (font) {
383     if (font->name)
384     free(font->name);
385     free(font);
386     }
387     }
388    
389     void psiconv_free_bullet(psiconv_bullet bullet)
390     {
391     if (bullet) {
392     psiconv_free_color(bullet->color);
393     psiconv_free_font(bullet->font);
394     free(bullet);
395     }
396     }
397    
398     void psiconv_free_character_layout(psiconv_character_layout layout)
399     {
400     if (layout) {
401     psiconv_free_color(layout->color);
402     psiconv_free_color(layout->back_color);
403     psiconv_free_font(layout->font);
404     free(layout);
405     }
406     }
407    
408     void psiconv_free_tab(psiconv_tab tab)
409     {
410     if (tab)
411     free(tab);
412     }
413    
414     void psiconv_free_tabs(psiconv_all_tabs tabs)
415     {
416     if (tabs) {
417     psiconv_list_free(tabs->extras);
418     free(tabs);
419     }
420     }
421    
422     void psiconv_free_paragraph_layout(psiconv_paragraph_layout layout)
423     {
424     if (layout) {
425     psiconv_free_color(layout->back_color);
426     psiconv_free_bullet(layout->bullet);
427     psiconv_free_border(layout->left_border);
428     psiconv_free_border(layout->right_border);
429     psiconv_free_border(layout->top_border);
430     psiconv_free_border(layout->bottom_border);
431     psiconv_free_tabs(layout->tabs);
432     free(layout);
433     }
434     }
435    
436     void psiconv_free_style_aux(void *style)
437     {
438     if(((psiconv_word_style) style)->name)
439     free(((psiconv_word_style) style)->name);
440     psiconv_free_character_layout(((psiconv_word_style) style)->character);
441     psiconv_free_paragraph_layout(((psiconv_word_style) style)->paragraph);
442     }
443    
444     void psiconv_free_word_style(psiconv_word_style style)
445     {
446     if (style) {
447     psiconv_free_style_aux(style);
448     free(style);
449     }
450     }
451    
452     void psiconv_free_word_styles_section(psiconv_word_styles_section styles)
453     {
454     if (styles) {
455     psiconv_free_word_style(styles->normal);
456     if (styles->styles)
457     psiconv_list_free_el(styles->styles,psiconv_free_style_aux);
458 frodo 143 free(styles);
459 frodo 2 }
460     }
461    
462     void psiconv_free_header_section(psiconv_header_section header)
463     {
464     if (header)
465     free(header);
466     }
467    
468     void psiconv_free_section_table_entry(psiconv_section_table_entry entry)
469     {
470     if (entry)
471     free(entry);
472     }
473    
474     void psiconv_free_section_table_section(psiconv_section_table_section section)
475     {
476     if (section)
477     psiconv_list_free(section);
478     }
479    
480     void psiconv_free_application_id_section(psiconv_application_id_section section)
481     {
482     if (section) {
483     if (section->name)
484     free(section->name);
485     free(section);
486     }
487     }
488    
489 frodo 159 void psiconv_free_object_icon_section(psiconv_object_icon_section section)
490     {
491     if (section) {
492     if (section->icon_name)
493     free(section->icon_name);
494     free(section);
495     }
496     }
497    
498     void psiconv_free_object_display_section(psiconv_object_display_section section)
499     {
500     if (section)
501     free(section);
502     }
503    
504 frodo 167 void psiconv_free_embedded_object_section
505     (psiconv_embedded_object_section object)
506 frodo 159 {
507     if (object) {
508     psiconv_free_object_icon_section(object->icon);
509     psiconv_free_object_display_section(object->display);
510     psiconv_free_file(object->object);
511     free(object);
512     }
513     }
514    
515 frodo 2 void psiconv_free_in_line_layout_aux(void * layout)
516     {
517     psiconv_free_character_layout(((psiconv_in_line_layout) layout)->layout);
518 frodo 167 psiconv_free_embedded_object_section
519     (((psiconv_in_line_layout) layout)->object);
520 frodo 2 }
521    
522     void psiconv_free_in_line_layout(psiconv_in_line_layout layout)
523     {
524     if (layout) {
525     psiconv_free_in_line_layout_aux(layout);
526     free(layout);
527     }
528     }
529    
530     void psiconv_free_in_line_layouts(psiconv_in_line_layouts layouts)
531     {
532     if (layouts)
533     psiconv_list_free_el(layouts,&psiconv_free_in_line_layout_aux);
534     }
535    
536     void psiconv_free_replacement(psiconv_replacement replacement)
537     {
538     if (replacement)
539     free(replacement);
540     }
541    
542     void psiconv_free_replacements(psiconv_replacements replacements)
543     {
544     if (replacements)
545     psiconv_list_free(replacements);
546     }
547    
548     void psiconv_free_paragraph_aux(void * paragraph)
549     {
550     if(((psiconv_paragraph) paragraph)->text)
551     free(((psiconv_paragraph) paragraph)->text);
552     psiconv_free_character_layout(((psiconv_paragraph) paragraph)
553     ->base_character);
554     psiconv_free_paragraph_layout(((psiconv_paragraph) paragraph)
555     ->base_paragraph);
556     psiconv_free_in_line_layouts(((psiconv_paragraph) paragraph)
557     ->in_lines);
558     psiconv_free_replacements(((psiconv_paragraph) paragraph)
559     ->replacements);
560     }
561    
562     void psiconv_free_paragraph(psiconv_paragraph paragraph)
563     {
564     if (paragraph) {
565     psiconv_free_paragraph_aux(paragraph);
566     free(paragraph);
567     }
568     }
569    
570     void psiconv_free_text_and_layout(psiconv_text_and_layout text)
571     {
572     if (text)
573     psiconv_list_free_el(text,&psiconv_free_paragraph_aux);
574     }
575    
576     void psiconv_free_texted_section(psiconv_texted_section section)
577     {
578     if (section) {
579     psiconv_free_text_and_layout(section->paragraphs);
580     free(section);
581     }
582     }
583    
584     void psiconv_free_page_header(psiconv_page_header header)
585     {
586     if (header) {
587     psiconv_free_character_layout(header->base_character_layout);
588     psiconv_free_paragraph_layout(header->base_paragraph_layout);
589     psiconv_free_texted_section(header->text);
590     free(header);
591     }
592     }
593    
594     void psiconv_free_page_layout_section(psiconv_page_layout_section section)
595     {
596     if (section) {
597     psiconv_free_page_header(section->header);
598     psiconv_free_page_header(section->footer);
599     free(section);
600     }
601     }
602    
603     void psiconv_free_word_status_section(psiconv_word_status_section section)
604     {
605     if (section)
606     free(section);
607     }
608    
609     void psiconv_free_word_f(psiconv_word_f file)
610     {
611     if (file) {
612     psiconv_free_page_layout_section(file->page_sec);
613     psiconv_free_text_and_layout(file->paragraphs);
614     psiconv_free_word_status_section(file->status_sec);
615     psiconv_free_word_styles_section(file->styles_sec);
616     free(file);
617     }
618     }
619    
620 frodo 94 void psiconv_free_sheet_status_section(psiconv_sheet_status_section section)
621     {
622     if (section)
623     free(section);
624     }
625    
626 frodo 111 void psiconv_free_sheet_numberformat(psiconv_sheet_numberformat numberformat)
627 frodo 110 {
628     if (numberformat)
629     free(numberformat);
630     }
631    
632 frodo 111 void psiconv_free_sheet_cell_layout(psiconv_sheet_cell_layout layout)
633     {
634     psiconv_free_paragraph_layout(layout->paragraph);
635     psiconv_free_character_layout(layout->character);
636     psiconv_free_sheet_numberformat(layout->numberformat);
637     }
638    
639 frodo 121 void psiconv_free_sheet_cell_aux(void *cell)
640     {
641     psiconv_sheet_cell data = cell;
642    
643     psiconv_free_sheet_cell_layout(data->layout);
644    
645     if ((data->type == psiconv_cell_string) && (data->data.dat_string))
646     free(data->data.dat_string);
647     }
648    
649 frodo 110 void psiconv_free_sheet_cell(psiconv_sheet_cell cell)
650     {
651     if (cell) {
652 frodo 121 psiconv_free_sheet_cell_aux(cell);
653 frodo 111 free(cell);
654 frodo 110 }
655     }
656    
657     void psiconv_free_sheet_cell_list(psiconv_sheet_cell_list list)
658     {
659     if (list)
660     psiconv_list_free_el(list,psiconv_free_sheet_cell_aux);
661     }
662    
663 frodo 128 void psiconv_free_sheet_line_aux(void *line)
664     {
665     psiconv_sheet_line data = line;
666    
667     psiconv_free_sheet_cell_layout(data->layout);
668     }
669    
670     void psiconv_free_sheet_line(psiconv_sheet_line line)
671     {
672     if (line) {
673     psiconv_free_sheet_line_aux(line);
674     free(line);
675     }
676     }
677    
678 frodo 134
679 frodo 128 void psiconv_free_sheet_line_list(psiconv_sheet_line_list list)
680     {
681     if (list)
682     psiconv_list_free_el(list,psiconv_free_sheet_line_aux);
683     }
684    
685 frodo 134 void psiconv_free_sheet_grid_break_list(psiconv_sheet_grid_break_list list)
686     {
687     if (list)
688     psiconv_list_free(list);
689     }
690    
691     void psiconv_free_sheet_grid_size(psiconv_sheet_grid_size s)
692     {
693     if (s)
694     free(s);
695     }
696    
697     void psiconv_free_sheet_grid_size_list(psiconv_sheet_grid_size_list list)
698     {
699     if (list)
700     psiconv_list_free(list);
701     }
702    
703     void psiconv_free_sheet_grid_section(psiconv_sheet_grid_section sec)
704     {
705     if (sec) {
706     psiconv_free_sheet_grid_size_list(sec->row_heights);
707     psiconv_free_sheet_grid_size_list(sec->column_heights);
708     psiconv_free_sheet_grid_break_list(sec->row_page_breaks);
709     psiconv_free_sheet_grid_break_list(sec->column_page_breaks);
710     free(sec);
711     }
712     }
713    
714 frodo 111 void psiconv_free_sheet_worksheet_aux (void *data)
715 frodo 110 {
716 frodo 111 psiconv_sheet_worksheet section = data;
717     psiconv_free_sheet_cell_layout(section->default_layout);
718     psiconv_free_sheet_cell_list(section->cells);
719 frodo 128 psiconv_free_sheet_line_list(section->row_default_layouts);
720     psiconv_free_sheet_line_list(section->col_default_layouts);
721 frodo 134 psiconv_free_sheet_grid_section(section->grid);
722 frodo 111 }
723    
724     void psiconv_free_sheet_worksheet(psiconv_sheet_worksheet sheet)
725     {
726     if (sheet) {
727     psiconv_free_sheet_worksheet_aux(sheet);
728     free(sheet);
729 frodo 110 }
730     }
731    
732 frodo 111 void psiconv_free_sheet_worksheet_list(psiconv_sheet_worksheet_list list)
733     {
734     if (list)
735     psiconv_list_free_el(list,psiconv_free_sheet_worksheet_aux);
736     }
737    
738 frodo 99 void psiconv_free_formula_aux(void *data)
739     {
740     psiconv_formula formula;
741     formula = data;
742     if (formula->type == psiconv_formula_dat_string)
743     free(formula->data.dat_string);
744     else if ((formula->type != psiconv_formula_dat_int) &&
745     (formula->type != psiconv_formula_dat_var) &&
746     (formula->type != psiconv_formula_dat_float) &&
747     (formula->type != psiconv_formula_dat_cellref) &&
748     (formula->type != psiconv_formula_dat_cellblock) &&
749     (formula->type != psiconv_formula_dat_vcellblock) &&
750     (formula->type != psiconv_formula_mark_opsep) &&
751     (formula->type != psiconv_formula_mark_opend) &&
752     (formula->type != psiconv_formula_mark_eof) &&
753     (formula->type != psiconv_formula_unknown))
754     psiconv_free_formula_list(formula->data.fun_operands);
755     }
756    
757 frodo 98 void psiconv_free_formula(psiconv_formula formula)
758 frodo 97 {
759 frodo 99 if (formula) {
760     psiconv_free_formula_aux(formula);
761 frodo 97 free(formula);
762 frodo 99 }
763 frodo 97 }
764    
765 frodo 98 void psiconv_free_formula_list(psiconv_formula_list list)
766 frodo 97 {
767 frodo 99 if (list)
768     psiconv_list_free_el(list,psiconv_free_formula_aux);
769 frodo 97 }
770    
771 frodo 129 void psiconv_free_sheet_name_section(psiconv_sheet_name_section section)
772     {
773     if (section) {
774     if(section->name)
775     free(section->name);
776     free(section);
777     }
778     }
779    
780     void psiconv_free_sheet_info_section(psiconv_sheet_info_section section)
781     {
782     if (section) {
783     free(section);
784     }
785     }
786    
787     void psiconv_free_sheet_variable_aux(void * variable)
788     {
789     psiconv_sheet_variable var = variable;
790     if (var->name)
791     free(var->name);
792     if (var->type == psiconv_var_string)
793     free(var->data.dat_string);
794     }
795    
796     void psiconv_free_sheet_variable(psiconv_sheet_variable var)
797     {
798     if (var) {
799     psiconv_free_sheet_variable_aux(var);
800     free(var);
801     }
802     }
803    
804     void psiconv_free_sheet_variable_list(psiconv_sheet_variable_list list)
805     {
806     if (list)
807     psiconv_list_free_el(list,psiconv_free_sheet_variable_aux);
808     }
809    
810 frodo 95 void psiconv_free_sheet_workbook_section(psiconv_sheet_workbook_section section)
811     {
812 frodo 97 if (section) {
813 frodo 98 psiconv_free_formula_list(section->formulas);
814 frodo 121 psiconv_free_sheet_worksheet_list(section->worksheets);
815 frodo 129 psiconv_free_sheet_name_section(section->name);
816     psiconv_free_sheet_info_section(section->info);
817     psiconv_free_sheet_variable_list(section->variables);
818 frodo 95 free(section);
819 frodo 97 }
820 frodo 95 }
821    
822 frodo 94 void psiconv_free_sheet_f(psiconv_sheet_f file)
823     {
824     if (file) {
825     psiconv_free_page_layout_section(file->page_sec);
826     psiconv_free_sheet_status_section(file->status_sec);
827 frodo 95 psiconv_free_sheet_workbook_section(file->workbook_sec);
828 frodo 94 free(file);
829     }
830     }
831    
832 frodo 12 void psiconv_free_texted_f(psiconv_texted_f file)
833     {
834     if (file) {
835     psiconv_free_page_layout_section(file->page_sec);
836     psiconv_free_texted_section(file->texted_sec);
837     free(file);
838     }
839     }
840    
841     void psiconv_free_paint_data_section_aux(void * section)
842     {
843     if (((psiconv_paint_data_section) section)->red)
844     free(((psiconv_paint_data_section)section) -> red);
845     if (((psiconv_paint_data_section) section)->green)
846     free(((psiconv_paint_data_section)section) -> green);
847     if (((psiconv_paint_data_section) section)->blue)
848     free(((psiconv_paint_data_section)section) -> blue);
849     }
850    
851     void psiconv_free_paint_data_section(psiconv_paint_data_section section)
852     {
853     if (section) {
854     psiconv_free_paint_data_section_aux(section);
855     free(section);
856     }
857     }
858    
859     void psiconv_free_pictures(psiconv_pictures section)
860     {
861     if (section)
862     psiconv_list_free_el(section,&psiconv_free_paint_data_section_aux);
863     }
864    
865 frodo 42 void psiconv_free_jumptable_section (psiconv_jumptable_section section)
866 frodo 13 {
867     if (section)
868     psiconv_list_free(section);
869     }
870    
871 frodo 12 void psiconv_free_mbm_f(psiconv_mbm_f file)
872     {
873     if (file) {
874     psiconv_free_pictures(file->sections);
875     free(file);
876     }
877     }
878    
879 frodo 24 void psiconv_free_sketch_section(psiconv_sketch_section sec)
880     {
881     if (sec) {
882     psiconv_free_paint_data_section(sec->picture);
883     free(sec);
884     }
885     }
886    
887     void psiconv_free_sketch_f(psiconv_sketch_f file)
888     {
889     if (file) {
890     psiconv_free_sketch_section(file->sketch_sec);
891     free(file);
892     }
893     }
894    
895 frodo 42 void psiconv_free_clipart_section_aux(void *section)
896 frodo 41 {
897     if (section)
898 frodo 208 psiconv_free_paint_data_section(((psiconv_clipart_section) section)->picture);
899 frodo 41 }
900    
901     void psiconv_free_clipart_section(psiconv_clipart_section section)
902     {
903     if (section) {
904     psiconv_free_clipart_section_aux(section);
905     free(section);
906     }
907     }
908    
909     void psiconv_free_cliparts(psiconv_cliparts section)
910     {
911     if (section)
912     psiconv_list_free_el(section,&psiconv_free_clipart_section_aux);
913     }
914    
915     void psiconv_free_clipart_f(psiconv_clipart_f file)
916     {
917     if (file) {
918     psiconv_free_cliparts(file->sections);
919     free(file);
920     }
921     }
922    
923 frodo 2 void psiconv_free_file(psiconv_file file)
924     {
925     if (file) {
926     if (file->type == psiconv_word_file)
927     psiconv_free_word_f((psiconv_word_f) file->file);
928 frodo 12 else if (file->type == psiconv_texted_file)
929     psiconv_free_texted_f((psiconv_texted_f) file->file);
930     else if (file->type == psiconv_mbm_file)
931     psiconv_free_mbm_f((psiconv_mbm_f) file->file);
932 frodo 24 else if (file->type == psiconv_sketch_file)
933     psiconv_free_sketch_f((psiconv_sketch_f) file->file);
934 frodo 41 else if (file->type == psiconv_clipart_file)
935 frodo 42 psiconv_free_clipart_f((psiconv_clipart_f) file->file);
936 frodo 94 else if (file->type == psiconv_sheet_file)
937     psiconv_free_sheet_f((psiconv_sheet_f) file->file);
938 frodo 2 free(file);
939     }
940     }
941 frodo 78
942     int psiconv_compare_color(const psiconv_color value1,
943     const psiconv_color value2)
944     {
945     if (!value1 || !value2)
946     return 1;
947     if ((value1->red == value2->red) &&
948     (value1->green == value2->green) &&
949     (value1->blue == value2->blue))
950     return 0;
951     else
952     return 1;
953     }
954    
955     int psiconv_compare_font(const psiconv_font value1,
956     const psiconv_font value2)
957     {
958     if (!value1 || !value2 || !value1->name || !value2->name)
959     return 1;
960     if ((value1->screenfont == value2->screenfont) &&
961 frodo 184 !psiconv_unicode_strcmp(value1->name,value2->name))
962 frodo 78 return 0;
963     else
964     return 1;
965     }
966    
967     int psiconv_compare_border(const psiconv_border value1,
968     const psiconv_border value2)
969     {
970     if (!value1 || !value2)
971     return 1;
972     if ((value1->kind == value2->kind) &&
973     (value1->thickness == value2->thickness) &&
974     !psiconv_compare_color(value1->color,value2->color))
975     return 0;
976     else
977     return 1;
978     }
979    
980     int psiconv_compare_bullet(const psiconv_bullet value1,
981     const psiconv_bullet value2)
982     {
983     if (!value1 || !value2)
984     return 1;
985     if ((value1->on == value2->on) &&
986     (value1->font_size == value2->font_size) &&
987     (value1->character == value2->character) &&
988     (value1->indent == value2->indent) &&
989     !psiconv_compare_color(value1->color,value2->color) &&
990     !psiconv_compare_font(value1->font,value2->font))
991     return 0;
992     else
993     return 1;
994     }
995    
996     int psiconv_compare_tab(const psiconv_tab value1, const psiconv_tab value2)
997     {
998     if (!value1 || !value2)
999     return 1;
1000     if ((value1->location == value2->location) &&
1001     (value1->kind == value2->kind))
1002     return 0;
1003     else
1004     return 1;
1005     }
1006    
1007     int psiconv_compare_all_tabs(const psiconv_all_tabs value1,
1008     const psiconv_all_tabs value2)
1009     {
1010     int i;
1011    
1012     if (!value1 || !value2 || !value1->extras || !value2->extras)
1013     return 1;
1014    
1015     if ((value1->normal != value2->normal) ||
1016     psiconv_list_length(value1->extras) !=
1017     psiconv_list_length(value2->extras))
1018     return 1;
1019     for (i = 0; i < psiconv_list_length(value1->extras); i++)
1020     if (psiconv_compare_tab(psiconv_list_get(value1->extras,i),
1021     psiconv_list_get(value2->extras,i)))
1022    
1023     return 1;
1024     return 0;
1025     }
1026    
1027     int psiconv_compare_paragraph_layout(const psiconv_paragraph_layout value1,
1028     const psiconv_paragraph_layout value2)
1029     {
1030     if (!value1 || !value2)
1031     return 1;
1032     if ((value1->indent_left == value2->indent_left) &&
1033     (value1->indent_right == value2->indent_right) &&
1034     (value1->indent_first == value2->indent_first) &&
1035     (value1->justify_hor == value2->justify_hor) &&
1036     (value1->justify_ver == value2->justify_ver) &&
1037     (value1->linespacing == value2->linespacing) &&
1038     (value1->space_above == value2->space_above) &&
1039     (value1->space_below == value2->space_below) &&
1040     (value1->keep_together == value2->keep_together) &&
1041     (value1->keep_with_next == value2->keep_with_next) &&
1042     (value1->on_next_page == value2->on_next_page) &&
1043     (value1->no_widow_protection == value2->no_widow_protection) &&
1044     (value1->border_distance == value2->border_distance) &&
1045     !psiconv_compare_color(value1->back_color,value2->back_color) &&
1046     !psiconv_compare_bullet(value1->bullet,value2->bullet) &&
1047     !psiconv_compare_border(value1->left_border,value2->left_border) &&
1048     !psiconv_compare_border(value1->right_border,value2->right_border) &&
1049     !psiconv_compare_border(value1->top_border,value2->top_border) &&
1050     !psiconv_compare_border(value1->bottom_border,value2->bottom_border) &&
1051     !psiconv_compare_all_tabs(value1->tabs,value2->tabs))
1052     return 0;
1053     else
1054     return 1;
1055     }
1056    
1057    
1058     int psiconv_compare_character_layout(const psiconv_character_layout value1,
1059     const psiconv_character_layout value2)
1060     {
1061     if (!value1 || !value2)
1062     return 1;
1063     if ((value1->font_size == value2->font_size) &&
1064     (value1->italic == value2->italic) &&
1065     (value1->bold == value2->bold) &&
1066     (value1->super_sub == value2->super_sub) &&
1067     (value1->underline == value2->underline) &&
1068     (value1->strikethrough == value2->strikethrough) &&
1069     !psiconv_compare_color(value1->color,value2->color) &&
1070     !psiconv_compare_color(value1->back_color,value2->back_color) &&
1071     !psiconv_compare_font(value1->font,value2->font))
1072     return 0;
1073     else
1074     return 1;
1075     }
1076 frodo 87
1077    
1078    
1079     psiconv_word_styles_section psiconv_empty_word_styles_section(void)
1080     {
1081     psiconv_word_styles_section result;
1082     if (!(result = malloc(sizeof(*result))))
1083     goto ERROR1;
1084     if (!(result->styles = psiconv_list_new(sizeof(struct psiconv_word_style_s))))
1085     goto ERROR2;
1086     if (!(result->normal = malloc(sizeof(struct psiconv_word_style_s))))
1087     goto ERROR3;
1088     if (!(result->normal->character = psiconv_basic_character_layout()))
1089     goto ERROR4;
1090     if (!(result->normal->paragraph = psiconv_basic_paragraph_layout()))
1091     goto ERROR5;
1092     result->normal->hotkey = 'N';
1093     result->normal->name = NULL;
1094     result->normal->built_in = psiconv_bool_true;
1095     result->normal->outline_level = 0;
1096     return result;
1097     ERROR5:
1098     psiconv_free_character_layout(result->normal->character);
1099     ERROR4:
1100     free(result->normal);
1101     ERROR3:
1102     psiconv_list_free(result->styles);
1103     ERROR2:
1104     free(result);
1105     ERROR1:
1106     return NULL;
1107     }
1108    
1109     psiconv_text_and_layout psiconv_empty_text_and_layout(void)
1110     {
1111     return psiconv_list_new(sizeof(struct psiconv_paragraph_s));
1112     }
1113    
1114     psiconv_texted_section psiconv_empty_texted_section(void)
1115     {
1116     psiconv_texted_section result;
1117     if (!(result = malloc(sizeof(*result))))
1118     goto ERROR1;
1119     if (!(result->paragraphs = psiconv_empty_text_and_layout()))
1120     goto ERROR2;
1121     return result;
1122     ERROR2:
1123     free(result);
1124     ERROR1:
1125     return NULL;
1126     }
1127    
1128     psiconv_page_header psiconv_empty_page_header(void)
1129     {
1130     psiconv_page_header result;
1131     if (!(result = malloc(sizeof(*result))))
1132     goto ERROR1;
1133     result->on_first_page = psiconv_bool_true;
1134     if (!(result->base_paragraph_layout = psiconv_basic_paragraph_layout()))
1135     goto ERROR2;
1136     if (!(result->base_character_layout = psiconv_basic_character_layout()))
1137     goto ERROR3;
1138     if (!(result->text = psiconv_empty_texted_section()))
1139     goto ERROR4;
1140     return result;
1141     ERROR4:
1142     psiconv_free_character_layout(result->base_character_layout);
1143     ERROR3:
1144     psiconv_free_paragraph_layout(result->base_paragraph_layout);
1145     ERROR2:
1146     free(result);
1147     ERROR1:
1148     return NULL;
1149     }
1150    
1151     psiconv_page_layout_section psiconv_empty_page_layout_section(void)
1152     {
1153     psiconv_page_layout_section result;
1154     if (!(result = malloc(sizeof(*result))))
1155     goto ERROR1;
1156 frodo 88 result->first_page_nr = 1;
1157 frodo 87 result->header_dist = result->footer_dist = 1.27;
1158     result->left_margin = result->right_margin = 3.175;
1159     result->top_margin = result->bottom_margin = 2.54;
1160     result->page_width = 21.0;
1161     result->page_height = 29.7;
1162     result->landscape = psiconv_bool_false;
1163     if (!(result->header = psiconv_empty_page_header()))
1164     goto ERROR2;
1165     if (!(result->footer = psiconv_empty_page_header()))
1166     goto ERROR3;
1167     return result;
1168     ERROR3:
1169     psiconv_free_page_header(result->header);
1170     ERROR2:
1171     free(result);
1172     ERROR1:
1173     return NULL;
1174     }
1175    
1176     psiconv_word_status_section psiconv_empty_word_status_section(void)
1177     {
1178     psiconv_word_status_section result;
1179     if (!(result = malloc(sizeof(*result))))
1180     return NULL;
1181     result->show_tabs = result->show_spaces = result->show_paragraph_ends =
1182     result->show_hard_minus = result->show_hard_space =
1183     result->fit_lines_to_screen = psiconv_bool_false;
1184     result->show_full_pictures = result->show_full_graphs =
1185     result->show_top_toolbar = result->show_side_toolbar =
1186     psiconv_bool_true;
1187     result->cursor_position = 0;
1188     result->display_size = 1000;
1189     return result;
1190     }
1191    
1192     psiconv_word_f psiconv_empty_word_f(void)
1193     {
1194     psiconv_word_f result;
1195     if (!(result = malloc(sizeof(*result))))
1196     goto ERROR1;
1197     if (!(result->page_sec = psiconv_empty_page_layout_section()))
1198     goto ERROR2;
1199     if (!(result->paragraphs = psiconv_empty_text_and_layout()))
1200     goto ERROR3;
1201     if (!(result->status_sec = psiconv_empty_word_status_section()))
1202     goto ERROR4;
1203     if (!(result->styles_sec = psiconv_empty_word_styles_section()))
1204     goto ERROR5;
1205     return result;
1206     ERROR5:
1207     psiconv_free_word_status_section(result->status_sec);
1208     ERROR4:
1209     psiconv_free_text_and_layout(result->paragraphs);
1210     ERROR3:
1211     psiconv_free_page_layout_section(result->page_sec);
1212     ERROR2:
1213     free(result);
1214     ERROR1:
1215     return NULL;
1216     }
1217    
1218 frodo 94 psiconv_sheet_status_section psiconv_empty_sheet_status_section(void)
1219     {
1220     psiconv_sheet_status_section result;
1221     if (!(result = malloc(sizeof(*result))))
1222     return NULL;
1223     result->show_horizontal_scrollbar = result->show_vertical_scrollbar =
1224     psiconv_triple_auto;
1225     result->show_graph = psiconv_bool_false;
1226     result->show_top_sheet_toolbar = result->show_side_sheet_toolbar =
1227     result->show_top_graph_toolbar = result->show_side_graph_toolbar =
1228     psiconv_bool_true;
1229     result->cursor_row = result->cursor_column = 0;
1230     result->sheet_display_size = result->graph_display_size = 1000;
1231     return result;
1232     }
1233    
1234 frodo 98 psiconv_formula_list psiconv_empty_formula_list(void)
1235 frodo 97 {
1236 frodo 98 return psiconv_list_new(sizeof(struct psiconv_formula_s));
1237 frodo 97 }
1238    
1239 frodo 95 psiconv_sheet_workbook_section psiconv_empty_sheet_workbook_section(void)
1240     {
1241     psiconv_sheet_workbook_section result;
1242     if (!(result = malloc(sizeof(*result))))
1243 frodo 97 goto ERROR1;
1244 frodo 98 if (!(result->formulas = psiconv_empty_formula_list()))
1245 frodo 97 goto ERROR2;
1246 frodo 95 return result;
1247 frodo 97 ERROR2:
1248     free(result);
1249     ERROR1:
1250     return NULL;
1251 frodo 95 }
1252    
1253 frodo 97
1254 frodo 94 psiconv_sheet_f psiconv_empty_sheet_f(void)
1255     {
1256     psiconv_sheet_f result;
1257     if (!(result = malloc(sizeof(*result))))
1258     goto ERROR1;
1259     if (!(result->page_sec = psiconv_empty_page_layout_section()))
1260     goto ERROR2;
1261     if (!(result->status_sec = psiconv_empty_sheet_status_section()))
1262     goto ERROR3;
1263 frodo 95 if (!(result->workbook_sec = psiconv_empty_sheet_workbook_section()))
1264     goto ERROR4;
1265 frodo 94 return result;
1266 frodo 95 ERROR4:
1267     psiconv_free_sheet_status_section(result->status_sec);
1268 frodo 94 ERROR3:
1269     psiconv_free_page_layout_section(result->page_sec);
1270     ERROR2:
1271     free(result);
1272     ERROR1:
1273     return NULL;
1274     }
1275    
1276 frodo 87 psiconv_texted_f psiconv_empty_texted_f(void)
1277     {
1278     psiconv_texted_f result;
1279     if (!(result = malloc(sizeof(*result))))
1280     goto ERROR1;
1281     if (!(result->page_sec = psiconv_empty_page_layout_section()))
1282     goto ERROR2;
1283     if (!(result->texted_sec = psiconv_empty_texted_section()))
1284     goto ERROR3;
1285     return result;
1286     ERROR3:
1287     psiconv_free_page_layout_section(result->page_sec);
1288     ERROR2:
1289     free(result);
1290     ERROR1:
1291     return NULL;
1292     }
1293    
1294     psiconv_paint_data_section psiconv_empty_paint_data_section(void)
1295     {
1296     psiconv_paint_data_section result;
1297     if (!(result = malloc(sizeof(*result))))
1298     goto ERROR1;
1299     /* Is this correct? */
1300     result->xsize = result->ysize = result->pic_xsize = result->pic_ysize = 0;
1301     /* Probably forbidden... */
1302     if (!(result->red = malloc(0)))
1303     goto ERROR2;
1304     if (!(result->green = malloc(0)))
1305     goto ERROR3;
1306     if (!(result->blue = malloc(0)))
1307     goto ERROR4;
1308     return result;
1309     ERROR4:
1310     free(result->green);
1311     ERROR3:
1312     free(result->red);
1313     ERROR2:
1314     free(result);
1315     ERROR1:
1316     return NULL;
1317     }
1318    
1319    
1320     psiconv_pictures psiconv_empty_pictures(void)
1321     {
1322     psiconv_pictures result;
1323     psiconv_paint_data_section pds;
1324     if (!(result = psiconv_list_new(sizeof(struct psiconv_paint_data_section_s))))
1325     goto ERROR1;
1326     if (!(pds = psiconv_empty_paint_data_section()))
1327     goto ERROR2;
1328     if (psiconv_list_add(result,pds))
1329     goto ERROR3;
1330     free(pds);
1331     return result;
1332     ERROR3:
1333     psiconv_free_paint_data_section(pds);
1334     ERROR2:
1335     psiconv_list_free(result);
1336     ERROR1:
1337     return NULL;
1338     }
1339    
1340     psiconv_mbm_f psiconv_empty_mbm_f(void)
1341     {
1342     psiconv_mbm_f result;
1343     if (!(result = malloc(sizeof(*result))))
1344     goto ERROR1;
1345     if (!(result->sections = psiconv_empty_pictures()))
1346     goto ERROR2;
1347     return result;
1348     ERROR2:
1349     free(result);
1350     ERROR1:
1351     return NULL;
1352     }
1353    
1354     psiconv_sketch_section psiconv_empty_sketch_section(void)
1355     {
1356     psiconv_sketch_section result;
1357     if (!(result = malloc(sizeof(*result))))
1358     goto ERROR1;
1359 frodo 163 result->displayed_xsize = 320;
1360     result->displayed_ysize = 200;
1361     result->picture_data_x_offset = result->picture_data_y_offset =
1362     result->form_xsize = result->form_ysize =
1363     result->displayed_size_x_offset = result->displayed_size_y_offset = 0;
1364 frodo 87 result->magnification_x = result->magnification_y = 1.0;
1365     result->cut_left = result->cut_right = result->cut_top =
1366     result->cut_bottom = 0.0;
1367     if (!(result->picture = psiconv_empty_paint_data_section()))
1368     goto ERROR2;
1369     return result;
1370     ERROR2:
1371     free(result);
1372     ERROR1:
1373     return NULL;
1374     }
1375    
1376     psiconv_sketch_f psiconv_empty_sketch_f(void)
1377     {
1378     psiconv_sketch_f result;
1379     if (!(result = malloc(sizeof(*result))))
1380     goto ERROR1;
1381     if (!(result->sketch_sec = psiconv_empty_sketch_section()))
1382     goto ERROR2;
1383     return result;
1384     ERROR2:
1385     free(result);
1386     ERROR1:
1387     return NULL;
1388     }
1389    
1390     psiconv_cliparts psiconv_empty_cliparts(void)
1391     {
1392     /* Is this correct? */
1393     return psiconv_list_new(sizeof(struct psiconv_clipart_section_s));
1394     }
1395    
1396     psiconv_clipart_f psiconv_empty_clipart_f(void)
1397     {
1398     psiconv_clipart_f result;
1399     if (!(result = malloc(sizeof(*result))))
1400     goto ERROR1;
1401     if (!(result->sections = psiconv_empty_cliparts()))
1402     goto ERROR2;
1403     return result;
1404     ERROR2:
1405     free(result);
1406     ERROR1:
1407     return NULL;
1408     }
1409    
1410     psiconv_file psiconv_empty_file(psiconv_file_type_t type)
1411     {
1412     psiconv_file result;
1413     if (!(result = malloc(sizeof(*result))))
1414     return NULL;
1415     result->type = type;
1416     if (type == psiconv_word_file) {
1417     if (!(result->file = psiconv_empty_word_f()))
1418     goto ERROR;
1419 frodo 94 } else if (type == psiconv_sheet_file) {
1420     if (!(result->file = psiconv_empty_sheet_f()))
1421     goto ERROR;
1422 frodo 87 } else if (type == psiconv_texted_file) {
1423     if (!(result->file = psiconv_empty_texted_f()))
1424     goto ERROR;
1425     } else if (type == psiconv_mbm_file) {
1426     if (!(result->file = psiconv_empty_mbm_f()))
1427     goto ERROR;
1428     } else if (type == psiconv_sketch_file) {
1429     if (!(result->file = psiconv_empty_sketch_f()))
1430     goto ERROR;
1431     } else if (type == psiconv_clipart_file) {
1432     if (!(result->file = psiconv_empty_clipart_f()))
1433     goto ERROR;
1434     } else
1435     goto ERROR;
1436     return result;
1437     ERROR:
1438     free(result);
1439     return NULL;
1440     }

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