(cos_release_object): Fixed.
[chise/concord.git] / read.c
1 /* Copyright (C) 2013 MORIOKA Tomohiko
2    This file is part of the CONCORD Library.
3
4    The CONCORD Library is free software; you can redistribute it and/or
5    modify it under the terms of the GNU Lesser General Public
6    License as published by the Free Software Foundation; either
7    version 2.1 of the License, or (at your option) any later version.
8
9    The CONCORD Library is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12    Lesser General Public License for more details.
13
14    You should have received a copy of the GNU Lesser General Public
15    License along with the CONCORD Library; if not, write to the Free
16    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
17    02111-1307 USA.  */
18
19 #include <stdlib.h>
20 #include <ctype.h>
21 #include "cos-read.h"
22
23 static int
24 is_delimiter (int ch)
25 {
26   return isspace (ch)
27     || ( ch == '(' )
28     || ( ch == ')' )
29     || ( ch == '[' )
30     || ( ch == ']' )
31     || ( ch == '"' )
32     || ( ch == '#' )
33     || ( ch == ';' );
34 }
35
36 static int
37 cos_skip_space (unsigned char *str, size_t len, size_t start, size_t* endp)
38 {
39   int i = start;
40
41   while ( ( i < len ) && isspace (str[i]) )
42     {
43       i++;
44     }
45   *endp = i;
46   return i;
47 }
48
49 COS_object
50 cos_read_int (unsigned char *str, size_t len, size_t start, size_t* endp)
51 {
52   size_t i = start;
53   int c;
54   int negative_flag;
55   int dest;
56
57   if ( i < len )
58     {
59       switch ( str[i] )
60         {
61         case '+':
62           negative_flag = 0;
63           i++;
64           break;
65         case '-':
66           negative_flag = 1;
67           i++;
68           break;
69         default:
70           negative_flag = 0;
71         }
72
73       if ( (i < len) && (c = str[i++])
74            && ('0' <= c) && (c <= '9') )
75         {
76           dest = c - '0';
77
78           while ( i < len )
79             {
80               c = str[i];
81               if ( ('0' <= c) && (c <= '9') )
82                 {
83                   dest = dest * 10 + c - '0';
84                   i++;
85                 }
86               else if ( is_delimiter (c) )
87                 {
88                   *endp = i;
89                   return cos_make_int ( negative_flag ? - dest : dest );
90                 }
91               else
92                 return NULL;
93             }
94           *endp = i;
95           return cos_make_int ( negative_flag ? - dest : dest );
96         }
97     }
98   return NULL;
99 }
100
101
102 int
103 cos_read_utf8 (unsigned char *str, size_t len, size_t start, size_t* endp)
104 {
105   size_t i = start;
106
107   if ( len >= i + 1 )
108     {
109       unsigned char c = str[i++];
110       int counter;
111       int cid;
112
113       if ( c < 0xC0 )
114         {
115           cid = c;
116           counter = 0;
117         }
118       else if ( c < 0xE0 )
119         {
120           cid = c & 0x1f;
121           counter = 1;
122         }
123       else if ( c < 0xF0 )
124         {
125           cid = c & 0x0f;
126           counter = 2;
127         }
128       else if ( c < 0xF8 )
129         {
130           cid = c & 0x07;
131           counter = 3;
132         }
133       else if ( c < 0xFC )
134         {
135           cid = c & 0x03;
136           counter = 4;
137         }
138       else
139         {
140           cid = c & 0x01;
141           counter = 5;
142         }
143
144       if (counter + i <= len)
145         {
146           int j;
147
148           for (j = 0; j < counter; j++)
149             cid = (cid << 6) | (str[i++] & 0x3F);
150           *endp = i;
151           return cid;
152         }
153     }
154   return -1;
155 }
156
157 int
158 cos_read_char (unsigned char *str, size_t len, size_t start, size_t* endp)
159 {
160   size_t i = start;
161
162   if ( (len >= start + 2) && (str[i++] == '?') )
163     {
164       if ( (len >= start + 3) && (str[i] == '\\') )
165         {
166           i++;
167           return cos_read_utf8 (str, len, i, endp);
168         }
169       else
170         return cos_read_utf8 (str, len, i, endp);
171     }
172
173   return -1;
174 }
175
176
177 COS_String
178 cos_read_string (unsigned char *str, size_t len, size_t start, size_t* endp)
179 {
180   size_t i = start;
181   int c;
182
183   if ( (len >= start + 2) && (str[i++] == '"') )
184     {
185       while ( ( i < len )
186               && ( (c = cos_read_utf8 (str, len, i, &i)) >= 0 )
187               )
188         {
189           if ( c == '"' )
190             {
191               *endp = i;
192               return cos_make_string ((char*)&str[start + 1], i - 2 - start);
193             }
194           else if ( c == '\\' )
195             {
196               i++;
197               if ( cos_read_utf8 (str, len, i, &i) < 0 )
198                 return NULL;
199             }
200         }
201     }
202   return NULL;
203 }
204
205
206 COS_Symbol
207 cos_read_symbol (unsigned char *str, size_t len, size_t start, size_t* endp)
208 {
209   size_t i = start;
210   int c;
211
212   if ( i < len )
213     {
214       while ( ( i < len )
215               && ( (c = cos_read_utf8 (str, len, i, &i)) >= 0 )
216               )
217         {
218           if ( is_delimiter (c) )
219             {
220               i--;
221               if ( i == start )
222                 return NULL;
223               else
224                 {
225                   *endp = i;
226                   return
227                     cos_intern (cos_make_string (&str[start], i - start));
228                 }
229             }
230           else if ( c == '\\' )
231             {
232               i++;
233               if ( cos_read_utf8 (str, len, i, &i) < 0 )
234                 return NULL;
235             }
236         }
237     }
238   if ( i == start )
239     return NULL;
240   else
241     {
242       *endp = i;
243       return cos_intern (cos_make_string (&str[start], i - start));
244     }
245 }
246
247
248 static COS_Cons
249 cos_read_list0 (unsigned char *str, size_t len, size_t start, size_t* endp)
250 {
251   size_t i = start;
252
253   i = cos_skip_space (str, len, i, endp);
254   if ( len >= start + 1 )
255     {
256       COS_object car = cos_read_object (str, len, i, endp);
257
258       if ( car == NULL )
259         return NULL;
260       i = *endp;
261
262       i = cos_skip_space (str, len, i, endp);
263       if ( str[i] == ')' )
264         {
265           *endp = i + 1;
266           return cos_cons (car, cos_Qnil);
267         }
268       else if ( str[i] == '.' )
269         {
270           COS_object cdr;
271
272           i++;
273           if ( isspace (str[i])
274                || ( str[i] == '"' )
275                || ( str[i] == '[' )
276                || ( str[i] == '(' ) )
277             {
278               cdr = cos_read_object (str, len, i, endp);
279               if ( cdr == NULL )
280                 return NULL;
281               i = *endp;
282               i = cos_skip_space (str, len, i, endp);
283               if ( str[i] == ')' )
284                 {
285                   *endp = i + 1;
286                   return cos_cons (car, cdr);
287                 }
288               cos_release_object (car);
289               cos_release_object (cdr);
290               return NULL;
291             }
292           else
293             {
294               cos_release_object (car);
295               return NULL;
296             }
297         }
298       else
299         {
300           COS_object rest;
301
302           rest = cos_read_list0 (str, len, i, endp);
303           if ( rest == NULL )
304             return NULL;
305           return cos_cons (car, rest);
306         }
307     }
308   return NULL;
309 }
310
311 COS_Cons
312 cos_read_list (unsigned char *str, size_t len, size_t start, size_t* endp)
313 {
314   size_t i = start;
315
316   i = cos_skip_space (str, len, i, endp);
317   if ( (len >= start + 2) && (str[i++] == '(') )
318     {
319       return cos_read_list0 (str, len, i, endp);
320     }
321   return NULL;
322 }
323
324
325 COS_object
326 cos_read_object (unsigned char *str, size_t len, size_t start, size_t* endp)
327 {
328   COS_object val_obj;
329   int val_cid;
330   COS_String val_str;
331
332   start = cos_skip_space (str, len, start, endp);
333
334   val_obj = cos_read_list (str, len, start, endp);
335   if ( val_obj != NULL )
336     return val_obj;
337
338   val_obj = cos_read_int (str, len, start, endp);
339   if ( val_obj != NULL )
340     return val_obj;
341
342   val_cid = cos_read_char (str, len, start, endp);
343   if ( val_cid >= 0 )
344     return cos_make_char (val_cid);
345
346   val_str = cos_read_string (str, len, start, endp);
347   if ( val_str != NULL )
348     return val_str;
349
350   val_obj = cos_read_symbol (str, len, start, endp);
351   if ( val_obj != NULL )
352     return val_obj;
353
354   return NULL;
355 }