Line data Source code
1 : % -*- mode: slang; mode: fold -*-
2 :
3 1 : import("json");
4 :
5 : %{{{ Type Handlers for json_encode
6 :
7 1 : private variable Type_Map = Ref_Type[0];
8 :
9 : private define add_type_handler ()
10 : {
11 6 : variable func = ();
12 6 : loop (_NARGS-1)
13 : {
14 18 : variable type = ();
15 18 : variable idx = __class_id (type);
16 18 : variable n = length (Type_Map);
17 18 : if (idx >= n)
18 : {
19 6 : variable new_map = Ref_Type[idx+1];
20 6 : new_map[[0:n-1]] = Type_Map;
21 6 : Type_Map = new_map;
22 : }
23 18 : Type_Map[idx] = func;
24 : }
25 : }
26 :
27 : private define get_encode_func (type)
28 : {
29 : try
30 : {
31 64 : variable func = Type_Map[__class_id (type)];
32 64 : if (func == NULL) throw IndexError;
33 64 : return func;
34 : }
35 : catch IndexError:
36 0 : throw Json_Invalid_Json_Error, "$type does not represent a JSON data structure"$;
37 : }
38 : %}}}
39 :
40 : private define json_encode_string (indent, q, data) %{{{
41 : {
42 4 : return _json_encode_string (data);
43 : }
44 1 : add_type_handler (String_Type, BString_Type, &json_encode_string);
45 : %}}}
46 :
47 : private define json_encode_boolean (indent, q, data) %{{{
48 : {
49 4 : if (data == 1) return "true"B;
50 3 : if (data == 0) return "false"B;
51 1 : throw Json_Invalid_Json_Error, sprintf (`invalid boolean value '\%03o'; only '\000' and '\001' are allowed`, data);
52 : }
53 1 : add_type_handler (UChar_Type, &json_encode_boolean);
54 : %}}}
55 :
56 : private define json_encode_null (indent, q, data) %{{{
57 : {
58 2 : return "null"B;
59 : }
60 1 : add_type_handler (Null_Type, &json_encode_null);
61 : %}}}
62 :
63 : private define json_encode_number (indent, q, data) %{{{
64 : {
65 34 : return string (data);
66 : }
67 1 : add_type_handler (
68 : Char_Type, % UChar_Type,
69 : Short_Type, UShort_Type,
70 : Int_Type, UInt_Type,
71 : Long_Type, ULong_Type,
72 : #ifexists LLong_Type
73 : LLong_Type, ULLong_Type,
74 : #endif
75 : Float_Type, Double_Type,
76 : &json_encode_number);
77 : %}}}
78 :
79 : private define json_encode_object (indent, q, object) %{{{
80 : {
81 8 : variable json = "{"B;
82 8 : variable keys = get_struct_field_names (object);
83 8 : variable n_values = length (keys);
84 8 : if (n_values)
85 : {
86 : % pvs indent KEY nsep VAL vsep pvs indent KEY nsep VAL vsep
87 : % ... pvs indent KEY nsep VAL pvs
88 :
89 7 : variable new_indent = bstrcat (indent, q.indent);
90 7 : variable sep = bstrcat (q.vsep, q.post_vsep, new_indent);
91 7 : variable nsep = q.nsep;
92 :
93 7 : variable key = keys[0];
94 7 : variable val = get_struct_field(object, key);
95 7 : variable type = typeof (val);
96 7 : variable func = get_encode_func (type);
97 7 : json = bstrcat (__tmp(json), q.post_vsep, new_indent,
98 : _json_encode_string (key), nsep, (@func)(new_indent, q, val));
99 :
100 : variable i;
101 7 : _for i (1, n_values-1)
102 : {
103 9 : key = keys[i];
104 9 : val = get_struct_field(object, key);
105 9 : variable next_type = typeof (val);
106 9 : if (next_type == String_Type)
107 : {
108 1 : json = bstrcat (__tmp(json), sep, _json_encode_string (key),
109 : nsep, _json_encode_string (val));
110 1 : continue;
111 : }
112 :
113 8 : if (next_type != type)
114 6 : (type, func) = (next_type, get_encode_func (next_type));
115 8 : json = bstrcat (__tmp(json), sep, _json_encode_string (key),
116 : nsep, (@func)(new_indent, q, val));
117 : }
118 7 : json = bstrcat (__tmp(json), q.post_vsep);
119 : }
120 8 : return bstrcat (__tmp(json), indent, "}");
121 : }
122 1 : add_type_handler (Struct_Type, &json_encode_object);
123 : %}}}
124 :
125 : private define json_encode_array (indent, q, array) %{{{
126 : {
127 20 : variable json = "["B;
128 20 : variable n_values = length (array);
129 20 : if (n_values)
130 : {
131 : % pvs, new_indent, VALUE, vsep, pvs, new_indent, VALUE, vsep, pvs, ..., new_indent, VALUE, pvs
132 :
133 17 : variable new_indent = bstrcat (indent, q.indent);
134 17 : variable sep = bstrcat (q.vsep, q.post_vsep, new_indent);
135 :
136 17 : variable i = 0;
137 17 : variable a = array[i];
138 17 : variable type = typeof (a);
139 17 : variable func = get_encode_func (type);
140 17 : json = bstrcat (__tmp(json), q.post_vsep,
141 : new_indent, (@func)(new_indent, q, a));
142 :
143 16 : if ((typeof (array) == Array_Type) && not any (_isnull (array)))
144 : {
145 3 : if (type == String_Type)
146 1 : _for i (1, n_values-1)
147 1 : json = bstrcat (__tmp(json), sep, _json_encode_string (array[i]));
148 : else
149 2 : _for i (1, n_values-1)
150 4 : json = bstrcat (__tmp(json), sep, (@func)(new_indent, q, array[i]));
151 : }
152 13 : else _for i (1, n_values-1)
153 : {
154 27 : a = array[i];
155 27 : variable next_type = typeof (a);
156 27 : if (next_type == String_Type)
157 : {
158 8 : json = bstrcat (__tmp(json), sep, _json_encode_string (a));
159 8 : continue;
160 : }
161 :
162 19 : if (next_type != type)
163 17 : (type, func) = (next_type, get_encode_func (next_type));
164 19 : json = bstrcat (__tmp(json), sep, (@func)(new_indent, q, a));
165 : }
166 :
167 16 : json = bstrcat (__tmp(json), q.post_vsep);
168 : }
169 19 : return bstrcat (__tmp(json), indent, "]");
170 : }
171 1 : add_type_handler (List_Type, Array_Type, &json_encode_array);
172 : %}}}
173 :
174 : private define default_handler (indent, q, data) %{{{
175 : {
176 1 : if (0 < __is_numeric (data) < 3)
177 0 : return json_encode_number (data);
178 :
179 1 : if (is_struct_type (data))
180 0 : return json_encode_object (data);
181 :
182 1 : variable type = _typeof (data);
183 1 : throw Json_Invalid_Json_Error, "$type does not represent a JSON data structure"$;
184 : }
185 1 : Type_Map[where (_isnull (Type_Map))] = &default_handler;
186 : %}}}
187 :
188 : % process_qualifiers %{{{
189 :
190 : private define split_post_vsep (post_vsep) %{{{
191 : {
192 17 : variable indent = "";
193 17 : variable parts = strchop (post_vsep, '\n', 0);
194 17 : if (length (parts) > 1)
195 : {
196 5 : indent = parts[-1];
197 5 : parts[-1] = "";
198 5 : post_vsep = strjoin (parts, "\n");
199 : }
200 17 : return (indent, post_vsep);
201 : }
202 : %}}}
203 :
204 : private define only_whitespace (s)
205 : {
206 85 : return ""B + str_delete_chars (s, "^ \t\n\r");
207 : }
208 :
209 : private define process_qualifiers ()
210 : {
211 17 : variable post_vsep = split_post_vsep (qualifier ("post_vsep", ""));
212 17 : variable indent = (); % other return value from split_post_vsep
213 17 : variable q = struct {
214 17 : pre_nsep = only_whitespace (qualifier ("pre_nsep", "")),
215 17 : post_nsep = only_whitespace (qualifier ("post_nsep", "")),
216 17 : pre_vsep = only_whitespace (qualifier ("pre_vsep", "")),
217 17 : post_vsep = only_whitespace (post_vsep),
218 17 : indent = only_whitespace (indent),
219 : };
220 17 : return struct {
221 17 : nsep = q.pre_nsep + ":" + q.post_nsep,
222 17 : vsep = q.pre_vsep + ",",
223 17 : @q
224 : };
225 : }
226 : %}}}
227 :
228 : define json_encode (data)
229 : {
230 17 : variable q = process_qualifiers (;; __qualifiers);
231 17 : variable func = get_encode_func (typeof (data));
232 17 : variable json = (@func)(""B, q, data);
233 15 : return typecast (json, String_Type);
234 : }
|
