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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 129 - (hide annotations)
Tue Jul 24 20:32:51 2001 UTC (22 years, 8 months ago) by frodo
File MIME type: text/plain
File size: 11256 byte(s)
(Frodo) Many new sheet things

  * Variable section and formula variable parsing
  * Info section
  * Name section
  * Better parsing of vararg functions

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

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