/[public]/psiconv/trunk/lib/psiconv/parse_sheet.c

Diff of /psiconv/trunk/lib/psiconv/parse_sheet.c

Parent Directory | Revision Log | View Patch Patch

Revision 129		Revision 168
…		…
22		22
23	#include <stdlib.h>	23	#include <stdlib.h>
24		24
25	#include "parse_routines.h"	25	#include "parse_routines.h"
26	#include "error.h"	26	#include "error.h"
		27
		28	#ifdef DMALLOC
		29	#include <dmalloc.h>
		30	#endif
27		31
28	static psiconv_sheet_cell_layout psiconv_basic_cell_layout(void)	32	static psiconv_sheet_cell_layout psiconv_basic_cell_layout(void)
29	{	33	{
30	psiconv_sheet_cell_layout result;	34	psiconv_sheet_cell_layout result;
31	if (!(result = malloc(sizeof(*result))))	35	if (!(result = malloc(sizeof(*result))))
…		…
75	ERROR1:	79	ERROR1:
76	return NULL;	80	return NULL;
77	}	81	}
78		82
79	static psiconv_sheet_cell_reference_t	83	static psiconv_sheet_cell_reference_t
80	psiconv_read_var_cellref (const psiconv_buffer buf, int lev,	84	psiconv_read_var_cellref (const psiconv_config config,
		85	const psiconv_buffer buf, int lev,
81	psiconv_u32 off, int *length,	86	psiconv_u32 off, int *length,
82	int *status)	87	int *status)
83	{	88	{
84	int len=0;	89	int len=0;
85	int res;	90	int res;
86	psiconv_sheet_cell_reference_t result;	91	psiconv_sheet_cell_reference_t result;
87	psiconv_u32 temp;	92	psiconv_u32 temp;
88		93
89	psiconv_progress(lev+1,off+len,"Going to read a sheet cell reference");	94	psiconv_progress(config,lev+1,off+len,"Going to read a sheet cell reference");
90	psiconv_progress(lev+2,off+len,	95	psiconv_progress(config,lev+2,off+len,
91	"Going to read the initial byte (%02x expected)",0x00);	96	"Going to read the initial byte (%02x expected)",0x00);
92	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	97	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
93	if (res)	98	if (res)
94	goto ERROR1;	99	goto ERROR1;
95	if (temp != 0x00) {	100	if (temp != 0x00) {
96	psiconv_warn(lev+2,off+len,	101	psiconv_warn(config,lev+2,off+len,
97	"Sheet cell reference initial byte unknown value (ignored)");	102	"Sheet cell reference initial byte unknown value (ignored)");
98	psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);	103	psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
99	}	104	}
100	len ++;	105	len ++;
101		106
102	temp = psiconv_read_u32(buf,lev+2,off+len,&res);	107	temp = psiconv_read_u32(config,buf,lev+2,off+len,&res);
103	if (res)	108	if (res)
104	goto ERROR1;	109	goto ERROR1;
105	if (temp & 0xffff0000) {	110	if (temp & 0xffff0000) {
106	psiconv_warn(lev+2,off+len,	111	psiconv_warn(config,lev+2,off+len,
107	"Sheet cell row reference to unknown row (reset)");	112	"Sheet cell row reference to unknown row (reset)");
108	}	113	}
109	result.row.offset = temp;	114	result.row.offset = temp;
110	result.row.absolute = psiconv_bool_true;	115	result.row.absolute = psiconv_bool_true;
111	len += 4;	116	len += 4;
112		117
113	temp = psiconv_read_u32(buf,lev+2,off+len,&res);	118	temp = psiconv_read_u32(config,buf,lev+2,off+len,&res);
114	if (res)	119	if (res)
115	goto ERROR1;	120	goto ERROR1;
116	if (temp & 0xffff0000) {	121	if (temp & 0xffff0000) {
117	psiconv_warn(lev+2,off+len,	122	psiconv_warn(config,lev+2,off+len,
118	"Sheet cell column reference to unknown row (reset)");	123	"Sheet cell column reference to unknown row (reset)");
119	}	124	}
120	result.column.offset = temp;	125	result.column.offset = temp;
121	result.column.absolute = psiconv_bool_true;	126	result.column.absolute = psiconv_bool_true;
122	len += 4;	127	len += 4;
123		128
124	if (length)	129	if (length)
125	*length = len;	130	*length = len;
126		131
127	psiconv_progress(lev,off+len-1,	132	psiconv_progress(config,lev,off+len-1,
128	"End of sheet column reference (total length: %08x)", len);	133	"End of sheet column reference (total length: %08x)", len);
129	return result;	134	return result;
130	ERROR1:	135	ERROR1:
131	psiconv_warn(lev+1,off,"Reading of Sheet Column Reference failed");	136	psiconv_warn(config,lev+1,off,"Reading of Sheet Column Reference failed");
132	if (length)	137	if (length)
133	*length = 0;	138	*length = 0;
134	if (status)	139	if (status)
135	*status = res?res:-PSICONV_E_NOMEM;	140	*status = res?res:-PSICONV_E_NOMEM;
136	return result;	141	return result;
137	}	142	}
138		143
139	static psiconv_sheet_cell_block_t	144	static psiconv_sheet_cell_block_t
140	psiconv_read_var_cellblock (const psiconv_buffer buf, int lev,	145	psiconv_read_var_cellblock (const psiconv_config config,
		146	const psiconv_buffer buf, int lev,
141	psiconv_u32 off, int *length,	147	psiconv_u32 off, int *length,
142	int *status)	148	int *status)
143	{	149	{
144	int len=0;	150	int len=0;
145	int res;	151	int res;
146	psiconv_sheet_cell_block_t result;	152	psiconv_sheet_cell_block_t result;
147	psiconv_u32 temp;	153	psiconv_u32 temp;
148		154
149	psiconv_progress(lev+1,off+len,"Going to read a sheet cell block reference");	155	psiconv_progress(config,lev+1,off+len,"Going to read a sheet cell block reference");
150	psiconv_progress(lev+2,off+len,	156	psiconv_progress(config,lev+2,off+len,
151	"Going to read the initial byte (%02x expected)",0x00);	157	"Going to read the initial byte (%02x expected)",0x00);
152	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	158	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
153	if (res)	159	if (res)
154	goto ERROR1;	160	goto ERROR1;
155	if (temp != 0x00) {	161	if (temp != 0x00) {
156	psiconv_warn(lev+2,off+len,	162	psiconv_warn(config,lev+2,off+len,
157	"Sheet cell reference initial byte unknown value (ignored)");	163	"Sheet cell reference initial byte unknown value (ignored)");
158	psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);	164	psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
159	}	165	}
160	len ++;	166	len ++;
161		167
162	temp = psiconv_read_u32(buf,lev+2,off+len,&res);	168	temp = psiconv_read_u32(config,buf,lev+2,off+len,&res);
163	if (res)	169	if (res)
164	goto ERROR1;	170	goto ERROR1;
165	if (temp & 0xffff0000) {	171	if (temp & 0xffff0000) {
166	psiconv_warn(lev+2,off+len,	172	psiconv_warn(config,lev+2,off+len,
167	"Sheet block initial row reference to unknown row (reset)");	173	"Sheet block initial row reference to unknown row (reset)");
168	}	174	}
169	result.first.row.offset = temp;	175	result.first.row.offset = temp;
170	result.first.row.absolute = psiconv_bool_true;	176	result.first.row.absolute = psiconv_bool_true;
171	len += 4;	177	len += 4;
172		178
173	temp = psiconv_read_u32(buf,lev+2,off+len,&res);	179	temp = psiconv_read_u32(config,buf,lev+2,off+len,&res);
174	if (res)	180	if (res)
175	goto ERROR1;	181	goto ERROR1;
176	if (temp & 0xffff0000) {	182	if (temp & 0xffff0000) {
177	psiconv_warn(lev+2,off+len,	183	psiconv_warn(config,lev+2,off+len,
178	"Sheet block initial column reference to unknown row (reset)");	184	"Sheet block initial column reference to unknown row (reset)");
179	}	185	}
180	result.first.column.offset = temp;	186	result.first.column.offset = temp;
181	result.first.column.absolute = psiconv_bool_true;	187	result.first.column.absolute = psiconv_bool_true;
182	len += 4;	188	len += 4;
183		189
184	temp = psiconv_read_u32(buf,lev+2,off+len,&res);	190	temp = psiconv_read_u32(config,buf,lev+2,off+len,&res);
185	if (res)	191	if (res)
186	goto ERROR1;	192	goto ERROR1;
187	if (temp & 0xffff0000) {	193	if (temp & 0xffff0000) {
188	psiconv_warn(lev+2,off+len,	194	psiconv_warn(config,lev+2,off+len,
189	"Sheet block final row reference to unknown row (reset)");	195	"Sheet block final row reference to unknown row (reset)");
190	}	196	}
191	result.last.row.offset = temp;	197	result.last.row.offset = temp;
192	result.last.row.absolute = psiconv_bool_true;	198	result.last.row.absolute = psiconv_bool_true;
193	len += 4;	199	len += 4;
194		200
195	temp = psiconv_read_u32(buf,lev+2,off+len,&res);	201	temp = psiconv_read_u32(config,buf,lev+2,off+len,&res);
196	if (res)	202	if (res)
197	goto ERROR1;	203	goto ERROR1;
198	if (temp & 0xffff0000) {	204	if (temp & 0xffff0000) {
199	psiconv_warn(lev+2,off+len,	205	psiconv_warn(config,lev+2,off+len,
200	"Sheet block final column reference to unknown row (reset)");	206	"Sheet block final column reference to unknown row (reset)");
201	}	207	}
202	result.last.column.offset = temp;	208	result.last.column.offset = temp;
203	result.last.column.absolute = psiconv_bool_true;	209	result.last.column.absolute = psiconv_bool_true;
204	len += 4;	210	len += 4;
205		211
206	if (length)	212	if (length)
207	*length = len;	213	*length = len;
208		214
209	psiconv_progress(lev,off+len-1,	215	psiconv_progress(config,lev,off+len-1,
210	"End of sheet cell block reference (total length: %08x)",	216	"End of sheet cell block reference (total length: %08x)",
211	len);	217	len);
212	return result;	218	return result;
213	ERROR1:	219	ERROR1:
214	psiconv_warn(lev+1,off,"Reading of Sheet Cell Block Reference failed");	220	psiconv_warn(config,lev+1,off,"Reading of Sheet Cell Block Reference failed");
215	if (length)	221	if (length)
216	*length = 0;	222	*length = 0;
217	if (status)	223	if (status)
218	*status = res?res:-PSICONV_E_NOMEM;	224	*status = res?res:-PSICONV_E_NOMEM;
219	return result;	225	return result;
220	}	226	}
221		227
222	int psiconv_parse_sheet_numberformat(const psiconv_buffer buf, int lev,	228	int psiconv_parse_sheet_numberformat(const psiconv_config config,
		229	const psiconv_buffer buf, int lev,
223	psiconv_u32 off, int *length,	230	psiconv_u32 off, int *length,
224	psiconv_sheet_numberformat result)	231	psiconv_sheet_numberformat result)
225	{	232	{
226	int res=0;	233	int res=0;
227	int len=0;	234	int len=0;
228	psiconv_u8 temp;	235	psiconv_u8 temp;
229		236
230	psiconv_progress(lev+1,off,"Going to read a sheet numberformat");	237	psiconv_progress(config,lev+1,off,"Going to read a sheet numberformat");
231		238
232	psiconv_progress(lev+2,off+len,	239	psiconv_progress(config,lev+2,off+len,
233	"Going to read the initial byte (%02x expected)",0x02);	240	"Going to read the initial byte (%02x expected)",0x02);
234	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	241	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
235	if (res)	242	if (res)
236	goto ERROR1;	243	goto ERROR1;
237	if (temp != 0x02) {	244	if (temp != 0x02) {
238	psiconv_warn(lev+2,off+len,	245	psiconv_warn(config,lev+2,off+len,
239	"Sheet numberformat initial byte unknown value (ignored)");	246	"Sheet numberformat initial byte unknown value (ignored)");
240	psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);	247	psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
241	}	248	}
242	len ++;	249	len ++;
243		250
244	psiconv_progress(lev+2,off+len, "Going to read the code byte");	251	psiconv_progress(config,lev+2,off+len, "Going to read the code byte");
245	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	252	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
246	if (res)	253	if (res)
247	goto ERROR1;	254	goto ERROR1;
248	psiconv_debug(lev+2,off+len,"Code: %02x",temp);	255	psiconv_debug(config,lev+2,off+len,"Code: %02x",temp);
249	if (temp == 0x00)	256	if (temp == 0x00)
250	result->code = psiconv_numberformat_general;	257	result->code = psiconv_numberformat_general;
251	else if (temp == 0x02)	258	else if (temp == 0x02)
252	result->code = psiconv_numberformat_fixeddecimal;	259	result->code = psiconv_numberformat_fixeddecimal;
253	else if (temp == 0x04)	260	else if (temp == 0x04)
…		…
307	else if (temp == 0x3A)	314	else if (temp == 0x3A)
308	result->code = psiconv_numberformat_time_HHii;	315	result->code = psiconv_numberformat_time_HHii;
309	else if (temp == 0x3C)	316	else if (temp == 0x3C)
310	result->code = psiconv_numberformat_time_HHiiss;	317	result->code = psiconv_numberformat_time_HHiiss;
311	else {	318	else {
312	psiconv_warn(lev+2,off+len,"Unknown number format (assumed general)");	319	psiconv_warn(config,lev+2,off+len,"Unknown number format (assumed general)");
313	result->code = psiconv_numberformat_general;	320	result->code = psiconv_numberformat_general;
314	}	321	}
315	len ++;	322	len ++;
316		323
317	psiconv_progress(lev+2,off+len, "Going to read the number of decimals");	324	psiconv_progress(config,lev+2,off+len, "Going to read the number of decimals");
318	result->decimal = psiconv_read_u8(buf,lev+2,off+len,&res) >> 1;	325	result->decimal = psiconv_read_u8(config,buf,lev+2,off+len,&res) >> 1;
319	if (res)	326	if (res)
320	goto ERROR1;	327	goto ERROR1;
321	psiconv_debug(lev+2,off+len,"Decimals: %d",result->decimal);	328	psiconv_debug(config,lev+2,off+len,"Decimals: %d",result->decimal);
322	len ++;	329	len ++;
323		330
324	if (length)	331	if (length)
325	*length = len;	332	*length = len;
326		333
327	psiconv_progress(lev,off+len-1,	334	psiconv_progress(config,lev,off+len-1,
328	"End of sheet number format (total length: %08x)", len);	335	"End of sheet number format (total length: %08x)", len);
329	return 0;	336	return 0;
330		337
331	ERROR1:	338	ERROR1:
332	psiconv_warn(lev+1,off,"Reading of Sheet Number Format failed");	339	psiconv_warn(config,lev+1,off,"Reading of Sheet Number Format failed");
333	if (length)	340	if (length)
334	*length = 0;	341	*length = 0;
335	if (!res)	342	if (!res)
336	return -PSICONV_E_NOMEM;	343	return -PSICONV_E_NOMEM;
337	else	344	else
338	return res;	345	return res;
339	}	346	}
340		347
341	int psiconv_parse_sheet_status_section(const psiconv_buffer buf, int lev,	348	int psiconv_parse_sheet_status_section(const psiconv_config config,
		349	const psiconv_buffer buf, int lev,
342	psiconv_u32 off, int *length,	350	psiconv_u32 off, int *length,
343	psiconv_sheet_status_section *result)	351	psiconv_sheet_status_section *result)
344	{	352	{
345	int res=0;	353	int res=0;
346	int len=0;	354	int len=0;
347	psiconv_u32 temp;	355	psiconv_u32 temp;
348	int leng;	356	int leng;
349		357
350	psiconv_progress(lev+1,off,"Going to read the sheet status section");	358	psiconv_progress(config,lev+1,off,"Going to read the sheet status section");
351	if (!(result = malloc(sizeof(*result))))	359	if (!(result = malloc(sizeof(*result))))
352	goto ERROR1;	360	goto ERROR1;
353		361
354	psiconv_progress(lev+2,off+len,	362	psiconv_progress(config,lev+2,off+len,
355	"Going to read the initial byte (%02x expected)",0x02);	363	"Going to read the initial byte (%02x expected)",0x02);
356	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	364	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
357	if (res)	365	if (res)
358	goto ERROR2;	366	goto ERROR2;
359	if (temp != 0x02) {	367	if (temp != 0x02) {
360	psiconv_warn(lev+2,off+len,	368	psiconv_warn(config,lev+2,off+len,
361	"Sheet status section initial byte unknown value (ignored)");	369	"Sheet status section initial byte unknown value (ignored)");
362	psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);	370	psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
363	}	371	}
364	len ++;	372	len ++;
365		373
366	psiconv_progress(lev+2,off+len,	374	psiconv_progress(config,lev+2,off+len,
367	"Going to read the cursor row");	375	"Going to read the cursor row");
368	(*result)->cursor_row = psiconv_read_u32(buf,lev+2,off + len,&res);	376	(*result)->cursor_row = psiconv_read_u32(config,buf,lev+2,off + len,&res);
369	if (res)	377	if (res)
370	goto ERROR2;	378	goto ERROR2;
371	psiconv_debug(lev+2,off+len,"Cursor row: %08x",	379	psiconv_debug(config,lev+2,off+len,"Cursor row: %08x",
372	(*result)->cursor_row);	380	(*result)->cursor_row);
373	len += 0x04;	381	len += 0x04;
374		382
375	psiconv_progress(lev+2,off+len,	383	psiconv_progress(config,lev+2,off+len,
376	"Going to read the cursor column");	384	"Going to read the cursor column");
377	(*result)->cursor_column = psiconv_read_u32(buf,lev+2,off + len,&res);	385	(*result)->cursor_column = psiconv_read_u32(config,buf,lev+2,off + len,&res);
378	if (res)	386	if (res)
379	goto ERROR2;	387	goto ERROR2;
380	psiconv_debug(lev+2,off+len,"Cursor column: %08x",	388	psiconv_debug(config,lev+2,off+len,"Cursor column: %08x",
381	(*result)->cursor_column);	389	(*result)->cursor_column);
382	len += 0x04;	390	len += 0x04;
383		391
384	psiconv_progress(lev+2,off+len,"Going to read initially display graph");	392	psiconv_progress(config,lev+2,off+len,"Going to read initially display graph");
385	if ((res = psiconv_parse_bool(buf,lev+2,off+len,&leng,	393	if ((res = psiconv_parse_bool(config,buf,lev+2,off+len,&leng,
386	&(*result)->show_graph)))	394	&(*result)->show_graph)))
387	goto ERROR2;	395	goto ERROR2;
388	len += leng;	396	len += leng;
389		397
390	psiconv_progress(lev+2,off+len,	398	psiconv_progress(config,lev+2,off+len,
391	"Going to read the toolbar status byte");	399	"Going to read the toolbar status byte");
392	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	400	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
393	if (res)	401	if (res)
394	goto ERROR2;	402	goto ERROR2;
395		403
396	(*result)->show_side_sheet_toolbar = temp&0x01 ? psiconv_bool_true :	404	(*result)->show_side_sheet_toolbar = temp&0x01 ? psiconv_bool_true :
397	psiconv_bool_false;	405	psiconv_bool_false;
398	psiconv_debug(lev+2,off+len,"Show side sheet toolbar: %02x",	406	psiconv_debug(config,lev+2,off+len,"Show side sheet toolbar: %02x",
399	(*result)->show_side_sheet_toolbar);	407	(*result)->show_side_sheet_toolbar);
400	(*result)->show_top_sheet_toolbar = temp&0x02 ? psiconv_bool_true :	408	(*result)->show_top_sheet_toolbar = temp&0x02 ? psiconv_bool_true :
401	psiconv_bool_false;	409	psiconv_bool_false;
402	psiconv_debug(lev+2,off+len,"Show top sheet toolbar: %02x",	410	psiconv_debug(config,lev+2,off+len,"Show top sheet toolbar: %02x",
403	(*result)->show_top_sheet_toolbar);	411	(*result)->show_top_sheet_toolbar);
404	(*result)->show_side_graph_toolbar = temp&0x04 ? psiconv_bool_true :	412	(*result)->show_side_graph_toolbar = temp&0x04 ? psiconv_bool_true :
405	psiconv_bool_false;	413	psiconv_bool_false;
406	psiconv_debug(lev+2,off+len,"Show side graph toolbar: %02x",	414	psiconv_debug(config,lev+2,off+len,"Show side graph toolbar: %02x",
407	(*result)->show_side_graph_toolbar);	415	(*result)->show_side_graph_toolbar);
408	(*result)->show_top_graph_toolbar = temp&0x08 ? psiconv_bool_true :	416	(*result)->show_top_graph_toolbar = temp&0x08 ? psiconv_bool_true :
409	psiconv_bool_false;	417	psiconv_bool_false;
410	psiconv_debug(lev+2,off+len,"Show top graph toolbar: %02x",	418	psiconv_debug(config,lev+2,off+len,"Show top graph toolbar: %02x",
411	(*result)->show_top_graph_toolbar);	419	(*result)->show_top_graph_toolbar);
412	if (temp & 0xf0) {	420	if (temp & 0xf0) {
413	psiconv_warn(lev+2,off+len,"Sheet status section toolbar byte "	421	psiconv_warn(config,lev+2,off+len,"Sheet status section toolbar byte "
414	"flags contains unknown flags (ignored)");	422	"flags contains unknown flags (ignored)");
415	psiconv_debug(lev+2,off+len,"Unknown flags: %02x",temp & 0xf0);	423	psiconv_debug(config,lev+2,off+len,"Unknown flags: %02x",temp & 0xf0);
416	}	424	}
417	len ++;	425	len ++;
418		426
419	psiconv_progress(lev+2,off+len,	427	psiconv_progress(config,lev+2,off+len,
420	"Going to read the scrollbar status byte");	428	"Going to read the scrollbar status byte");
421	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	429	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
422	if (res)	430	if (res)
423	goto ERROR2;	431	goto ERROR2;
424	if ((temp & 0x03) == 0x03) {	432	if ((temp & 0x03) == 0x03) {
425	psiconv_warn(lev+2,off+len,"Sheet status section scrollbar byte "	433	psiconv_warn(config,lev+2,off+len,"Sheet status section scrollbar byte "
426	"flags contains unknown flags (ignored)");	434	"flags contains unknown flags (ignored)");
427	psiconv_debug(lev+2,off+len,"Unknown flag: %02x",temp & 0x03);	435	psiconv_debug(config,lev+2,off+len,"Unknown flag: %02x",temp & 0x03);
428	}	436	}
429	(*result)->show_horizontal_scrollbar = (temp&0x03) == 1? psiconv_triple_off :	437	(*result)->show_horizontal_scrollbar = (temp&0x03) == 1? psiconv_triple_off :
430	(temp&0x03) == 2? psiconv_triple_auto:	438	(temp&0x03) == 2? psiconv_triple_auto:
431	psiconv_triple_on;	439	psiconv_triple_on;
432	psiconv_debug(lev+2,off+len,"Show horizontal scrollbar: %02x",	440	psiconv_debug(config,lev+2,off+len,"Show horizontal scrollbar: %02x",
433	(*result)->show_horizontal_scrollbar);	441	(*result)->show_horizontal_scrollbar);
434	if ((temp & 0x0c) == 0x0c) {	442	if ((temp & 0x0c) == 0x0c) {
435	psiconv_warn(lev+2,off+len,"Sheet status section scrollbar byte "	443	psiconv_warn(config,lev+2,off+len,"Sheet status section scrollbar byte "
436	"flags contains unknown flags (ignored)");	444	"flags contains unknown flags (ignored)");
437	psiconv_debug(lev+2,off+len,"Unknown flag: %02x",temp & 0x0c);	445	psiconv_debug(config,lev+2,off+len,"Unknown flag: %02x",temp & 0x0c);
438	}	446	}
439	(*result)->show_vertical_scrollbar = (temp&0x0c) ==0x04? psiconv_triple_off:	447	(*result)->show_vertical_scrollbar = (temp&0x0c) ==0x04? psiconv_triple_off:
440	(temp&0x0c) ==0x08? psiconv_triple_auto:	448	(temp&0x0c) ==0x08? psiconv_triple_auto:
441	psiconv_triple_on;	449	psiconv_triple_on;
442	psiconv_debug(lev+2,off+len,"Show vertical scrollbar: %02x",	450	psiconv_debug(config,lev+2,off+len,"Show vertical scrollbar: %02x",
443	(*result)->show_vertical_scrollbar);	451	(*result)->show_vertical_scrollbar);
444	if (temp & 0xf0) {	452	if (temp & 0xf0) {
445	psiconv_warn(lev+2,off+len,"Sheet status section scrollbar byte "	453	psiconv_warn(config,lev+2,off+len,"Sheet status section scrollbar byte "
446	"flags contains unknown flags (ignored)");	454	"flags contains unknown flags (ignored)");
447	psiconv_debug(lev+2,off+len,"Unknown flags: %02x",temp & 0xf0);	455	psiconv_debug(config,lev+2,off+len,"Unknown flags: %02x",temp & 0xf0);
448	}	456	}
449	len ++;	457	len ++;
450		458
451	psiconv_progress(lev+2,off+len,	459	psiconv_progress(config,lev+2,off+len,
452	"Going to read an unknown byte (%02x expected)",0x00);	460	"Going to read an unknown byte (%02x expected)",0x00);
453	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	461	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
454	if (res)	462	if (res)
455	goto ERROR2;	463	goto ERROR2;
456	if (temp != 0x00) {	464	if (temp != 0x00) {
457	psiconv_warn(lev+2,off+len,	465	psiconv_warn(config,lev+2,off+len,
458	"Sheet status section unknown byte unknown value (ignored)");	466	"Sheet status section unknown byte unknown value (ignored)");
459	psiconv_debug(lev+2,off+len,"Unknown byte: %02x",temp);	467	psiconv_debug(config,lev+2,off+len,"Unknown byte: %02x",temp);
460	}	468	}
461	len ++;	469	len ++;
462		470
463	psiconv_progress(lev+2,off+len,"Going to read sheet display size");	471	psiconv_progress(config,lev+2,off+len,"Going to read sheet display size");
464	(*result)->sheet_display_size = psiconv_read_u32(buf,lev+2,off + len,&res);	472	(*result)->sheet_display_size = psiconv_read_u32(config,buf,lev+2,off + len,&res);
465	if (res)	473	if (res)
466	goto ERROR2;	474	goto ERROR2;
467	psiconv_debug(lev+2,off+len,"Sheet display size: %08x",	475	psiconv_debug(config,lev+2,off+len,"Sheet display size: %08x",
468	(*result)->sheet_display_size);	476	(*result)->sheet_display_size);
469	len += 0x04;	477	len += 0x04;
470		478
471	psiconv_progress(lev+2,off+len,"Going to read graph display size");	479	psiconv_progress(config,lev+2,off+len,"Going to read graph display size");
472	(*result)->graph_display_size = psiconv_read_u32(buf,lev+2,off + len,&res);	480	(*result)->graph_display_size = psiconv_read_u32(config,buf,lev+2,off + len,&res);
473	if (res)	481	if (res)
474	goto ERROR2;	482	goto ERROR2;
475	psiconv_debug(lev+2,off+len,"Graph display size: %08x",	483	psiconv_debug(config,lev+2,off+len,"Graph display size: %08x",
476	(*result)->graph_display_size);	484	(*result)->graph_display_size);
477	len += 0x04;	485	len += 0x04;
478		486
479	if (length)	487	if (length)
480	*length = len;	488	*length = len;
481		489
482	psiconv_progress(lev,off+len-1,	490	psiconv_progress(config,lev,off+len-1,
483	"End of sheet status section (total length: %08x)", len);	491	"End of sheet status section (total length: %08x)", len);
484	return 0;	492	return 0;
485		493
486	ERROR2:	494	ERROR2:
487	free (*result);	495	free (*result);
488	ERROR1:	496	ERROR1:
489	psiconv_warn(lev+1,off,"Reading of Sheet Status Section failed");	497	psiconv_warn(config,lev+1,off,"Reading of Sheet Status Section failed");
490	if (length)	498	if (length)
491	*length = 0;	499	*length = 0;
492	if (!res)	500	if (!res)
493	return -PSICONV_E_NOMEM;	501	return -PSICONV_E_NOMEM;
494	else	502	else
495	return res;	503	return res;
496	}	504	}
497		505
498	int psiconv_parse_sheet_workbook_section(const psiconv_buffer buf, int lev,	506	int psiconv_parse_sheet_workbook_section(const psiconv_config config,
		507	const psiconv_buffer buf, int lev,
499	psiconv_u32 off, int *length,	508	psiconv_u32 off, int *length,
500	psiconv_sheet_workbook_section *result)	509	psiconv_sheet_workbook_section *result)
501	{	510	{
502	int res=0,with_name;	511	int res=0,with_name;
503	psiconv_u32 temp,formulas_off,worksheets_off,info_off,var_off,name_off=0;	512	psiconv_u32 temp,formulas_off,worksheets_off,info_off,var_off,name_off=0;
504	int len=0;	513	int len=0;
505		514
506	psiconv_progress(lev+1,off,"Going to read the sheet workbook section");	515	psiconv_progress(config,lev+1,off,"Going to read the sheet workbook section");
507	if (!(result = malloc(sizeof(*result))))	516	if (!(result = malloc(sizeof(*result))))
508	goto ERROR1;	517	goto ERROR1;
509		518
510	psiconv_progress(lev+2,off+len,	519	psiconv_progress(config,lev+2,off+len,
511	"Going to read the initial byte (%02x or $02xexpected)",	520	"Going to read the initial byte (%02x or %02x expected)",
512	0x02,0x04);	521	0x02,0x04);
513	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	522	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
514	if (res)	523	if (res)
515	goto ERROR2;	524	goto ERROR2;
516	if ((temp != 0x04) && temp !=0x02) {	525	if ((temp != 0x04) && temp !=0x02) {
517	psiconv_warn(lev+2,off+len,	526	psiconv_warn(config,lev+2,off+len,
518	"Sheet workbook section initial byte unknown value (ignored)");	527	"Sheet workbook section initial byte unknown value (ignored)");
519	psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);	528	psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
520	}	529	}
521	with_name = temp ==0x04;	530	with_name = temp ==0x04;
522	len ++;	531	len ++;
523		532
524	psiconv_progress(lev+2,off+len,	533	psiconv_progress(config,lev+2,off+len,
525	"Going to read the offset of the sheet info Section");	534	"Going to read the offset of the sheet info Section");
526	info_off = psiconv_read_u32(buf,lev+2,off+len,&res);	535	info_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
527	if (res)	536	if (res)
528	goto ERROR2;	537	goto ERROR2;
529	psiconv_debug(lev+2,off+len,"Offset: %04x",info_off);	538	psiconv_debug(config,lev+2,off+len,"Offset: %04x",info_off);
530	len += 4;	539	len += 4;
531		540
532	psiconv_progress(lev+2,off+len,	541	psiconv_progress(config,lev+2,off+len,
533	"Going to read the offset of the Formulas List");	542	"Going to read the offset of the Formulas List");
534	formulas_off = psiconv_read_u32(buf,lev+2,off+len,&res);	543	formulas_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
535	if (res)	544	if (res)
536	goto ERROR2;	545	goto ERROR2;
537	psiconv_debug(lev+2,off+len,"Offset: %04x",formulas_off);	546	psiconv_debug(config,lev+2,off+len,"Offset: %04x",formulas_off);
538	len += 4;	547	len += 4;
539		548
540	psiconv_progress(lev+2,off+len,	549	psiconv_progress(config,lev+2,off+len,
541	"Going to read the offset of the Worksheet List");	550	"Going to read the offset of the Worksheet List");
542	worksheets_off = psiconv_read_u32(buf,lev+2,off+len,&res);	551	worksheets_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
543	if (res)	552	if (res)
544	goto ERROR2;	553	goto ERROR2;
545	psiconv_debug(lev+2,off+len,"Offset: %04x",worksheets_off);	554	psiconv_debug(config,lev+2,off+len,"Offset: %04x",worksheets_off);
546	len += 4;	555	len += 4;
547		556
548	psiconv_progress(lev+2,off+len,	557	psiconv_progress(config,lev+2,off+len,
549	"Going to read the offset of the Variable List");	558	"Going to read the offset of the Variable List");
550	var_off = psiconv_read_u32(buf,lev+2,off+len,&res);	559	var_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
551	if (res)	560	if (res)
552	goto ERROR2;	561	goto ERROR2;
553	psiconv_debug(lev+2,off+len,"Offset: %04x",var_off);	562	psiconv_debug(config,lev+2,off+len,"Offset: %04x",var_off);
554	len += 4;	563	len += 4;
555		564
556	if (with_name) {	565	if (with_name) {
557	psiconv_progress(lev+2,off+len,	566	psiconv_progress(config,lev+2,off+len,
558	"Going to read the offset of the Name Section");	567	"Going to read the offset of the Name Section");
559	name_off = psiconv_read_u32(buf,lev+2,off+len,&res);	568	name_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
560	if (res)	569	if (res)
561	goto ERROR2;	570	goto ERROR2;
562	psiconv_debug(lev+2,off+len,"Offset: %04x",name_off);	571	psiconv_debug(config,lev+2,off+len,"Offset: %04x",name_off);
563	len += 4;	572	len += 4;
564	}	573	}
565		574
566		575
567	psiconv_progress(lev+2,off+len,"Going to read the info section");	576	psiconv_progress(config,lev+2,off+len,"Going to read the info section");
568	if ((res = psiconv_parse_sheet_info_section(buf,lev+2,info_off,NULL,	577	if ((res = psiconv_parse_sheet_info_section(config,buf,lev+2,info_off,NULL,
569	&(*result)->info)))	578	&(*result)->info)))
570	goto ERROR2;	579	goto ERROR2;
571		580
572	psiconv_progress(lev+2,off+len,"Going to read the variables list");	581	psiconv_progress(config,lev+2,off+len,"Going to read the variables list");
573	if ((res = psiconv_parse_sheet_variable_list(buf,lev+2,var_off,NULL,	582	if ((res = psiconv_parse_sheet_variable_list(config,buf,lev+2,var_off,NULL,
574	&(*result)->variables)))	583	&(*result)->variables)))
575	goto ERROR3;	584	goto ERROR3;
576		585
577	psiconv_progress(lev+2,off+len,"Going to read the formulas list");	586	psiconv_progress(config,lev+2,off+len,"Going to read the formulas list");
578	if ((res = psiconv_parse_sheet_formula_list(buf,lev+2,formulas_off,NULL,	587	if ((res = psiconv_parse_sheet_formula_list(config,buf,lev+2,formulas_off,NULL,
579	&(*result)->formulas)))	588	&(*result)->formulas)))
580	goto ERROR4;	589	goto ERROR4;
581		590
582	psiconv_progress(lev+2,off+len,"Going to read the worksheet list");	591	psiconv_progress(config,lev+2,off+len,"Going to read the worksheet list");
583	if ((res = psiconv_parse_sheet_worksheet_list(buf,lev+2,worksheets_off,	592	if ((res = psiconv_parse_sheet_worksheet_list(config,buf,lev+2,worksheets_off,
584	NULL,&(*result)->worksheets)))	593	NULL,&(*result)->worksheets)))
585	goto ERROR5;	594	goto ERROR5;
586		595
587	if (with_name) {	596	if (with_name) {
588	psiconv_progress(lev+2,off+len,"Going to read the name section");	597	psiconv_progress(config,lev+2,off+len,"Going to read the name section");
589
590	if ((res = psiconv_parse_sheet_name_section(buf,lev+2,name_off,NULL,	598	if ((res = psiconv_parse_sheet_name_section(config,buf,lev+2,name_off,NULL,
591	&(*result)->name)))	599	&(*result)->name)))
592	goto ERROR6;	600	goto ERROR6;
593	} else	601	} else
594	(*result)->name = NULL;	602	(*result)->name = NULL;
595		603
596	if (length)	604	if (length)
597	*length = len;	605	*length = len;
598		606
599	psiconv_progress(lev,off+len-1,	607	psiconv_progress(config,lev,off+len-1,
600	"End of sheet workbook section (total length: %08x)", len);	608	"End of sheet workbook section (total length: %08x)", len);
601	return 0;	609	return 0;
602		610
603	ERROR6:	611	ERROR6:
604	psiconv_free_sheet_worksheet_list((*result)->worksheets);	612	psiconv_free_sheet_worksheet_list((*result)->worksheets);
…		…
609	ERROR3:	617	ERROR3:
610	psiconv_free_sheet_info_section((*result)->info);	618	psiconv_free_sheet_info_section((*result)->info);
611	ERROR2:	619	ERROR2:
612	free (*result);	620	free (*result);
613	ERROR1:	621	ERROR1:
614	psiconv_warn(lev+1,off,"Reading of Sheet Workbook Section failed");	622	psiconv_warn(config,lev+1,off,"Reading of Sheet Workbook Section failed");
615	if (length)	623	if (length)
616	*length = 0;	624	*length = 0;
617	if (!res)	625	if (!res)
618	return -PSICONV_E_NOMEM;	626	return -PSICONV_E_NOMEM;
619	else	627	else
620	return res;	628	return res;
621	}	629	}
622		630
623	int psiconv_parse_sheet_name_section(const psiconv_buffer buf, int lev,	631	int psiconv_parse_sheet_name_section(const psiconv_config config,
		632	const psiconv_buffer buf, int lev,
624	psiconv_u32 off, int *length,	633	psiconv_u32 off, int *length,
625	psiconv_sheet_name_section *result)	634	psiconv_sheet_name_section *result)
626	{	635	{
627	int res=0;	636	int res=0;
628	psiconv_u32 temp;	637	psiconv_u32 temp;
629	int len=0,leng;	638	int len=0,leng;
630		639
631	psiconv_progress(lev+1,off,"Going to read the sheet name section");	640	psiconv_progress(config,lev+1,off,"Going to read the sheet name section");
632	if (!(result = malloc(sizeof(*result))))	641	if (!(result = malloc(sizeof(*result))))
633	goto ERROR1;	642	goto ERROR1;
634		643
635	psiconv_progress(lev+2,off+len,	644	psiconv_progress(config,lev+2,off+len,
636	"Going to read the initial byte (%02x expected)",0x02);	645	"Going to read the initial byte (%02x expected)",0x02);
637	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	646	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
638	if (res)	647	if (res)
639	goto ERROR2;	648	goto ERROR2;
640	if (temp != 0x02) {	649	if (temp != 0x02) {
641	psiconv_warn(lev+2,off+len,	650	psiconv_warn(config,lev+2,off+len,
642	"Sheet name section initial byte unknown value (ignored)");	651	"Sheet name section initial byte unknown value (ignored)");
643	psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);	652	psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
644	}	653	}
645	len ++;	654	len ++;
646		655
647	psiconv_progress(lev+2,off+len, "Going to read the sheet name");	656	psiconv_progress(config,lev+2,off+len, "Going to read the sheet name");
648	(*result)->name = psiconv_read_string(buf,lev+2,off+len,&leng,&res);	657	(*result)->name = psiconv_read_string(config,buf,lev+2,off+len,&leng,&res);
649	if (res)	658	if (res)
650	goto ERROR2;	659	goto ERROR2;
651	len += leng;	660	len += leng;
652		661
653	if (length)	662	if (length)
654	*length = len;	663	*length = len;
655		664
656	psiconv_progress(lev,off+len-1,	665	psiconv_progress(config,lev,off+len-1,
657	"End of sheet name section (total length: %08x)", len);	666	"End of sheet name section (total length: %08x)", len);
658	return 0;	667	return 0;
659		668
660	ERROR2:	669	ERROR2:
661	free(*result);	670	free(*result);
662	ERROR1:	671	ERROR1:
663	psiconv_warn(lev+1,off,"Reading of Sheet Name Section failed");	672	psiconv_warn(config,lev+1,off,"Reading of Sheet Name Section failed");
664	if (length)	673	if (length)
665	*length = 0;	674	*length = 0;
666	if (!res)	675	if (!res)
667	return -PSICONV_E_NOMEM;	676	return -PSICONV_E_NOMEM;
668	else	677	else
669	return res;	678	return res;
670	}	679	}
671		680
672	int psiconv_parse_sheet_info_section(const psiconv_buffer buf, int lev,	681	int psiconv_parse_sheet_info_section(const psiconv_config config,
		682	const psiconv_buffer buf, int lev,
673	psiconv_u32 off, int *length,	683	psiconv_u32 off, int *length,
674	psiconv_sheet_info_section *result)	684	psiconv_sheet_info_section *result)
675	{	685	{
676	int res=0;	686	int res=0;
677	psiconv_u32 temp;	687	psiconv_u32 temp;
678	int len=0;	688	int len=0,leng;
679		689
680	psiconv_progress(lev+1,off,"Going to read the sheet info section");	690	psiconv_progress(config,lev+1,off,"Going to read the sheet info section");
681	if (!(result = malloc(sizeof(*result))))	691	if (!(result = malloc(sizeof(*result))))
682	goto ERROR1;	692	goto ERROR1;
683		693
684	psiconv_progress(lev+2,off+len,	694	psiconv_progress(config,lev+2,off+len,
685	"Going to read the initial byte (%02x expected)",0x02);	695	"Going to read the initial byte (%02x expected)",0x02);
686	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	696	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
687	if (res)	697	if (res)
688	goto ERROR2;	698	goto ERROR2;
689	if (temp != 0x02) {	699	if (temp != 0x02) {
690	psiconv_warn(lev+2,off+len,	700	psiconv_warn(config,lev+2,off+len,
691	"Sheet info section initial byte unknown value (ignored)");	701	"Sheet info section initial byte unknown value (ignored)");
692	psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);	702	psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
693	}	703	}
694	len ++;	704	len ++;
695		705
		706	psiconv_progress(config,lev+2,off+len, "Going to read an unknown Xint");
		707	temp = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
		708	if (res)
		709	goto ERROR2;
		710	psiconv_debug(config,lev+2,off+len,"Value: %d\n",temp);
		711	len += leng;
		712
696	psiconv_progress(lev+2,off+len, "Going to read the flags byte");	713	psiconv_progress(config,lev+2,off+len, "Going to read the flags byte");
697	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	714	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
698	if (res)	715	if (res)
699	goto ERROR2;	716	goto ERROR2;
700	(*result)->auto_recalc = temp & 0x01 ? psiconv_bool_true:psiconv_bool_false;	717	(*result)->auto_recalc = temp & 0x01 ? psiconv_bool_true:psiconv_bool_false;
701	psiconv_debug(lev+2,off+len,"Auto recalculation: %02x",	718	psiconv_debug(config,lev+2,off+len,"Auto recalculation: %02x",
702	(*result)->auto_recalc);	719	(*result)->auto_recalc);
703	if ((temp & 0xfe) != 0x02) {	720	if ((temp & 0xfe) != 0x02) {
704	psiconv_warn(lev+2,off+len,"Sheet Info Section flags byte "	721	psiconv_warn(config,lev+2,off+len,"Sheet Info Section flags byte "
705	"contains unknown flags (ignored)");	722	"contains unknown flags (ignored)");
706	psiconv_debug(lev+2,off+len,"Unknown flags: %02x",temp &0xfe);	723	psiconv_debug(config,lev+2,off+len,"Unknown flags: %02x",temp &0xfe);
707	}	724	}
708		725
709	len ++;	726	len ++;
710		727
711		728
712	if (length)	729	if (length)
713	*length = len;	730	*length = len;
714		731
715	psiconv_progress(lev,off+len-1,	732	psiconv_progress(config,lev,off+len-1,
716	"End of sheet info section (total length: %08x)", len);	733	"End of sheet info section (total length: %08x)", len);
717	return 0;	734	return 0;
718		735
719	ERROR2:	736	ERROR2:
720	free(*result);	737	free(*result);
721	ERROR1:	738	ERROR1:
722	psiconv_warn(lev+1,off,"Reading of Sheet Name Section failed");	739	psiconv_warn(config,lev+1,off,"Reading of Sheet Name Section failed");
723	if (length)	740	if (length)
724	*length = 0;	741	*length = 0;
725	if (!res)	742	if (!res)
726	return -PSICONV_E_NOMEM;	743	return -PSICONV_E_NOMEM;
727	else	744	else
728	return res;	745	return res;
729	}	746	}
730		747
731	int psiconv_parse_sheet_formula_list(const psiconv_buffer buf, int lev,	748	int psiconv_parse_sheet_formula_list(const psiconv_config config,
		749	const psiconv_buffer buf, int lev,
732	psiconv_u32 off, int *length,	750	psiconv_u32 off, int *length,
733	psiconv_formula_list *result)	751	psiconv_formula_list *result)
734	{	752	{
735	int res=0;	753	int res=0;
736	int len=0;	754	int len=0;
737	psiconv_u32 temp;	755	psiconv_u32 temp;
738	psiconv_formula formula;	756	psiconv_formula formula;
739	psiconv_u32 listlen,i;	757	psiconv_u32 listlen,i;
740	int leng;	758	int leng;
741		759
742	psiconv_progress(lev+1,off,"Going to read the sheet formula list");	760	psiconv_progress(config,lev+1,off,"Going to read the sheet formula list");
743	if (!(*result = psiconv_list_new(sizeof(struct psiconv_formula_s))))	761	if (!(*result = psiconv_list_new(sizeof(struct psiconv_formula_s))))
744	goto ERROR1;	762	goto ERROR1;
745		763
746	psiconv_progress(lev+2,off+len,	764	psiconv_progress(config,lev+2,off+len,
747	"Going to read the initial byte (%02x expected)",0x02);	765	"Going to read the initial byte (%02x expected)",0x02);
748	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	766	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
749	if (res)	767	if (res)
750	goto ERROR2;	768	goto ERROR2;
751	if (temp != 0x02) {	769	if (temp != 0x02) {
752	psiconv_warn(lev+2,off+len,	770	psiconv_warn(config,lev+2,off+len,
753	"Sheet formula list initial byte unknown value (ignored)");	771	"Sheet formula list initial byte unknown value (ignored)");
754	psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);	772	psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
755	}	773	}
756	len ++;	774	len ++;
757		775
758	psiconv_progress(lev+2,off+len,	776	psiconv_progress(config,lev+2,off+len,
759	"Going to read the number of formulas");	777	"Going to read the number of formulas");
760	listlen = psiconv_read_X(buf,lev+2,off+len,&leng,&res);	778	listlen = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
761	if (res)	779	if (res)
762	goto ERROR2;	780	goto ERROR2;
763	psiconv_debug(lev+2,off+len,"Number of formulas: %d",listlen);	781	psiconv_debug(config,lev+2,off+len,"Number of formulas: %d",listlen);
764	len += leng;	782	len += leng;
765		783
766	psiconv_progress(lev+2,off+len,"Going to read all formulas");	784	psiconv_progress(config,lev+2,off+len,"Going to read all formulas");
767	for (i = 0; i < listlen; i++) {	785	for (i = 0; i < listlen; i++) {
768	psiconv_progress(lev+3,off+len,"Going to read formula %d",i);	786	psiconv_progress(config,lev+3,off+len,"Going to read formula %d",i);
769	if ((res = psiconv_parse_formula(buf,lev+3,off+len,&leng,&formula)))	787	if ((res = psiconv_parse_formula(config,buf,lev+3,off+len,&leng,&formula)))
770	goto ERROR2;	788	goto ERROR2;
771	if ((res = psiconv_list_add(*result,formula)))	789	if ((res = psiconv_list_add(*result,formula)))
772	goto ERROR3;	790	goto ERROR3;
		791	free(formula);
773	len += leng;	792	len += leng;
774	}	793	}
775		794
776	if (length)	795	if (length)
777	*length = len;	796	*length = len;
778		797
779	psiconv_progress(lev,off+len-1,	798	psiconv_progress(config,lev,off+len-1,
780	"End of sheet formula list (total length: %08x)", len);	799	"End of sheet formula list (total length: %08x)", len);
781	return 0;	800	return 0;
782		801
783	ERROR3:	802	ERROR3:
784	psiconv_free_formula(formula);	803	psiconv_free_formula(formula);
785	ERROR2:	804	ERROR2:
786	psiconv_list_free(*result);	805	psiconv_list_free(*result);
787	ERROR1:	806	ERROR1:
788	psiconv_warn(lev+1,off,"Reading of Sheet Formula list failed");	807	psiconv_warn(config,lev+1,off,"Reading of Sheet Formula list failed");
789	if (length)	808	if (length)
790	*length = 0;	809	*length = 0;
791	if (!res)	810	if (!res)
792	return -PSICONV_E_NOMEM;	811	return -PSICONV_E_NOMEM;
793	else	812	else
794	return res;	813	return res;
795	}	814	}
796		815
797	int psiconv_parse_sheet_cell(const psiconv_buffer buf, int lev,	816	int psiconv_parse_sheet_cell(const psiconv_config config,
		817	const psiconv_buffer buf, int lev,
798	psiconv_u32 off, int *length,	818	psiconv_u32 off, int *length,
799	psiconv_sheet_cell *result,	819	psiconv_sheet_cell *result,
800	const psiconv_sheet_cell_layout default_layout,	820	const psiconv_sheet_cell_layout default_layout,
801	const psiconv_sheet_line_list row_default_layouts,	821	const psiconv_sheet_line_list row_default_layouts,
802	const psiconv_sheet_line_list col_default_layouts)	822	const psiconv_sheet_line_list col_default_layouts)
…		…
805	int len=0;	825	int len=0;
806	psiconv_u32 temp;	826	psiconv_u32 temp;
807	psiconv_bool_t has_layout;	827	psiconv_bool_t has_layout;
808	int leng;	828	int leng;
809		829
810	psiconv_progress(lev+1,off,"Going to read a sheet cell structure");	830	psiconv_progress(config,lev+1,off,"Going to read a sheet cell structure");
811	if (!(result = malloc(sizeof(*result))))	831	if (!(result = malloc(sizeof(*result))))
812	goto ERROR1;	832	goto ERROR1;
813		833
814	(*result)->layout = NULL;	834	(*result)->layout = NULL;
815	(*result)->type = psiconv_cell_blank;	835	(*result)->type = psiconv_cell_blank;
816		836
817	psiconv_progress(lev+2,off+len,"Going to read the cell position");	837	psiconv_progress(config,lev+2,off+len,"Going to read the cell position");
818	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	838	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
819	if (res)	839	if (res)
820	goto ERROR2;	840	goto ERROR2;
821	len ++;	841	len ++;
822	temp += psiconv_read_u8(buf,lev+2,off+len,&res) << 8;	842	temp += psiconv_read_u8(config,buf,lev+2,off+len,&res) << 8;
823	if (res)	843	if (res)
824	goto ERROR2;	844	goto ERROR2;
825	len ++;	845	len ++;
826	temp += psiconv_read_u8(buf,lev+2,off+len,&res) << 16;	846	temp += psiconv_read_u8(config,buf,lev+2,off+len,&res) << 16;
827	if (res)	847	if (res)
828	goto ERROR2;	848	goto ERROR2;
829	len ++;	849	len ++;
830	(*result)->column = (temp >> 2) & 0xFF;	850	(*result)->column = (temp >> 2) & 0xFF;
831	(*result)->row = (temp >> 10) & 0x3FFF;	851	(*result)->row = (temp >> 10) & 0x3FFF;
832	psiconv_debug(lev+2,off+len,"Cell position is col:%02x row:%04x",	852	psiconv_debug(config,lev+2,off+len,"Cell position is col:%02x row:%04x",
833	(result)->column,(result)->row);	853	(result)->column,(result)->row);
834	if (temp & 0x03) {	854	if (temp & 0x03) {
835	psiconv_warn(lev+2,off+len,"Unknown flags in cell position (ignored)");	855	psiconv_warn(config,lev+2,off+len,"Unknown flags in cell position (ignored)");
836	psiconv_debug(lev+2,off+len,"Flags: %02x",temp & 0x03);	856	psiconv_debug(config,lev+2,off+len,"Flags: %02x",temp & 0x03);
837	}	857	}
838		858
839	psiconv_progress(lev+2,off+len,"Going to read the cell type");	859	psiconv_progress(config,lev+2,off+len,"Going to read the cell type");
840	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	860	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
841	if (res)	861	if (res)
842	goto ERROR2;	862	goto ERROR2;
843	len ++;	863	len ++;
844	(*result)->type = (temp >> 5) & 0x07;	864	(*result)->type = (temp >> 5) & 0x07;
845	(*result)->calculated = (temp & 0x08)?psiconv_bool_true:psiconv_bool_false;	865	(*result)->calculated = (temp & 0x08)?psiconv_bool_true:psiconv_bool_false;
846	has_layout = (temp & 0x10)?psiconv_bool_true:psiconv_bool_false;	866	has_layout = (temp & 0x10)?psiconv_bool_true:psiconv_bool_false;
847		867
848	psiconv_progress(lev+2,off+len,"Going to read the cell value");	868	psiconv_progress(config,lev+2,off+len,"Going to read the cell value");
849	if ((*result)->type == psiconv_cell_blank) {	869	if ((*result)->type == psiconv_cell_blank) {
850	psiconv_debug(lev+2,off+len,"Cell type is blank: no value given.");	870	psiconv_debug(config,lev+2,off+len,"Cell type is blank: no value given.");
851	} else if ((*result)->type == psiconv_cell_int) {	871	} else if ((*result)->type == psiconv_cell_int) {
852	psiconv_progress(lev+2,off+len,"Going to read an integer");	872	psiconv_progress(config,lev+2,off+len,"Going to read an integer");
853	(*result)->data.dat_int = psiconv_read_u32(buf,lev+2,off+len,&res);	873	(*result)->data.dat_int = psiconv_read_u32(config,buf,lev+2,off+len,&res);
854	if (res)	874	if (res)
855	goto ERROR2;	875	goto ERROR2;
856	len += 4;	876	len += 4;
857	psiconv_debug(lev+2,off+len,"Cell contents: %ld",(*result)->data.dat_int);	877	psiconv_debug(config,lev+2,off+len,"Cell contents: %ld",(*result)->data.dat_int);
858		878
859	} else if ((*result)->type == psiconv_cell_bool) {	879	} else if ((*result)->type == psiconv_cell_bool) {
860	psiconv_progress(lev+2,off+len,"Going to read a boolean");	880	psiconv_progress(config,lev+2,off+len,"Going to read a boolean");
861	if ((res = psiconv_parse_bool(buf,lev+2,off+len,&leng,	881	if ((res = psiconv_parse_bool(config,buf,lev+2,off+len,&leng,
862	&(*result)->data.dat_bool)))	882	&(*result)->data.dat_bool)))
863	goto ERROR2;	883	goto ERROR2;
864	psiconv_debug(lev+2,off+len,"Cell contents: %01x",temp);	884	psiconv_debug(config,lev+2,off+len,"Cell contents: %01x",temp);
865	(*result)->data.dat_bool = temp?psiconv_bool_true:psiconv_bool_false;	885	(*result)->data.dat_bool = temp?psiconv_bool_true:psiconv_bool_false;
866	len += leng;	886	len += leng;
867	} else if ((*result)->type == psiconv_cell_error) {	887	} else if ((*result)->type == psiconv_cell_error) {
868	psiconv_progress(lev+2,off+len,"Going to read the error code");	888	psiconv_progress(config,lev+2,off+len,"Going to read the error code");
869	temp = psiconv_read_u16(buf,lev+2,off+len,&res);	889	temp = psiconv_read_u16(config,buf,lev+2,off+len,&res);
870	if (res)	890	if (res)
871	goto ERROR2;	891	goto ERROR2;
872	if (temp == 0)	892	if (temp == 0)
873	(*result)->data.dat_error = psiconv_sheet_error_none;	893	(*result)->data.dat_error = psiconv_sheet_error_none;
874	else if (temp == 1)	894	else if (temp == 1)
…		…
884	else if (temp == 6)	904	else if (temp == 6)
885	(*result)->data.dat_error = psiconv_sheet_error_number;	905	(*result)->data.dat_error = psiconv_sheet_error_number;
886	else if (temp == 7)	906	else if (temp == 7)
887	(*result)->data.dat_error = psiconv_sheet_error_notavail;	907	(*result)->data.dat_error = psiconv_sheet_error_notavail;
888	else {	908	else {
889	psiconv_warn(lev+2,off+len,"Unknown error code (default assumed)");	909	psiconv_warn(config,lev+2,off+len,"Unknown error code (default assumed)");
890	psiconv_debug(lev+2,off+len,"Error code: %04x",temp);	910	psiconv_debug(config,lev+2,off+len,"Error code: %04x",temp);
891	(*result)->data.dat_error = psiconv_sheet_error_none;	911	(*result)->data.dat_error = psiconv_sheet_error_none;
892	}	912	}
893	psiconv_debug(lev+2,off+len,"Cell contents: %04x",	913	psiconv_debug(config,lev+2,off+len,"Cell contents: %04x",
894	(*result)->data.dat_error);	914	(*result)->data.dat_error);
895	len += 2;	915	len += 2;
896	} else if ((*result)->type == psiconv_cell_float) {	916	} else if ((*result)->type == psiconv_cell_float) {
897	psiconv_progress(lev+2,off+len,"Going to read a float");	917	psiconv_progress(config,lev+2,off+len,"Going to read a float");
898	(*result)->data.dat_float =	918	(*result)->data.dat_float =
899	psiconv_read_float(buf,lev+2,off+len,&leng,&res);	919	psiconv_read_float(config,buf,lev+2,off+len,&leng,&res);
900	if (res)	920	if (res)
901	goto ERROR2;	921	goto ERROR2;
902	psiconv_debug(lev+2,off+len,"Cell contents: %f",(*result)->data.dat_float);	922	psiconv_debug(config,lev+2,off+len,"Cell contents: %f",(*result)->data.dat_float);
903	len += leng;	923	len += leng;
904	} else if ((*result)->type == psiconv_cell_string) {	924	} else if ((*result)->type == psiconv_cell_string) {
905	psiconv_progress(lev+2,off+len,"Going to read a string");	925	psiconv_progress(config,lev+2,off+len,"Going to read a string");
906	(*result)->data.dat_string =	926	(*result)->data.dat_string =
907	psiconv_read_string(buf,lev+2,off+len,&leng,&res);	927	psiconv_read_string(config,buf,lev+2,off+len,&leng,&res);
908	if (res)	928	if (res)
909	goto ERROR2;	929	goto ERROR2;
910	psiconv_debug(lev+2,off+len,"Cell contents: `%s'",	930	psiconv_debug(config,lev+2,off+len,"Cell contents: `%s'",
911	(*result)->data.dat_string);	931	(*result)->data.dat_string);
912	len += leng;	932	len += leng;
913	} else {	933	} else {
914	psiconv_warn(lev+2,off+len,"Unknown Sheet Cell type: %02x",(*result)->type);	934	psiconv_warn(config,lev+2,off+len,"Unknown Sheet Cell type: %02x",(*result)->type);
915	res = PSICONV_E_PARSE;	935	res = PSICONV_E_PARSE;
916	goto ERROR2;	936	goto ERROR2;
917	}	937	}
918		938
919	if (!((*result)->layout = psiconv_clone_cell_layout(	939	if (!((*result)->layout = psiconv_clone_cell_layout(
…		…
922	default_layout,	942	default_layout,
923	(*result)->row,	943	(*result)->row,
924	(*result)->column))))	944	(*result)->column))))
925	goto ERROR2;	945	goto ERROR2;
926	if (has_layout) {	946	if (has_layout) {
927	if ((res = psiconv_parse_sheet_cell_layout(buf,lev+2,off+len,	947	if ((res = psiconv_parse_sheet_cell_layout(config,buf,lev+2,off+len,
928	&leng,(*result)->layout)))	948	&leng,(*result)->layout)))
929	goto ERROR2;	949	goto ERROR2;
930	len += leng;	950	len += leng;
931	}	951	}
932		952
933	if ((*result)->calculated) {	953	if ((*result)->calculated) {
934	psiconv_progress(lev+2,off+len,"Going to read the cell formula reference");	954	psiconv_progress(config,lev+2,off+len,"Going to read the cell formula reference");
935	temp = psiconv_read_X(buf,lev+2,off+len,&leng,&res);	955	temp = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
936	if (res)	956	if (res)
937	goto ERROR2;	957	goto ERROR2;
938	psiconv_debug(lev+2,off+len,"Cell formula reference: %d",temp);	958	psiconv_debug(config,lev+2,off+len,"Cell formula reference: %d",temp);
939	len += leng;	959	len += leng;
940	(*result)->ref_formula = temp;	960	(*result)->ref_formula = temp;
941	}	961	}
942		962
943	if (length)	963	if (length)
944	*length = len;	964	*length = len;
945		965
946	psiconv_progress(lev,off+len-1,	966	psiconv_progress(config,lev,off+len-1,
947	"End of sheet cell structure (total length: %08x)", len);	967	"End of sheet cell structure (total length: %08x)", len);
948	return 0;	968	return 0;
949		969
950	ERROR2:	970	ERROR2:
951	psiconv_free_sheet_cell(*result);	971	psiconv_free_sheet_cell(*result);
952	ERROR1:	972	ERROR1:
953	psiconv_warn(lev+1,off,"Reading of Sheet Cell Structure failed");	973	psiconv_warn(config,lev+1,off,"Reading of Sheet Cell Structure failed");
954	if (length)	974	if (length)
955	*length = 0;	975	*length = 0;
956	if (!res)	976	if (!res)
957	return -PSICONV_E_NOMEM;	977	return -PSICONV_E_NOMEM;
958	else	978	else
959	return res;	979	return res;
960	}	980	}
961		981
962	int psiconv_parse_sheet_cell_list(const psiconv_buffer buf, int lev,	982	int psiconv_parse_sheet_cell_list(const psiconv_config config,
		983	const psiconv_buffer buf, int lev,
963	psiconv_u32 off, int *length,	984	psiconv_u32 off, int *length,
964	psiconv_sheet_cell_list *result,	985	psiconv_sheet_cell_list *result,
965	const psiconv_sheet_cell_layout default_layout,	986	const psiconv_sheet_cell_layout default_layout,
966	const psiconv_sheet_line_list row_default_layouts,	987	const psiconv_sheet_line_list row_default_layouts,
967	const psiconv_sheet_line_list col_default_layouts)	988	const psiconv_sheet_line_list col_default_layouts)
…		…
971	psiconv_u32 temp;	992	psiconv_u32 temp;
972	psiconv_sheet_cell cell;	993	psiconv_sheet_cell cell;
973	psiconv_u32 listlen,i;	994	psiconv_u32 listlen,i;
974	int leng;	995	int leng;
975		996
976	psiconv_progress(lev+1,off,"Going to read the sheet cell list");	997	psiconv_progress(config,lev+1,off,"Going to read the sheet cell list");
977	if (!(*result = psiconv_list_new(sizeof(struct psiconv_sheet_cell_s))))	998	if (!(*result = psiconv_list_new(sizeof(struct psiconv_sheet_cell_s))))
978	goto ERROR1;	999	goto ERROR1;
979		1000
980	psiconv_progress(lev+2,off+len,	1001	psiconv_progress(config,lev+2,off+len,
981	"Going to read the initial byte (%02x expected)",0x02);	1002	"Going to read the initial byte (%02x expected)",0x02);
982	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	1003	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
983	if (res)	1004	if (res)
984	goto ERROR2;	1005	goto ERROR2;
985	if (temp != 0x02) {	1006	if (temp != 0x02) {
986	psiconv_warn(lev+2,off+len,	1007	psiconv_warn(config,lev+2,off+len,
987	"Sheet cell list initial byte unknown value (ignored)");	1008	"Sheet cell list initial byte unknown value (ignored)");
988	psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);	1009	psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
989	}	1010	}
990	len ++;	1011	len ++;
991		1012
992	psiconv_progress(lev+2,off+len,	1013	psiconv_progress(config,lev+2,off+len,
993	"Going to read the initial byte (%02x expected)",0x00);	1014	"Going to read the initial byte (%02x expected)",0x00);
994	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	1015	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
995	if (res)	1016	if (res)
996	goto ERROR2;	1017	goto ERROR2;
997	if (temp != 0x00) {	1018	if (temp != 0x00) {
998	psiconv_warn(lev+2,off+len,	1019	psiconv_warn(config,lev+2,off+len,
999	"Sheet cell list initial byte unknown value (ignored)");	1020	"Sheet cell list initial byte unknown value (ignored)");
1000	psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);	1021	psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
1001	}	1022	}
1002	len ++;	1023	len ++;
1003		1024
1004	psiconv_progress(lev+2,off+len,	1025	psiconv_progress(config,lev+2,off+len,
1005	"Going to read the number of defined cells");	1026	"Going to read the number of defined cells");
1006	listlen = psiconv_read_X(buf,lev+2,off+len,&leng,&res);	1027	listlen = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
1007	if (res)	1028	if (res)
1008	goto ERROR2;	1029	goto ERROR2;
1009	psiconv_debug(lev+2,off+len,"Number of defined cells: %d",listlen);	1030	psiconv_debug(config,lev+2,off+len,"Number of defined cells: %d",listlen);
1010	len += leng;	1031	len += leng;
1011		1032
1012	psiconv_progress(lev+2,off+len,"Going to read all cells");	1033	psiconv_progress(config,lev+2,off+len,"Going to read all cells");
1013	for (i = 0; i < listlen; i++) {	1034	for (i = 0; i < listlen; i++) {
1014	psiconv_progress(lev+3,off+len,"Going to read cell %d",i);	1035	psiconv_progress(config,lev+3,off+len,"Going to read cell %d",i);
1015	if ((res = psiconv_parse_sheet_cell(buf,lev+3,off+len,&leng,&cell,	1036	if ((res = psiconv_parse_sheet_cell(config,buf,lev+3,off+len,&leng,&cell,
1016	default_layout,row_default_layouts,	1037	default_layout,row_default_layouts,
1017	col_default_layouts)))	1038	col_default_layouts)))
1018	goto ERROR2;	1039	goto ERROR2;
1019	if ((res = psiconv_list_add(*result,cell)))	1040	if ((res = psiconv_list_add(*result,cell)))
1020	goto ERROR3;	1041	goto ERROR3;
…		…
1023	}	1044	}
1024		1045
1025	if (length)	1046	if (length)
1026	*length = len;	1047	*length = len;
1027		1048
1028	psiconv_progress(lev,off+len-1,	1049	psiconv_progress(config,lev,off+len-1,
1029	"End of sheet cell list (total length: %08x)", len);	1050	"End of sheet cell list (total length: %08x)", len);
1030	return 0;	1051	return 0;
1031		1052
1032	ERROR3:	1053	ERROR3:
1033	psiconv_free_sheet_cell(cell);	1054	psiconv_free_sheet_cell(cell);
1034	ERROR2:	1055	ERROR2:
1035	psiconv_free_sheet_cell_list(*result);	1056	psiconv_free_sheet_cell_list(*result);
1036	ERROR1:	1057	ERROR1:
1037	psiconv_warn(lev+1,off,"Reading of Sheet Cells List failed");	1058	psiconv_warn(config,lev+1,off,"Reading of Sheet Cells List failed");
1038	if (length)	1059	if (length)
1039	*length = 0;	1060	*length = 0;
1040	if (!res)	1061	if (!res)
1041	return -PSICONV_E_NOMEM;	1062	return -PSICONV_E_NOMEM;
1042	else	1063	else
1043	return res;	1064	return res;
1044	}	1065	}
1045		1066
1046		1067
1047	int psiconv_parse_sheet_worksheet_list( const psiconv_buffer buf, int lev,	1068	int psiconv_parse_sheet_worksheet_list(const psiconv_config config,
		1069	const psiconv_buffer buf, int lev,
1048	psiconv_u32 off, int *length,	1070	psiconv_u32 off, int *length,
1049	psiconv_sheet_worksheet_list *result)	1071	psiconv_sheet_worksheet_list *result)
1050	{	1072	{
1051	psiconv_sheet_worksheet worksheet;	1073	psiconv_sheet_worksheet worksheet;
1052	int res=0;	1074	int res=0;
1053	int len=0;	1075	int len=0;
1054	psiconv_u8 temp;	1076	psiconv_u8 temp;
1055	psiconv_u32 offset;	1077	psiconv_u32 offset;
1056	int leng,i,nr;	1078	int leng,i,nr;
1057		1079
1058	psiconv_progress(lev+1,off,"Going to read the worksheet list");	1080	psiconv_progress(config,lev+1,off,"Going to read the worksheet list");
1059	if (!(result = psiconv_list_new(sizeof(worksheet))))	1081	if (!(result = psiconv_list_new(sizeof(worksheet))))
1060	goto ERROR1;	1082	goto ERROR1;
1061		1083
1062	psiconv_progress(lev+2,off+len,	1084	psiconv_progress(config,lev+2,off+len,
1063	"Going to read the initial bytes (%02x expected)",0x02);	1085	"Going to read the initial bytes (%02x expected)",0x02);
1064	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	1086	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1065	if (res)	1087	if (res)
1066	goto ERROR2;	1088	goto ERROR2;
1067	if (temp != 0x02) {	1089	if (temp != 0x02) {
1068	psiconv_warn(lev+2,off+len,	1090	psiconv_warn(config,lev+2,off+len,
1069	"Sheet worksheet list initial byte unknown value (ignored)");	1091	"Sheet worksheet list initial byte unknown value (ignored)");
1070	psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);	1092	psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
1071	}	1093	}
1072	len ++;	1094	len ++;
1073		1095
1074	psiconv_progress(lev+2,off+len,"Going to read the list length");	1096	psiconv_progress(config,lev+2,off+len,"Going to read the list length");
1075	nr = psiconv_read_X(buf,lev+2,off+len,&leng,&res);	1097	nr = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
1076	if (res)	1098	if (res)
1077	goto ERROR2;	1099	goto ERROR2;
1078	psiconv_debug(lev+2,off+len,"Length: %02x",nr);	1100	psiconv_debug(config,lev+2,off+len,"Length: %02x",nr);
1079	len += leng;	1101	len += leng;
1080		1102
1081	psiconv_progress(lev+2,off+len,"Going to read the list");	1103	psiconv_progress(config,lev+2,off+len,"Going to read the list");
1082	for (i=0 ; i < nr; i++) {	1104	for (i=0 ; i < nr; i++) {
1083	psiconv_progress(lev+3,off+len,"Going to read element %d",i);	1105	psiconv_progress(config,lev+3,off+len,"Going to read element %d",i);
1084	psiconv_progress(lev+4,off+len,	1106	psiconv_progress(config,lev+4,off+len,
1085	"Going to read the initial byte (%02x expected)",0x00);	1107	"Going to read the initial byte (%02x expected)",0x00);
1086	temp = psiconv_read_u8(buf,lev+4,off+len,&res);	1108	temp = psiconv_read_u8(config,buf,lev+4,off+len,&res);
1087	if (res)	1109	if (res)
1088	goto ERROR2;	1110	goto ERROR2;
1089	if (temp != 0x00) {	1111	if (temp != 0x00) {
1090	psiconv_warn(lev+4,off+len,	1112	psiconv_warn(config,lev+4,off+len,
1091	"Sheet worksheet element initial byte unknown value (ignored)");	1113	"Sheet worksheet element initial byte unknown value (ignored)");
1092	psiconv_debug(lev+4,off+len,"Initial byte: %02x",temp);	1114	psiconv_debug(config,lev+4,off+len,"Initial byte: %02x",temp);
1093	}	1115	}
1094	len ++;	1116	len ++;
1095		1117
1096	psiconv_progress(lev+4,off+len,"Going to read the worksheet offset");	1118	psiconv_progress(config,lev+4,off+len,"Going to read the worksheet offset");
1097	offset = psiconv_read_u32(buf,lev+2,off+len,&res);	1119	offset = psiconv_read_u32(config,buf,lev+2,off+len,&res);
1098	if (res)	1120	if (res)
1099	goto ERROR2;	1121	goto ERROR2;
1100	psiconv_debug(lev+4,off+len,"Offset: %08x",offset);	1122	psiconv_debug(config,lev+4,off+len,"Offset: %08x",offset);
1101	len += 4;	1123	len += 4;
1102		1124
1103	if ((res = psiconv_parse_sheet_worksheet(buf,lev+4,offset,NULL,	1125	if ((res = psiconv_parse_sheet_worksheet(config,buf,lev+4,offset,NULL,
1104	&worksheet)))	1126	&worksheet)))
1105	goto ERROR2;	1127	goto ERROR2;
1106	if ((res = psiconv_list_add(*result,worksheet)))	1128	if ((res = psiconv_list_add(*result,worksheet)))
1107	goto ERROR3;	1129	goto ERROR3;
1108	free(worksheet);	1130	free(worksheet);
1109	}	1131	}
1110		1132
1111	if (length)	1133	if (length)
1112	*length = len;	1134	*length = len;
1113		1135
1114	psiconv_progress(lev,off+len-1,	1136	psiconv_progress(config,lev,off+len-1,
1115	"End of worksheet list (total length: %08x)", len);	1137	"End of worksheet list (total length: %08x)", len);
1116		1138
1117	return 0;	1139	return 0;
1118		1140
1119	ERROR3:	1141	ERROR3:
1120	psiconv_free_sheet_worksheet(worksheet);	1142	psiconv_free_sheet_worksheet(worksheet);
1121	ERROR2:	1143	ERROR2:
1122	psiconv_free_sheet_worksheet_list(*result);	1144	psiconv_free_sheet_worksheet_list(*result);
1123	ERROR1:	1145	ERROR1:
1124	psiconv_warn(lev+1,off,"Reading of worksheet list failed");	1146	psiconv_warn(config,lev+1,off,"Reading of worksheet list failed");
1125	if (length)	1147	if (length)
1126	*length = 0;	1148	*length = 0;
1127	if (!res)	1149	if (!res)
1128	return -PSICONV_E_NOMEM;	1150	return -PSICONV_E_NOMEM;
1129	else	1151	else
1130	return res;	1152	return res;
1131	}	1153	}
1132		1154
1133	int psiconv_parse_sheet_cell_layout(const psiconv_buffer buf, int lev,	1155	int psiconv_parse_sheet_cell_layout(const psiconv_config config,
		1156	const psiconv_buffer buf, int lev,
1134	psiconv_u32 off, int *length,	1157	psiconv_u32 off, int *length,
1135	psiconv_sheet_cell_layout result)	1158	psiconv_sheet_cell_layout result)
1136		1159
1137	{	1160	{
1138	int res=0;	1161	int res=0;
1139	int len=0;	1162	int len=0;
1140	int leng;	1163	int leng;
1141	psiconv_u8 temp;	1164	psiconv_u8 temp;
1142		1165
1143	psiconv_progress(lev+1,off,"Going to read a sheet cell layout");	1166	psiconv_progress(config,lev+1,off,"Going to read a sheet cell layout");
1144		1167
1145	psiconv_progress(lev+2,off+len,	1168	psiconv_progress(config,lev+2,off+len,
1146	"Going to read the first byte (%02x expected)",0x02);	1169	"Going to read the first byte (%02x expected)",0x02);
1147	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	1170	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1148	if (res)	1171	if (res)
1149	goto ERROR1;	1172	goto ERROR1;
1150	if (temp != 0x02) {	1173	if (temp != 0x02) {
1151	psiconv_warn(lev+2,off+len,	1174	psiconv_warn(config,lev+2,off+len,
1152	"Worksheet section initial byte unknown value (ignored)");	1175	"Worksheet section initial byte unknown value (ignored)");
1153	psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);	1176	psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
1154	}	1177	}
1155	len ++;	1178	len ++;
1156		1179
1157	psiconv_progress(lev+2,off+len,"Going to read the default formats flag");	1180	psiconv_progress(config,lev+2,off+len,"Going to read the default formats flag");
1158	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	1181	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1159	if (res)	1182	if (res)
1160	goto ERROR1;	1183	goto ERROR1;
1161	len ++;	1184	len ++;
1162		1185
1163	if (temp & 0x01) {	1186	if (temp & 0x01) {
1164	psiconv_progress(lev+3,off+len,"Going to read the default paragraph codes");	1187	psiconv_progress(config,lev+3,off+len,"Going to read the default paragraph codes");
1165	if ((res = psiconv_parse_paragraph_layout_list(buf,lev+3,off+len,&leng,	1188	if ((res = psiconv_parse_paragraph_layout_list(config,buf,lev+3,off+len,&leng,
1166	result->paragraph)))	1189	result->paragraph)))
1167	goto ERROR1;	1190	goto ERROR1;
1168	len += leng;	1191	len += leng;
1169	}	1192	}
1170		1193
1171	if (temp & 0x02) {	1194	if (temp & 0x02) {
1172	psiconv_progress(lev+3,off+len,"Going to read the default character codes");	1195	psiconv_progress(config,lev+3,off+len,"Going to read the default character codes");
1173	if ((res = psiconv_parse_character_layout_list(buf,lev+3,off+len,&leng,	1196	if ((res = psiconv_parse_character_layout_list(config,buf,lev+3,off+len,&leng,
1174	result->character)))	1197	result->character)))
1175	goto ERROR1;	1198	goto ERROR1;
1176	len += leng;	1199	len += leng;
1177	}	1200	}
1178		1201
1179	if (temp & 0x04) {	1202	if (temp & 0x04) {
1180	psiconv_progress(lev+3,off+len, "Going to read the default number format");	1203	psiconv_progress(config,lev+3,off+len, "Going to read the default number format");
1181	psiconv_parse_sheet_numberformat(buf,lev+3,off+len,&leng,	1204	psiconv_parse_sheet_numberformat(config,buf,lev+3,off+len,&leng,
1182	result->numberformat);	1205	result->numberformat);
1183	len += leng;	1206	len += leng;
1184	}	1207	}
1185		1208
1186	if (length)	1209	if (length)
1187	*length = len;	1210	*length = len;
1188		1211
1189	psiconv_progress(lev,off+len-1,	1212	psiconv_progress(config,lev,off+len-1,
1190	"End of sheet cell layout (total length: %08x)", len);	1213	"End of sheet cell layout (total length: %08x)", len);
1191		1214
1192	return 0;	1215	return 0;
1193		1216
1194	ERROR1:	1217	ERROR1:
1195	psiconv_warn(lev+1,off,"Reading of sheet cell layout failed");	1218	psiconv_warn(config,lev+1,off,"Reading of sheet cell layout failed");
1196	if (length)	1219	if (length)
1197	*length = 0;	1220	*length = 0;
1198	if (!res)	1221	if (!res)
1199	return -PSICONV_E_NOMEM;	1222	return -PSICONV_E_NOMEM;
1200	else	1223	else
1201	return res;	1224	return res;
1202	}	1225	}
1203		1226
1204		1227
1205	int psiconv_parse_sheet_worksheet(const psiconv_buffer buf, int lev,	1228	int psiconv_parse_sheet_worksheet(const psiconv_config config,
		1229	const psiconv_buffer buf, int lev,
1206	psiconv_u32 off, int *length,	1230	psiconv_u32 off, int *length,
1207	psiconv_sheet_worksheet *result)	1231	psiconv_sheet_worksheet *result)
1208	{	1232	{
1209	int res=0;	1233	int res=0;
1210	psiconv_u32 temp,cells_off,grid_off,rows_off,cols_off;	1234	psiconv_u32 temp,cells_off,grid_off,rows_off,cols_off,unknown_off;
1211	int len=0;	1235	int len=0;
1212	int leng;	1236	int leng;
1213		1237
1214	psiconv_progress(lev+1,off,"Going to read the sheet worksheet section");	1238	psiconv_progress(config,lev+1,off,"Going to read the sheet worksheet section");
1215	if (!(result = malloc(sizeof(*result))))	1239	if (!(result = malloc(sizeof(*result))))
1216	goto ERROR1;	1240	goto ERROR1;
1217		1241
1218	psiconv_progress(lev+2,off+len,	1242	psiconv_progress(config,lev+2,off+len,
1219	"Going to read the initial bytes (%02x expected)",0x04);	1243	"Going to read the initial bytes (%02x expected)",0x04);
1220	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	1244	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1221	if (res)	1245	if (res)
1222	goto ERROR2;	1246	goto ERROR2;
1223	if (temp != 0x04) {	1247	if (temp != 0x04) {
1224	psiconv_warn(lev+2,off+len,	1248	psiconv_warn(config,lev+2,off+len,
1225	"Worksheet section initial byte unknown value (ignored)");	1249	"Worksheet section initial byte unknown value (ignored)");
1226	psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);	1250	psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
1227	}	1251	}
1228	len ++;	1252	len ++;
1229		1253
1230	psiconv_progress(lev+2,off+len, "Going to read the flags byte");	1254	psiconv_progress(config,lev+2,off+len, "Going to read the flags byte");
1231	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	1255	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1232	if (res)	1256	if (res)
1233	goto ERROR2;	1257	goto ERROR2;
1234	psiconv_debug(lev+2,off+len,"Flags byte: %02x",temp);	1258	psiconv_debug(config,lev+2,off+len,"Flags byte: %02x",temp);
1235	(*result)->show_zeros = (temp & 0x01)?psiconv_bool_true:psiconv_bool_false;	1259	(*result)->show_zeros = (temp & 0x01)?psiconv_bool_true:psiconv_bool_false;
1236	if (temp & 0xfe) {	1260	if (temp & 0xfe) {
1237	psiconv_warn(lev+2,off+len,	1261	psiconv_warn(config,lev+2,off+len,
1238	"Worksheet section flags byte unknown bits (ignored)");	1262	"Worksheet section flags byte unknown bits (ignored)");
1239	}	1263	}
1240	len ++;	1264	len ++;
1241		1265
1242	psiconv_progress(lev+2,off+len,"Going to read the default cell layout");	1266	psiconv_progress(config,lev+2,off+len,"Going to read the default cell layout");
1243	if (!((*result)->default_layout = psiconv_basic_cell_layout()))	1267	if (!((*result)->default_layout = psiconv_basic_cell_layout()))
1244	goto ERROR2;	1268	goto ERROR2;
1245	if ((res = psiconv_parse_sheet_cell_layout(buf,lev+2,off+len,&leng,	1269	if ((res = psiconv_parse_sheet_cell_layout(config,buf,lev+2,off+len,&leng,
1246	(*result)->default_layout)))	1270	(*result)->default_layout)))
1247	goto ERROR3;	1271	goto ERROR3;
1248	len += leng;	1272	len += leng;
1249		1273
1250	psiconv_progress(lev+2,off+len,	1274	psiconv_progress(config,lev+2,off+len,
1251	"Going to read the offset of the row defaults Section");	1275	"Going to read the offset of the row defaults Section");
1252	rows_off = psiconv_read_u32(buf,lev+2,off+len,&res);	1276	rows_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
1253	if (res)	1277	if (res)
1254	goto ERROR3;	1278	goto ERROR3;
1255	psiconv_debug(lev+2,off+len,"Offset: %04x",rows_off);	1279	psiconv_debug(config,lev+2,off+len,"Offset: %04x",rows_off);
1256	len += 4;	1280	len += 4;
1257		1281
1258	psiconv_progress(lev+2,off+len,	1282	psiconv_progress(config,lev+2,off+len,
1259	"Going to read the offset of the column defaults Section");	1283	"Going to read the offset of the column defaults Section");
1260	cols_off = psiconv_read_u32(buf,lev+2,off+len,&res);	1284	cols_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
1261	if (res)	1285	if (res)
1262	goto ERROR3;	1286	goto ERROR3;
1263	psiconv_debug(lev+2,off+len,"Offset: %04x",cols_off);	1287	psiconv_debug(config,lev+2,off+len,"Offset: %04x",cols_off);
1264	len += 4;	1288	len += 4;
1265		1289
1266	psiconv_progress(lev+2,off+len,	1290	psiconv_progress(config,lev+2,off+len,
1267	"Going to read the offset of the Cells List");	1291	"Going to read the offset of the Cells List");
1268	cells_off = psiconv_read_u32(buf,lev+2,off+len,&res);	1292	cells_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
1269	if (res)	1293	if (res)
1270	goto ERROR3;	1294	goto ERROR3;
1271	psiconv_debug(lev+2,off+len,"Offset: %04x",cells_off);	1295	psiconv_debug(config,lev+2,off+len,"Offset: %04x",cells_off);
1272	len += 4;	1296	len += 4;
1273		1297
1274	psiconv_progress(lev+2,off+len,	1298	psiconv_progress(config,lev+2,off+len,
1275	"Going to read the offset of the Grid Section");	1299	"Going to read the offset of the Grid Section");
1276	grid_off = psiconv_read_u32(buf,lev+2,off+len,&res);	1300	grid_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
1277	if (res)	1301	if (res)
1278	goto ERROR3;	1302	goto ERROR3;
1279	psiconv_debug(lev+2,off+len,"Offset: %04x",grid_off);	1303	psiconv_debug(config,lev+2,off+len,"Offset: %04x",grid_off);
1280	len += 4;	1304	len += 4;
1281		1305
1282	psiconv_progress(lev+2,off+len,	1306	psiconv_progress(config,lev+2,off+len,
1283	"Going to read the offset of the 3rd ??? Section");	1307	"Going to read the offset of the 3rd ??? Section");
1284	temp = psiconv_read_u32(buf,lev+2,off+len,&res);	1308	unknown_off = psiconv_read_u32(config,buf,lev+2,off+len,&res);
1285	if (res)	1309	if (res)
1286	goto ERROR3;	1310	goto ERROR3;
		1311	psiconv_debug(config,lev+2,off+len,"Offset: %04x",unknown_off);
		1312	len += 4;
		1313
		1314	psiconv_progress(config,lev+2,off+len,
		1315	"Going to read a long of the 3rd ??? Section "
		1316	"(%08x expected)",0x00);
		1317	temp = psiconv_read_u32(config,buf,lev+2,unknown_off,&res);
		1318	if (res)
		1319	goto ERROR3;
		1320	if (temp != 0x00) {
		1321	psiconv_warn(config,lev+2,unknown_off,
		1322	"Unknown worksheet subsection has unknown contents (ignored)");
1287	psiconv_debug(lev+2,off+len,"Offset: %04x",temp);	1323	psiconv_debug(config,lev+2,unknown_off,"Offset: %04x",temp);
		1324	}
1288	len += 4;	1325	len += 4;
1289		1326
1290	psiconv_progress(lev+2,off+len,"Going to read the row defaults");	1327	psiconv_progress(config,lev+2,off+len,"Going to read the row defaults");
1291	if ((res = psiconv_parse_sheet_line_list(buf,lev+2,rows_off,NULL,	1328	if ((res = psiconv_parse_sheet_line_list(config,buf,lev+2,rows_off,NULL,
1292	&(*result)->row_default_layouts,	1329	&(*result)->row_default_layouts,
1293	(*result)->default_layout)))	1330	(*result)->default_layout)))
1294	goto ERROR3;	1331	goto ERROR3;
1295		1332
1296	psiconv_progress(lev+2,off+len,"Going to read the column defaults");	1333	psiconv_progress(config,lev+2,off+len,"Going to read the column defaults");
1297	if ((res = psiconv_parse_sheet_line_list(buf,lev+2,cols_off,NULL,	1334	if ((res = psiconv_parse_sheet_line_list(config,buf,lev+2,cols_off,NULL,
1298	&(*result)->col_default_layouts,	1335	&(*result)->col_default_layouts,
1299	(*result)->default_layout)))	1336	(*result)->default_layout)))
1300	goto ERROR4;	1337	goto ERROR4;
1301		1338
1302	psiconv_progress(lev+2,off+len,"Going to read the cells list");	1339	psiconv_progress(config,lev+2,off+len,"Going to read the cells list");
1303	if ((res = psiconv_parse_sheet_cell_list(buf,lev+2,cells_off,NULL,	1340	if ((res = psiconv_parse_sheet_cell_list(config,buf,lev+2,cells_off,NULL,
1304	&(*result)->cells,	1341	&(*result)->cells,
1305	(*result)->default_layout,	1342	(*result)->default_layout,
1306	(*result)->row_default_layouts,	1343	(*result)->row_default_layouts,
1307	(*result)->col_default_layouts)))	1344	(*result)->col_default_layouts)))
1308	goto ERROR5;	1345	goto ERROR5;
1309		1346
1310		1347
1311	/* TODO: parse grid section */	1348	psiconv_progress(config,lev+2,off+len,"Going to read the grid section");
		1349	if ((res = psiconv_parse_sheet_grid_section(config,buf,lev+2,grid_off,NULL,
		1350	&(*result)->grid)))
		1351	goto ERROR6;
		1352
		1353
1312		1354
1313	if (length)	1355	if (length)
1314	*length = len;	1356	*length = len;
1315		1357
1316	psiconv_progress(lev,off+len-1,	1358	psiconv_progress(config,lev,off+len-1,
1317	"End of sheet worksheet section (total length: %08x)", len);	1359	"End of sheet worksheet section (total length: %08x)", len);
1318	return 0;	1360	return 0;
1319		1361
		1362	ERROR6:
		1363	psiconv_free_sheet_cell_list((*result)->cells);
1320	ERROR5:	1364	ERROR5:
1321	psiconv_free_sheet_line_list((*result)->col_default_layouts);	1365	psiconv_free_sheet_line_list((*result)->col_default_layouts);
1322	ERROR4:	1366	ERROR4:
1323	psiconv_free_sheet_line_list((*result)->row_default_layouts);	1367	psiconv_free_sheet_line_list((*result)->row_default_layouts);
1324	ERROR3:	1368	ERROR3:
1325	psiconv_free_sheet_cell_layout((*result)->default_layout);	1369	psiconv_free_sheet_cell_layout((*result)->default_layout);
1326	ERROR2:	1370	ERROR2:
1327	free (*result);	1371	free (*result);
1328	ERROR1:	1372	ERROR1:
1329	psiconv_warn(lev+1,off,"Reading of Sheet Worksheet Section failed");	1373	psiconv_warn(config,lev+1,off,"Reading of Sheet Worksheet Section failed");
1330	if (length)	1374	if (length)
1331	*length = 0;	1375	*length = 0;
1332	if (!res)	1376	if (!res)
1333	return -PSICONV_E_NOMEM;	1377	return -PSICONV_E_NOMEM;
1334	else	1378	else
1335	return res;	1379	return res;
1336	}	1380	}
1337		1381
1338	int psiconv_parse_sheet_line(const psiconv_buffer buf, int lev,	1382	int psiconv_parse_sheet_line(const psiconv_config config,
		1383	const psiconv_buffer buf, int lev,
1339	psiconv_u32 off, int *length,	1384	psiconv_u32 off, int *length,
1340	psiconv_sheet_line *result,	1385	psiconv_sheet_line *result,
1341	const psiconv_sheet_cell_layout default_layout)	1386	const psiconv_sheet_cell_layout default_layout)
1342	{	1387	{
1343	int res=0;	1388	int res=0;
1344	int len=0;	1389	int len=0;
1345	int leng;	1390	int leng;
1346		1391
1347		1392
1348	psiconv_progress(lev+1,off,"Going to read a sheet line");	1393	psiconv_progress(config,lev+1,off,"Going to read a sheet line");
1349	if (!(result = malloc(sizeof(*result))))	1394	if (!(result = malloc(sizeof(*result))))
1350	goto ERROR1;	1395	goto ERROR1;
1351		1396
1352	psiconv_progress(lev+2,off+len,"Going to read the line number");	1397	psiconv_progress(config,lev+2,off+len,"Going to read the line number");
1353	(*result)->position = psiconv_read_X(buf,lev+2,off+len,&leng,&res);	1398	(*result)->position = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
1354	if (res)	1399	if (res)
1355	goto ERROR2;	1400	goto ERROR2;
1356	psiconv_debug(lev+2,off+len,"Line number: %d\n",(*result)->position);	1401	psiconv_debug(config,lev+2,off+len,"Line number: %d\n",(*result)->position);
1357	len += leng;	1402	len += leng;
1358		1403
1359	if (!((*result)->layout = psiconv_clone_cell_layout(default_layout)))	1404	if (!((*result)->layout = psiconv_clone_cell_layout(default_layout)))
1360	goto ERROR2;	1405	goto ERROR2;
1361	if ((res = psiconv_parse_sheet_cell_layout(buf,lev+2,off+len,	1406	if ((res = psiconv_parse_sheet_cell_layout(config,buf,lev+2,off+len,
1362	&leng,(*result)->layout)))	1407	&leng,(*result)->layout)))
1363	goto ERROR3;	1408	goto ERROR3;
1364	len += leng;	1409	len += leng;
1365		1410
1366	if (length)	1411	if (length)
1367	*length = len;	1412	*length = len;
1368		1413
1369	psiconv_progress(lev,off+len-1,	1414	psiconv_progress(config,lev,off+len-1,
1370	"End of the sheet line (total length: %08x)", len);	1415	"End of the sheet line (total length: %08x)", len);
1371	return 0;	1416	return 0;
1372		1417
1373	ERROR3:	1418	ERROR3:
1374	psiconv_free_sheet_cell_layout((*result)->layout);	1419	psiconv_free_sheet_cell_layout((*result)->layout);
1375	ERROR2:	1420	ERROR2:
1376	free (*result);	1421	free (*result);
1377	ERROR1:	1422	ERROR1:
1378	psiconv_warn(lev+1,off,"Reading of the sheet line failed");	1423	psiconv_warn(config,lev+1,off,"Reading of the sheet line failed");
1379	if (length)	1424	if (length)
1380	*length = 0;	1425	*length = 0;
1381	if (!res)	1426	if (!res)
1382	return -PSICONV_E_NOMEM;	1427	return -PSICONV_E_NOMEM;
1383	else	1428	else
1384	return res;	1429	return res;
1385	}	1430	}
1386		1431
1387		1432
1388	int psiconv_parse_sheet_line_list(const psiconv_buffer buf, int lev,	1433	int psiconv_parse_sheet_line_list(const psiconv_config config,
		1434	const psiconv_buffer buf, int lev,
1389	psiconv_u32 off, int *length,	1435	psiconv_u32 off, int *length,
1390	psiconv_sheet_line_list *result,	1436	psiconv_sheet_line_list *result,
1391	const psiconv_sheet_cell_layout default_layout)	1437	const psiconv_sheet_cell_layout default_layout)
1392	{	1438	{
1393	int res=0;	1439	int res=0;
…		…
1395	psiconv_u32 temp;	1441	psiconv_u32 temp;
1396	psiconv_sheet_line line;	1442	psiconv_sheet_line line;
1397	psiconv_u32 listlen,i;	1443	psiconv_u32 listlen,i;
1398	int leng;	1444	int leng;
1399		1445
1400	psiconv_progress(lev+1,off,"Going to read the sheet line list");	1446	psiconv_progress(config,lev+1,off,"Going to read the sheet line list");
1401	if (!(*result = psiconv_list_new(sizeof(struct psiconv_sheet_line_s))))	1447	if (!(*result = psiconv_list_new(sizeof(struct psiconv_sheet_line_s))))
1402	goto ERROR1;	1448	goto ERROR1;
1403		1449
1404	psiconv_progress(lev+2,off+len,	1450	psiconv_progress(config,lev+2,off+len,
1405	"Going to read the initial byte (%02x expected)",0x02);	1451	"Going to read the initial byte (%02x expected)",0x02);
1406	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	1452	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1407	if (res)	1453	if (res)
1408	goto ERROR2;	1454	goto ERROR2;
1409	if (temp != 0x02) {	1455	if (temp != 0x02) {
1410	psiconv_warn(lev+2,off+len,	1456	psiconv_warn(config,lev+2,off+len,
1411	"Sheet line list initial byte unknown value (ignored)");	1457	"Sheet line list initial byte unknown value (ignored)");
1412	psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);	1458	psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
1413	}	1459	}
1414	len ++;	1460	len ++;
1415		1461
1416	psiconv_progress(lev+2,off+len,	1462	psiconv_progress(config,lev+2,off+len,
1417	"Going to read the number of defined lines");	1463	"Going to read the number of defined lines");
1418	listlen = psiconv_read_X(buf,lev+2,off+len,&leng,&res);	1464	listlen = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
1419	if (res)	1465	if (res)
1420	goto ERROR2;	1466	goto ERROR2;
1421	psiconv_debug(lev+2,off+len,"Number of defined lines: %d",listlen);	1467	psiconv_debug(config,lev+2,off+len,"Number of defined lines: %d",listlen);
1422	len += leng;	1468	len += leng;
1423		1469
1424	psiconv_progress(lev+2,off+len,"Going to read all lines");	1470	psiconv_progress(config,lev+2,off+len,"Going to read all lines");
1425	for (i = 0; i < listlen; i++) {	1471	for (i = 0; i < listlen; i++) {
1426	psiconv_progress(lev+3,off+len,"Going to read line %d",i);	1472	psiconv_progress(config,lev+3,off+len,"Going to read line %d",i);
1427	if ((res = psiconv_parse_sheet_line(buf,lev+3,off+len,&leng,&line,	1473	if ((res = psiconv_parse_sheet_line(config,buf,lev+3,off+len,&leng,&line,
1428	default_layout)))	1474	default_layout)))
1429	goto ERROR2;	1475	goto ERROR2;
1430	if ((res = psiconv_list_add(*result,line)))	1476	if ((res = psiconv_list_add(*result,line)))
1431	goto ERROR3;	1477	goto ERROR3;
1432	free(line);	1478	free(line);
…		…
1434	}	1480	}
1435		1481
1436	if (length)	1482	if (length)
1437	*length = len;	1483	*length = len;
1438		1484
1439	psiconv_progress(lev,off+len-1,	1485	psiconv_progress(config,lev,off+len-1,
1440	"End of sheet line list (total length: %08x)", len);	1486	"End of sheet line list (total length: %08x)", len);
1441	return 0;	1487	return 0;
1442		1488
1443	ERROR3:	1489	ERROR3:
1444	psiconv_free_sheet_line(line);	1490	psiconv_free_sheet_line(line);
1445	ERROR2:	1491	ERROR2:
1446	psiconv_free_sheet_line_list(*result);	1492	psiconv_free_sheet_line_list(*result);
1447	ERROR1:	1493	ERROR1:
1448	psiconv_warn(lev+1,off,"Reading of Sheet Line List failed");	1494	psiconv_warn(config,lev+1,off,"Reading of Sheet Line List failed");
1449	if (length)	1495	if (length)
1450	*length = 0;	1496	*length = 0;
1451	if (!res)	1497	if (!res)
1452	return -PSICONV_E_NOMEM;	1498	return -PSICONV_E_NOMEM;
1453	else	1499	else
1454	return res;	1500	return res;
1455	}	1501	}
1456		1502
1457	int psiconv_parse_sheet_variable(const psiconv_buffer buf, int lev,	1503	int psiconv_parse_sheet_variable(const psiconv_config config,
		1504	const psiconv_buffer buf, int lev,
1458	psiconv_u32 off, int *length,	1505	psiconv_u32 off, int *length,
1459	psiconv_sheet_variable *result)	1506	psiconv_sheet_variable *result)
1460	{	1507	{
1461	int res=0;	1508	int res=0;
1462	int len=0;	1509	int len=0;
1463	psiconv_u32 marker;	1510	psiconv_u32 marker;
1464	int leng;	1511	int leng;
1465		1512
1466	psiconv_progress(lev+1,off,"Going to read a sheet variable");	1513	psiconv_progress(config,lev+1,off,"Going to read a sheet variable");
1467	if (!(result = malloc(sizeof(*result))))	1514	if (!(result = malloc(sizeof(*result))))
1468	goto ERROR1;	1515	goto ERROR1;
1469		1516
1470	psiconv_progress(lev+2,off+len, "Going to read the variable name");	1517	psiconv_progress(config,lev+2,off+len, "Going to read the variable name");
1471	(*result)->name = psiconv_read_string(buf,lev+2,off+len,&leng,&res);	1518	(*result)->name = psiconv_read_string(config,buf,lev+2,off+len,&leng,&res);
1472	if (res)	1519	if (res)
1473	goto ERROR2;	1520	goto ERROR2;
1474	len += leng;	1521	len += leng;
1475		1522
1476	psiconv_progress(lev+2,off+len,"Going to read the type marker");	1523	psiconv_progress(config,lev+2,off+len,"Going to read the type marker");
1477	marker = psiconv_read_u8(buf,lev+2,off+len,&res);	1524	marker = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1478	if (res)	1525	if (res)
1479	goto ERROR3;	1526	goto ERROR3;
1480	psiconv_debug(lev+2,off+len,"Marker: %02x",marker);	1527	psiconv_debug(config,lev+2,off+len,"Marker: %02x",marker);
1481	len ++;	1528	len ++;
1482		1529
1483	if (marker == 0x00) {	1530	if (marker == 0x00) {
1484	(*result)->type = psiconv_var_int;	1531	(*result)->type = psiconv_var_int;
1485	psiconv_progress(lev+2,off+len,"Going to read a signed integer");	1532	psiconv_progress(config,lev+2,off+len,"Going to read a signed integer");
1486	(*result)->data.dat_int = psiconv_read_sint(buf,lev+2,off+len,&leng,&res);	1533	(*result)->data.dat_int = psiconv_read_sint(config,buf,lev+2,off+len,&leng,&res);
1487	if (res)	1534	if (res)
1488	goto ERROR3;	1535	goto ERROR3;
1489	psiconv_debug(lev+2,off+len,"Value: %d",(*result)->data.dat_int);	1536	psiconv_debug(config,lev+2,off+len,"Value: %d",(*result)->data.dat_int);
1490	len += leng;	1537	len += leng;
1491	} else if (marker == 0x01) {	1538	} else if (marker == 0x01) {
1492	(*result)->type = psiconv_var_float;	1539	(*result)->type = psiconv_var_float;
1493	psiconv_progress(lev+2,off+len,"Going to read a floating point number");	1540	psiconv_progress(config,lev+2,off+len,"Going to read a floating point number");
1494	(*result)->data.dat_float = psiconv_read_float(buf,lev+2,off+len,&leng,	1541	(*result)->data.dat_float = psiconv_read_float(config,buf,lev+2,off+len,&leng,
1495	&res);	1542	&res);
1496	if (res)	1543	if (res)
1497	goto ERROR3;	1544	goto ERROR3;
1498	psiconv_debug(lev+2,off+len,"Value: %f",(*result)->data.dat_float);	1545	psiconv_debug(config,lev+2,off+len,"Value: %f",(*result)->data.dat_float);
1499	len += leng;	1546	len += leng;
1500	} else if (marker == 0x02) {	1547	} else if (marker == 0x02) {
1501	(*result)->type = psiconv_var_string;	1548	(*result)->type = psiconv_var_string;
1502	psiconv_progress(lev+2,off+len,"Going to read a string");	1549	psiconv_progress(config,lev+2,off+len,"Going to read a string");
1503	(*result)->data.dat_string = psiconv_read_string(buf,lev+2,off+len,&leng,	1550	(*result)->data.dat_string = psiconv_read_string(config,buf,lev+2,off+len,&leng,
1504	&res);	1551	&res);
1505	if (res)	1552	if (res)
1506	goto ERROR3;	1553	goto ERROR3;
1507	len += leng;	1554	len += leng;
1508	} else if (marker == 0x03) {	1555	} else if (marker == 0x03) {
1509	(*result)->type = psiconv_var_cellref;	1556	(*result)->type = psiconv_var_cellref;
1510	psiconv_progress(lev+2,off+len,"Going to read a cell reference");	1557	psiconv_progress(config,lev+2,off+len,"Going to read a cell reference");
1511	(*result)->data.dat_cellref = psiconv_read_var_cellref(buf,lev+2,off+len,	1558	(*result)->data.dat_cellref = psiconv_read_var_cellref(config,buf,lev+2,off+len,
1512	&leng, &res);	1559	&leng, &res);
1513	if (res)	1560	if (res)
1514	goto ERROR3;	1561	goto ERROR3;
1515	len += leng;	1562	len += leng;
1516	} else if (marker == 0x04) {	1563	} else if (marker == 0x04) {
1517	(*result)->type = psiconv_var_cellblock;	1564	(*result)->type = psiconv_var_cellblock;
1518	psiconv_progress(lev+2,off+len,"Going to read a cell block reference");	1565	psiconv_progress(config,lev+2,off+len,"Going to read a cell block reference");
1519	(*result)->data.dat_cellblock = psiconv_read_var_cellblock(buf,lev+2,	1566	(*result)->data.dat_cellblock = psiconv_read_var_cellblock(config,buf,lev+2,
1520	off+len,	1567	off+len,
1521	&leng, &res);	1568	&leng, &res);
1522	if (res)	1569	if (res)
1523	goto ERROR3;	1570	goto ERROR3;
1524	len += leng;	1571	len += leng;
1525	} else {	1572	} else {
1526	psiconv_warn(lev+2,off+len,"Sheet variable unknown type marker");	1573	psiconv_warn(config,lev+2,off+len,"Sheet variable unknown type marker");
1527	res = -PSICONV_E_PARSE;	1574	res = -PSICONV_E_PARSE;
1528	goto ERROR3;	1575	goto ERROR3;
1529	}	1576	}
1530		1577
1531	psiconv_progress(lev+2,off+len,"Going to read the variable number");	1578	psiconv_progress(config,lev+2,off+len,"Going to read the variable number");
1532	(*result)->number = psiconv_read_u32(buf,lev+2,off+len,&res);	1579	(*result)->number = psiconv_read_u32(config,buf,lev+2,off+len,&res);
1533	if (res)	1580	if (res)
1534	goto ERROR4;	1581	goto ERROR4;
1535	psiconv_debug(lev+2,off+len,"Number: %08x",(*result)->number);	1582	psiconv_debug(config,lev+2,off+len,"Number: %08x",(*result)->number);
1536	len += 4;	1583	len += 4;
1537		1584
1538	if (length)	1585	if (length)
1539	*length = len;	1586	*length = len;
1540		1587
1541	psiconv_progress(lev,off+len-1,	1588	psiconv_progress(config,lev,off+len-1,
1542	"End of sheet variable (total length: %08x)", len);	1589	"End of sheet variable (total length: %08x)", len);
1543	return 0;	1590	return 0;
1544		1591
1545	ERROR4:	1592	ERROR4:
1546	if ((*result)->type == psiconv_var_string)	1593	if ((*result)->type == psiconv_var_string)
…		…
1548	ERROR3:	1595	ERROR3:
1549	free((*result)->name);	1596	free((*result)->name);
1550	ERROR2:	1597	ERROR2:
1551	free (*result);	1598	free (*result);
1552	ERROR1:	1599	ERROR1:
1553	psiconv_warn(lev+1,off,"Reading of Sheet Variable failed");	1600	psiconv_warn(config,lev+1,off,"Reading of Sheet Variable failed");
1554	if (length)	1601	if (length)
1555	*length = 0;	1602	*length = 0;
1556	if (!res)	1603	if (!res)
1557	return -PSICONV_E_NOMEM;	1604	return -PSICONV_E_NOMEM;
1558	else	1605	else
1559	return res;	1606	return res;
1560	}	1607	}
1561		1608
1562		1609
1563	int psiconv_parse_sheet_variable_list(const psiconv_buffer buf, int lev,	1610	int psiconv_parse_sheet_variable_list(const psiconv_config config,
		1611	const psiconv_buffer buf, int lev,
1564	psiconv_u32 off, int *length,	1612	psiconv_u32 off, int *length,
1565	psiconv_sheet_variable_list *result)	1613	psiconv_sheet_variable_list *result)
1566	{	1614	{
1567	int res=0;	1615	int res=0;
1568	int len=0;	1616	int len=0;
1569	psiconv_u32 temp;	1617	psiconv_u32 temp;
1570	psiconv_sheet_variable variable;	1618	psiconv_sheet_variable variable;
1571	psiconv_u32 listlen,i;	1619	psiconv_u32 listlen,i;
1572	int leng;	1620	int leng;
1573		1621
1574	psiconv_progress(lev+1,off,"Going to read the sheet variable list");	1622	psiconv_progress(config,lev+1,off,"Going to read the sheet variable list");
1575	if (!(*result = psiconv_list_new(sizeof(struct psiconv_sheet_variable_s))))	1623	if (!(*result = psiconv_list_new(sizeof(struct psiconv_sheet_variable_s))))
1576	goto ERROR1;	1624	goto ERROR1;
1577		1625
1578	psiconv_progress(lev+2,off+len,	1626	psiconv_progress(config,lev+2,off+len,
1579	"Going to read the initial byte (%02x expected)",0x02);	1627	"Going to read the initial byte (%02x expected)",0x02);
1580	temp = psiconv_read_u8(buf,lev+2,off+len,&res);	1628	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
1581	if (res)	1629	if (res)
1582	goto ERROR2;	1630	goto ERROR2;
1583	if (temp != 0x02) {	1631	if (temp != 0x02) {
1584	psiconv_warn(lev+2,off+len,	1632	psiconv_warn(config,lev+2,off+len,
1585	"Sheet variable list initial byte unknown value (ignored)");	1633	"Sheet variable list initial byte unknown value (ignored)");
1586	psiconv_debug(lev+2,off+len,"Initial byte: %02x",temp);	1634	psiconv_debug(config,lev+2,off+len,"Initial byte: %02x",temp);
1587	}	1635	}
1588	len ++;	1636	len ++;
1589		1637
1590	psiconv_progress(lev+2,off+len,	1638	psiconv_progress(config,lev+2,off+len,
1591	"Going to read the number of variables");	1639	"Going to read the number of variables");
1592	listlen = psiconv_read_X(buf,lev+2,off+len,&leng,&res);	1640	listlen = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
1593	if (res)	1641	if (res)
1594	goto ERROR2;	1642	goto ERROR2;
1595	psiconv_debug(lev+2,off+len,"Number of variables: %d",listlen);	1643	psiconv_debug(config,lev+2,off+len,"Number of variables: %d",listlen);
1596	len += leng;	1644	len += leng;
1597		1645
1598	psiconv_progress(lev+2,off+len,"Going to read all variables");	1646	psiconv_progress(config,lev+2,off+len,"Going to read all variables");
1599	for (i = 0; i < listlen; i++) {	1647	for (i = 0; i < listlen; i++) {
1600	psiconv_progress(lev+3,off+len,"Going to read variable %d",i);	1648	psiconv_progress(config,lev+3,off+len,"Going to read variable %d",i);
1601	if ((res = psiconv_parse_sheet_variable(buf,lev+3,off+len,&leng,&variable)))	1649	if ((res = psiconv_parse_sheet_variable(config,buf,lev+3,off+len,&leng,&variable)))
1602	goto ERROR2;	1650	goto ERROR2;
1603	if ((res = psiconv_list_add(*result,variable)))	1651	if ((res = psiconv_list_add(*result,variable)))
1604	goto ERROR3;	1652	goto ERROR3;
1605	len += leng;	1653	len += leng;
1606	}	1654	}
1607		1655
1608	if (length)	1656	if (length)
1609	*length = len;	1657	*length = len;
1610		1658
1611	psiconv_progress(lev,off+len-1,	1659	psiconv_progress(config,lev,off+len-1,
1612	"End of sheet variabels list (total length: %08x)", len);	1660	"End of sheet variabels list (total length: %08x)", len);
1613	return 0;	1661	return 0;
1614		1662
1615	ERROR3:	1663	ERROR3:
1616	psiconv_free_sheet_variable(variable);	1664	psiconv_free_sheet_variable(variable);
1617	ERROR2:	1665	ERROR2:
1618	psiconv_list_free(*result);	1666	psiconv_list_free(*result);
1619	ERROR1:	1667	ERROR1:
1620	psiconv_warn(lev+1,off,"Reading of Sheet Variable list failed");	1668	psiconv_warn(config,lev+1,off,"Reading of Sheet Variable list failed");
1621	if (length)	1669	if (length)
1622	*length = 0;	1670	*length = 0;
1623	if (!res)	1671	if (!res)
1624	return -PSICONV_E_NOMEM;	1672	return -PSICONV_E_NOMEM;
1625	else	1673	else
1626	return res;	1674	return res;
1627	}	1675	}
		1676
		1677	int psiconv_parse_sheet_grid_section(const psiconv_config config,
		1678	const psiconv_buffer buf, int lev,
		1679	psiconv_u32 off, int *length,
		1680	psiconv_sheet_grid_section *result)
		1681	{
		1682	int res=0,i;
		1683	int len=0,leng;
		1684	psiconv_u32 temp;
		1685
		1686	psiconv_progress(config,lev+1,off,"Going to read the sheet grid section");
		1687	if (!(result = malloc(sizeof(*result))))
		1688	goto ERROR1;
		1689
		1690	psiconv_progress(config,lev+2,off+len, "Going to read the first flags byte");
		1691	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
		1692	if (res)
		1693	goto ERROR2;
		1694	(*result)->show_column_titles = temp&0x01?psiconv_bool_true:
		1695	psiconv_bool_false;
		1696	psiconv_debug(config,lev+2,off+len,
		1697	"Show column titles: %s",
		1698	(*result)->show_column_titles?"true":"false");
		1699	(*result)->show_row_titles = temp&0x02?psiconv_bool_true:psiconv_bool_false;
		1700	psiconv_debug(config,lev+2,off+len,
		1701	"Show row titles: %s",
		1702	(*result)->show_row_titles?"true":"false");
		1703	(*result)->show_vertical_grid = temp&0x04?psiconv_bool_true:
		1704	psiconv_bool_false;
		1705	psiconv_debug(config,lev+2,off+len,
		1706	"Show vertical grid: %s",
		1707	(*result)->show_vertical_grid?"true":"false");
		1708	(*result)->show_horizontal_grid = temp&0x07?psiconv_bool_true:
		1709	psiconv_bool_false;
		1710	psiconv_debug(config,lev+2,off+len,
		1711	"Show horizontal grid: %s",
		1712	(*result)->show_horizontal_grid?"true":"false");
		1713	(*result)->freeze_rows = temp&0x80?psiconv_bool_true:psiconv_bool_false;
		1714	psiconv_debug(config,lev+2,off+len,
		1715	"Freeze rows: %s",
		1716	(*result)->freeze_rows?"true":"false");
		1717	if ((temp & 0x70) != 0x30) {
		1718	psiconv_warn(config,lev+2,off+len,
		1719	"Grid section first flag byte has unknown bits (ignored)");
		1720	psiconv_debug(config,lev+2,off+len,"Bits: %02x (%02x expected)",temp&0x70,0x30);
		1721	}
		1722	len ++;
		1723
		1724	psiconv_progress(config,lev+2,off+len, "Going to read the second flags byte");
		1725	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
		1726	if (res)
		1727	goto ERROR2;
		1728	(*result)->freeze_columns = temp&0x01?psiconv_bool_true:psiconv_bool_false;
		1729	psiconv_debug(config,lev+2,off+len,
		1730	"Freeze columns: %s", (*result)->freeze_columns?"true":"false");
		1731	if ((temp & 0xfe) != 0x80) {
		1732	psiconv_warn(config,lev+2,off+len,
		1733	"Grid section second flag byte has unknown bits (ignored)");
		1734	psiconv_debug(config,lev+2,off+len,"Bits: %02x (%02x expected)",temp&0xfe,0x80);
		1735	}
		1736	len ++;
		1737
		1738	psiconv_progress(config,lev+2,off+len,
		1739	"Going to an unknown byte (%02x expected)",0x90);
		1740	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
		1741	if (res)
		1742	goto ERROR2;
		1743	if (temp != 0x90) {
		1744	psiconv_warn(config,lev+2,off+len,
		1745	"Grid section third byte unknown value (ignored)");
		1746	psiconv_debug(config,lev+2,off+len,"Value: %02x",temp);
		1747	}
		1748	len ++;
		1749
		1750	psiconv_progress(config,lev+2,off+len, "Going to read the fourth flags byte");
		1751	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
		1752	if (res)
		1753	goto ERROR2;
		1754	(*result)->show_page_breaks = temp&0x04?psiconv_bool_true:psiconv_bool_false;
		1755	psiconv_debug(config,lev+2,off+len,
		1756	"Show page breaks: %s",
		1757	(*result)->show_page_breaks?"true":"false");
		1758	if ((temp & 0xfc) != 0x00) {
		1759	psiconv_warn(config,lev+2,off+len,
		1760	"Grid section fourth flag byte has unknown bits (ignored)");
		1761	psiconv_debug(config,lev+2,off+len,"Bits: %02x (%02x expected)",temp&0xfc,0x00);
		1762	}
		1763	len ++;
		1764
		1765	psiconv_progress(config,lev+2,off+len,"Going to read the first visible row");
		1766	(*result)->first_row = psiconv_read_u32(config,buf,lev+2,off+len,&res);
		1767	if (res)
		1768	goto ERROR2;
		1769	psiconv_debug(config,lev+2,off+len,"First row: %d",(*result)->first_row);
		1770	len += 4;
		1771
		1772	psiconv_progress(config,lev+2,off+len,"Going to read the first visible column");
		1773	(*result)->first_column = psiconv_read_u32(config,buf,lev+2,off+len,&res);
		1774	if (res)
		1775	goto ERROR2;
		1776	psiconv_debug(config,lev+2,off+len,"First column: %d",(*result)->first_column);
		1777	len += 4;
		1778
		1779	psiconv_progress(config,lev+2,off+len,"Going to read the last visible row");
		1780	(*result)->last_row = psiconv_read_u32(config,buf,lev+2,off+len,&res);
		1781	if (res)
		1782	goto ERROR2;
		1783	psiconv_debug(config,lev+2,off+len,"Last row: %d",(*result)->last_row);
		1784	len += 4;
		1785
		1786	psiconv_progress(config,lev+2,off+len,"Going to read the last visible column");
		1787	(*result)->last_column = psiconv_read_u32(config,buf,lev+2,off+len,&res);
		1788	if (res)
		1789	goto ERROR2;
		1790	psiconv_debug(config,lev+2,off+len,"Last column: %d",(*result)->last_column);
		1791	len += 4;
		1792
		1793	psiconv_progress(config,lev+2,off+len,"Going to read the default row height");
		1794	(*result)->default_row_height = psiconv_read_length(config,buf,lev+2,off+len,
		1795	&leng,&res);
		1796	if (res)
		1797	goto ERROR2;
		1798	psiconv_debug(config,lev+2,off+len,"Default row height: %f",
		1799	(*result)->default_row_height);
		1800	len += leng;
		1801
		1802	psiconv_progress(config,lev+2,off+len,"Going to read the row heights list");
		1803	if ((res = psiconv_parse_sheet_grid_size_list(config,buf,lev+2,off+len,&leng,
		1804	&(*result)->row_heights)))
		1805	goto ERROR2;
		1806	len += leng;
		1807
		1808	psiconv_progress(config,lev+2,off+len,"Going to read the default column height");
		1809	(*result)->default_column_width = psiconv_read_length(config,buf,lev+2,off+len,
		1810	&leng,&res);
		1811	if (res)
		1812	goto ERROR3;
		1813	psiconv_debug(config,lev+2,off+len,"Default column width: %f",
		1814	(*result)->default_column_width);
		1815	len += leng;
		1816
		1817	psiconv_progress(config,lev+2,off+len,"Going to read the column heights list");
		1818	if ((res = psiconv_parse_sheet_grid_size_list(config,buf,lev+2,off+len,&leng,
		1819	&(*result)->column_heights)))
		1820	goto ERROR3;
		1821	len += leng;
		1822
		1823	psiconv_progress(config,lev+2,off+len,
		1824	"Going to read an unknown word (%04x expected)",0x00);
		1825	temp = psiconv_read_u16(config,buf,lev+2,off+len,&res);
		1826	if (res)
		1827	goto ERROR4;
		1828	if (temp != 0x00) {
		1829	psiconv_warn(config,lev+2,off+len,
		1830	"Grid section unknown word has unknown value (ignored)");
		1831	psiconv_debug(config,lev+2,off+len,"Value: %04x",temp);
		1832	}
		1833	len += 2;
		1834
		1835	psiconv_progress(config,lev+2,off+len,"Going to read the row breaks list");
		1836	if ((res = psiconv_parse_sheet_grid_break_list(config,buf,lev+2,off+len,&leng,
		1837	&(*result)->row_page_breaks)))
		1838	goto ERROR4;
		1839	len += leng;
		1840
		1841	psiconv_progress(config,lev+2,off+len,"Going to read the column breaks list");
		1842	if ((res = psiconv_parse_sheet_grid_break_list(config,buf,lev+2,off+len,&leng,
		1843	&(*result)->column_page_breaks)))
		1844	goto ERROR5;
		1845	len += leng;
		1846
		1847
		1848	psiconv_progress(config,lev+2,off+len,
		1849	"Going to read 22 unknown bytes (%02x expected)",0x00);
		1850	for (i = 0; i < 22 ; i++) {
		1851	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
		1852	if (res)
		1853	goto ERROR6;
		1854	if (temp != 0x00) {
		1855	psiconv_warn(config,lev+2,off+len,
		1856	"Grid section unknown byte %d has unknown value (ignored)",
		1857	i);
		1858	psiconv_debug(config,lev+2,off+len,"Value: %02x",temp);
		1859	}
		1860	len += 1;
		1861	}
		1862
		1863	if ((result)->freeze_rows \|\| (result)->freeze_columns) {
		1864
		1865	psiconv_progress(config,lev+2,off+len,"Going to read number of frozen rows");
		1866	(*result)->frozen_rows = psiconv_read_u32(config,buf,lev+2,off+len, &res);
		1867	if (res)
		1868	goto ERROR6;
		1869	psiconv_debug(config,lev+2,off+len,"Number of frozen rows: %d",
		1870	(*result)->frozen_rows);
		1871	len += leng;
		1872
		1873	psiconv_progress(config,lev+2,off+len,"Going to read number of frozen columns");
		1874	(*result)->frozen_columns = psiconv_read_u32(config,buf,lev+2,off+len, &res);
		1875	if (res)
		1876	goto ERROR6;
		1877	psiconv_debug(config,lev+2,off+len,"Number of frozen columns: %d",
		1878	(*result)->frozen_columns);
		1879	len += leng;
		1880
		1881	psiconv_progress(config,lev+2,off+len,"Going to read first unfrozen row");
		1882	(*result)->first_unfrozen_row_displayed = psiconv_read_u32(config,buf,lev+2,
		1883	off+len, &res);
		1884	if (res)
		1885	goto ERROR6;
		1886	psiconv_debug(config,lev+2,off+len,"First row: %d",
		1887	(*result)->first_unfrozen_row_displayed);
		1888	len += leng;
		1889
		1890	psiconv_progress(config,lev+2,off+len,"Going to read first unfrozen column");
		1891	(*result)->first_unfrozen_column_displayed = psiconv_read_u32(config,buf,lev+2,
		1892	off+len,&res);
		1893	if (res)
		1894	goto ERROR6;
		1895	psiconv_debug(config,lev+2,off+len,"First column: %d",
		1896	(*result)->first_unfrozen_column_displayed);
		1897	len += leng;
		1898	} else
		1899	(result)->frozen_rows = (result)->frozen_columns =
		1900	(*result)->first_unfrozen_row_displayed =
		1901	(*result)->first_unfrozen_column_displayed = 0;
		1902
		1903	psiconv_progress(config,lev+2,off+len,
		1904	"Going to read 3 unknown bytes (%02x expected)",0xff);
		1905	for (i = 0; i < 3 ; i++) {
		1906	temp = psiconv_read_u8(config,buf,lev+2,off+len,&res);
		1907	if (res)
		1908	goto ERROR6;
		1909	if (temp != 0xff) {
		1910	psiconv_warn(config,lev+2,off+len,
		1911	"Grid section unknown byte %d has unknown value (ignored)",
		1912	i);
		1913	psiconv_debug(config,lev+2,off+len,"Value: %02x",temp);
		1914	}
		1915	len ++;
		1916	}
		1917
		1918	if (length)
		1919	*length = len;
		1920
		1921	psiconv_progress(config,lev,off+len-1,
		1922	"End of sheet grid section (total length: %08x)", len);
		1923	return 0;
		1924
		1925	ERROR6:
		1926	psiconv_free_sheet_grid_break_list((*result)->column_page_breaks);
		1927	ERROR5:
		1928	psiconv_free_sheet_grid_break_list((*result)->row_page_breaks);
		1929	ERROR4:
		1930	psiconv_free_sheet_grid_size_list((*result)->column_heights);
		1931	ERROR3:
		1932	psiconv_free_sheet_grid_size_list((*result)->row_heights);
		1933	ERROR2:
		1934	free(*result);
		1935	ERROR1:
		1936	psiconv_warn(config,lev+1,off,"Reading of Sheet Grid Section failed");
		1937	if (length)
		1938	*length = 0;
		1939	if (!res)
		1940	return -PSICONV_E_NOMEM;
		1941	else
		1942	return res;
		1943	}
		1944
		1945
		1946	int psiconv_parse_sheet_grid_size_list(const psiconv_config config,
		1947	const psiconv_buffer buf, int lev,
		1948	psiconv_u32 off, int *length,
		1949	psiconv_sheet_grid_size_list *result)
		1950	{
		1951	int res=0;
		1952	int len=0,i;
		1953	int leng,listlen;
		1954	psiconv_sheet_grid_size size;
		1955
		1956	psiconv_progress(config,lev+1,off,"Going to read a sheet grid size list");
		1957	if (!(*result = psiconv_list_new(sizeof(struct psiconv_sheet_grid_size_s))))
		1958	goto ERROR1;
		1959
		1960	psiconv_progress(config,lev+2,off+len,
		1961	"Going to read the number of elements");
		1962	listlen = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
		1963	if (res)
		1964	goto ERROR2;
		1965	psiconv_debug(config,lev+2,off+len,"Number of elements: %d",listlen);
		1966	len += leng;
		1967
		1968	psiconv_progress(config,lev+2,off+len,"Going to read all elements");
		1969	for (i = 0; i < listlen; i++) {
		1970	psiconv_progress(config,lev+3,off+len,"Going to read element %d",i);
		1971	if ((res = psiconv_parse_sheet_grid_size(config,buf,lev+3,off+len,&leng,&size)))
		1972	goto ERROR2;
		1973	if ((res = psiconv_list_add(*result,size)))
		1974	goto ERROR3;
		1975	free(size);
		1976	len += leng;
		1977	}
		1978
		1979	if (length)
		1980	*length = len;
		1981
		1982	psiconv_progress(config,lev,off+len-1,
		1983	"End of sheet grid size list (total length: %08x)", len);
		1984	return 0;
		1985
		1986	ERROR3:
		1987	psiconv_free_sheet_grid_size(size);
		1988	ERROR2:
		1989	psiconv_list_free(*result);
		1990	ERROR1:
		1991	psiconv_warn(config,lev+1,off,"Reading of Sheet Grid Size List failed");
		1992	if (length)
		1993	*length = 0;
		1994	if (!res)
		1995	return -PSICONV_E_NOMEM;
		1996	else
		1997	return res;
		1998	}
		1999
		2000	int psiconv_parse_sheet_grid_size(const psiconv_config config,
		2001	const psiconv_buffer buf, int lev,
		2002	psiconv_u32 off, int *length,
		2003	psiconv_sheet_grid_size *result)
		2004	{
		2005	int res=0;
		2006	int len=0;
		2007	int leng;
		2008
		2009	psiconv_progress(config,lev+1,off,"Going to read a sheet grid size");
		2010
		2011	if (!(result = malloc(sizeof(*result))))
		2012	goto ERROR1;
		2013
		2014	psiconv_progress(config,lev+2,off+len, "Going to read the row or column number");
		2015	(*result)->line_number = psiconv_read_u32(config,buf,lev+2,off+len,&res);
		2016	if (res)
		2017	goto ERROR2;
		2018	psiconv_debug(config,lev+2,off+len,"Line number: %d\n",(*result)->line_number);
		2019	len += 4;
		2020
		2021	psiconv_progress(config,lev+2,off+len, "Going to read the row or column height");
		2022	(*result)->size = psiconv_read_length(config,buf,lev+2,off+len,&leng,&res);
		2023	if (res)
		2024	goto ERROR2;
		2025	psiconv_debug(config,lev+2,off+len,"Size: %f\n",(*result)->size);
		2026	len += leng;
		2027
		2028	if (length)
		2029	*length = len;
		2030
		2031	psiconv_progress(config,lev,off+len-1,
		2032	"End of sheet grid size(total length: %08x)", len);
		2033	return 0;
		2034
		2035	ERROR2:
		2036	free (*result);
		2037	ERROR1:
		2038	psiconv_warn(config,lev+1,off,"Reading of Sheet Grid Size failed");
		2039	if (length)
		2040	*length = 0;
		2041	if (!res)
		2042	return -PSICONV_E_NOMEM;
		2043	else
		2044	return res;
		2045	}
		2046
		2047
		2048	int psiconv_parse_sheet_grid_break_list(const psiconv_config config,
		2049	const psiconv_buffer buf, int lev,
		2050	psiconv_u32 off, int *length,
		2051	psiconv_sheet_grid_break_list *result)
		2052	{
		2053	int res=0;
		2054	int len=0,i;
		2055	int leng,listlen;
		2056	psiconv_u32 nr;
		2057
		2058	psiconv_progress(config,lev+1,off,"Going to read a sheet grid break list");
		2059	if (!(*result = psiconv_list_new(sizeof(psiconv_u32))))
		2060	goto ERROR1;
		2061
		2062	psiconv_progress(config,lev+2,off+len,
		2063	"Going to read the number of elements");
		2064	listlen = psiconv_read_X(config,buf,lev+2,off+len,&leng,&res);
		2065	if (res)
		2066	goto ERROR2;
		2067	psiconv_debug(config,lev+2,off+len,"Number of elements: %d",listlen);
		2068	len += leng;
		2069
		2070	psiconv_progress(config,lev+2,off+len,"Going to read all elements");
		2071	for (i = 0; i < listlen; i++) {
		2072	psiconv_progress(config,lev+3,off+len,"Going to read element %d",i);
		2073	nr = psiconv_read_u32(config,buf,lev+3,off+len,&res);
		2074	if (res)
		2075	goto ERROR2;
		2076	if ((res = psiconv_list_add(*result,&nr)))
		2077	goto ERROR2;
		2078	len += leng;
		2079	}
		2080
		2081	if (length)
		2082	*length = len;
		2083
		2084	psiconv_progress(config,lev,off+len-1,
		2085	"End of sheet grid break list (total length: %08x)", len);
		2086	return 0;
		2087
		2088	ERROR2:
		2089	psiconv_list_free(*result);
		2090	ERROR1:
		2091	psiconv_warn(config,lev+1,off,"Reading of Sheet Grid break List failed");
		2092	if (length)
		2093	*length = 0;
		2094	if (!res)
		2095	return -PSICONV_E_NOMEM;
		2096	else
		2097	return res;
		2098	}
		2099

 Legend:



Removed from v.129
 


changed lines


 
Added in v.168
 Legend:



Removed from v.129
 


changed lines


 
Added in v.168
-Removed from v.129
+Added in v.168

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