JAL-3619 fix up error messages and try to bail quietly if the viewer doesn’t open
[jalview.git] / src / org / json / JSONML.java
1 package org.json;
2
3 /*
4 Copyright (c) 2008 JSON.org
5
6 Permission is hereby granted, free of charge, to any person obtaining a copy
7 of this software and associated documentation files (the "Software"), to deal
8 in the Software without restriction, including without limitation the rights
9 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 copies of the Software, and to permit persons to whom the Software is
11 furnished to do so, subject to the following conditions:
12
13 The above copyright notice and this permission notice shall be included in all
14 copies or substantial portions of the Software.
15
16 The Software shall be used for Good, not Evil.
17
18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
24 SOFTWARE.
25 */
26
27 /**
28  * This provides static methods to convert an XML text into a JSONArray or
29  * JSONObject, and to covert a JSONArray or JSONObject into an XML text using
30  * the JsonML transform.
31  *
32  * @author JSON.org
33  * @version 2016-01-30
34  */
35 public class JSONML {
36     /**
37      * Parse XML values and store them in a JSONArray.
38      * @param x       The XMLTokener containing the source string.
39      * @param arrayForm true if array form, false if object form.
40      * @param ja      The JSONArray that is containing the current tag or null
41      *     if we are at the outermost level.
42      * @param keepStrings       Don't type-convert text nodes and attribute values
43      * @return A JSONArray if the value is the outermost tag, otherwise null.
44      * @throws JSONException
45      */
46     private static Object parse(
47         XMLTokener x,
48         boolean    arrayForm,
49         JSONArray  ja,
50         boolean keepStrings
51     ) throws JSONException {
52         String     attribute;
53         char       c;
54         String     closeTag = null;
55         int        i;
56         JSONArray  newja = null;
57         JSONObject newjo = null;
58         Object     token;
59         String     tagName = null;
60
61 // Test for and skip past these forms:
62 //      <!-- ... -->
63 //      <![  ... ]]>
64 //      <!   ...   >
65 //      <?   ...  ?>
66
67         while (true) {
68             if (!x.more()) {
69                 throw x.syntaxError("Bad XML");
70             }
71             token = x.nextContent();
72             if (token == XML.LT) {
73                 token = x.nextToken();
74                 if (token instanceof Character) {
75                     if (token == XML.SLASH) {
76
77 // Close tag </
78
79                         token = x.nextToken();
80                         if (!(token instanceof String)) {
81                             throw new JSONException(
82                                     "Expected a closing name instead of '" +
83                                     token + "'.");
84                         }
85                         if (x.nextToken() != XML.GT) {
86                             throw x.syntaxError("Misshaped close tag");
87                         }
88                         return token;
89                     } else if (token == XML.BANG) {
90
91 // <!
92
93                         c = x.next();
94                         if (c == '-') {
95                             if (x.next() == '-') {
96                                 x.skipPast("-->");
97                             } else {
98                                 x.back();
99                             }
100                         } else if (c == '[') {
101                             token = x.nextToken();
102                             if (token.equals("CDATA") && x.next() == '[') {
103                                 if (ja != null) {
104                                     ja.put(x.nextCDATA());
105                                 }
106                             } else {
107                                 throw x.syntaxError("Expected 'CDATA['");
108                             }
109                         } else {
110                             i = 1;
111                             do {
112                                 token = x.nextMeta();
113                                 if (token == null) {
114                                     throw x.syntaxError("Missing '>' after '<!'.");
115                                 } else if (token == XML.LT) {
116                                     i += 1;
117                                 } else if (token == XML.GT) {
118                                     i -= 1;
119                                 }
120                             } while (i > 0);
121                         }
122                     } else if (token == XML.QUEST) {
123
124 // <?
125
126                         x.skipPast("?>");
127                     } else {
128                         throw x.syntaxError("Misshaped tag");
129                     }
130
131 // Open tag <
132
133                 } else {
134                     if (!(token instanceof String)) {
135                         throw x.syntaxError("Bad tagName '" + token + "'.");
136                     }
137                     tagName = (String)token;
138                     newja = new JSONArray();
139                     newjo = new JSONObject();
140                     if (arrayForm) {
141                         newja.put(tagName);
142                         if (ja != null) {
143                             ja.put(newja);
144                         }
145                     } else {
146                         newjo.put("tagName", tagName);
147                         if (ja != null) {
148                             ja.put(newjo);
149                         }
150                     }
151                     token = null;
152                     for (;;) {
153                         if (token == null) {
154                             token = x.nextToken();
155                         }
156                         if (token == null) {
157                             throw x.syntaxError("Misshaped tag");
158                         }
159                         if (!(token instanceof String)) {
160                             break;
161                         }
162
163 // attribute = value
164
165                         attribute = (String)token;
166                         if (!arrayForm && ("tagName".equals(attribute) || "childNode".equals(attribute))) {
167                             throw x.syntaxError("Reserved attribute.");
168                         }
169                         token = x.nextToken();
170                         if (token == XML.EQ) {
171                             token = x.nextToken();
172                             if (!(token instanceof String)) {
173                                 throw x.syntaxError("Missing value");
174                             }
175                             newjo.accumulate(attribute, keepStrings ? ((String)token) :XML.stringToValue((String)token));
176                             token = null;
177                         } else {
178                             newjo.accumulate(attribute, "");
179                         }
180                     }
181                     if (arrayForm && newjo.length() > 0) {
182                         newja.put(newjo);
183                     }
184
185 // Empty tag <.../>
186
187                     if (token == XML.SLASH) {
188                         if (x.nextToken() != XML.GT) {
189                             throw x.syntaxError("Misshaped tag");
190                         }
191                         if (ja == null) {
192                             if (arrayForm) {
193                                 return newja;
194                             }
195                             return newjo;
196                         }
197
198 // Content, between <...> and </...>
199
200                     } else {
201                         if (token != XML.GT) {
202                             throw x.syntaxError("Misshaped tag");
203                         }
204                         closeTag = (String)parse(x, arrayForm, newja, keepStrings);
205                         if (closeTag != null) {
206                             if (!closeTag.equals(tagName)) {
207                                 throw x.syntaxError("Mismatched '" + tagName +
208                                         "' and '" + closeTag + "'");
209                             }
210                             tagName = null;
211                             if (!arrayForm && newja.length() > 0) {
212                                 newjo.put("childNodes", newja);
213                             }
214                             if (ja == null) {
215                                 if (arrayForm) {
216                                     return newja;
217                                 }
218                                 return newjo;
219                             }
220                         }
221                     }
222                 }
223             } else {
224                 if (ja != null) {
225                     ja.put(token instanceof String
226                         ? keepStrings ? XML.unescape((String)token) :XML.stringToValue((String)token)
227                         : token);
228                 }
229             }
230         }
231     }
232
233
234     /**
235      * Convert a well-formed (but not necessarily valid) XML string into a
236      * JSONArray using the JsonML transform. Each XML tag is represented as
237      * a JSONArray in which the first element is the tag name. If the tag has
238      * attributes, then the second element will be JSONObject containing the
239      * name/value pairs. If the tag contains children, then strings and
240      * JSONArrays will represent the child tags.
241      * Comments, prologs, DTDs, and <code>&lt;[ [ ]]></code> are ignored.
242      * @param string The source string.
243      * @return A JSONArray containing the structured data from the XML string.
244      * @throws JSONException Thrown on error converting to a JSONArray
245      */
246     public static JSONArray toJSONArray(String string) throws JSONException {
247         return (JSONArray)parse(new XMLTokener(string), true, null, false);
248     }
249
250
251     /**
252      * Convert a well-formed (but not necessarily valid) XML string into a
253      * JSONArray using the JsonML transform. Each XML tag is represented as
254      * a JSONArray in which the first element is the tag name. If the tag has
255      * attributes, then the second element will be JSONObject containing the
256      * name/value pairs. If the tag contains children, then strings and
257      * JSONArrays will represent the child tags.
258      * As opposed to toJSONArray this method does not attempt to convert 
259      * any text node or attribute value to any type 
260      * but just leaves it as a string.
261      * Comments, prologs, DTDs, and <code>&lt;[ [ ]]></code> are ignored.
262      * @param string The source string.
263      * @param keepStrings If true, then values will not be coerced into boolean
264      *  or numeric values and will instead be left as strings
265      * @return A JSONArray containing the structured data from the XML string.
266      * @throws JSONException Thrown on error converting to a JSONArray
267      */
268     public static JSONArray toJSONArray(String string, boolean keepStrings) throws JSONException {
269         return (JSONArray)parse(new XMLTokener(string), true, null, keepStrings);
270     }
271
272
273     /**
274      * Convert a well-formed (but not necessarily valid) XML string into a
275      * JSONArray using the JsonML transform. Each XML tag is represented as
276      * a JSONArray in which the first element is the tag name. If the tag has
277      * attributes, then the second element will be JSONObject containing the
278      * name/value pairs. If the tag contains children, then strings and
279      * JSONArrays will represent the child content and tags.
280      * As opposed to toJSONArray this method does not attempt to convert 
281      * any text node or attribute value to any type 
282      * but just leaves it as a string.
283      * Comments, prologs, DTDs, and <code>&lt;[ [ ]]></code> are ignored.
284      * @param x An XMLTokener.
285      * @param keepStrings If true, then values will not be coerced into boolean
286      *  or numeric values and will instead be left as strings
287      * @return A JSONArray containing the structured data from the XML string.
288      * @throws JSONException Thrown on error converting to a JSONArray
289      */
290     public static JSONArray toJSONArray(XMLTokener x, boolean keepStrings) throws JSONException {
291         return (JSONArray)parse(x, true, null, keepStrings);
292     }
293
294
295     /**
296      * Convert a well-formed (but not necessarily valid) XML string into a
297      * JSONArray using the JsonML transform. Each XML tag is represented as
298      * a JSONArray in which the first element is the tag name. If the tag has
299      * attributes, then the second element will be JSONObject containing the
300      * name/value pairs. If the tag contains children, then strings and
301      * JSONArrays will represent the child content and tags.
302      * Comments, prologs, DTDs, and <code>&lt;[ [ ]]></code> are ignored.
303      * @param x An XMLTokener.
304      * @return A JSONArray containing the structured data from the XML string.
305      * @throws JSONException Thrown on error converting to a JSONArray
306      */
307     public static JSONArray toJSONArray(XMLTokener x) throws JSONException {
308         return (JSONArray)parse(x, true, null, false);
309     }
310
311
312     /**
313      * Convert a well-formed (but not necessarily valid) XML string into a
314      * JSONObject using the JsonML transform. Each XML tag is represented as
315      * a JSONObject with a "tagName" property. If the tag has attributes, then
316      * the attributes will be in the JSONObject as properties. If the tag
317      * contains children, the object will have a "childNodes" property which
318      * will be an array of strings and JsonML JSONObjects.
319
320      * Comments, prologs, DTDs, and <code>&lt;[ [ ]]></code> are ignored.
321      * @param string The XML source text.
322      * @return A JSONObject containing the structured data from the XML string.
323      * @throws JSONException Thrown on error converting to a JSONObject
324      */
325     public static JSONObject toJSONObject(String string) throws JSONException {
326         return (JSONObject)parse(new XMLTokener(string), false, null, false);
327     }
328     
329     
330     /**
331      * Convert a well-formed (but not necessarily valid) XML string into a
332      * JSONObject using the JsonML transform. Each XML tag is represented as
333      * a JSONObject with a "tagName" property. If the tag has attributes, then
334      * the attributes will be in the JSONObject as properties. If the tag
335      * contains children, the object will have a "childNodes" property which
336      * will be an array of strings and JsonML JSONObjects.
337
338      * Comments, prologs, DTDs, and <code>&lt;[ [ ]]></code> are ignored.
339      * @param string The XML source text.
340      * @param keepStrings If true, then values will not be coerced into boolean
341      *  or numeric values and will instead be left as strings
342      * @return A JSONObject containing the structured data from the XML string.
343      * @throws JSONException Thrown on error converting to a JSONObject
344      */
345     public static JSONObject toJSONObject(String string, boolean keepStrings) throws JSONException {
346         return (JSONObject)parse(new XMLTokener(string), false, null, keepStrings);
347     }
348
349     
350     /**
351      * Convert a well-formed (but not necessarily valid) XML string into a
352      * JSONObject using the JsonML transform. Each XML tag is represented as
353      * a JSONObject with a "tagName" property. If the tag has attributes, then
354      * the attributes will be in the JSONObject as properties. If the tag
355      * contains children, the object will have a "childNodes" property which
356      * will be an array of strings and JsonML JSONObjects.
357
358      * Comments, prologs, DTDs, and <code>&lt;[ [ ]]></code> are ignored.
359      * @param x An XMLTokener of the XML source text.
360      * @return A JSONObject containing the structured data from the XML string.
361      * @throws JSONException Thrown on error converting to a JSONObject
362      */
363     public static JSONObject toJSONObject(XMLTokener x) throws JSONException {
364            return (JSONObject)parse(x, false, null, false);
365     }
366
367
368     /**
369      * Convert a well-formed (but not necessarily valid) XML string into a
370      * JSONObject using the JsonML transform. Each XML tag is represented as
371      * a JSONObject with a "tagName" property. If the tag has attributes, then
372      * the attributes will be in the JSONObject as properties. If the tag
373      * contains children, the object will have a "childNodes" property which
374      * will be an array of strings and JsonML JSONObjects.
375
376      * Comments, prologs, DTDs, and <code>&lt;[ [ ]]></code> are ignored.
377      * @param x An XMLTokener of the XML source text.
378      * @param keepStrings If true, then values will not be coerced into boolean
379      *  or numeric values and will instead be left as strings
380      * @return A JSONObject containing the structured data from the XML string.
381      * @throws JSONException Thrown on error converting to a JSONObject
382      */
383     public static JSONObject toJSONObject(XMLTokener x, boolean keepStrings) throws JSONException {
384            return (JSONObject)parse(x, false, null, keepStrings);
385     }
386
387
388     /**
389      * Reverse the JSONML transformation, making an XML text from a JSONArray.
390      * @param ja A JSONArray.
391      * @return An XML string.
392      * @throws JSONException Thrown on error converting to a string
393      */
394     public static String toString(JSONArray ja) throws JSONException {
395         int                 i;
396         JSONObject          jo;
397         int                 length;
398         Object              object;
399         StringBuilder        sb = new StringBuilder();
400         String              tagName;
401
402 // Emit <tagName
403
404         tagName = ja.getString(0);
405         XML.noSpace(tagName);
406         tagName = XML.escape(tagName);
407         sb.append('<');
408         sb.append(tagName);
409
410         object = ja.opt(1);
411         if (object instanceof JSONObject) {
412             i = 2;
413             jo = (JSONObject)object;
414
415 // Emit the attributes
416
417             // Don't use the new entrySet API to maintain Android support
418             for (final String key : jo.keySet()) {
419                 final Object value = jo.opt(key);
420                 XML.noSpace(key);
421                 if (value != null) {
422                     sb.append(' ');
423                     sb.append(XML.escape(key));
424                     sb.append('=');
425                     sb.append('"');
426                     sb.append(XML.escape(value.toString()));
427                     sb.append('"');
428                 }
429             }
430         } else {
431             i = 1;
432         }
433
434 // Emit content in body
435
436         length = ja.length();
437         if (i >= length) {
438             sb.append('/');
439             sb.append('>');
440         } else {
441             sb.append('>');
442             do {
443                 object = ja.get(i);
444                 i += 1;
445                 if (object != null) {
446                     if (object instanceof String) {
447                         sb.append(XML.escape(object.toString()));
448                     } else if (object instanceof JSONObject) {
449                         sb.append(toString((JSONObject)object));
450                     } else if (object instanceof JSONArray) {
451                         sb.append(toString((JSONArray)object));
452                     } else {
453                         sb.append(object.toString());
454                     }
455                 }
456             } while (i < length);
457             sb.append('<');
458             sb.append('/');
459             sb.append(tagName);
460             sb.append('>');
461         }
462         return sb.toString();
463     }
464
465     /**
466      * Reverse the JSONML transformation, making an XML text from a JSONObject.
467      * The JSONObject must contain a "tagName" property. If it has children,
468      * then it must have a "childNodes" property containing an array of objects.
469      * The other properties are attributes with string values.
470      * @param jo A JSONObject.
471      * @return An XML string.
472      * @throws JSONException Thrown on error converting to a string
473      */
474     public static String toString(JSONObject jo) throws JSONException {
475         StringBuilder sb = new StringBuilder();
476         int                 i;
477         JSONArray           ja;
478         int                 length;
479         Object              object;
480         String              tagName;
481         Object              value;
482
483 //Emit <tagName
484
485         tagName = jo.optString("tagName");
486         if (tagName == null) {
487             return XML.escape(jo.toString());
488         }
489         XML.noSpace(tagName);
490         tagName = XML.escape(tagName);
491         sb.append('<');
492         sb.append(tagName);
493
494 //Emit the attributes
495
496         // Don't use the new entrySet API to maintain Android support
497         for (final String key : jo.keySet()) {
498             if (!"tagName".equals(key) && !"childNodes".equals(key)) {
499                 XML.noSpace(key);
500                 value = jo.opt(key);
501                 if (value != null) {
502                     sb.append(' ');
503                     sb.append(XML.escape(key));
504                     sb.append('=');
505                     sb.append('"');
506                     sb.append(XML.escape(value.toString()));
507                     sb.append('"');
508                 }
509             }
510         }
511
512 //Emit content in body
513
514         ja = jo.optJSONArray("childNodes");
515         if (ja == null) {
516             sb.append('/');
517             sb.append('>');
518         } else {
519             sb.append('>');
520             length = ja.length();
521             for (i = 0; i < length; i += 1) {
522                 object = ja.get(i);
523                 if (object != null) {
524                     if (object instanceof String) {
525                         sb.append(XML.escape(object.toString()));
526                     } else if (object instanceof JSONObject) {
527                         sb.append(toString((JSONObject)object));
528                     } else if (object instanceof JSONArray) {
529                         sb.append(toString((JSONArray)object));
530                     } else {
531                         sb.append(object.toString());
532                     }
533                 }
534             }
535             sb.append('<');
536             sb.append('/');
537             sb.append(tagName);
538             sb.append('>');
539         }
540         return sb.toString();
541     }
542 }