lib/psiconv/parse_simple.c

/*
    parse_simple.c - Part of psiconv, a PSION 5 file formats converter
    Copyright (c) 1999, 2000  Frodo Looijaard <frodol@dds.nl>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#include "config.h"
#include "compat.h"

#include <stdlib.h>
#include <math.h>

#include "parse_routines.h"
#include "error.h"

#ifdef DMALLOC
#include <dmalloc.h>
#endif

/* Very inefficient, but good enough for now. By implementing it ourselves,
   we do not have to link with -lm */
psiconv_float_t pow2(int n)
{
  psiconv_float_t res=1.0;
  int i;

  for (i = 0; i < (n<0?-n:n); i++) 
    res *= 2.0;

  return n<0?1/res:res;
}
psiconv_u8 psiconv_read_u8(const psiconv_buffer buf,int lev,psiconv_u32 off,
                           int *status)
{
  psiconv_u8 *ptr;
  ptr = psiconv_buffer_get(buf,off);
  if (!ptr) {
    psiconv_warn(lev,off,"Trying byte read past the end of the file");
    if (status)
      *status = -PSICONV_E_PARSE;
    return 0;
  }
  if (status)
    *status = 0;
  return *ptr;
}

psiconv_u16 psiconv_read_u16(const psiconv_buffer buf,int lev,psiconv_u32 off,
                             int *status)
{
  psiconv_u8 *ptr0,*ptr1;
  ptr0 = psiconv_buffer_get(buf,off);
  ptr1 = psiconv_buffer_get(buf,off+1);
  if (!ptr0 || !ptr1) {
    psiconv_warn(lev,off,"Trying word read past the end of the file");
    if (status)
      *status = -PSICONV_E_PARSE;
    return 0;
  }
  if (status)
    *status = 0;
  return *ptr0 + (*ptr1 << 8);
}

psiconv_u32 psiconv_read_u32(const psiconv_buffer buf,int lev,psiconv_u32 off,
                             int *status)
{
  psiconv_u8 *ptr0,*ptr1,*ptr2,*ptr3;
  ptr0 = psiconv_buffer_get(buf,off);
  ptr1 = psiconv_buffer_get(buf,off+1);
  ptr2 = psiconv_buffer_get(buf,off+2);
  ptr3 = psiconv_buffer_get(buf,off+3);
  if (!ptr0 || !ptr1 || !ptr2 || !ptr3) {
    psiconv_warn(lev,off,"Trying long read past the end of the file");
    if (status)
      *status = -PSICONV_E_PARSE;
    return 0;
  }
  if (status)
    *status = 0;
  return *ptr0 + (*ptr1 << 8) + (*ptr2 << 16) + (*ptr3 << 24);
}

psiconv_s32 psiconv_read_sint(const psiconv_buffer buf,int lev,psiconv_u32 off,
                              int *length,int *status)
{
  int localstatus;
  psiconv_u32 temp;

  temp=psiconv_read_u32(buf,lev,off,&localstatus);
  if (status) 
    *status = localstatus;
  if (length)
    *length = localstatus?0:4;

  return localstatus?0:(temp & 0x7fffffff)*(temp&0x80000000?-1:1);
}

psiconv_S_t psiconv_read_S(const psiconv_buffer buf, int lev, psiconv_u32 off,
                           int *length,int *status)
{
  psiconv_u8 temp;
  psiconv_S_t res;
  int len,localstatus;

  psiconv_progress(lev+1,off,"Going to read a S length indicator");
  temp = psiconv_read_u8(buf,lev+2,off,&localstatus);
  if (localstatus)
    goto ERROR;
  if ((temp & 0x03) == 0x02) {
    res = psiconv_read_u8(buf,lev+2,off,&localstatus) >> 2;
    if (localstatus)
      goto ERROR;
    len = 1;
    psiconv_debug(lev+2,off,"Indicator (1 byte): %02x",res);
  } else if ((temp & 0x07) == 0x05) {
    res = psiconv_read_u16(buf,lev+2,off,&localstatus) >> 3;
    if (localstatus)
      goto ERROR;
    len = 2;
    psiconv_debug(lev+2,off,"Indicator (2 bytes): %04x",res);
  } else {
    psiconv_warn(lev+2,off,"S indicator: unknown encoding!");
    psiconv_debug(lev+2,off,"Raw data first byte: %02x",temp);
    goto ERROR;
  }

  if (length)
    *length = len;
  if (status)
    *status = 0;

  psiconv_progress(lev+1,off+len-1,
                   "End of S length indicator (total length: %08x)", len);

  return res;

ERROR:
  psiconv_warn(lev+1,off,"Reading of S indicator failed");
  if (status)
    *status = localstatus;
  if (length)
     *length = 0;
  return 0;
}

psiconv_X_t psiconv_read_X(const psiconv_buffer buf, int lev, psiconv_u32 off,
                           int *length, int *status)
{
  psiconv_u8 temp;
  psiconv_X_t res;
  int len,localstatus;

  psiconv_progress(lev+1,off,"Going to read a X length indicator");
  temp = psiconv_read_u8(buf,lev+2,off,&localstatus);
  if (localstatus)
    goto ERROR;
  if ((temp & 0x01) == 0x00) {
    res = psiconv_read_u8(buf,lev+2,off,&localstatus) >> 1;
    if (localstatus)
      goto ERROR;
    len = 1;
    psiconv_debug(lev+2,off,"Indicator (1 byte): %02x",res);
  } else if ((temp & 0x03) == 0x01) {
    res = psiconv_read_u16(buf,lev+2,off,&localstatus) >> 2;
    if (localstatus)
      goto ERROR;
    len = 2;
    psiconv_debug(lev+2,off,"Indicator (2 bytes): %04x",res);
  } else if ((temp & 0x07) == 0x03) {
    res = psiconv_read_u32(buf,lev+2,off,&localstatus) >> 3;
    if (localstatus)
      goto ERROR;
    len = 4;
    psiconv_debug(lev+2,off,"Indicator (4 bytes): %08x",res);
  } else {
    psiconv_warn(lev+2,off,"X indicator: unknown encoding!");
    psiconv_debug(lev+2,off,"Raw data first byte: %02x",temp);
    goto ERROR;
  }

  if (length)
    *length = len;
  if (status)
    *status = 0;

  psiconv_progress(lev+1,off+len-1,
                   "End of X length indicator (total length: %08x)", len);

  return res;

ERROR:
  psiconv_warn(lev+1,off,"Reading of X indicator failed");
  if (status)
    *status = localstatus;
  if (length)
     *length = 0;
  return 0;
}

psiconv_length_t psiconv_read_length(const psiconv_buffer buf, int lev,
                                     psiconv_u32 off, int *length, int *status)
{
  psiconv_length_t res;
  int localstatus;

  res = (2.54/1440.0) * ((psiconv_s32) psiconv_read_u32(buf,lev,off,
                                                        &localstatus));
  if (localstatus) {
    psiconv_warn(lev+1,off,"Reading of length failed");
    if (length)
      *length = 0;
    if (status)
       *status = localstatus;
     return 0;
  }
  psiconv_debug(lev+1,off,"Length: %f",res);
  if (length)
    *length = 4;
  if (status)
     *status = 0;
  return res;
}

psiconv_size_t psiconv_read_size(const psiconv_buffer buf, int lev,
                                 psiconv_u32 off, int *length, int *status)
{
  psiconv_size_t res;
  int localstatus;
  res = ((psiconv_s32) psiconv_read_u32(buf,lev,off,&localstatus)) / 20.0;
  if (localstatus) {
    psiconv_warn(lev+1,off,"Reading of size failed");
    if (length)
      *length = 0;
    if (status)
       *status = localstatus;
     return 0;
  }
  psiconv_debug(lev+1,off,"Size: %f",res);
  if (status)
     *status = 0;
  if (length)
    *length = 4;
  return res;
}

int psiconv_parse_bool(const psiconv_buffer buf, int lev, psiconv_u32 off, 
                       int *length, psiconv_bool_t *result)
{
  psiconv_u8 temp;
  int localstatus;
  temp = psiconv_read_u8(buf,lev,off,&localstatus);
  if (localstatus) {
    psiconv_warn(lev+1,off,"Reading of bool failed");
    if (length)
      *length = 0;
     return localstatus;
  }
  if (length)
    *length = 1;
  if (temp == 0) {
    *result = psiconv_bool_false;
    return 0;
  } else if (temp == 1) {
    *result = psiconv_bool_true;
    return 0;
  }
  psiconv_warn(lev+1,off,"Unknown value for boolean");
  psiconv_debug(lev+1,off,"Boolean value: %02x",temp);
  *result = psiconv_bool_true;
  return 0;
}

psiconv_string_t psiconv_read_string(const psiconv_buffer buf,int lev,
                                     psiconv_u32 off,int *length, int *status)
{
  int stringlen,i,leng,len,localstatus;
  psiconv_string_t result;
  char *res_copy;

  psiconv_progress(lev+1,off,"Going to read a string");

  stringlen = psiconv_read_S(buf,lev+2,off,&leng,&localstatus);
  if (localstatus)
    goto ERROR1;
  psiconv_debug(lev+2,off,"Length: %i",stringlen);
  len = leng;

  result = malloc(stringlen + 1);
  if (!result)
    goto ERROR1;
  for (i = 0; (i < stringlen) && !localstatus; i++)
    result[i] = psiconv_read_u8(buf,lev,off+i+len,&localstatus);
  if (localstatus)
    goto ERROR2;
  result[stringlen] = 0;
  len += stringlen;

  res_copy = psiconv_make_printable(result);
  if (!res_copy)
    goto ERROR2;
  psiconv_debug(lev+2,off,"Contents: `%s'",res_copy);
  free(res_copy);

  if (length)
    *length = len;

  if (status)
    *status = 0;

  psiconv_progress(lev+1,off+len-1,"End of string (total length: %08x)",len);

  return result;

ERROR2:
  free(result);
ERROR1:
  psiconv_warn(lev+1,off,"Reading of string failed");
  if (status)
    *status = localstatus;
  if (length)
    *length = 0;
  return NULL;
}

psiconv_string_t psiconv_read_short_string(const psiconv_buffer buf,
                                     int lev,
                                     psiconv_u32 off,int *length, int *status)
{
  int stringlen,i,len,localstatus;
  psiconv_string_t result;
  char *res_copy;

  psiconv_progress(lev+1,off,"Going to read a short string");

  stringlen = psiconv_read_u8(buf,lev+2,off,&localstatus);
  if (localstatus)
    goto ERROR1;
  psiconv_debug(lev+2,off,"Length: %i",stringlen);
  len = 1;

  result = malloc(stringlen + 1);
  if (!result)
    goto ERROR1;
  for (i = 0; (i < stringlen) && !localstatus; i++)
    result[i] = psiconv_read_u8(buf,lev,off+i+len,&localstatus);
  if (localstatus)
    goto ERROR2;
  result[stringlen] = 0;
  len += stringlen;

  res_copy = psiconv_make_printable(result);
  if (!res_copy)
    goto ERROR2;
  psiconv_debug(lev+2,off,"Contents: `%s'",res_copy);
  free(res_copy);

  if (length)
    *length = len;

  if (status)
    *status = 0;

  psiconv_progress(lev+1,off+len-1,"End of short string (total length: %08x)",
                   len);

  return result;


ERROR2:
  free(result);
ERROR1:
  psiconv_warn(lev+1,off,"Reading of short string failed");
  if (status)
    *status = localstatus;
  if (length)
    *length = 0;
  return NULL;
}

psiconv_float_t psiconv_read_float(const psiconv_buffer buf, int lev,
                                   psiconv_u32 off, int *length, int *status)
{
  psiconv_float_t result,bitvalue;
  int res,bit;
  psiconv_u32 temp=0;

  psiconv_progress(lev+1,off,"Going to read a float");

  bitvalue = 0.5;
  result = 1.0;
  for (bit = 0x33; bit > 0; bit--) {
    if ((bit == 0x33) || ((bit & 0x07) == 0x07))
      temp = psiconv_read_u8(buf,lev+2,off+ (bit >> 3),&res);
    if (res)
      goto ERROR;
    if (temp & (0x01 << (bit & 0x07)))
      result += bitvalue;
    bitvalue /= 2.0;
  }
  temp = psiconv_read_u16(buf,lev+2,off+6,&res);
  if (res)
    goto ERROR;
  if (temp & 0x8000)
    result = -result;
  temp = (temp & 0x7ff0) >> 4;
  result *= pow2(((int) temp)-0x3ff);
  psiconv_debug(lev+1,off,"Float value: %f",result);
  if (length)
    *length = 8;
  if (*status)
    *status = res;
  return result;
ERROR:
  psiconv_warn(lev+1,off,"Reading of float failed");
  if (length)
    *length = 0;
  if (*status)
    *status = res;
  return 0.0;
}

1	/*
2	parse_simple.c - Part of psiconv, a PSION 5 file formats converter
3	Copyright (c) 1999, 2000 Frodo Looijaard <frodol@dds.nl>
4
5	This program is free software; you can redistribute it and/or modify
6	it under the terms of the GNU General Public License as published by
7	the Free Software Foundation; either version 2 of the License, or
8	(at your option) any later version.
9
10	This program is distributed in the hope that it will be useful,
11	but WITHOUT ANY WARRANTY; without even the implied warranty of
12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	GNU General Public License for more details.
14
15	You should have received a copy of the GNU General Public License
16	along with this program; if not, write to the Free Software
17	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18	*/
19
20	#include "config.h"
21	#include "compat.h"
22
23	#include <stdlib.h>
24	#include <math.h>
25
26	#include "parse_routines.h"
27	#include "error.h"
28
29	#ifdef DMALLOC
30	#include <dmalloc.h>
31	#endif
32
33	/* Very inefficient, but good enough for now. By implementing it ourselves,
34	we do not have to link with -lm */
35	psiconv_float_t pow2(int n)
36	{
37	psiconv_float_t res=1.0;
38	int i;
39
40	for (i = 0; i < (n<0?-n:n); i++)
41	res *= 2.0;
42
43	return n<0?1/res:res;
44	}
45	psiconv_u8 psiconv_read_u8(const psiconv_buffer buf,int lev,psiconv_u32 off,
46	int *status)
47	{
48	psiconv_u8 *ptr;
49	ptr = psiconv_buffer_get(buf,off);
50	if (!ptr) {
51	psiconv_warn(lev,off,"Trying byte read past the end of the file");
52	if (status)
53	*status = -PSICONV_E_PARSE;
54	return 0;
55	}
56	if (status)
57	*status = 0;
58	return *ptr;
59	}
60
61	psiconv_u16 psiconv_read_u16(const psiconv_buffer buf,int lev,psiconv_u32 off,
62	int *status)
63	{
64	psiconv_u8 ptr0,ptr1;
65	ptr0 = psiconv_buffer_get(buf,off);
66	ptr1 = psiconv_buffer_get(buf,off+1);
67	if (!ptr0 \|\| !ptr1) {
68	psiconv_warn(lev,off,"Trying word read past the end of the file");
69	if (status)
70	*status = -PSICONV_E_PARSE;
71	return 0;
72	}
73	if (status)
74	*status = 0;
75	return ptr0 + (ptr1 << 8);
76	}
77
78	psiconv_u32 psiconv_read_u32(const psiconv_buffer buf,int lev,psiconv_u32 off,
79	int *status)
80	{
81	psiconv_u8 ptr0,ptr1,ptr2,ptr3;
82	ptr0 = psiconv_buffer_get(buf,off);
83	ptr1 = psiconv_buffer_get(buf,off+1);
84	ptr2 = psiconv_buffer_get(buf,off+2);
85	ptr3 = psiconv_buffer_get(buf,off+3);
86	if (!ptr0 \|\| !ptr1 \|\| !ptr2 \|\| !ptr3) {
87	psiconv_warn(lev,off,"Trying long read past the end of the file");
88	if (status)
89	*status = -PSICONV_E_PARSE;
90	return 0;
91	}
92	if (status)
93	*status = 0;
94	return ptr0 + (ptr1 << 8) + (ptr2 << 16) + (ptr3 << 24);
95	}
96
97	psiconv_s32 psiconv_read_sint(const psiconv_buffer buf,int lev,psiconv_u32 off,
98	int length,int status)
99	{
100	int localstatus;
101	psiconv_u32 temp;
102
103	temp=psiconv_read_u32(buf,lev,off,&localstatus);
104	if (status)
105	*status = localstatus;
106	if (length)
107	*length = localstatus?0:4;
108
109	return localstatus?0:(temp & 0x7fffffff)*(temp&0x80000000?-1:1);
110	}
111
112	psiconv_S_t psiconv_read_S(const psiconv_buffer buf, int lev, psiconv_u32 off,
113	int length,int status)
114	{
115	psiconv_u8 temp;
116	psiconv_S_t res;
117	int len,localstatus;
118
119	psiconv_progress(lev+1,off,"Going to read a S length indicator");
120	temp = psiconv_read_u8(buf,lev+2,off,&localstatus);
121	if (localstatus)
122	goto ERROR;
123	if ((temp & 0x03) == 0x02) {
124	res = psiconv_read_u8(buf,lev+2,off,&localstatus) >> 2;
125	if (localstatus)
126	goto ERROR;
127	len = 1;
128	psiconv_debug(lev+2,off,"Indicator (1 byte): %02x",res);
129	} else if ((temp & 0x07) == 0x05) {
130	res = psiconv_read_u16(buf,lev+2,off,&localstatus) >> 3;
131	if (localstatus)
132	goto ERROR;
133	len = 2;
134	psiconv_debug(lev+2,off,"Indicator (2 bytes): %04x",res);
135	} else {
136	psiconv_warn(lev+2,off,"S indicator: unknown encoding!");
137	psiconv_debug(lev+2,off,"Raw data first byte: %02x",temp);
138	goto ERROR;
139	}
140
141	if (length)
142	*length = len;
143	if (status)
144	*status = 0;
145
146	psiconv_progress(lev+1,off+len-1,
147	"End of S length indicator (total length: %08x)", len);
148
149	return res;
150
151	ERROR:
152	psiconv_warn(lev+1,off,"Reading of S indicator failed");
153	if (status)
154	*status = localstatus;
155	if (length)
156	*length = 0;
157	return 0;
158	}
159
160	psiconv_X_t psiconv_read_X(const psiconv_buffer buf, int lev, psiconv_u32 off,
161	int length, int status)
162	{
163	psiconv_u8 temp;
164	psiconv_X_t res;
165	int len,localstatus;
166
167	psiconv_progress(lev+1,off,"Going to read a X length indicator");
168	temp = psiconv_read_u8(buf,lev+2,off,&localstatus);
169	if (localstatus)
170	goto ERROR;
171	if ((temp & 0x01) == 0x00) {
172	res = psiconv_read_u8(buf,lev+2,off,&localstatus) >> 1;
173	if (localstatus)
174	goto ERROR;
175	len = 1;
176	psiconv_debug(lev+2,off,"Indicator (1 byte): %02x",res);
177	} else if ((temp & 0x03) == 0x01) {
178	res = psiconv_read_u16(buf,lev+2,off,&localstatus) >> 2;
179	if (localstatus)
180	goto ERROR;
181	len = 2;
182	psiconv_debug(lev+2,off,"Indicator (2 bytes): %04x",res);
183	} else if ((temp & 0x07) == 0x03) {
184	res = psiconv_read_u32(buf,lev+2,off,&localstatus) >> 3;
185	if (localstatus)
186	goto ERROR;
187	len = 4;
188	psiconv_debug(lev+2,off,"Indicator (4 bytes): %08x",res);
189	} else {
190	psiconv_warn(lev+2,off,"X indicator: unknown encoding!");
191	psiconv_debug(lev+2,off,"Raw data first byte: %02x",temp);
192	goto ERROR;
193	}
194
195	if (length)
196	*length = len;
197	if (status)
198	*status = 0;
199
200	psiconv_progress(lev+1,off+len-1,
201	"End of X length indicator (total length: %08x)", len);
202
203	return res;
204
205	ERROR:
206	psiconv_warn(lev+1,off,"Reading of X indicator failed");
207	if (status)
208	*status = localstatus;
209	if (length)
210	*length = 0;
211	return 0;
212	}
213
214	psiconv_length_t psiconv_read_length(const psiconv_buffer buf, int lev,
215	psiconv_u32 off, int length, int status)
216	{
217	psiconv_length_t res;
218	int localstatus;
219
220	res = (2.54/1440.0) * ((psiconv_s32) psiconv_read_u32(buf,lev,off,
221	&localstatus));
222	if (localstatus) {
223	psiconv_warn(lev+1,off,"Reading of length failed");
224	if (length)
225	*length = 0;
226	if (status)
227	*status = localstatus;
228	return 0;
229	}
230	psiconv_debug(lev+1,off,"Length: %f",res);
231	if (length)
232	*length = 4;
233	if (status)
234	*status = 0;
235	return res;
236	}
237
238	psiconv_size_t psiconv_read_size(const psiconv_buffer buf, int lev,
239	psiconv_u32 off, int length, int status)
240	{
241	psiconv_size_t res;
242	int localstatus;
243	res = ((psiconv_s32) psiconv_read_u32(buf,lev,off,&localstatus)) / 20.0;
244	if (localstatus) {
245	psiconv_warn(lev+1,off,"Reading of size failed");
246	if (length)
247	*length = 0;
248	if (status)
249	*status = localstatus;
250	return 0;
251	}
252	psiconv_debug(lev+1,off,"Size: %f",res);
253	if (status)
254	*status = 0;
255	if (length)
256	*length = 4;
257	return res;
258	}
259
260	int psiconv_parse_bool(const psiconv_buffer buf, int lev, psiconv_u32 off,
261	int length, psiconv_bool_t result)
262	{
263	psiconv_u8 temp;
264	int localstatus;
265	temp = psiconv_read_u8(buf,lev,off,&localstatus);
266	if (localstatus) {
267	psiconv_warn(lev+1,off,"Reading of bool failed");
268	if (length)
269	*length = 0;
270	return localstatus;
271	}
272	if (length)
273	*length = 1;
274	if (temp == 0) {
275	*result = psiconv_bool_false;
276	return 0;
277	} else if (temp == 1) {
278	*result = psiconv_bool_true;
279	return 0;
280	}
281	psiconv_warn(lev+1,off,"Unknown value for boolean");
282	psiconv_debug(lev+1,off,"Boolean value: %02x",temp);
283	*result = psiconv_bool_true;
284	return 0;
285	}
286
287	psiconv_string_t psiconv_read_string(const psiconv_buffer buf,int lev,
288	psiconv_u32 off,int length, int status)
289	{
290	int stringlen,i,leng,len,localstatus;
291	psiconv_string_t result;
292	char *res_copy;
293
294	psiconv_progress(lev+1,off,"Going to read a string");
295
296	stringlen = psiconv_read_S(buf,lev+2,off,&leng,&localstatus);
297	if (localstatus)
298	goto ERROR1;
299	psiconv_debug(lev+2,off,"Length: %i",stringlen);
300	len = leng;
301
302	result = malloc(stringlen + 1);
303	if (!result)
304	goto ERROR1;
305	for (i = 0; (i < stringlen) && !localstatus; i++)
306	result[i] = psiconv_read_u8(buf,lev,off+i+len,&localstatus);
307	if (localstatus)
308	goto ERROR2;
309	result[stringlen] = 0;
310	len += stringlen;
311
312	res_copy = psiconv_make_printable(result);
313	if (!res_copy)
314	goto ERROR2;
315	psiconv_debug(lev+2,off,"Contents: `%s'",res_copy);
316	free(res_copy);
317
318	if (length)
319	*length = len;
320
321	if (status)
322	*status = 0;
323
324	psiconv_progress(lev+1,off+len-1,"End of string (total length: %08x)",len);
325
326	return result;
327
328	ERROR2:
329	free(result);
330	ERROR1:
331	psiconv_warn(lev+1,off,"Reading of string failed");
332	if (status)
333	*status = localstatus;
334	if (length)
335	*length = 0;
336	return NULL;
337	}
338
339	psiconv_string_t psiconv_read_short_string(const psiconv_buffer buf,
340	int lev,
341	psiconv_u32 off,int length, int status)
342	{
343	int stringlen,i,len,localstatus;
344	psiconv_string_t result;
345	char *res_copy;
346
347	psiconv_progress(lev+1,off,"Going to read a short string");
348
349	stringlen = psiconv_read_u8(buf,lev+2,off,&localstatus);
350	if (localstatus)
351	goto ERROR1;
352	psiconv_debug(lev+2,off,"Length: %i",stringlen);
353	len = 1;
354
355	result = malloc(stringlen + 1);
356	if (!result)
357	goto ERROR1;
358	for (i = 0; (i < stringlen) && !localstatus; i++)
359	result[i] = psiconv_read_u8(buf,lev,off+i+len,&localstatus);
360	if (localstatus)
361	goto ERROR2;
362	result[stringlen] = 0;
363	len += stringlen;
364
365	res_copy = psiconv_make_printable(result);
366	if (!res_copy)
367	goto ERROR2;
368	psiconv_debug(lev+2,off,"Contents: `%s'",res_copy);
369	free(res_copy);
370
371	if (length)
372	*length = len;
373
374	if (status)
375	*status = 0;
376
377	psiconv_progress(lev+1,off+len-1,"End of short string (total length: %08x)",
378	len);
379
380	return result;
381
382
383	ERROR2:
384	free(result);
385	ERROR1:
386	psiconv_warn(lev+1,off,"Reading of short string failed");
387	if (status)
388	*status = localstatus;
389	if (length)
390	*length = 0;
391	return NULL;
392	}
393
394	psiconv_float_t psiconv_read_float(const psiconv_buffer buf, int lev,
395	psiconv_u32 off, int length, int status)
396	{
397	psiconv_float_t result,bitvalue;
398	int res,bit;
399	psiconv_u32 temp=0;
400
401	psiconv_progress(lev+1,off,"Going to read a float");
402
403	bitvalue = 0.5;
404	result = 1.0;
405	for (bit = 0x33; bit > 0; bit--) {
406	if ((bit == 0x33) \|\| ((bit & 0x07) == 0x07))
407	temp = psiconv_read_u8(buf,lev+2,off+ (bit >> 3),&res);
408	if (res)
409	goto ERROR;
410	if (temp & (0x01 << (bit & 0x07)))
411	result += bitvalue;
412	bitvalue /= 2.0;
413	}
414	temp = psiconv_read_u16(buf,lev+2,off+6,&res);
415	if (res)
416	goto ERROR;
417	if (temp & 0x8000)
418	result = -result;
419	temp = (temp & 0x7ff0) >> 4;
420	result *= pow2(((int) temp)-0x3ff);
421	psiconv_debug(lev+1,off,"Float value: %f",result);
422	if (length)
423	*length = 8;
424	if (*status)
425	*status = res;
426	return result;
427	ERROR:
428	psiconv_warn(lev+1,off,"Reading of float failed");
429	if (length)
430	*length = 0;
431	if (*status)
432	*status = res;
433	return 0.0;
434	}
435
frodo@frodo.looijaard.name	ViewVC Help
Powered by ViewVC 1.1.26